How can I optimize PCI Scan?

[gamingjam60]

Does all 65536 PCI bus scan necessary during initial load?
It will takes very long . Is this normal to scan all PCI bus or it is good idea to search for necessary items like mass storage, network controller etc and then break the scan?

I am scanning pci device by below:

Code: Select all

void pci_scan() {

    printf("[INFO] Scanning PCI devices... \n");

    for (uint8_t bus = 0; bus < 256; bus++) {
        for (uint8_t device = 0; device < 32; device++) {
            for (uint8_t function = 0; function < 8; function++) {

                // read the device and  vendor id
                uint32_t _dev_vend = pci_read(bus, device, function, DEVICE_VENDOR_OFFSET);
                uint16_t device_id = _dev_vend >> 16;       // upper 16 bit
                uint16_t vendor_id = _dev_vend & 0xFFFF;    // lower 16 bit

                // if(bus == 0 & device == 31 & function == 2){
                //     printf("Device ID: %x, Vendor ID: %x\n", device_id, vendor_id);
                // }

                // Check if the device exists
                if (vendor_id == 0xFFFF) {
                    continue; // Invalid device
                }

                if(vendor_id == 0x8086 & device_id == 0x0) { // Intel do not have any pci device with device id 0x0
                    continue;
                }

                if(vendor_id == 0x1234 & device_id == 0x0) { // No vendor not have any pci device with device id 0x0
                    continue;
                }
                
                // Read the status and command
                uint32_t _status_command = pci_read(bus, device, function, STATUS_COMMAND_OFFSET);
                uint16_t status = _status_command >> 16;       // upper 16 bit
                uint16_t command = _status_command & 0xFFFF;   // lower 16 bit
                
                // Read the class and subclass codes
                uint32_t _class_code = pci_read(bus, device, function, CLASS_SUBCLASS_PROG_REV_OFFSET);
                uint8_t class = (_class_code >> 24) & 0xFF;     // upper 8 bit
                uint8_t subclass = (_class_code >> 16) & 0xFF;  // 23-16 th bit
                uint8_t prog_if = (_class_code >> 8) & 0xFF;    // 15-8 th bit
                uint8_t revision = (_class_code >> 0) & 0xFF;   // lower 8 bit

                // Read bist, header type, latency timer, cache line size
                uint32_t _bist = pci_read(bus, device, function, BIST_HEADER_LATENCY_CACHE_LINE_OFFSET);
                uint8_t bist = (_bist >> 24) & 0xFF;            // upper 8 bit
                uint8_t header_type = (_bist >> 16) & 0xFF;     // 23-16 th bit
                uint8_t latency_timer = (_bist >> 8) & 0xFF;    // 15-8 th bit
                uint8_t cache_line_size = (_bist >> 0) & 0xFF;  // lower 8 bit

                printf("Device ID: %x, Vendor ID: %x\n", device_id, vendor_id);

                // Detecting SATA Disk and storing into sata_disks array
                int found_sata = detect_sata_disk(bus, device, function,
                    class, subclass, prog_if, revision);
                if(found_sata) {
                    break;
                }

                // Detecting Network Controller
                int found_network = detect_network_controller(bus, device, function,
                    class, subclass, prog_if, revision);
                if(found_network){
                    break;
                }

                // Detecting Wireless controller
                int found_wireless = detect_wireless_controller(bus, device, function,
                    class, subclass, prog_if, revision);
                if(found_network){
                    break;
                }
            }
        }
    }
    printf("[INFO] PCI Scan Completed\n");
    printf("Total %d SATA drives found\n", total_sata_disks);
}

The above is taking too long

[nullplan]

A couple of ideas:

• Try to figure out the root busses. I never understood how this was supposed to be done properly, but usually there is only bus 0. However, rdos recently wrote about a system that had root busses 0 and 64. But he also thinks that ACPI is useless, so maybe the info was in there.
• Only enumerate the root busses and then those busses they link to. If you find a PCI-PCI bridge, it will tell you what busses it links to.
• Don't enumerate functions 1-7 on devices that don't return the multi-function flag. They might not decode the function and just respond on all of them. And don't even attempt it at all when there is no device there at all.

That ought to cut down massively on the startup time, by not wasting time on enumerating nonexistant functions or busses. That would also explain the special cases you have in your enumerator: Just get rid of them. Vendor/device = 0xffff is the only one you need to care about.

And your program flow is a bit weird. Do you know that the break statement only breaks out of the innermost loop? I see no sense in aborting the enumeration of a device's functions just because you found what you were looking for.

[gamingjam60]

Thanks @nullplan
I don't know why above for loops stuck into bus=0 so why it is taking too long and never break so I have added manually break function. Now I am using following for loop which is working fine

Code: Select all

for (uint32_t index = 0; index < (256 * 32 * 8); index++) {
        uint8_t bus = (index >> 8) & 0xFF;
        uint8_t device = (index >> 3) & 0x1F;
        uint8_t function = index & 0x07;
        
        . . .
        }

[nullplan]

This still enumerates everything, including what might not exist, and still enumerates the functions of single-function devices. Sooner or later you will get into trouble for this. Latest when you go to real hardware.

[Octocontrabass]

Code: Select all

    for (uint8_t bus = 0; bus < 256; bus++) {

It got stuck because it's an infinite loop. Your compiler should have given you a warning about this. Did you enable enough compiler warnings?