Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 663f41c4 in mainline


Ignore:
Timestamp:
2010-10-23T10:56:44Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
5291411
Parents:
49698fa
Message:

Cstyle fixes in pciintel.

Location:
uspace/drv/pciintel
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/pciintel/pci.c

    r49698fa r663f41c4  
    5858#define NAME "pciintel"
    5959
    60 #define CONF_ADDR(bus, dev, fn, reg)   ((1 << 31) | (bus << 16) | (dev << 11) | (fn << 8) | (reg & ~3))
    61 
    62 
    63 static hw_resource_list_t * pciintel_get_child_resources(device_t *dev)
    64 {
    65         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
    66         if (NULL == dev_data) {
     60#define CONF_ADDR(bus, dev, fn, reg) \
     61        ((1 << 31) | (bus << 16) | (dev << 11) | (fn << 8) | (reg & ~3))
     62
     63static hw_resource_list_t *pciintel_get_child_resources(device_t *dev)
     64{
     65        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
     66       
     67        if (NULL == dev_data)
    6768                return NULL;
    68         }
    6969        return &dev_data->hw_resources;
    7070}
    7171
    72 static bool pciintel_enable_child_interrupt(device_t *dev) 
    73 {
    74         // TODO
     72static bool pciintel_enable_child_interrupt(device_t *dev)
     73{
     74        /* TODO */
    7575       
    7676        return false;
     
    7979static resource_iface_t pciintel_child_res_iface = {
    8080        &pciintel_get_child_resources,
    81         &pciintel_enable_child_interrupt       
     81        &pciintel_enable_child_interrupt
    8282};
    8383
    8484static device_ops_t pci_child_ops;
    8585
    86 
    87 static int pci_add_device(device_t *dev);
    88 
    89 /** The pci bus driver's standard operations.
    90  */
     86static int pci_add_device(device_t *);
     87
     88/** The pci bus driver's standard operations. */
    9189static driver_ops_t pci_ops = {
    9290        .add_device = &pci_add_device
    9391};
    9492
    95 /** The pci bus driver structure.
    96  */
     93/** The pci bus driver structure. */
    9794static driver_t pci_driver = {
    9895        .name = NAME,
     
    103100        uint32_t conf_io_addr;
    104101        void *conf_data_port;
    105         void *conf_addr_port;   
     102        void *conf_addr_port;
    106103        fibril_mutex_t conf_mutex;
    107104} pci_bus_data_t;
    108105
    109 static inline pci_bus_data_t *create_pci_bus_data()
    110 {
    111         pci_bus_data_t *bus_data = (pci_bus_data_t *)malloc(sizeof(pci_bus_data_t));
    112         if(NULL != bus_data) {
     106static pci_bus_data_t *create_pci_bus_data(void)
     107{
     108        pci_bus_data_t *bus_data;
     109       
     110        bus_data = (pci_bus_data_t *) malloc(sizeof(pci_bus_data_t));
     111        if (NULL != bus_data) {
    113112                memset(bus_data, 0, sizeof(pci_bus_data_t));
    114113                fibril_mutex_initialize(&bus_data->conf_mutex);
    115114        }
    116         return bus_data;       
    117 }
    118 
    119 static inline void delete_pci_bus_data(pci_bus_data_t *bus_data)
    120 {
    121         free(bus_data); 
     115        return bus_data;
     116}
     117
     118static void delete_pci_bus_data(pci_bus_data_t *bus_data)
     119{
     120        free(bus_data);
    122121}
    123122
     
    126125        assert(NULL != dev->parent);
    127126       
    128         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
    129         pci_bus_data_t *bus_data = (pci_bus_data_t *)dev->parent->driver_data;
     127        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
     128        pci_bus_data_t *bus_data = (pci_bus_data_t *) dev->parent->driver_data;
    130129       
    131130        fibril_mutex_lock(&bus_data->conf_mutex);
    132131       
    133         uint32_t conf_addr =  CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
     132        uint32_t conf_addr;
     133        conf_addr = CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
    134134        void *addr = bus_data->conf_data_port + (reg & 3);
    135135       
     
    137137       
    138138        switch (len) {
    139                 case 1:
    140                         buf[0] = pio_read_8(addr);
    141                         break;
    142                 case 2:
    143                         ((uint16_t *)buf)[0] = pio_read_16(addr);
    144                         break;
    145                 case 4:
    146                         ((uint32_t *)buf)[0] = pio_read_32(addr);
    147                         break;
    148         }
    149        
    150         fibril_mutex_unlock(&bus_data->conf_mutex);     
     139        case 1:
     140                buf[0] = pio_read_8(addr);
     141                break;
     142        case 2:
     143                ((uint16_t *) buf)[0] = pio_read_16(addr);
     144                break;
     145        case 4:
     146                ((uint32_t *) buf)[0] = pio_read_32(addr);
     147                break;
     148        }
     149       
     150        fibril_mutex_unlock(&bus_data->conf_mutex);
    151151}
    152152
     
    155155        assert(NULL != dev->parent);
    156156       
    157         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
    158         pci_bus_data_t *bus_data = (pci_bus_data_t *)dev->parent->driver_data;
     157        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
     158        pci_bus_data_t *bus_data = (pci_bus_data_t *) dev->parent->driver_data;
    159159       
    160160        fibril_mutex_lock(&bus_data->conf_mutex);
    161161       
    162         uint32_t conf_addr =  CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
     162        uint32_t conf_addr;
     163        conf_addr = CONF_ADDR(dev_data->bus, dev_data->dev, dev_data->fn, reg);
    163164        void *addr = bus_data->conf_data_port + (reg & 3);
    164165       
     
    166167       
    167168        switch (len) {
    168                 case 1:
    169                         pio_write_8(addr, buf[0]);
    170                         break;
    171                 case 2:
    172                         pio_write_16(addr, ((uint16_t *)buf)[0]);
    173                         break;
    174                 case 4:
    175                         pio_write_32(addr, ((uint32_t *)buf)[0]);
    176                         break;
    177         }
    178        
    179         fibril_mutex_unlock(&bus_data->conf_mutex);     
     169        case 1:
     170                pio_write_8(addr, buf[0]);
     171                break;
     172        case 2:
     173                pio_write_16(addr, ((uint16_t *) buf)[0]);
     174                break;
     175        case 4:
     176                pio_write_32(addr, ((uint32_t *) buf)[0]);
     177                break;
     178        }
     179       
     180        fibril_mutex_unlock(&bus_data->conf_mutex);
    180181}
    181182
     
    190191{
    191192        uint16_t res;
    192         pci_conf_read(dev, reg, (uint8_t *)&res, 2);
     193        pci_conf_read(dev, reg, (uint8_t *) &res, 2);
    193194        return res;
    194195}
     
    197198{
    198199        uint32_t res;
    199         pci_conf_read(dev, reg, (uint8_t *)&res, 4);
    200         return res;     
    201 }
    202 
    203 void pci_conf_write_8(device_t *dev, int reg, uint8_t val)
    204 {
    205         pci_conf_write(dev, reg, (uint8_t *)&val, 1);   
    206 }
    207 
    208 void pci_conf_write_16(device_t *dev, int reg, uint16_t val)
    209 {
    210         pci_conf_write(dev, reg, (uint8_t *)&val, 2);   
    211 }
    212 
    213 void pci_conf_write_32(device_t *dev, int reg, uint32_t val)
    214 {
    215         pci_conf_write(dev, reg, (uint8_t *)&val, 4);   
    216 }
    217 
     200        pci_conf_read(dev, reg, (uint8_t *) &res, 4);
     201        return res;
     202}
     203
     204void pci_conf_write_8(device_t *dev, int reg, uint8_t val)
     205{
     206        pci_conf_write(dev, reg, (uint8_t *) &val, 1);
     207}
     208
     209void pci_conf_write_16(device_t *dev, int reg, uint16_t val)
     210{
     211        pci_conf_write(dev, reg, (uint8_t *) &val, 2);
     212}
     213
     214void pci_conf_write_32(device_t *dev, int reg, uint32_t val)
     215{
     216        pci_conf_write(dev, reg, (uint8_t *) &val, 4);
     217}
    218218
    219219void create_pci_match_ids(device_t *dev)
    220220{
    221         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
    222         match_id_t *match_id = NULL;   
    223         char *match_id_str;     
     221        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
     222        match_id_t *match_id = NULL;
     223        char *match_id_str;
     224       
    224225        match_id = create_match_id();
    225226        if (NULL != match_id) {
    226                 asprintf(&match_id_str, "pci/ven=%04x&dev=%04x", dev_data->vendor_id, dev_data->device_id);
     227                asprintf(&match_id_str, "pci/ven=%04x&dev=%04x",
     228                    dev_data->vendor_id, dev_data->device_id);
    227229                match_id->id = match_id_str;
    228230                match_id->score = 90;
    229231                add_match_id(&dev->match_ids, match_id);
    230232        }       
    231         // TODO add more ids (with subsys ids, using class id etc.)
    232 }
    233 
    234 void pci_add_range(device_t *dev, uint64_t range_addr, size_t range_size, bool io)
    235 {
    236         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
     233        /* TODO add more ids (with subsys ids, using class id etc.) */
     234}
     235
     236void
     237pci_add_range(device_t *dev, uint64_t range_addr, size_t range_size, bool io)
     238{
     239        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
    237240        hw_resource_list_t *hw_res_list = &dev_data->hw_resources;
    238241        hw_resource_t *hw_resources =  hw_res_list->resources;
    239         size_t count = hw_res_list->count;     
     242        size_t count = hw_res_list->count;
    240243       
    241244        assert(NULL != hw_resources);
     
    245248                hw_resources[count].type = IO_RANGE;
    246249                hw_resources[count].res.io_range.address = range_addr;
    247                 hw_resources[count].res.io_range.size = range_size;     
    248                 hw_resources[count].res.io_range.endianness = LITTLE_ENDIAN;   
     250                hw_resources[count].res.io_range.size = range_size;
     251                hw_resources[count].res.io_range.endianness = LITTLE_ENDIAN;
    249252        } else {
    250253                hw_resources[count].type = MEM_RANGE;
    251254                hw_resources[count].res.mem_range.address = range_addr;
    252                 hw_resources[count].res.mem_range.size = range_size;   
     255                hw_resources[count].res.mem_range.size = range_size;
    253256                hw_resources[count].res.mem_range.endianness = LITTLE_ENDIAN;
    254257        }
    255258       
    256         hw_res_list->count++;   
    257 }
    258 
    259 
    260 /** Read the base address register (BAR) of the device
    261  *  and if it contains valid address add it to the devices hw resource list.
    262  *
    263  * @param dev the pci device.
    264  * @param addr the address of the BAR in the PCI configuration address space of the device.
    265  *
    266  * @return the addr the address of the BAR which should be read next.
     259        hw_res_list->count++;
     260}
     261
     262/** Read the base address register (BAR) of the device and if it contains valid
     263 * address add it to the devices hw resource list.
     264 *
     265 * @param dev   The pci device.
     266 * @param addr  The address of the BAR in the PCI configuration address space of
     267 *              the device.
     268 * @return      The addr the address of the BAR which should be read next.
    267269 */
    268 int pci_read_bar(device_t *dev, int addr) 
     270int pci_read_bar(device_t *dev, int addr)
    269271{       
    270         // value of the BAR
     272        /* Value of the BAR */
    271273        uint32_t val, mask;
    272         // IO space address
     274        /* IO space address */
    273275        bool io;
    274         // 64-bit wide address
     276        /* 64-bit wide address */
    275277        bool w64;
    276278       
    277         // size of the io or memory range specified by the BAR
     279        /* Size of the io or memory range specified by the BAR */
    278280        size_t range_size;
    279         // beginning of the io or memory range specified by the BAR
     281        /* Beginning of the io or memory range specified by the BAR */
    280282        uint64_t range_addr;
    281283       
    282         // get the value of the BAR
     284        /* Get the value of the BAR. */
    283285        val = pci_conf_read_32(dev, addr);
    284286       
    285         io = (bool)(val & 1);
     287        io = (bool) (val & 1);
    286288        if (io) {
    287289                w64 = false;
     
    295297                        break;
    296298                default:
    297                         // reserved, go to the next BAR
    298                         return addr + 4;                                                       
     299                        /* reserved, go to the next BAR */
     300                        return addr + 4;
    299301                }
    300302        }
    301303       
    302         // get the address mask
     304        /* Get the address mask. */
    303305        pci_conf_write_32(dev, addr, 0xffffffff);
    304         mask = pci_conf_read_32(dev, addr);     
    305        
    306         // restore the original value
     306        mask = pci_conf_read_32(dev, addr);
     307       
     308        /* Restore the original value. */
    307309        pci_conf_write_32(dev, addr, val);
    308         val = pci_conf_read_32(dev, addr);     
     310        val = pci_conf_read_32(dev, addr);
    309311       
    310312        range_size = pci_bar_mask_to_size(mask);
    311313       
    312314        if (w64) {
    313                 range_addr = ((uint64_t)pci_conf_read_32(dev, addr + 4) << 32) | (val & 0xfffffff0);   
     315                range_addr = ((uint64_t)pci_conf_read_32(dev, addr + 4) << 32) |
     316                    (val & 0xfffffff0);
    314317        } else {
    315318                range_addr = (val & 0xfffffff0);
    316         }       
     319        }
     320       
    317321        if (0 != range_addr) {
    318322                printf(NAME ": device %s : ", dev->name);
    319                 printf("address = %x", range_addr);             
     323                printf("address = %x", range_addr);
    320324                printf(", size = %x\n", range_size);
    321325        }
     
    323327        pci_add_range(dev, range_addr, range_size, io);
    324328       
    325         if (w64) {
     329        if (w64)
    326330                return addr + 8;
    327         }
    328         return addr + 4;       
     331       
     332        return addr + 4;
    329333}
    330334
    331335void pci_add_interrupt(device_t *dev, int irq)
    332336{
    333         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
     337        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
    334338        hw_resource_list_t *hw_res_list = &dev_data->hw_resources;
    335         hw_resource_t *hw_resources =  hw_res_list->resources;
    336         size_t count = hw_res_list->count;     
     339        hw_resource_t *hw_resources = hw_res_list->resources;
     340        size_t count = hw_res_list->count;
    337341       
    338342        assert(NULL != hw_resources);
     
    342346        hw_resources[count].res.interrupt.irq = irq;
    343347       
    344         hw_res_list->count++;           
    345        
     348        hw_res_list->count++;
    346349       
    347350        printf(NAME ": device %s uses irq %x.\n", dev->name, irq);
     
    351354{
    352355        uint8_t irq = pci_conf_read_8(dev, PCI_BRIDGE_INT_LINE);
    353         if (0xff != irq) {
     356        if (0xff != irq)
    354357                pci_add_interrupt(dev, irq);
    355         }       
    356358}
    357359
    358360/** Enumerate (recursively) and register the devices connected to a pci bus.
    359  * 
    360  * @param parent the host-to-pci bridge device.
    361  * @param bus_num the bus number.
     361 *
     362 * @param parent        The host-to-pci bridge device.
     363 * @param bus_num       The bus number.
    362364 */
    363365void pci_bus_scan(device_t *parent, int bus_num)
     
    377379                for (fnum = 0; multi && fnum < 8; fnum++) {
    378380                        init_pci_dev_data(dev_data, bus_num, dnum, fnum);
    379                         dev_data->vendor_id = pci_conf_read_16(dev, PCI_VENDOR_ID);
    380                         dev_data->device_id = pci_conf_read_16(dev, PCI_DEVICE_ID);
    381                         if (dev_data->vendor_id == 0xffff) { // device is not present, go on scanning the bus
    382                                 if (fnum == 0) {
     381                        dev_data->vendor_id = pci_conf_read_16(dev,
     382                            PCI_VENDOR_ID);
     383                        dev_data->device_id = pci_conf_read_16(dev,
     384                            PCI_DEVICE_ID);
     385                        if (dev_data->vendor_id == 0xffff) {
     386                                /*
     387                                 * The device is not present, go on scanning the
     388                                 * bus.
     389                                 */
     390                                if (fnum == 0)
    383391                                        break;
    384                                 } else {
    385                                         continue; 
    386                                 }
     392                                else
     393                                        continue;
    387394                        }
     395                       
    388396                        header_type = pci_conf_read_8(dev, PCI_HEADER_TYPE);
    389397                        if (fnum == 0) {
    390                                  multi = header_type >> 7;  // is the device multifunction?
     398                                /* Is the device multifunction? */
     399                                multi = header_type >> 7;
    391400                        }
    392                         header_type = header_type & 0x7F; // clear the multifunction bit
     401                        /* Clear the multifunction bit. */
     402                        header_type = header_type & 0x7F;
    393403                       
    394404                        create_pci_dev_name(dev);
     
    398408                        pci_read_interrupt(dev);
    399409                       
    400                         dev->ops = &pci_child_ops;                     
    401                        
    402                         printf(NAME ": adding new child device %s.\n", dev->name);
     410                        dev->ops = &pci_child_ops;
     411                       
     412                        printf(NAME ": adding new child device %s.\n",
     413                            dev->name);
    403414                       
    404415                        create_pci_match_ids(dev);
    405416                       
    406                         if (EOK != child_device_register(dev, parent)) {                               
    407                                 pci_clean_resource_list(dev);                           
     417                        if (EOK != child_device_register(dev, parent)) {
     418                                pci_clean_resource_list(dev);
    408419                                clean_match_ids(&dev->match_ids);
    409                                 free((char *)dev->name);
     420                                free((char *) dev->name);
    410421                                dev->name = NULL;
    411422                                continue;
    412423                        }
    413424                       
    414                         //printf(NAME ": new device %s was successfully registered by device manager.\n", dev->name);
    415                        
    416                         if (header_type == PCI_HEADER_TYPE_BRIDGE || header_type == PCI_HEADER_TYPE_CARDBUS ) {
    417                                 child_bus = pci_conf_read_8(dev, PCI_BRIDGE_SEC_BUS_NUM);
    418                                 printf(NAME ": device is pci-to-pci bridge, secondary bus number = %d.\n", bus_num);
    419                                 if(child_bus > bus_num) {                       
    420                                         pci_bus_scan(parent, child_bus);       
    421                                 }                                       
     425                        if (header_type == PCI_HEADER_TYPE_BRIDGE ||
     426                            header_type == PCI_HEADER_TYPE_CARDBUS ) {
     427                                child_bus = pci_conf_read_8(dev,
     428                                    PCI_BRIDGE_SEC_BUS_NUM);
     429                                printf(NAME ": device is pci-to-pci bridge, "
     430                                    "secondary bus number = %d.\n", bus_num);
     431                                if(child_bus > bus_num)
     432                                        pci_bus_scan(parent, child_bus);
    422433                        }
    423434                       
    424                         dev = create_device();  // alloc new aux. dev. structure
     435                        /* Alloc new aux. dev. structure. */
     436                        dev = create_device();
    425437                        dev_data = create_pci_dev_data();
    426438                        dev->driver_data = dev_data;
     
    431443        if (dev_data->vendor_id == 0xffff) {
    432444                delete_device(dev);
    433                 delete_pci_dev_data(dev_data);  // free the auxiliary device structure
    434         }               
     445                /* Free the auxiliary device structure. */
     446                delete_pci_dev_data(dev_data);
     447        }
    435448}
    436449
     
    443456                printf(NAME ": pci_add_device allocation failed.\n");
    444457                return ENOMEM;
    445         }       
    446        
    447         dev->parent_phone = devman_parent_device_connect(dev->handle,  IPC_FLAG_BLOCKING);
    448         if (dev->parent_phone <= 0) {
    449                 printf(NAME ": pci_add_device failed to connect to the parent's driver.\n");
     458        }
     459       
     460        dev->parent_phone = devman_parent_device_connect(dev->handle,
     461            IPC_FLAG_BLOCKING);
     462        if (dev->parent_phone < 0) {
     463                printf(NAME ": pci_add_device failed to connect to the "
     464                    "parent's driver.\n");
    450465                delete_pci_bus_data(bus_data);
    451466                return EPARTY;  /* FIXME: use another EC */
     
    455470       
    456471        if (!get_hw_resources(dev->parent_phone, &hw_resources)) {
    457                 printf(NAME ": pci_add_device failed to get hw resources for the device.\n");
     472                printf(NAME ": pci_add_device failed to get hw resources for "
     473                    "the device.\n");
    458474                delete_pci_bus_data(bus_data);
    459475                ipc_hangup(dev->parent_phone);
     
    461477        }       
    462478       
    463         printf(NAME ": conf_addr = %x.\n", hw_resources.resources[0].res.io_range.address);     
     479        printf(NAME ": conf_addr = %x.\n",
     480            hw_resources.resources[0].res.io_range.address);
    464481       
    465482        assert(hw_resources.count > 0);
     
    467484        assert(hw_resources.resources[0].res.io_range.size == 8);
    468485       
    469         bus_data->conf_io_addr = (uint32_t)hw_resources.resources[0].res.io_range.address;
    470        
    471         if (pio_enable((void *)bus_data->conf_io_addr, 8, &bus_data->conf_addr_port)) {
     486        bus_data->conf_io_addr =
     487            (uint32_t) hw_resources.resources[0].res.io_range.address;
     488       
     489        if (pio_enable((void *)bus_data->conf_io_addr, 8,
     490            &bus_data->conf_addr_port)) {
    472491                printf(NAME ": failed to enable configuration ports.\n");
    473492                delete_pci_bus_data(bus_data);
    474493                ipc_hangup(dev->parent_phone);
    475494                clean_hw_resource_list(&hw_resources);
    476                 return EADDRNOTAVAIL;                                   
    477         }
    478         bus_data->conf_data_port = (char *)bus_data->conf_addr_port + 4;
     495                return EADDRNOTAVAIL;
     496        }
     497        bus_data->conf_data_port = (char *) bus_data->conf_addr_port + 4;
    479498       
    480499        dev->driver_data = bus_data;
    481500       
    482         // enumerate child devices
     501        /* Enumerate child devices. */
    483502        printf(NAME ": scanning the bus\n");
    484503        pci_bus_scan(dev, 0);
     
    489508}
    490509
    491 static void pciintel_init()
     510static void pciintel_init(void)
    492511{
    493512        pci_child_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_child_res_iface;
  • uspace/drv/pciintel/pci.h

    r49698fa r663f41c4  
    11/*
    2  * Copyright (c) 2010 Lenka Trochtova 
     2 * Copyright (c) 2010 Lenka Trochtova
    33 * All rights reserved.
    44 *
     
    3232/** @file
    3333 */
    34  
    35 #ifndef PCI_H
    36 #define PCI_H
    3734
     35#ifndef PCI_H_
     36#define PCI_H_
    3837
    3938#include <stdlib.h>
     
    5453} pci_dev_data_t;
    5554
    56 void create_pci_match_ids(device_t *dev);
     55extern void create_pci_match_ids(device_t *);
    5756
    58 uint8_t pci_conf_read_8(device_t *dev, int reg);
    59 uint16_t pci_conf_read_16(device_t *dev, int reg);
    60 uint32_t pci_conf_read_32(device_t *dev, int reg);
    61 void pci_conf_write_8(device_t *dev, int reg, uint8_t val);
    62 void pci_conf_write_16(device_t *dev, int reg, uint16_t val);
    63 void pci_conf_write_32(device_t *dev, int reg, uint32_t val);
     57extern uint8_t pci_conf_read_8(device_t *, int);
     58extern uint16_t pci_conf_read_16(device_t *, int);
     59extern uint32_t pci_conf_read_32(device_t *, int);
     60extern void pci_conf_write_8(device_t *, int, uint8_t);
     61extern void pci_conf_write_16(device_t *, int, uint16_t);
     62extern void pci_conf_write_32(device_t *, int, uint32_t);
    6463
    65 void pci_add_range(device_t *dev, uint64_t range_addr, size_t range_size, bool io);
    66 int pci_read_bar(device_t *dev, int addr);
    67 void pci_read_interrupt(device_t *dev);
    68 void pci_add_interrupt(device_t *dev, int irq);
     64extern void pci_add_range(device_t *, uint64_t, size_t, bool);
     65extern int pci_read_bar(device_t *, int);
     66extern void pci_read_interrupt(device_t *);
     67extern void pci_add_interrupt(device_t *, int);
    6968
    70 void pci_bus_scan(device_t *parent, int bus_num);
     69extern void pci_bus_scan(device_t *, int);
    7170
    72 
    73 static inline pci_dev_data_t *create_pci_dev_data()
     71static inline pci_dev_data_t *create_pci_dev_data(void)
    7472{
    75         pci_dev_data_t *res = (pci_dev_data_t *)malloc(sizeof(pci_dev_data_t));
    76         if (NULL != res) {
     73        pci_dev_data_t *res = (pci_dev_data_t *) malloc(sizeof(pci_dev_data_t));
     74       
     75        if (NULL != res)
    7776                memset(res, 0, sizeof(pci_dev_data_t));
    78         }
    79         return res;     
     77        return res;
    8078}
    8179
    82 static inline void init_pci_dev_data(pci_dev_data_t *d, int bus, int dev, int fn)
     80static inline void
     81init_pci_dev_data(pci_dev_data_t *d, int bus, int dev, int fn)
    8382{
    8483        d->bus = bus;
    8584        d->dev = dev;
    86         d->fn = fn;     
     85        d->fn = fn;
    8786}
    8887
    89 static inline void delete_pci_dev_data(pci_dev_data_t *d) 
     88static inline void delete_pci_dev_data(pci_dev_data_t *d)
    9089{
    9190        if (NULL != d) {
    9291                clean_hw_resource_list(&d->hw_resources);
    93                 free(d);       
     92                free(d);
    9493        }
    9594}
     
    9796static inline void create_pci_dev_name(device_t *dev)
    9897{
    99         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
     98        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
    10099        char *name = NULL;
    101         asprintf(&name, "%02x:%02x.%01x", dev_data->bus, dev_data->dev, dev_data->fn);
     100       
     101        asprintf(&name, "%02x:%02x.%01x", dev_data->bus, dev_data->dev,
     102            dev_data->fn);
    102103        dev->name = name;
    103104}
     
    106107{
    107108        pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
    108         dev_data->hw_resources.resources = (hw_resource_t *)malloc(PCI_MAX_HW_RES * sizeof(hw_resource_t));
    109         return dev_data->hw_resources.resources != NULL;       
     109       
     110        dev_data->hw_resources.resources =
     111            (hw_resource_t *) malloc(PCI_MAX_HW_RES * sizeof(hw_resource_t));
     112        return dev_data->hw_resources.resources != NULL;
    110113}
    111114
    112115static inline void pci_clean_resource_list(device_t *dev)
    113116{
    114         pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data;
     117        pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data;
     118       
    115119        if (NULL != dev_data->hw_resources.resources) {
    116120                free(dev_data->hw_resources.resources);
     
    119123}
    120124
    121 /** Read the base address registers (BARs) of the device
    122  *  and adds the addresses to its hw resource list.
    123  * 
     125/** Read the base address registers (BARs) of the device and adds the addresses
     126 * to its hw resource list.
     127 *
    124128 * @param dev the pci device.
    125129 */
    126130static inline  void pci_read_bars(device_t *dev)
    127131{
    128         // position of the BAR in the PCI configuration address space of the device
     132        /*
     133         * Position of the BAR in the PCI configuration address space of the
     134         * device.
     135         */
    129136        int addr = PCI_BASE_ADDR_0;
    130137       
    131         while (addr <= PCI_BASE_ADDR_5) {
    132                 addr = pci_read_bar(dev, addr);
    133         }       
     138        while (addr <= PCI_BASE_ADDR_5)
     139                addr = pci_read_bar(dev, addr);
    134140}
    135141
     
    139145}
    140146
    141 
    142147#endif
    143 
    144148
    145149/**
  • uspace/drv/pciintel/pci_regs.h

    r49698fa r663f41c4  
    11/*
    2  * Copyright (c) 2010 Lenka Trochtova 
     2 * Copyright (c) 2010 Lenka Trochtova
    33 * All rights reserved.
    44 *
     
    3232/** @file
    3333 */
    34  
    35 #ifndef PCI_REGS_H
    36 #define PCI_REGS_H
    3734
    38 // Header types
    39 #define PCI_HEADER_TYPE_DEV                     0
    40 #define PCI_HEADER_TYPE_BRIDGE          1
    41 #define PCI_HEADER_TYPE_CARDBUS         2
     35#ifndef PCI_REGS_H_
     36#define PCI_REGS_H_
    4237
    43 // Header type 0 and 1
    44 #define PCI_VENDOR_ID                                   0x00
    45 #define PCI_DEVICE_ID                                   0x02
    46 #define PCI_COMMAND                                     0x04
    47 #define PCI_STATUS                                              0x06
    48 #define PCI_REVISION_ID                                 0x08
    49 #define PCI_PROG_IF                                             0x09
    50 #define PCI_SUB_CLASS                                   0x0A
    51 #define PCI_BASE_CLASS                                  0x0B
    52 #define PCI_CACHE_LINE_SIZE                             0x0C
    53 #define PCI_LATENCY_TIMER                               0x0D
    54 #define PCI_HEADER_TYPE                                 0x0E
    55 #define PCI_BIST                                                0x0F
     38/* Header types */
     39#define PCI_HEADER_TYPE_DEV     0
     40#define PCI_HEADER_TYPE_BRIDGE  1
     41#define PCI_HEADER_TYPE_CARDBUS 2
    5642
    57 #define PCI_BASE_ADDR_0                                 0x10
    58 #define PCI_BASE_ADDR_1                                 0x14
     43/* Header type 0 and 1 */
     44#define PCI_VENDOR_ID           0x00
     45#define PCI_DEVICE_ID           0x02
     46#define PCI_COMMAND             0x04
     47#define PCI_STATUS              0x06
     48#define PCI_REVISION_ID         0x08
     49#define PCI_PROG_IF             0x09
     50#define PCI_SUB_CLASS           0x0A
     51#define PCI_BASE_CLASS          0x0B
     52#define PCI_CACHE_LINE_SIZE     0x0C
     53#define PCI_LATENCY_TIMER       0x0D
     54#define PCI_HEADER_TYPE         0x0E
     55#define PCI_BIST                0x0F
    5956
    60 // Header type 0
    61 #define PCI_BASE_ADDR_2                                 0x18
    62 #define PCI_BASE_ADDR_3                                 0x1B
    63 #define PCI_BASE_ADDR_4                                 0x20
    64 #define PCI_BASE_ADDR_5                                 0x24
     57#define PCI_BASE_ADDR_0         0x10
     58#define PCI_BASE_ADDR_1         0x14
    6559
    66 #define PCI_CARDBUS_CIS_PTR                             0x28
    67 #define PCI_SUBSYSTEM_VENDOR_ID                 0x2C
    68 #define PCI_SUBSYSTEM_ID                                0x2E
    69 #define PCI_EXP_ROM_BASE                                0x30
    70 #define PCI_CAP_PTR                                             0x34
    71 #define PCI_INT_LINE                                    0x3C
    72 #define PCI_INT_PIN                                             0x3D
    73 #define PCI_MIN_GNT                                             0x3E
    74 #define PCI_MAX_LAT                                             0x3F
     60/* Header type 0 */
     61#define PCI_BASE_ADDR_2                 0x18
     62#define PCI_BASE_ADDR_3                 0x1B
     63#define PCI_BASE_ADDR_4                 0x20
     64#define PCI_BASE_ADDR_5                 0x24
    7565
    76 // Header type 1
    77 #define PCI_BRIDGE_PRIM_BUS_NUM                 0x18
    78 #define PCI_BRIDGE_SEC_BUS_NUM                  0x19
    79 #define PCI_BRIDGE_SUBORD_BUS_NUM               0x1A
    80 #define PCI_BRIDGE_SEC_LATENCY_TIMER    0x1B
    81 #define PCI_BRIDGE_IO_BASE                              0x1C
    82 #define PCI_BRIDGE_IO_LIMIT                     0x1D
    83 #define PCI_BRIDGE_SEC_STATUS                   0x1E
    84 #define PCI_BRIDGE_MEMORY_BASE                  0x20
    85 #define PCI_BRIDGE_MEMORY_LIMIT                 0x22
    86 #define PCI_BRIDGE_PREF_MEMORY_BASE             0x24
     66#define PCI_CARDBUS_CIS_PTR             0x28
     67#define PCI_SUBSYSTEM_VENDOR_ID         0x2C
     68#define PCI_SUBSYSTEM_ID                0x2E
     69#define PCI_EXP_ROM_BASE                0x30
     70#define PCI_CAP_PTR                     0x34
     71#define PCI_INT_LINE                    0x3C
     72#define PCI_INT_PIN                     0x3D
     73#define PCI_MIN_GNT                     0x3E
     74#define PCI_MAX_LAT                     0x3F
     75
     76/* Header type 1 */
     77#define PCI_BRIDGE_PRIM_BUS_NUM         0x18
     78#define PCI_BRIDGE_SEC_BUS_NUM          0x19
     79#define PCI_BRIDGE_SUBORD_BUS_NUM       0x1A
     80#define PCI_BRIDGE_SEC_LATENCY_TIMER    0x1B
     81#define PCI_BRIDGE_IO_BASE              0x1C
     82#define PCI_BRIDGE_IO_LIMIT             0x1D
     83#define PCI_BRIDGE_SEC_STATUS           0x1E
     84#define PCI_BRIDGE_MEMORY_BASE          0x20
     85#define PCI_BRIDGE_MEMORY_LIMIT         0x22
     86#define PCI_BRIDGE_PREF_MEMORY_BASE     0x24
    8787#define PCI_BRIDGE_PREF_MEMORY_LIMIT    0x26
    8888#define PCI_BRIDGE_PREF_MEMORY_BASE_UP  0x28
    8989#define PCI_BRIDGE_PREF_MEMORY_LIMIT_UP 0x2C
    90 #define PCI_BRIDGE_IO_BASE_UP                   0x30
    91 #define PCI_BRIDGE_IO_LIMIT_UP                  0x32
    92 #define PCI_BRIDGE_EXP_ROM_BASE                 0x38
    93 #define PCI_BRIDGE_INT_LINE                             0x3C
    94 #define PCI_BRIDGE_INT_PIN                              0x3D
    95 #define PCI_BRIDGE_CTL                                  0x3E
     90#define PCI_BRIDGE_IO_BASE_UP           0x30
     91#define PCI_BRIDGE_IO_LIMIT_UP          0x32
     92#define PCI_BRIDGE_EXP_ROM_BASE         0x38
     93#define PCI_BRIDGE_INT_LINE             0x3C
     94#define PCI_BRIDGE_INT_PIN              0x3D
     95#define PCI_BRIDGE_CTL                  0x3E
    9696
    9797#endif
    98 
    9998
    10099/**
Note: See TracChangeset for help on using the changeset viewer.