Changes in uspace/drv/pciintel/pci.c [fb78ae72:af6b5157] in mainline
- File:
-
- 1 edited
-
uspace/drv/pciintel/pci.c (modified) (18 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/drv/pciintel/pci.c
rfb78ae72 raf6b5157 1 1 /* 2 2 * Copyright (c) 2010 Lenka Trochtova 3 * Copyright (c) 2011 Jiri Svoboda 3 4 * All rights reserved. 4 5 * … … 44 45 #include <ctype.h> 45 46 #include <macros.h> 46 47 #include <driver.h> 47 #include <str_error.h> 48 49 #include <ddf/driver.h> 48 50 #include <devman.h> 49 51 #include <ipc/devman.h> 50 52 #include <ipc/dev_iface.h> 51 #include <ipc/irc.h>52 #include <ipc/ns.h>53 #include <ipc/services.h>54 #include <sysinfo.h>55 53 #include <ops/hw_res.h> 56 54 #include <device/hw_res.h> … … 65 63 ((1 << 31) | (bus << 16) | (dev << 11) | (fn << 8) | (reg & ~3)) 66 64 67 static hw_resource_list_t *pciintel_get_child_resources(device_t *dev) 68 { 69 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 70 71 if (dev_data == NULL) 65 /** Obtain PCI function soft-state from DDF function node */ 66 #define PCI_FUN(fnode) ((pci_fun_t *) (fnode)->driver_data) 67 68 /** Obtain PCI bus soft-state from DDF device node */ 69 #define PCI_BUS(dnode) ((pci_bus_t *) (dnode)->driver_data) 70 71 /** Obtain PCI bus soft-state from function soft-state */ 72 #define PCI_BUS_FROM_FUN(fun) ((fun)->busptr) 73 74 static hw_resource_list_t *pciintel_get_resources(ddf_fun_t *fnode) 75 { 76 pci_fun_t *fun = PCI_FUN(fnode); 77 78 if (fun == NULL) 72 79 return NULL; 73 return &dev_data->hw_resources; 74 } 75 76 static bool pciintel_enable_child_interrupt(device_t *dev) 77 { 78 /* This is an old ugly way, copied from ne2000 driver */ 79 assert(dev); 80 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 81 82 sysarg_t apic; 83 sysarg_t i8259; 84 int irc_phone = -1; 85 int irc_service = 0; 86 87 if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) { 88 irc_service = SERVICE_APIC; 89 } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) { 90 irc_service = SERVICE_I8259; 91 } 92 93 if (irc_service) { 94 while (irc_phone < 0) 95 irc_phone = service_connect_blocking(irc_service, 0, 0); 96 } else { 97 return false; 98 } 99 100 size_t i; 101 for (i = 0; i < dev_data->hw_resources.count; i++) { 102 if (dev_data->hw_resources.resources[i].type == INTERRUPT) { 103 int irq = dev_data->hw_resources.resources[i].res.interrupt.irq; 104 async_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, irq); 105 } 106 } 107 108 async_hangup(irc_phone); 109 return true; 110 } 111 112 static hw_res_ops_t pciintel_child_hw_res_ops = { 113 &pciintel_get_child_resources, 114 &pciintel_enable_child_interrupt 80 return &fun->hw_resources; 81 } 82 83 static bool pciintel_enable_interrupt(ddf_fun_t *fnode) 84 { 85 /* TODO */ 86 87 return false; 88 } 89 90 static hw_res_ops_t pciintel_hw_res_ops = { 91 &pciintel_get_resources, 92 &pciintel_enable_interrupt 115 93 }; 116 94 117 static d evice_ops_t pci_child_ops;118 119 static int pci_add_device(d evice_t *);120 121 /** The pci bus driver's standard operations.*/95 static ddf_dev_ops_t pci_fun_ops; 96 97 static int pci_add_device(ddf_dev_t *); 98 99 /** PCI bus driver standard operations */ 122 100 static driver_ops_t pci_ops = { 123 101 .add_device = &pci_add_device 124 102 }; 125 103 126 /** The pci bus driver structure.*/104 /** PCI bus driver structure */ 127 105 static driver_t pci_driver = { 128 106 .name = NAME, … … 130 108 }; 131 109 132 typedef struct pciintel_bus_data { 133 uint32_t conf_io_addr; 134 void *conf_data_port; 135 void *conf_addr_port; 136 fibril_mutex_t conf_mutex; 137 } pci_bus_data_t; 138 139 static pci_bus_data_t *create_pci_bus_data(void) 140 { 141 pci_bus_data_t *bus_data; 142 143 bus_data = (pci_bus_data_t *) malloc(sizeof(pci_bus_data_t)); 144 if (bus_data != NULL) { 145 memset(bus_data, 0, sizeof(pci_bus_data_t)); 146 fibril_mutex_initialize(&bus_data->conf_mutex); 147 } 148 149 return bus_data; 150 } 151 152 static void delete_pci_bus_data(pci_bus_data_t *bus_data) 153 { 154 free(bus_data); 155 } 156 157 static void pci_conf_read(device_t *dev, int reg, uint8_t *buf, size_t len) 158 { 159 assert(dev->parent != NULL); 160 161 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 162 pci_bus_data_t *bus_data = (pci_bus_data_t *) dev->parent->driver_data; 163 164 fibril_mutex_lock(&bus_data->conf_mutex); 110 static pci_bus_t *pci_bus_new(void) 111 { 112 pci_bus_t *bus; 113 114 bus = (pci_bus_t *) calloc(1, sizeof(pci_bus_t)); 115 if (bus == NULL) 116 return NULL; 117 118 fibril_mutex_initialize(&bus->conf_mutex); 119 return bus; 120 } 121 122 static void pci_bus_delete(pci_bus_t *bus) 123 { 124 assert(bus != NULL); 125 free(bus); 126 } 127 128 static void pci_conf_read(pci_fun_t *fun, int reg, uint8_t *buf, size_t len) 129 { 130 pci_bus_t *bus = PCI_BUS_FROM_FUN(fun); 131 132 fibril_mutex_lock(&bus->conf_mutex); 165 133 166 134 uint32_t conf_addr; 167 conf_addr = CONF_ADDR( dev_data->bus, dev_data->dev, dev_data->fn, reg);168 void *addr = bus _data->conf_data_port + (reg & 3);169 170 pio_write_32(bus _data->conf_addr_port, conf_addr);135 conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg); 136 void *addr = bus->conf_data_port + (reg & 3); 137 138 pio_write_32(bus->conf_addr_port, conf_addr); 171 139 172 140 switch (len) { … … 182 150 } 183 151 184 fibril_mutex_unlock(&bus_data->conf_mutex); 185 } 186 187 static void pci_conf_write(device_t *dev, int reg, uint8_t *buf, size_t len) 188 { 189 assert(dev->parent != NULL); 190 191 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 192 pci_bus_data_t *bus_data = (pci_bus_data_t *) dev->parent->driver_data; 193 194 fibril_mutex_lock(&bus_data->conf_mutex); 152 fibril_mutex_unlock(&bus->conf_mutex); 153 } 154 155 static void pci_conf_write(pci_fun_t *fun, int reg, uint8_t *buf, size_t len) 156 { 157 pci_bus_t *bus = PCI_BUS_FROM_FUN(fun); 158 159 fibril_mutex_lock(&bus->conf_mutex); 195 160 196 161 uint32_t conf_addr; 197 conf_addr = CONF_ADDR( dev_data->bus, dev_data->dev, dev_data->fn, reg);198 void *addr = bus _data->conf_data_port + (reg & 3);199 200 pio_write_32(bus _data->conf_addr_port, conf_addr);162 conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg); 163 void *addr = bus->conf_data_port + (reg & 3); 164 165 pio_write_32(bus->conf_addr_port, conf_addr); 201 166 202 167 switch (len) { … … 212 177 } 213 178 214 fibril_mutex_unlock(&bus _data->conf_mutex);215 } 216 217 uint8_t pci_conf_read_8( device_t *dev, int reg)179 fibril_mutex_unlock(&bus->conf_mutex); 180 } 181 182 uint8_t pci_conf_read_8(pci_fun_t *fun, int reg) 218 183 { 219 184 uint8_t res; 220 pci_conf_read( dev, reg, &res, 1);185 pci_conf_read(fun, reg, &res, 1); 221 186 return res; 222 187 } 223 188 224 uint16_t pci_conf_read_16( device_t *dev, int reg)189 uint16_t pci_conf_read_16(pci_fun_t *fun, int reg) 225 190 { 226 191 uint16_t res; 227 pci_conf_read( dev, reg, (uint8_t *) &res, 2);192 pci_conf_read(fun, reg, (uint8_t *) &res, 2); 228 193 return res; 229 194 } 230 195 231 uint32_t pci_conf_read_32( device_t *dev, int reg)196 uint32_t pci_conf_read_32(pci_fun_t *fun, int reg) 232 197 { 233 198 uint32_t res; 234 pci_conf_read( dev, reg, (uint8_t *) &res, 4);199 pci_conf_read(fun, reg, (uint8_t *) &res, 4); 235 200 return res; 236 201 } 237 202 238 void pci_conf_write_8(device_t *dev, int reg, uint8_t val) 239 { 240 pci_conf_write(dev, reg, (uint8_t *) &val, 1); 241 } 242 243 void pci_conf_write_16(device_t *dev, int reg, uint16_t val) 244 { 245 pci_conf_write(dev, reg, (uint8_t *) &val, 2); 246 } 247 248 void pci_conf_write_32(device_t *dev, int reg, uint32_t val) 249 { 250 pci_conf_write(dev, reg, (uint8_t *) &val, 4); 251 } 252 253 void create_pci_match_ids(device_t *dev) 254 { 255 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 256 match_id_t *match_id = NULL; 203 void pci_conf_write_8(pci_fun_t *fun, int reg, uint8_t val) 204 { 205 pci_conf_write(fun, reg, (uint8_t *) &val, 1); 206 } 207 208 void pci_conf_write_16(pci_fun_t *fun, int reg, uint16_t val) 209 { 210 pci_conf_write(fun, reg, (uint8_t *) &val, 2); 211 } 212 213 void pci_conf_write_32(pci_fun_t *fun, int reg, uint32_t val) 214 { 215 pci_conf_write(fun, reg, (uint8_t *) &val, 4); 216 } 217 218 void pci_fun_create_match_ids(pci_fun_t *fun) 219 { 257 220 char *match_id_str; 258 259 match_id = create_match_id(); 260 if (match_id != NULL) { 261 asprintf(&match_id_str, "pci/ven=%04x&dev=%04x", 262 dev_data->vendor_id, dev_data->device_id); 263 match_id->id = match_id_str; 264 match_id->score = 90; 265 add_match_id(&dev->match_ids, match_id); 266 } 267 221 int rc; 222 223 asprintf(&match_id_str, "pci/ven=%04x&dev=%04x", 224 fun->vendor_id, fun->device_id); 225 226 if (match_id_str == NULL) { 227 printf(NAME ": out of memory creating match ID.\n"); 228 return; 229 } 230 231 rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90); 232 if (rc != EOK) { 233 printf(NAME ": error adding match ID: %s\n", 234 str_error(rc)); 235 } 236 268 237 /* TODO add more ids (with subsys ids, using class id etc.) */ 269 238 } 270 239 271 void 272 pci_add_range(device_t *dev, uint64_t range_addr, size_t range_size, bool io) 273 { 274 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 275 hw_resource_list_t *hw_res_list = &dev_data->hw_resources; 240 void pci_add_range(pci_fun_t *fun, uint64_t range_addr, size_t range_size, 241 bool io) 242 { 243 hw_resource_list_t *hw_res_list = &fun->hw_resources; 276 244 hw_resource_t *hw_resources = hw_res_list->resources; 277 245 size_t count = hw_res_list->count; … … 298 266 * address add it to the devices hw resource list. 299 267 * 300 * @param dev The pci device.268 * @param fun PCI function 301 269 * @param addr The address of the BAR in the PCI configuration address space of 302 * the device .303 * @return The addr the address of the BAR which should be read next .270 * the device 271 * @return The addr the address of the BAR which should be read next 304 272 */ 305 int pci_read_bar( device_t *dev, int addr)306 { 273 int pci_read_bar(pci_fun_t *fun, int addr) 274 { 307 275 /* Value of the BAR */ 308 276 uint32_t val, mask; … … 318 286 319 287 /* Get the value of the BAR. */ 320 val = pci_conf_read_32( dev, addr);288 val = pci_conf_read_32(fun, addr); 321 289 322 290 io = (bool) (val & 1); … … 338 306 339 307 /* Get the address mask. */ 340 pci_conf_write_32( dev, addr, 0xffffffff);341 mask = pci_conf_read_32( dev, addr);308 pci_conf_write_32(fun, addr, 0xffffffff); 309 mask = pci_conf_read_32(fun, addr); 342 310 343 311 /* Restore the original value. */ 344 pci_conf_write_32( dev, addr, val);345 val = pci_conf_read_32( dev, addr);312 pci_conf_write_32(fun, addr, val); 313 val = pci_conf_read_32(fun, addr); 346 314 347 315 range_size = pci_bar_mask_to_size(mask); 348 316 349 317 if (addrw64) { 350 range_addr = ((uint64_t)pci_conf_read_32( dev, addr + 4) << 32) |318 range_addr = ((uint64_t)pci_conf_read_32(fun, addr + 4) << 32) | 351 319 (val & 0xfffffff0); 352 320 } else { … … 355 323 356 324 if (range_addr != 0) { 357 printf(NAME ": device %s : ", dev->name);325 printf(NAME ": function %s : ", fun->fnode->name); 358 326 printf("address = %" PRIx64, range_addr); 359 327 printf(", size = %x\n", (unsigned int) range_size); 360 328 } 361 329 362 pci_add_range( dev, range_addr, range_size, io);330 pci_add_range(fun, range_addr, range_size, io); 363 331 364 332 if (addrw64) … … 368 336 } 369 337 370 void pci_add_interrupt(device_t *dev, int irq) 371 { 372 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 373 hw_resource_list_t *hw_res_list = &dev_data->hw_resources; 338 void pci_add_interrupt(pci_fun_t *fun, int irq) 339 { 340 hw_resource_list_t *hw_res_list = &fun->hw_resources; 374 341 hw_resource_t *hw_resources = hw_res_list->resources; 375 342 size_t count = hw_res_list->count; … … 383 350 hw_res_list->count++; 384 351 385 printf(NAME ": device %s uses irq %x.\n", dev->name, irq);386 } 387 388 void pci_read_interrupt( device_t *dev)389 { 390 uint8_t irq = pci_conf_read_8( dev, PCI_BRIDGE_INT_LINE);352 printf(NAME ": function %s uses irq %x.\n", fun->fnode->name, irq); 353 } 354 355 void pci_read_interrupt(pci_fun_t *fun) 356 { 357 uint8_t irq = pci_conf_read_8(fun, PCI_BRIDGE_INT_LINE); 391 358 if (irq != 0xff) 392 pci_add_interrupt( dev, irq);359 pci_add_interrupt(fun, irq); 393 360 } 394 361 395 362 /** Enumerate (recursively) and register the devices connected to a pci bus. 396 363 * 397 * @param parent The host-to-pci bridge device.398 * @param bus_num The bus number.364 * @param bus Host-to-PCI bridge 365 * @param bus_num Bus number 399 366 */ 400 void pci_bus_scan(device_t *parent, int bus_num) 401 { 402 device_t *dev = create_device(); 403 pci_dev_data_t *dev_data = create_pci_dev_data(); 404 dev->driver_data = dev_data; 405 dev->parent = parent; 367 void pci_bus_scan(pci_bus_t *bus, int bus_num) 368 { 369 ddf_fun_t *fnode; 370 pci_fun_t *fun; 406 371 407 372 int child_bus = 0; 408 373 int dnum, fnum; 409 374 bool multi; 410 uint8_t header_type; 375 uint8_t header_type; 376 377 fun = pci_fun_new(bus); 411 378 412 379 for (dnum = 0; dnum < 32; dnum++) { 413 380 multi = true; 414 381 for (fnum = 0; multi && fnum < 8; fnum++) { 415 init_pci_dev_data(dev_data, bus_num, dnum, fnum);416 dev_data->vendor_id = pci_conf_read_16(dev,382 pci_fun_init(fun, bus_num, dnum, fnum); 383 fun->vendor_id = pci_conf_read_16(fun, 417 384 PCI_VENDOR_ID); 418 dev_data->device_id = pci_conf_read_16(dev,385 fun->device_id = pci_conf_read_16(fun, 419 386 PCI_DEVICE_ID); 420 if ( dev_data->vendor_id == 0xffff) {387 if (fun->vendor_id == 0xffff) { 421 388 /* 422 389 * The device is not present, go on scanning the … … 429 396 } 430 397 431 header_type = pci_conf_read_8( dev, PCI_HEADER_TYPE);398 header_type = pci_conf_read_8(fun, PCI_HEADER_TYPE); 432 399 if (fnum == 0) { 433 400 /* Is the device multifunction? */ … … 437 404 header_type = header_type & 0x7F; 438 405 439 create_pci_dev_name(dev); 440 441 pci_alloc_resource_list(dev); 442 pci_read_bars(dev); 443 pci_read_interrupt(dev); 444 445 dev->ops = &pci_child_ops; 446 447 printf(NAME ": adding new child device %s.\n", 448 dev->name); 449 450 create_pci_match_ids(dev); 451 452 if (child_device_register(dev, parent) != EOK) { 453 pci_clean_resource_list(dev); 454 clean_match_ids(&dev->match_ids); 455 free((char *) dev->name); 456 dev->name = NULL; 406 char *fun_name = pci_fun_create_name(fun); 407 if (fun_name == NULL) { 408 printf(NAME ": out of memory.\n"); 409 return; 410 } 411 412 fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name); 413 if (fnode == NULL) { 414 printf(NAME ": error creating function.\n"); 415 return; 416 } 417 418 free(fun_name); 419 fun->fnode = fnode; 420 421 pci_alloc_resource_list(fun); 422 pci_read_bars(fun); 423 pci_read_interrupt(fun); 424 425 fnode->ops = &pci_fun_ops; 426 fnode->driver_data = fun; 427 428 printf(NAME ": adding new function %s.\n", 429 fnode->name); 430 431 pci_fun_create_match_ids(fun); 432 433 if (ddf_fun_bind(fnode) != EOK) { 434 pci_clean_resource_list(fun); 435 clean_match_ids(&fnode->match_ids); 436 free((char *) fnode->name); 437 fnode->name = NULL; 457 438 continue; 458 439 } … … 460 441 if (header_type == PCI_HEADER_TYPE_BRIDGE || 461 442 header_type == PCI_HEADER_TYPE_CARDBUS) { 462 child_bus = pci_conf_read_8( dev,443 child_bus = pci_conf_read_8(fun, 463 444 PCI_BRIDGE_SEC_BUS_NUM); 464 445 printf(NAME ": device is pci-to-pci bridge, " 465 446 "secondary bus number = %d.\n", bus_num); 466 447 if (child_bus > bus_num) 467 pci_bus_scan( parent, child_bus);448 pci_bus_scan(bus, child_bus); 468 449 } 469 450 470 /* Alloc new aux. dev. structure. */ 471 dev = create_device(); 472 dev_data = create_pci_dev_data(); 473 dev->driver_data = dev_data; 474 dev->parent = parent; 451 fun = pci_fun_new(bus); 475 452 } 476 453 } 477 454 478 if (dev_data->vendor_id == 0xffff) { 479 delete_device(dev); 480 /* Free the auxiliary device structure. */ 481 delete_pci_dev_data(dev_data); 482 } 483 } 484 485 static int pci_add_device(device_t *dev) 486 { 455 if (fun->vendor_id == 0xffff) { 456 /* Free the auxiliary function structure. */ 457 pci_fun_delete(fun); 458 } 459 } 460 461 static int pci_add_device(ddf_dev_t *dnode) 462 { 463 pci_bus_t *bus = NULL; 464 ddf_fun_t *ctl = NULL; 465 bool got_res = false; 487 466 int rc; 488 467 489 468 printf(NAME ": pci_add_device\n"); 490 491 pci_bus_data_t *bus_data = create_pci_bus_data(); 492 if (bus_data == NULL) { 469 dnode->parent_phone = -1; 470 471 bus = pci_bus_new(); 472 if (bus == NULL) { 493 473 printf(NAME ": pci_add_device allocation failed.\n"); 494 return ENOMEM; 495 } 496 497 dev->parent_phone = devman_parent_device_connect(dev->handle, 474 rc = ENOMEM; 475 goto fail; 476 } 477 bus->dnode = dnode; 478 dnode->driver_data = bus; 479 480 dnode->parent_phone = devman_parent_device_connect(dnode->handle, 498 481 IPC_FLAG_BLOCKING); 499 if (d ev->parent_phone < 0) {482 if (dnode->parent_phone < 0) { 500 483 printf(NAME ": pci_add_device failed to connect to the " 501 484 "parent's driver.\n"); 502 delete_pci_bus_data(bus_data);503 return dev->parent_phone;485 rc = dnode->parent_phone; 486 goto fail; 504 487 } 505 488 506 489 hw_resource_list_t hw_resources; 507 490 508 rc = hw_res_get_resource_list(d ev->parent_phone, &hw_resources);491 rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources); 509 492 if (rc != EOK) { 510 493 printf(NAME ": pci_add_device failed to get hw resources for " 511 494 "the device.\n"); 512 delete_pci_bus_data(bus_data); 513 async_hangup(dev->parent_phone); 514 return rc; 515 } 495 goto fail; 496 } 497 got_res = true; 516 498 517 499 printf(NAME ": conf_addr = %" PRIx64 ".\n", … … 522 504 assert(hw_resources.resources[0].res.io_range.size == 8); 523 505 524 bus _data->conf_io_addr =506 bus->conf_io_addr = 525 507 (uint32_t) hw_resources.resources[0].res.io_range.address; 526 508 527 if (pio_enable((void *)(uintptr_t)bus _data->conf_io_addr, 8,528 &bus _data->conf_addr_port)) {509 if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8, 510 &bus->conf_addr_port)) { 529 511 printf(NAME ": failed to enable configuration ports.\n"); 530 delete_pci_bus_data(bus_data); 531 async_hangup(dev->parent_phone); 512 rc = EADDRNOTAVAIL; 513 goto fail; 514 } 515 bus->conf_data_port = (char *) bus->conf_addr_port + 4; 516 517 /* Make the bus device more visible. It has no use yet. */ 518 printf(NAME ": adding a 'ctl' function\n"); 519 520 ctl = ddf_fun_create(bus->dnode, fun_exposed, "ctl"); 521 if (ctl == NULL) { 522 printf(NAME ": error creating control function.\n"); 523 rc = ENOMEM; 524 goto fail; 525 } 526 527 rc = ddf_fun_bind(ctl); 528 if (rc != EOK) { 529 printf(NAME ": error binding control function.\n"); 530 goto fail; 531 } 532 533 /* Enumerate functions. */ 534 printf(NAME ": scanning the bus\n"); 535 pci_bus_scan(bus, 0); 536 537 hw_res_clean_resource_list(&hw_resources); 538 539 return EOK; 540 541 fail: 542 if (bus != NULL) 543 pci_bus_delete(bus); 544 if (dnode->parent_phone >= 0) 545 async_hangup(dnode->parent_phone); 546 if (got_res) 532 547 hw_res_clean_resource_list(&hw_resources); 533 return EADDRNOTAVAIL; 534 } 535 bus_data->conf_data_port = (char *) bus_data->conf_addr_port + 4; 536 537 dev->driver_data = bus_data; 538 539 /* Enumerate child devices. */ 540 printf(NAME ": scanning the bus\n"); 541 pci_bus_scan(dev, 0); 542 543 hw_res_clean_resource_list(&hw_resources); 544 545 return EOK; 548 if (ctl != NULL) 549 ddf_fun_destroy(ctl); 550 551 return rc; 546 552 } 547 553 548 554 static void pciintel_init(void) 549 555 { 550 pci_child_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_child_hw_res_ops; 551 } 552 553 pci_dev_data_t *create_pci_dev_data(void) 554 { 555 pci_dev_data_t *res = (pci_dev_data_t *) malloc(sizeof(pci_dev_data_t)); 556 557 if (res != NULL) 558 memset(res, 0, sizeof(pci_dev_data_t)); 559 return res; 560 } 561 562 void init_pci_dev_data(pci_dev_data_t *dev_data, int bus, int dev, int fn) 563 { 564 dev_data->bus = bus; 565 dev_data->dev = dev; 566 dev_data->fn = fn; 567 } 568 569 void delete_pci_dev_data(pci_dev_data_t *dev_data) 570 { 571 if (dev_data != NULL) { 572 hw_res_clean_resource_list(&dev_data->hw_resources); 573 free(dev_data); 574 } 575 } 576 577 void create_pci_dev_name(device_t *dev) 578 { 579 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 556 pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops; 557 } 558 559 pci_fun_t *pci_fun_new(pci_bus_t *bus) 560 { 561 pci_fun_t *fun; 562 563 fun = (pci_fun_t *) calloc(1, sizeof(pci_fun_t)); 564 if (fun == NULL) 565 return NULL; 566 567 fun->busptr = bus; 568 return fun; 569 } 570 571 void pci_fun_init(pci_fun_t *fun, int bus, int dev, int fn) 572 { 573 fun->bus = bus; 574 fun->dev = dev; 575 fun->fn = fn; 576 } 577 578 void pci_fun_delete(pci_fun_t *fun) 579 { 580 assert(fun != NULL); 581 hw_res_clean_resource_list(&fun->hw_resources); 582 free(fun); 583 } 584 585 char *pci_fun_create_name(pci_fun_t *fun) 586 { 580 587 char *name = NULL; 581 588 582 asprintf(&name, "%02x:%02x.%01x", dev_data->bus, dev_data->dev, 583 dev_data->fn); 584 dev->name = name; 585 } 586 587 bool pci_alloc_resource_list(device_t *dev) 588 { 589 pci_dev_data_t *dev_data = (pci_dev_data_t *)dev->driver_data; 590 591 dev_data->hw_resources.resources = 589 asprintf(&name, "%02x:%02x.%01x", fun->bus, fun->dev, 590 fun->fn); 591 return name; 592 } 593 594 bool pci_alloc_resource_list(pci_fun_t *fun) 595 { 596 fun->hw_resources.resources = 592 597 (hw_resource_t *) malloc(PCI_MAX_HW_RES * sizeof(hw_resource_t)); 593 return dev_data->hw_resources.resources != NULL; 594 } 595 596 void pci_clean_resource_list(device_t *dev) 597 { 598 pci_dev_data_t *dev_data = (pci_dev_data_t *) dev->driver_data; 599 600 if (dev_data->hw_resources.resources != NULL) { 601 free(dev_data->hw_resources.resources); 602 dev_data->hw_resources.resources = NULL; 603 } 604 } 605 606 /** Read the base address registers (BARs) of the device and adds the addresses 607 * to its hw resource list. 598 return fun->hw_resources.resources != NULL; 599 } 600 601 void pci_clean_resource_list(pci_fun_t *fun) 602 { 603 if (fun->hw_resources.resources != NULL) { 604 free(fun->hw_resources.resources); 605 fun->hw_resources.resources = NULL; 606 } 607 } 608 609 /** Read the base address registers (BARs) of the function and add the addresses 610 * to its HW resource list. 608 611 * 609 * @param dev the pci device.612 * @param fun PCI function 610 613 */ 611 void pci_read_bars( device_t *dev)614 void pci_read_bars(pci_fun_t *fun) 612 615 { 613 616 /* … … 618 621 619 622 while (addr <= PCI_BASE_ADDR_5) 620 addr = pci_read_bar( dev, addr);623 addr = pci_read_bar(fun, addr); 621 624 } 622 625 … … 630 633 printf(NAME ": HelenOS pci bus driver (intel method 1).\n"); 631 634 pciintel_init(); 632 return d river_main(&pci_driver);635 return ddf_driver_main(&pci_driver); 633 636 } 634 637
Note:
See TracChangeset
for help on using the changeset viewer.
