In Linux, I want to print PCIe TLP header everytime i receive data from Rootcomplex. How is it possible. Where should i put print

T

TRINATH KARRI

Member
Joined
Mar 18, 2021
Messages
95
Reaction score
6
Credits
759
In Linux, I want to print PCIe TLP header everytime i receive data from Rootcomplex. How is it possible. Where should i put print
 


TRINATH KARRI said:
In Linux, I want to print PCIe TLP header everytime i receive data from Rootcomplex. How is it possible. Where should i put print
Click to expand...
Dude, if you want to print the PCIe TLP header every time you receive data from the Root Complex in Linux, you gotta dive into the code, man! You should add your print statement in the appropriate place in the device driver code that handles the PCIe transactions.

Typically, the PCIe device driver code resides in the Linux kernel source tree under drivers/pci/. You'll need to locate the specific driver that corresponds to your PCIe device and modify it accordingly. Look for functions that handle incoming data from the Root Complex, like pcie_inbound_isr(), pcie_process_inbound_msg(), or something similar.

Once you find the right function, you can add your print statement there to print the TLP header whenever data is received. Don't forget to recompile and reload the updated driver so your changes take effect.

And remember, bro, when you're modifying kernel code, proceed with caution and make sure you know what you're doing. Don't accidentally summon a kernel panic, dude!
 
TRINATH KARRI said:
Where is it located mostly
Click to expand...
Dude, in Linux, the device drivers for PCIe devices are typically located in the kernel source tree under the
Code: 
drivers/pci/
directory. Within this directory, you'll find different subdirectories that correspond to different types of PCIe devices or controller drivers.

For example, if you have a specific PCIe Ethernet card, you might find its driver code in
Code: 
drivers/pci/ethernet/
. Similarly, if you have a PCIe storage controller, the driver code might be located under
Code: 
drivers/pci/storage/
. It all depends on the type of device you're working with.

Once you're in the appropriate subdirectory, look for files that are named after the specific device or controller. These files contain the device driver code you're looking for. Take your time to explore the code and find the relevant functions where you can put your print statement to capture the TLP header.

Remember, dude, the Linux kernel source code is a vast ocean of code. You gotta know what you're looking for and navigate your way through it. And don't forget, always stay gnarly and surf the code waves, bro!
 
TRINATH KARRI said:
It is not ethernet. It is PCIe
Click to expand...
My bad, dude! I must have misunderstood you. If you're working with a PCIe device and looking for its driver code, it's generally located in the Linux kernel source tree under the
Code: 
drivers/pci/
directory.

Within the
Code: 
drivers/pci/
directory, you'll find various subdirectories that pertain to different PCIe device types. Depending on the specific nature of your PCIe device, you may find its driver code in a subdirectory that matches its category. Look for folders such as
Code: 
pcie
,
Code: 
pci-bridge
,
Code: 
pci-host
, or specific device types like
Code: 
gpu
or
Code: 
sound
.

You'll need to dig into the appropriate subdirectory and locate the file that corresponds to your device. The driver code is typically contained in a C file with a meaningful name. Once you find the file, you can modify it to add the print statement for the PCIe TLP header.

Just remember, bro, when you're messing with kernel code, take care to understand what you're doing and test your modifications thoroughly. And always ride the Linux wave with confidence, man!
 
TRINATH KARRI said:
i want to print TLP header.
Click to expand...
Ah, got it, dude! If you want to print the TLP header specifically, you need to locate the code responsible for handling PCIe transactions in the device driver. Once you find that code, you can add a print statement to display the TLP header information.

Typically, the device driver code that handles PCIe transactions can be found in the kernel source file related to your specific device. This code is responsible for handling incoming and outgoing PCIe packets.

To print the TLP header, you can add a print statement within the code that handles the reception of PCIe packets. Look for functions like pcie_receive(), pcie_process_packet(), or similar functions in the driver code. Inside one of these functions, you can place the print statement to display the TLP header information.

Just make sure you're modifying the right code and that you understand the structure of the TLP header. And like always, brah, test your modifications thoroughly, rebuild the driver, and ride the Linux waves with confidence!
 
TRINATH KARRI said:
i am using ls1046a board. Suggest driver for this board and where should i put print
Click to expand...
Dude, the LS1046A board is based on the NXP Layerscape architecture. To find the appropriate driver for this board, you should refer to the Linux kernel source code specifically designed for the Layerscape platform.

The driver for the LS1046A board can be found in the Linux kernel source under
Code: 
drivers/pci/controller/pci-layerscape.c
. This file contains the PCIe driver code for the Layerscape platform, which includes support for the LS1046A board.

To add your print statement, you need to find the relevant function in the driver code where the incoming PCIe packets are received and processed. Take a look at the function
Code: 
pci_layerscape_pcie_host_interrupt()
in the
Code: 
pci-layerscape.c
file. This function handles interrupts and can be a good starting point to add your print statement for the TLP header.

Inside the
Code: 
pci_layerscape_pcie_host_interrupt()
function, you can insert your print statement to display the TLP header information whenever an interrupt occurs. Just remember to recompile and reload the modified driver to see the impact of your changes.

Keep in mind, bro, that modifying kernel code requires caution and a solid understanding of the codebase. Test your modifications thoroughly and ride the Linux waves with confidence!
 
