source: mainline/uspace/srv/dd/pci.c@ cf8cc36

#include <futex.h>
#include <assert.h>

#include "pci.h"
#include "pci_bus.h"
#include "pci_regs.h"
#include "pci_conf.h"

#define NAME "PCI"

LIST_INITIALIZE(devices_list);
LIST_INITIALIZE(buses_list);
LIST_INITIALIZE(drivers_list);

static atomic_t pci_bus_futex = FUTEX_INITIALIZER;

static int pci_match(pci_drv_t *drv, pci_dev_t *dev);
static int pci_pass_dev(pci_drv_t *drv, pci_dev_t *dev);
static void pci_lookup_driver(pci_dev_t *dev);
static void pci_lookup_devices(pci_drv_t *drv);


void pci_bus_scan(pci_bus_t *bus)
{
        pci_dev_t *dev = pci_alloc_dev();
        pci_bus_t *child_bus = NULL;
        int dnum, fnum, bus_num;
        bool multi;
        uint8_t header_type;
        
        for (dnum = 0; dnum < 32; dnum++) {
                multi = true;
                for (fnum = 0; multi && fnum < 8; fnum++) {
                        pci_init_dev(dev, bus, dnum, fnum);
                        dev->vendor_id = pci_conf_read_16(dev, PCI_VENDOR_ID);
                        dev->device_id = pci_conf_read_16(dev, PCI_DEVICE_ID);
                        if (dev->vendor_id == 0xFFFF) { // device is not present, go on scanning the bus
                                if (fnum == 0) {
                                        break;
                                } else {
                                        continue;  
                                }
                        }
                        header_type = pci_conf_read_8(dev, PCI_HEADER_TYPE);
                        if (fnum == 0) {
                                 multi = header_type >> 7;  // is the device multifunction?
                        }
                        header_type = header_type & 0x7F; // clear the multifunction bit
                        
                        printf(NAME ": adding new device %3d : %2d : %2d", dev->bus->num, dnum, fnum);
                        printf(" - vendor = 0x%04X, device = 0x%04X.\n", dev->vendor_id, dev->device_id);
                        pci_device_register(dev);                       
                        
                        if (header_type == PCI_HEADER_TYPE_BRIDGE || header_type == PCI_HEADER_TYPE_CARDBUS ) {
                                bus_num = pci_conf_read_8(dev, PCI_BRIDGE_SEC_BUS_NUM);
                                printf(NAME ": device is pci-to-pci bridge, secondary bus number = %d.\n", bus_num);
                                if(bus_num > bus->num) {                                        
                                        child_bus = pci_alloc_bus();
                                        pci_init_bus(child_bus, bus, bus_num);
                                        pci_bus_register(child_bus);
                                        pci_bus_scan(child_bus);        
                                }                                       
                        }
                        
                        dev = pci_alloc_dev();  // alloc new aux. dev. structure
                }
        }
        
        if (dev->vendor_id == 0xFFFF) {
                pci_free_dev(dev);  // free the auxiliary device structure
        }       
}

/*
 * Usage: pci_bus_futex must be down.
 */ 
static int pci_pass_dev(pci_drv_t *drv, pci_dev_t *dev)
{
        assert(dev->driver == NULL);
        assert(drv->name != NULL);
        
        printf(NAME ": passing device to driver '%s'.\n", drv->name);
        if (drv->ops->add_device != NULL && drv->ops->add_device(dev)) {
                dev->driver = drv;
                return 1;
        }
        
        return 0;
}

/*
 * Usage: pci_bus_futex must be down.
 */ 
static void pci_lookup_driver(pci_dev_t *dev)
{
        link_t *item = drivers_list.next;
        pci_drv_t *drv = NULL; 
        
        while (item != &drivers_list) {
                drv = list_get_instance(item, pci_drv_t, link);
                if (pci_match(drv, dev) && pci_pass_dev(drv, dev)) {
                        return;
                }
                item = item->next;
        }
}

/*
 * Usage: pci_bus_futex must be down.
 */ 
static void pci_lookup_devices(pci_drv_t *drv)
{
        link_t *item = devices_list.next;
        pci_dev_t *dev = NULL; 
        
        printf(NAME ": looking up devices for a newly added driver '%s'.\n", drv->name);
        
        while (item != &devices_list) {
                dev = list_get_instance(item, pci_dev_t, link);
                if (dev->driver == NULL && pci_match(drv, dev)) {
                        pci_pass_dev(drv, dev);
                }
                item = item->next;
        }
}

static int pci_match(pci_drv_t *drv, pci_dev_t *dev)
{
        return drv->vendor_id == dev->vendor_id && drv->device_id == dev->device_id;
}

void pci_bus_register(pci_bus_t *bus)
{
        futex_down(&pci_bus_futex);
        
        // add the device to the list of pci devices
        list_append(&(bus->link), &buses_list);
        
        futex_up(&pci_bus_futex);
}

void pci_device_register(pci_dev_t *dev)
{
        futex_down(&pci_bus_futex);
        
        // add the device to the list of pci devices
        list_append(&(dev->link), &devices_list);
        
        // try to find suitable driver for the device and pass the device to it
        pci_lookup_driver(dev);
        
        futex_up(&pci_bus_futex);       
}

void pci_driver_register(pci_drv_t *drv)
{       
        assert(drv->name != NULL);
        
        futex_down(&pci_bus_futex);
        printf(NAME ": registering new driver '%s'.\n", drv->name);
        list_append(&(drv->link), &drivers_list);
        
        // try to find compatible devices
        pci_lookup_devices(drv);
        
        futex_up(&pci_bus_futex);
}