Changeset 5e598e0 in mainline

Timestamp:

2010-04-07T20:55:50Z (15 years ago)

Author:

Lenka Trochtova <trochtova.lenka@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

89ce401a

Parents:

8c06905

Message:

parts of pci enumeration

Location:

uspace

Files:

• lib/libdrv/include/driver.h (modified) (1 diff)
• srv/drivers/pciintel/pci.c (modified) (5 diffs)
• srv/drivers/pciintel/pci.h (modified) (2 diffs)

uspace/lib/libdrv/include/driver.h

@@ -79 +79 @@
         /** Globally unique device identifier (assigned to the device by the device manager). */
         device_handle_t handle;
-        /** The phone to the parent device driver.*/
+        /** The phone to the parent device driver (if it is different from this driver).*/
         int parent_phone;
+        /** Parent device if handled by this driver, NULL otherwise. */
+        device_t *parent;
         /** The device's name.*/
         const char *name;

uspace/srv/drivers/pciintel/pci.c

@@ -41 +41 @@
 #include <bool.h>
 #include <fibril_synch.h>
-#include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
@@ -53 +52 @@
 #include <device/hw_res.h>
 #include <ddi.h>
+#include <libarch/ddi.h>
+
+#include "pci.h"
+#include "pci_regs.h"
 
 #define NAME "pciintel"
+
+
+#define CONF_ADDR(bus, dev, fn, reg)   ((1 << 31) | (bus << 16) | (dev << 11) | (fn << 8) | (reg & ~3))
+
 
 static bool pci_add_device(device_t *dev);
@@ -75 +82 @@
         void *conf_data_port;
         void *conf_addr_port;   
+        fibril_mutex_t conf_mutex;
 } pci_bus_data_t;
 
+static inline pci_bus_data_t *create_pci_bus_data() 
+{
+        pci_bus_data_t *bus_data = (pci_bus_data_t *)malloc(sizeof(pci_bus_data_t));
+        if(NULL != bus_data) {
+                memset(bus_data, 0, sizeof(pci_bus_data_t));
+                fibril_mutex_initialize(&bus_data->conf_mutex);
+        }
+        return bus_data;        
+}
+
+static inline void delete_pci_bus_data(pci_bus_data_t *bus_data) 
+{
+        free(bus_data); 
+}
+
+static void pci_conf_read(device_t *dev, int reg, uint8_t *buf, size_t len)
+{
+        assert(NULL != dev->parent);
+        
+        pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
+        pci_bus_data_t *bus_data = (pci_bus_data_t *)dev->parent->driver_data;
+        
+        fibril_mutex_lock(&bus_data->conf_mutex);
+        
+        uint32_t conf_addr =  CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
+        void *addr = bus_data->conf_data_port + (reg & 3);
+        
+        pio_write_32(bus_data->conf_addr_port, conf_addr);
+        
+        switch (len) {
+                case 1:
+                        buf[0] = pio_read_8(addr);
+                        break;
+                case 2:
+                        ((uint16_t *)buf)[0] = pio_read_16(addr);
+                        break;
+                case 4:
+                        ((uint32_t *)buf)[0] = pio_read_32(addr);
+                        break;
+        }
+        
+        fibril_mutex_unlock(&bus_data->conf_mutex);     
+}
+
+uint8_t pci_conf_read_8(device_t *dev, int reg)
+{
+        uint8_t res;
+        pci_conf_read(dev, reg, &res, 1);
+        return res;
+}
+
+uint16_t pci_conf_read_16(device_t *dev, int reg)
+{
+        uint16_t res;
+        pci_conf_read(dev, reg, (uint8_t *)&res, 2);
+        return res;
+}
+
+uint32_t pci_conf_read_32(device_t *dev, int reg)
+{
+        uint32_t res;
+        pci_conf_read(dev, reg, (uint8_t *)&res, 4);
+        return res;     
+}
+
+void pci_bus_scan(device_t *parent, int bus_num) 
+{
+        device_t *dev = create_device();
+        pci_dev_data_t *dev_data = create_pci_dev_data();
+        dev->driver_data = dev_data;
+        dev->parent = parent;
+        
+        int child_bus = 0;
+        int dnum, fnum;
+        bool multi;
+        uint8_t header_type;
+        
+        for (dnum = 0; dnum < 32; dnum++) {
+                multi = true;
+                for (fnum = 0; multi && fnum < 8; fnum++) {
+                        init_pci_dev_data(dev_data, bus_num, dnum, fnum);
+                        dev_data->vendor_id = pci_conf_read_16(dev, PCI_VENDOR_ID);
+                        dev_data->device_id = pci_conf_read_16(dev, PCI_DEVICE_ID);
+                        if (dev_data->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
+                        
+                        // TODO initialize device - name, match ids, interfaces
+                        // TODO register device
+                        
+                        if (header_type == PCI_HEADER_TYPE_BRIDGE || header_type == PCI_HEADER_TYPE_CARDBUS ) {
+                                child_bus = 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(child_bus > bus_num) {                       
+                                        pci_bus_scan(parent, child_bus);        
+                                }                                       
+                        }
+                        
+                        dev = create_device();  // alloc new aux. dev. structure
+                        dev_data = create_pci_dev_data();
+                        dev->driver_data = dev_data;
+                        dev->parent = parent;
+                }
+        }
+        
+        if (dev_data->vendor_id == 0xFFFF) {
+                delete_device(dev);
+                delete_pci_dev_data(dev_data);  // free the auxiliary device structure
+        }       
+        
+}
 
 static bool pci_add_device(device_t *dev)
@@ -82 +210 @@
         printf(NAME ": pci_add_device\n");
         
-        pci_bus_data_t *bus_data = (pci_bus_data_t *)malloc(sizeof(pci_bus_data_t));
+        pci_bus_data_t *bus_data = create_pci_bus_data();
         if (NULL == bus_data) {
                 printf(NAME ": pci_add_device allocation failed.\n");
@@ -125 +253 @@
         
         // TODO scan the bus    
+        pci_bus_scan(dev, 0);
         
         clean_hw_resource_list(&hw_resources);

uspace/srv/drivers/pciintel/pci.h

@@ -36 +36 @@
 #define PCI_H
 
+
+#include <stdlib.h>
 #include <driver.h>
+#include <malloc.h>
 
 typedef struct pci_dev_data {
@@ -42 +45 @@
         int dev;
         int fn;
-        hw_resource_list hw_resources;
+        int vendor_id;
+        int device_id;
+        hw_resource_list_t hw_resources;
 } pci_dev_data_t;
 
+static inline pci_dev_data_t *create_pci_dev_data() 
+{
+        pci_dev_data_t *res = (pci_dev_data_t *)malloc(sizeof(pci_dev_data_t));
+        if (NULL != res) {
+                memset(res, 0, sizeof(pci_dev_data_t));
+        }
+        return res;     
+}
 
+static inline void init_pci_dev_data(pci_dev_data_t *d, int bus, int dev, int fn) 
+{
+        d->bus = bus;
+        d->dev = dev;
+        d->fn = fn;     
+}
+
+static inline void delete_pci_dev_data(pci_dev_data_t *d) 
+{
+        if (NULL != d) {
+                clean_hw_resource_list(&d->hw_resources);
+                free(d);        
+        }
+}
+
+uint8_t pci_conf_read_8(device_t *dev, int reg);
+uint16_t pci_conf_read_16(device_t *dev, int reg);
+uint32_t pci_conf_read_32(device_t *dev, int reg);
+
+void pci_bus_scan(device_t *parent, int bus_num);
 
 #endif