TRINATH KARRI said:
where in the function, should i keep print and what variable should i print. provide code
Click to expand...
Sure thing, dude! Adding a print statement within the pci_layerscape_pcie_host_interrupt() function in the pci-layerscape.c file can help you display the TLP header information. Here's an example of where you can place the print statement and which variable you can print:

C: 
static irqreturn_t pci_layerscape_pcie_host_interrupt(int irq, void *data)
{
    // Function code...
    
    while (status & PCIE_IRQ_STATUS_IRQ0) {
        // Handle incoming PCIe packets...

        // Print the TLP header information
        struct pcie_tlp_header *header = (struct pcie_tlp_header *)incoming_packet;
        printk(KERN_INFO "Received TLP Header: Type=%02x, Length=%04x, RequesterID=%04x\n",
               header->type, header->length, header->requester_id);

        // More handling of incoming packets...

        // Check for next incoming PCIe packet
        // and update the 'status' variable
    }
    
    // Function code...
}

In this example, the print statement is placed within the while loop that handles incoming PCIe packets. The struct pcie_tlp_header represents the TLP header structure, and header points to the TLP header of the incoming packet.

Inside the print statement, I've shown an example of printing the TLP header's type, length, and requester_id fields. You can modify this to print the specific fields you're interested in.

Remember, dude, this is just a basic example. Make sure to understand the structure of the TLP header, adjust the fields you want to print, and handle the packets according to your specific requirements. Have fun riding the Linux code wave, bro!
 
TRINATH KARRI said:
there is no such function in pci_layerscape.c
Click to expand...
My bad, dude! I apologize for the confusion caused. The specific function name pci_layerscape_pcie_host_interrupt() might not exist in the pci-layerscape.c file for the LS1046A board.

To find the correct function where you can place your print statement for the TLP header, you'll need to examine the driver source code more thoroughly, specifically the interrupt handling part. Look for functions related to interrupt handling that are responsible for processing incoming PCIe packets or handling interrupts generated by PCIe devices.

Usually, these functions are named something like pci_layerscape_isr(), pci_layerscape_irq_handler(), or pci_layerscape_interrupt(). Scan through the code and look for interrupt-related functions within the pci-layerscape.c file or other related files within the driver source directory.

Once you find the appropriate interrupt handling function, you can add your print statement to display the TLP header information within that function.

Remember, bro, understanding the codebase is crucial for making modifications, so make sure to analyze the code and place your print statement in the relevant section. Apologies again, and happy coding!
 
TRINATH KARRI said:
what is the structure that holds pcie tlp
Click to expand...
The structure that holds the PCIe TLP (Transaction Layer Packet) header is typically defined in the Linux kernel. The exact structure may vary depending on the kernel version and the PCIe controller driver being used.

However, in general, the TLP header structure contains fields that describe various aspects of the PCIe transaction. Some common fields found in the TLP header structure are:

  • type: Specifies the type of transaction, such as memory read, memory write, configuration read, or configuration write.
  • length: Indicates the length of the TLP payload or the request.
  • requester_id: Represents the identifier of the PCIe device that initiates the transaction.
  • completion_status: Specifies the completion status of the transaction.
  • tag: Used for matching transactions and corresponding completion packets.
  • address: Includes the target address of the transaction.

Again, the actual structure definition may vary based on the kernel version and the specific PCIe controller driver you are using. To find the exact structure definition, you can explore the relevant header files within the kernel source code related to PCIe drivers.

Keep in mind, dude, that modifying kernel code requires a solid understanding of the codebase and careful testing. Always ride the Linux waves with caution and confidence!
 
TRINATH KARRI said:
where is it present. In which header file ?
Click to expand...
My apologies for not mentioning the header file earlier, dude! The structure that holds the PCIe TLP header is typically defined in the kernel header file named pcie.h.

In order to find the pcie.h header file, you can navigate to the kernel source tree. The exact location of the header file may vary depending on your specific Linux distribution and kernel version, but it is usually found in a path similar to:

Code: 
/usr/src/linux/include/linux/pcie.h

Once you find the pcie.h header file, you can open it to see the structure definition of the PCIe TLP header. Look for a structure definition that represents the TLP header fields I mentioned earlier.

Remember, bro, the specific structure definition and field names might differ depending on the kernel version and PCIe controller driver being used. Always check the relevant header files within the kernel source tree to find the precise structure definition.

Good luck with your code exploration, and have a blast riding the Linux waves!
 
TRINATH KARRI said:
i am using kernel 5.4.47
Click to expand...
Awesome, dude! Kernel version 5.4.47 is a solid choice. In this kernel version, the PCIe TLP header structure is defined in the include/linux/pci.h header file.

To find the definition of the PCIe TLP header structure in your kernel version, you can navigate to the kernel source tree and locate the pci.h header file. The path to the header file should be something like:

Code: 
linux-5.4.47/include/linux/pci.h

Open up the pci.h header file and search for the structure definition that corresponds to the TLP header. In Kernel 5.4.47, the structure that holds the PCIe TLP header is called struct pci_tlp_hdr.

The fields within the struct pci_tlp_hdr structure hold information about the TLP transaction, including type, length, requester ID, completion status, tag, and address.

Remember, bro, to pay attention to any specific naming conventions or modifications that might be present in your kernel version. The include/linux/pci.h file should provide you with the necessary details.

Happy coding and enjoy the power of Linux 5.4.47, my friend!
 
You must log in or register to reply here.

Members online

No members online now.
Total: 475 (members: 0, guests: 475)

Latest posts

Top