git.barrelfish.org Git - barrelfish/blob - usr/pci/pci.c

   1 /**
   2  * \file
   3  * \brief PCI driver
   4  *
   5  *  This file walks through the PCI bus, enumarates each device and gathers
   6  *  informatiom about each device.
   7  */
   8
   9 /*
  10  * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
  11  * All rights reserved.
  12  *
  13  * This file is distributed under the terms in the attached LICENSE file.
  14  * If you do not find this file, copies can be found by writing to:
  15  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20
  21 #include <barrelfish/barrelfish.h>
  22 #include <barrelfish/deferred.h>
  23
  24 #include <pci/devids.h>
  25 #include <mm/mm.h>
  26 #include <skb/skb.h>
  27 #include <octopus/getset.h>
  28 #include <acpi_client/acpi_client.h>
  29 #include <dev/pci_sr_iov_cap_dev.h>
  30
  31 #include "pci.h"
  32 #include "ht_config.h"
  33 #include <dev/ht_config_dev.h>
  34 #include "pci_debug.h"
  35
  36 #define MIN(a,b)        ((a) < (b) ? (a) : (b))
  37
  38 #define BAR_PROBE       0xffffffff
  39
  40 #define PAGE_BITS BASE_PAGE_BITS
  41
  42 struct device_caps
  43 {
  44     struct capref *phys_cap;
  45     struct capref *frame_cap;
  46     size_t nr_caps;
  47     uint8_t bar_nr;
  48     uint8_t bits;
  49     bool assigned;  //false => this entry is not in use
  50     uint8_t type;
  51 };
  52
  53 struct device_caps dev_caps[PCI_NBUSES][PCI_NDEVICES][PCI_NFUNCTIONS][PCI_NBARS];
  54 const char *skb_bridge_program = "bridge_page";
  55 uint16_t max_numvfs = 256;
  56
  57 static void
  58 query_bars(pci_hdr0_t devhdr,
  59            struct pci_address addr,
  60            bool pci2pci_bridge);
  61
  62 static uint32_t
  63 setup_interrupt(uint32_t bus,
  64                 uint32_t dev,
  65                 uint32_t fun);
  66 static void
  67 enable_busmaster(uint8_t bus,
  68                  uint8_t dev,
  69                  uint8_t fun,
  70                  bool pcie);
  71
  72 static uint32_t bar_mapping_size(pci_hdr0_bar32_t bar)
  73 {
  74     if (bar.base == 0) {
  75         return 0;
  76     }
  77
  78     for (uint32_t mask = 1;; mask <<= 1) {
  79         assert(mask != 0);
  80         if (bar.base & mask) {
  81             return mask << 7;
  82         }
  83     }
  84 }
  85
  86 static pciaddr_t bar_mapping_size64(uint64_t base)
  87 {
  88     if (base == 0) {
  89         return 0;
  90     }
  91
  92     for (pciaddr_t mask = 1;; mask <<= 1) {
  93         assert(mask != 0);
  94         if (base & mask) {
  95             /*
  96              * Note: we get the actual raw register content here and not
  97              *       the bar.base value so no shift.
  98              *       - 2014-05-03, RA
  99              */
 100             return mask;
 101         }
 102     }
 103 }
 104
 105 void pci_init_datastructures(void)
 106 {
 107     memset(dev_caps, 0, sizeof(dev_caps));
 108 }
 109
 110 int pci_bar_to_caps_index(uint8_t bus,
 111                           uint8_t dev,
 112                           uint8_t fun,
 113                           uint8_t BAR)
 114 {
 115     uint8_t i;
 116     for (i = 0; i < PCI_NBARS && dev_caps[bus][dev][fun][i].assigned; i++) {
 117         if (dev_caps[bus][dev][fun][i].bar_nr == BAR) {
 118             return i;
 119         }
 120     }
 121     return -1;
 122 }
 123
 124 int pci_get_bar_nr_for_index(uint8_t bus,
 125                             uint8_t dev,
 126                             uint8_t fun,
 127                             uint8_t idx)
 128 {
 129     return (dev_caps[bus][dev][fun][idx].bar_nr);
 130 }
 131
 132 int pci_get_nr_caps_for_bar(uint8_t bus,
 133                             uint8_t dev,
 134                             uint8_t fun,
 135                             uint8_t idx)
 136 {
 137     return (dev_caps[bus][dev][fun][idx].nr_caps);
 138 }
 139
 140 struct capref pci_get_bar_cap_for_device(uint8_t bus,
 141                                      uint8_t dev,
 142                                      uint8_t fun,
 143                                      uint8_t idx,
 144                                      int cap_nr)
 145 {
 146     return (dev_caps[bus][dev][fun][idx].frame_cap[cap_nr]);
 147 }
 148 uint8_t pci_get_bar_cap_type_for_device(uint8_t bus,
 149                                     uint8_t dev,
 150                                     uint8_t fun,
 151                                     uint8_t idx)
 152 {
 153     return (dev_caps[bus][dev][fun][idx].type);
 154 }
 155
 156 static errval_t alloc_device_bar(uint8_t idx,
 157                                  uint8_t bus,
 158                                  uint8_t dev,
 159                                  uint8_t fun,
 160                                  uint8_t BAR,
 161                                  pciaddr_t base,
 162                                  pciaddr_t high,
 163                                  pcisize_t size)
 164 {
 165     struct acpi_rpc_client* acl = get_acpi_rpc_client();
 166
 167     struct device_caps *c = &dev_caps[bus][dev][fun][idx];
 168     errval_t err;
 169
 170     // first try with maximally-sized caps (we'll reduce this if it doesn't work)
 171     uint8_t bits = log2ceil(size);
 172
 173     restart: ;
 174     pcisize_t framesize = 1UL << bits;
 175     c->nr_caps = size / framesize;
 176     PCI_DEBUG("nr caps for one BAR of size %"PRIuPCISIZE": %lu\n", size,
 177               c->nr_caps);
 178
 179     c->phys_cap = malloc(c->nr_caps * sizeof(struct capref));
 180     if (c->phys_cap == NULL) {
 181         return PCI_ERR_MEM_ALLOC;
 182     }
 183
 184     for (int i = 0; i < c->nr_caps; i++) {
 185         /*err = mm_alloc_range(&pci_mm_physaddr, bits, base + i * framesize,
 186          base + (i + 1) * framesize, &c->phys_cap[i], NULL);*/
 187         errval_t error_code;
 188         err = acl->vtbl.mm_alloc_range_proxy(acl, bits, base + i * framesize,
 189                                              base + (i + 1) * framesize,
 190                                              &c->phys_cap[i], &error_code);
 191         assert(err_is_ok(err));
 192         err = error_code;
 193         if (err_is_fail(err)) {
 194             PCI_DEBUG("mm_alloc_range() failed: bits = %hhu, base = %"PRIxPCIADDR","
 195                       " end = %"PRIxPCIADDR"\n", bits, base + i * framesize,
 196                       base + (i + 1) * framesize);
 197             if (err_no(err) == MM_ERR_MISSING_CAPS && bits > PAGE_BITS) {
 198                 /* try again with smaller page-sized caps */
 199                 for (int j = 0; j < i; j++) {
 200                     err = acl->vtbl.mm_free_proxy(acl, c->phys_cap[i],
 201                                                   base + j * framesize, bits,
 202                                                   &error_code);
 203                     assert(err_is_ok(err) && err_is_ok(error_code));
 204                 }
 205
 206                 free(c->phys_cap);
 207                 bits = PAGE_BITS;
 208                 goto restart;
 209             } else {
 210                 return err;
 211             }
 212         }
 213     }
 214
 215     c->frame_cap = malloc(c->nr_caps * sizeof(struct capref));
 216     if (c->frame_cap == NULL) {
 217         /* TODO: mm_free() */
 218         free(c->phys_cap);
 219         return PCI_ERR_MEM_ALLOC;
 220     }
 221
 222     for (int i = 0; i < c->nr_caps; i++) {
 223         err = devframe_type(&c->frame_cap[i], c->phys_cap[i], bits);
 224         if (err_is_fail(err)) {
 225             PCI_DEBUG("devframe_type() failed: bits = %hhu, base = %"PRIxPCIADDR
 226                       ", doba = %"PRIxPCIADDR"\n", bits, base, base + (1UL << bits));
 227             return err;
 228         }
 229     }
 230
 231     c->bits = bits;
 232     c->bar_nr = BAR;
 233     c->assigned = true;
 234     c->type = 0;
 235
 236     return SYS_ERR_OK;
 237 }
 238
 239 //XXX: FIXME: HACK: BAD!!! Only needed to allocate a full I/O range cap to
 240 //                         the VESA graphics driver
 241 static errval_t assign_complete_io_range(uint8_t idx,
 242                                          uint8_t bus,
 243                                          uint8_t dev,
 244                                          uint8_t fun,
 245                                          uint8_t BAR)
 246 {
 247     dev_caps[bus][dev][fun][idx].frame_cap = (struct capref*) malloc(
 248                     sizeof(struct capref));
 249     errval_t err = slot_alloc(&(dev_caps[bus][dev][fun][idx].frame_cap[0]));
 250     assert(err_is_ok(err));
 251     err = cap_copy(dev_caps[bus][dev][fun][idx].frame_cap[0], cap_io);
 252     assert(err_is_ok(err));
 253
 254     dev_caps[bus][dev][fun][idx].bits = 16;
 255     dev_caps[bus][dev][fun][idx].bar_nr = BAR;
 256     dev_caps[bus][dev][fun][idx].assigned = true;
 257     dev_caps[bus][dev][fun][idx].type = 1;
 258     dev_caps[bus][dev][fun][idx].nr_caps = 1;
 259     return SYS_ERR_OK;
 260 }
 261
 262 errval_t device_init(uint32_t class_code,
 263                      uint32_t sub_class,
 264                      uint32_t prog_if,
 265                      uint32_t vendor_id,
 266                      uint32_t device_id,
 267                      uint32_t *bus,
 268                      uint32_t *dev,
 269                      uint32_t *fun,
 270                      bool *pcie,
 271                      int *nr_allocated_bars)
 272 {
 273     *nr_allocated_bars = 0;
 274
 275     errval_t err;
 276     char s_bus[10], s_dev[10], s_fun[10], s_vendor_id[10], s_device_id[10];
 277     char s_class_code[10], s_sub_class[10], s_prog_if[10];
 278     char s_pcie[5];
 279     int error_code;
 280     int bar_nr;
 281     pciaddr_t bar_base, bar_high;
 282     pcisize_t bar_size;
 283
 284     if (*bus != PCI_DONT_CARE) {
 285         snprintf(s_bus, sizeof(s_bus), "%"PRIu32"", *bus);
 286     } else {
 287         strncpy(s_bus, "Bus", sizeof(s_bus));
 288     }
 289     if (*dev != PCI_DONT_CARE) {
 290         snprintf(s_dev, sizeof(s_dev), "%"PRIu32, *dev);
 291     } else {
 292         strncpy(s_dev, "Dev", sizeof(s_dev));
 293     }
 294     if (*fun != PCI_DONT_CARE) {
 295         snprintf(s_fun, sizeof(s_fun), "%"PRIu32, *fun);
 296     } else {
 297         strncpy(s_fun, "Fun", sizeof(s_fun));
 298     }
 299     if (vendor_id != PCI_DONT_CARE) {
 300         snprintf(s_vendor_id, sizeof(s_vendor_id), "%"PRIu32, vendor_id);
 301     } else {
 302         strncpy(s_vendor_id, "Ven", sizeof(s_vendor_id));
 303     }
 304     if (device_id != PCI_DONT_CARE) {
 305         snprintf(s_device_id, sizeof(s_device_id), "%"PRIu32, device_id);
 306     } else {
 307         strncpy(s_device_id, "DevID", sizeof(s_device_id));
 308     }
 309     if (class_code != PCI_DONT_CARE) {
 310         snprintf(s_class_code, sizeof(s_class_code), "%"PRIu32, class_code);
 311     } else {
 312         strncpy(s_class_code, "Cl", sizeof(s_class_code));
 313     }
 314     if (sub_class != PCI_DONT_CARE) {
 315         snprintf(s_sub_class, sizeof(s_sub_class), "%"PRIu32, sub_class);
 316     } else {
 317         strncpy(s_sub_class, "Sub", sizeof(s_sub_class));
 318     }
 319     if (prog_if != PCI_DONT_CARE) {
 320         snprintf(s_prog_if, sizeof(s_prog_if), "%"PRIu32, prog_if);
 321     } else {
 322         strncpy(s_prog_if, "ProgIf", sizeof(s_prog_if));
 323     }
 324
 325     PCI_DEBUG("device_init(): Searching device %s, %s, %s, %s, %s, %s, %s, %s\n",
 326               s_bus, s_dev, s_fun, s_vendor_id, s_device_id, s_class_code,
 327               s_sub_class, s_prog_if);
 328
 329 //find the device: Unify all values
 330     error_code = skb_execute_query(
 331                     "device(PCIE,addr(%s, %s, %s), %s, %s, %s, %s, %s, _),"
 332                     "writeln(d(PCIE,%s,%s,%s,%s,%s,%s,%s,%s)).",
 333                     s_bus, s_dev, s_fun, s_vendor_id, s_device_id, s_class_code,
 334                     s_sub_class, s_prog_if, s_bus, s_dev, s_fun, s_vendor_id,
 335                     s_device_id, s_class_code, s_sub_class, s_prog_if);
 336     if (error_code != 0) {
 337
 338         PCI_DEBUG("pci.c: device_init(): SKB returnd error code %s\n",
 339                   err_getcode(error_code));
 340
 341         PCI_DEBUG("SKB returned: %s\n", skb_get_output());
 342         PCI_DEBUG("SKB error returned: %s\n", skb_get_error_output());
 343
 344         return PCI_ERR_DEVICE_INIT;
 345     }
 346
 347     err = skb_read_output("d(%[a-z], %"PRIu32", %"PRIu32", %"PRIu32", %"PRIu32
 348                           ",%"PRIu32", %"PRIu32", %"PRIu32", %"PRIu32").",
 349                           s_pcie, bus, dev, fun, &vendor_id, &device_id,
 350                           &class_code, &sub_class, &prog_if);
 351
 352     if (err_is_fail(err)) {
 353         DEBUG_ERR(err, "skb read output\n");
 354
 355         PCI_DEBUG("device_init(): Could not read the SKB's output for the device\n");
 356         PCI_DEBUG("device_init(): SKB returned: %s\n", skb_get_output());
 357         PCI_DEBUG("device_init(): SKB error returned: %s\n",
 358                   skb_get_error_output());
 359         return err_push(err, PCI_ERR_DEVICE_INIT);
 360     }
 361     if (strncmp(s_pcie, "pcie", strlen("pcie")) == 0) {
 362         *pcie = true;
 363     } else {
 364         *pcie = false;
 365     }
 366
 367     PCI_DEBUG("device_init(): Found device at %u:%u:%u\n", *bus, *dev, *fun);
 368     //get the implemented BARs for the found device
 369     error_code = skb_execute_query("pci_get_implemented_BAR_addresses(%"PRIu32
 370                                    ",%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32",%"
 371                                    PRIu32",%"PRIu32",%"PRIu32",L),length(L,Len)"
 372                                    ",writeln(L)", *bus, *dev, *fun, vendor_id,
 373                                    device_id, class_code, sub_class, prog_if);
 374
 375     if (error_code != 0) {
 376         PCI_DEBUG("pci.c: device_init(): SKB returnd error code %d\n",
 377                   error_code);
 378
 379         PCI_DEBUG("SKB returned: %s\n", skb_get_output());
 380         PCI_DEBUG("SKB error returned: %s\n", skb_get_error_output());
 381
 382         return PCI_ERR_DEVICE_INIT;
 383     }
 384
 385     struct list_parser_status status;
 386     skb_read_list_init(&status);
 387
 388     //iterate over all buselements
 389     while (skb_read_list(&status, "baraddr(%d, %"PRIuPCIADDR", %"PRIuPCIADDR", "
 390                          "%"PRIuPCISIZE")", &bar_nr, &bar_base, &bar_high, &bar_size)) {
 391         err = alloc_device_bar(*nr_allocated_bars, *bus, *dev, *fun, bar_nr,
 392                                bar_base, bar_high, bar_size);
 393
 394         PCI_DEBUG("device_init(): BAR %d: base = %"PRIxPCIADDR ", size = %"
 395                   PRIxPCISIZE"\n", bar_nr, bar_base, bar_size);
 396
 397         if (err_is_fail(err)) {
 398             PCI_DEBUG("device_init(): Could not allocate cap for BAR %d\n", bar_nr);
 399             return err_push(err, PCI_ERR_DEVICE_INIT);
 400         }
 401         (*nr_allocated_bars)++;
 402     }
 403
 404 //XXX: FIXME: HACK: BAD!!! Only needed to allocate a full I/O range cap to
 405 //                         the VESA graphics driver
 406     if (class_code == PCI_CLASS_DISPLAY) {
 407         assert(*nr_allocated_bars < PCI_NBARS);
 408         err = assign_complete_io_range(*nr_allocated_bars, *bus, *dev, *fun,
 409                                        5 /*very BAAAD */);
 410         (*nr_allocated_bars)++;
 411     }
 412 //end of badness
 413
 414     PCI_DEBUG("device_init(): Allocated caps for %d BARs\n", *nr_allocated_bars);
 415
 416     PCI_DEBUG("enable busmaster for device (%u, %u, %u)...\n", *bus, *dev, *fun);
 417     enable_busmaster(*bus, *dev, *fun, *pcie);
 418
 419     return SYS_ERR_OK;
 420 }
 421
 422 errval_t device_reregister_interrupt(uint8_t coreid, int vector,
 423                  uint32_t class_code, uint32_t sub_class, uint32_t prog_if,
 424                  uint32_t vendor_id, uint32_t device_id, uint32_t *bus,
 425                  uint32_t *dev,uint32_t *fun)
 426 {
 427     errval_t err;
 428     char s_bus[10], s_dev[10], s_fun[10], s_vendor_id[10], s_device_id[10];
 429     char s_class_code[10], s_sub_class[10], s_prog_if[10];
 430     char s_pcie[5];
 431     bool pcie;
 432     int error_code;
 433
 434     if (*bus != PCI_DONT_CARE) {
 435         snprintf(s_bus, sizeof(s_bus), "%"PRIu32"", *bus);
 436     } else {
 437         strncpy(s_bus, "Bus", sizeof(s_bus));
 438     }
 439     if (*dev != PCI_DONT_CARE) {
 440         snprintf(s_dev, sizeof(s_dev), "%"PRIu32, *dev);
 441     } else {
 442         strncpy(s_dev, "Dev", sizeof(s_dev));
 443     }
 444     if (*fun != PCI_DONT_CARE) {
 445         snprintf(s_fun, sizeof(s_fun), "%"PRIu32, *fun);
 446     } else {
 447         strncpy(s_fun, "Fun", sizeof(s_fun));
 448     }
 449     if (vendor_id != PCI_DONT_CARE) {
 450         snprintf(s_vendor_id, sizeof(s_vendor_id), "%"PRIu32, vendor_id);
 451     } else {
 452         strncpy(s_vendor_id, "Ven", sizeof(s_vendor_id));
 453     }
 454     if (device_id != PCI_DONT_CARE) {
 455         snprintf(s_device_id, sizeof(s_device_id), "%"PRIu32, device_id);
 456     } else {
 457         strncpy(s_device_id, "DevID", sizeof(s_device_id));
 458     }
 459     if (class_code != PCI_DONT_CARE) {
 460         snprintf(s_class_code, sizeof(s_class_code), "%"PRIu32, class_code);
 461     } else {
 462         strncpy(s_class_code, "Cl", sizeof(s_class_code));
 463     }
 464     if (sub_class != PCI_DONT_CARE) {
 465         snprintf(s_sub_class, sizeof(s_sub_class), "%"PRIu32, sub_class);
 466     } else {
 467         strncpy(s_sub_class, "Sub", sizeof(s_sub_class));
 468     }
 469     if (prog_if != PCI_DONT_CARE) {
 470         snprintf(s_prog_if, sizeof(s_prog_if), "%"PRIu32, prog_if);
 471     } else {
 472         strncpy(s_prog_if, "ProgIf", sizeof(s_prog_if));
 473     }
 474
 475     PCI_DEBUG("device_init(): Searching device %s, %s, %s, %s, %s, %s, %s, %s\n",
 476         s_bus, s_dev, s_fun, s_vendor_id, s_device_id, s_class_code,
 477         s_sub_class, s_prog_if);
 478
 479 //find the device: Unify all values
 480     error_code = skb_execute_query(
 481         "device(PCIE,addr(%s, %s, %s), %s, %s, %s, %s, %s, _),"
 482         "writeln(d(PCIE,%s,%s,%s,%s,%s,%s,%s,%s)).",
 483         s_bus, s_dev, s_fun, s_vendor_id, s_device_id, s_class_code,
 484         s_sub_class, s_prog_if,
 485         s_bus, s_dev, s_fun, s_vendor_id, s_device_id, s_class_code,
 486         s_sub_class, s_prog_if
 487     );
 488     if (error_code != 0) {
 489
 490         PCI_DEBUG("pci.c: device_init(): SKB returnd error code %s\n",
 491             err_getcode(error_code));
 492
 493         PCI_DEBUG("SKB returned: %s\n", skb_get_output());
 494         PCI_DEBUG("SKB error returned: %s\n", skb_get_error_output());
 495
 496         return PCI_ERR_DEVICE_INIT;
 497     }
 498
 499     err = skb_read_output("d(%[a-z], %"PRIu32", %"PRIu32", %"PRIu32", %"PRIu32
 500                           ",%"PRIu32", %"PRIu32", %"PRIu32", %"PRIu32").",
 501                     s_pcie, bus, dev, fun, &vendor_id,
 502                     &device_id, &class_code, &sub_class, &prog_if);
 503
 504     if (err_is_fail(err)) {
 505         DEBUG_ERR(err, "skb read output\n");
 506
 507         PCI_DEBUG("device_init(): Could not read the SKB's output for the device\n");
 508         PCI_DEBUG("device_init(): SKB returned: %s\n", skb_get_output());
 509         PCI_DEBUG("device_init(): SKB error returned: %s\n", skb_get_error_output());
 510         return err_push(err,PCI_ERR_DEVICE_INIT);
 511     }
 512     if(strncmp(s_pcie, "pcie", strlen("pcie")) == 0) {
 513         pcie = true;
 514     } else {
 515         pcie = false;
 516     }
 517
 518
 519     PCI_DEBUG("device_init(): Found device at %u:%u:%u\n",
 520                 *bus, *dev, *fun);
 521 //get the implemented BARs for the found device
 522
 523     int irq = setup_interrupt(*bus, *dev, *fun);
 524     PCI_DEBUG("pci: init_device_handler_irq: init interrupt.\n");
 525     PCI_DEBUG("pci: irq = %u, core = %hhu, vector = %u\n",
 526             irq, coreid, vector);
 527     struct acpi_rpc_client* cl = get_acpi_rpc_client();
 528     errval_t ret_error;
 529     err = cl->vtbl.enable_and_route_interrupt(cl, irq, coreid, vector, &ret_error);
 530     assert(err_is_ok(err));
 531     assert(err_is_ok(ret_error)); // FIXME
 532     //        printf("IRQ for this device is %d\n", irq);
 533     //DEBUG_ERR(err, "enable_and_route_interrupt");
 534     pci_enable_interrupt_for_device(*bus, *dev, *fun, pcie);
 535
 536     return SYS_ERR_OK;
 537 }
 538
 539 void pci_enable_interrupt_for_device(uint32_t bus, uint32_t dev, uint32_t fun,
 540                                     bool pcie)
 541 {
 542     struct pci_address addr = { .bus = (uint8_t)(bus & 0xff),
 543                                 .device = (uint8_t)(dev & 0xff),
 544                                 .function = (uint8_t)(fun % 0xff) };
 545
 546     pci_hdr0_t hdr;
 547     pci_hdr0_initialize(&hdr, addr);
 548
 549     if (pcie) {
 550         pcie_enable();
 551     } else {
 552         pcie_disable();
 553     }
 554
 555     pci_hdr0_command_t cmd = pci_hdr0_command_rd(&hdr);
 556     cmd.int_dis = 0;
 557     pci_hdr0_command_wr(&hdr, cmd);
 558 }
 559
 560 /**
 561  * This function performs a recursive, depth-first search through the
 562  * PCI hierarchy starting at parentaddr (this should initially be a
 563  * PCI root complex), with bus number A. It enters whatever it
 564  * discovers (bridges and devices) into the SKB.
 565  *
 566  * Refer to http://www.tldp.org/LDP/tlk/dd/pci.html for an overview of
 567  * a similar discovery algorithm.
 568  *
 569  * Upon discovery of a bridge, it sets the bridge's primary bus number
 570  * to A and assigns a secondary bus number of A + 2. The subordinate
 571  * bus number is set to A + 3. This way, buses are spaced 2 apart,
 572  * which is sometimes required for SR-IOV hot-plugged buses.
 573  */
 574 static void assign_bus_numbers(struct pci_address parentaddr,
 575                                uint8_t *busnum,
 576                                uint8_t maxchild,
 577                                char* handle)
 578 {
 579     struct pci_address addr = {
 580         .bus = parentaddr.bus
 581     };
 582
 583     pcie_enable();
 584
 585     // First go through all bridges on this bus and disable them
 586     for (addr.device = 0; addr.device < PCI_NDEVICES; addr.device++) {
 587         for (addr.function = 0; addr.function < PCI_NFUNCTIONS; addr.function++) {
 588             pci_hdr1_t bhdr;
 589             pci_hdr1_initialize(&bhdr, addr);
 590
 591             uint16_t vendor = pci_hdr1_vendor_id_rd(&bhdr);
 592
 593             if (vendor == 0xffff) {
 594                 if (addr.function == 0) {
 595                     // this device doesn't exist at all
 596                     break;
 597                 } else {
 598                     // this function doesn't exist, but there may be others
 599                     continue;
 600                 }
 601             }
 602
 603             pci_hdr1_hdr_type_t hdr_type = pci_hdr1_hdr_type_rd(&bhdr);
 604             if (hdr_type.fmt == pci_hdr1_pci2pci) {
 605                 PCI_DEBUG("Disabling bridge (%u,%u,%u)\n", addr.bus, addr.device,
 606                           addr.function);
 607
 608                 pci_hdr1_bcfg_t bcfg = pci_hdr1_bcfg_rd(&bhdr);
 609                 bcfg.pri_bus = 0;
 610                 bcfg.sec_bus = 0;
 611                 bcfg.sub_bus = 0;
 612                 pci_hdr1_bcfg_wr(&bhdr, bcfg);
 613             }
 614         }
 615     }
 616
 617     for (addr.device = 0; addr.device < PCI_NDEVICES; addr.device++) {
 618         for (addr.function = 0; addr.function < PCI_NFUNCTIONS; addr.function++) {
 619             pci_hdr0_t hdr;
 620             pci_hdr0_initialize(&hdr, addr);
 621
 622             pcie_enable();
 623             uint16_t pcie_vendor = pci_hdr0_vendor_id_rd(&hdr);
 624             uint16_t vendor = pcie_vendor;
 625             bool pcie = true;
 626             bool extended_caps = false;  // Whether to scan for PCI Express extended caps
 627
 628             // Disable PCIe if device exists only in PCI
 629             if (pcie_vendor != 0xffff) {
 630                 vendor = pcie_vendor;
 631                 pcie = true;
 632             } else {
 633                 pcie_disable();
 634                 vendor = pci_hdr0_vendor_id_rd(&hdr);
 635                 pcie = false;
 636             }
 637
 638             if (vendor == 0xffff) {
 639                 if (addr.function == 0) {
 640                     // this device doesn't exist at all
 641                     break;
 642                 } else {
 643                     // this function doesn't exist, but there may be others
 644                     continue;
 645                 }
 646             }
 647             pci_hdr0_class_code_t classcode = pci_hdr0_class_code_rd(&hdr);
 648             uint16_t device_id = pci_hdr0_device_id_rd(&hdr);
 649
 650             /* Disable all decoders for this device,
 651              * they will be re-enabled as devices are setup.
 652              * NB: we are using "pci_hdr1" here, but the command field is
 653              * common to all configuration header types.
 654              */
 655             /* PCI_DEBUG("disabling decoders for (%hhu,%hhu,%hhu)\n", */
 656             /*     addr.bus, addr.device, addr.function); */
 657             pci_hdr0_command_t cmd = pci_hdr0_command_rd(&hdr);
 658
 659             cmd.mem_space = 0;
 660             cmd.io_space = 0;  // XXX: not handled in setup yet
 661
 662             // Ticket #210
 663             //XXX: This should be set to 0 and only enabled if needed
 664             //     (whenever a driver attaches to a device).
 665             //     For bridges the pci driver enables the bit later when
 666             //     programming the bridge window
 667 //            cmd.master = 0;
 668
 669             // Ticket 229
 670             //pci_hdr0_command_wr(&hdr, cmd);
 671
 672             // do we have a bridge?
 673             pci_hdr0_hdr_type_t hdr_type = pci_hdr0_hdr_type_rd(&hdr);
 674             if (hdr_type.fmt == pci_hdr0_pci2pci) {
 675                 pci_hdr1_t bhdr;
 676                 pci_hdr1_initialize(&bhdr, addr);
 677
 678                 //ACPI_HANDLE child;
 679                 char* child = NULL;
 680                 errval_t error_code;
 681                 PCI_DEBUG("get irq table for (%hhu,%hhu,%hhu)\n", (*busnum) + 1,
 682                           addr.device, addr.function);
 683                 struct acpi_rpc_client* cl = get_acpi_rpc_client();
 684                 // XXX: why do we have two different types for the same thing?
 685                 acpi_pci_address_t xaddr = {
 686                     .bus = addr.bus,
 687                     .device = addr.device,
 688                     .function = addr.function,
 689                 };
 690                 cl->vtbl.read_irq_table(cl, handle, xaddr, (*busnum) + 1,
 691                                         &error_code, &child);
 692                 if (err_is_fail(error_code)) {
 693                     DEBUG_ERR(error_code, "Reading IRQs failed");
 694                     assert(!"Check ACPI code");
 695                 }
 696
 697                 // Increase by 2 to leave room for SR-IOV
 698                 (*busnum) += 2;
 699                 //assert(*busnum <= maxchild);
 700
 701                 PCI_DEBUG("program busses for bridge (%hhu,%hhu,%hhu)\n"
 702                           "primary: %hhu, secondary: %hhu, subordinate: %hhu\n",
 703                           addr.bus, addr.device, addr.function, addr.bus, *busnum,
 704                           (*busnum) + 1);
 705
 706                 // Disable master abort mode on the bridge
 707                 pci_hdr1_brdg_ctrl_mabort_wrf(&bhdr, 0);
 708
 709                 // Clear all errors
 710                 pci_hdr1_status_wr_raw(&bhdr, 0);
 711
 712                 // program bus numbers for this bridge
 713                 pci_hdr1_bcfg_t bcfg = pci_hdr1_bcfg_rd(&bhdr);
 714                 bcfg.pri_bus = addr.bus;
 715                 bcfg.sec_bus = *busnum;
 716                 bcfg.sub_bus = 0xff;
 717                 pci_hdr1_bcfg_wr(&bhdr, bcfg);
 718
 719                 skb_add_fact("bridge(%s,addr(%u,%u,%u),%u,%u,%u,%u,%u, secondary(%hhu)).",
 720                              (pcie ? "pcie" : "pci"), addr.bus, addr.device,
 721                              addr.function, vendor, device_id, classcode.clss,
 722                              classcode.subclss, classcode.prog_if, *busnum);
 723
 724                 //use the original hdr (pci_hdr0_t) here
 725                 query_bars(hdr, addr, true);
 726
 727                 // assign bus numbers to secondary bus
 728                 struct pci_address bridge_addr = {
 729                     .bus = *busnum,
 730                     .device = addr.device,
 731                     .function = addr.function
 732                 };
 733                 assign_bus_numbers(bridge_addr, busnum, maxchild, child);
 734                 // Restore the old state of pcie. The above call changes this
 735                 // state according to the devices under this bridge
 736                 if (pcie) {
 737                     pcie_enable();
 738                 } else {
 739                     pcie_disable();
 740                 }
 741
 742                 // Set this bridge's subordinate to the maximum of the underlying hierarchy
 743                 pci_hdr1_bcfg_sub_bus_wrf(&bhdr, (*busnum) + 1);
 744             }
 745
 746             //is this a normal PCI device?
 747             if (hdr_type.fmt == pci_hdr0_nonbridge) {
 748                 PCI_DEBUG("Found device (%u, %u, %u), vendor = %x, device = %x\n",
 749                           addr.bus, addr.device, addr.function, vendor,
 750                           device_id);
 751
 752                 pci_hdr0_t devhdr;
 753                 pci_hdr0_initialize(&devhdr, addr);
 754                 skb_add_fact("device(%s,addr(%u,%u,%u),%u,%u,%u, %u, %u, %d).",
 755                              (pcie ? "pcie" : "pci"), addr.bus, addr.device,
 756                              addr.function, vendor, device_id, classcode.clss,
 757                              classcode.subclss, classcode.prog_if,
 758                              pci_hdr0_int_pin_rd(&devhdr) - 1);
 759
 760                 // octopus start
 761                 char* record = NULL;
 762                 static char* device_fmt = "hw.pci.device. { "
 763                                 "bus: %u, device: %u, function: %u, "
 764                                 "vendor: %u, device_id: %u, class: %u, "
 765                                 "subclass: %u, prog_if: %u }";
 766
 767                 errval_t err = oct_mset(SET_SEQUENTIAL, device_fmt, addr.bus,
 768                                         addr.device, addr.function, vendor,
 769                                         device_id, classcode.clss,
 770                                         classcode.subclss, classcode.prog_if);
 771
 772                 assert(err_is_ok(err));
 773                 free(record);
 774                 // end octopus
 775
 776                 query_bars(devhdr, addr, false);
 777
 778                 // Process device capabilities if existing
 779                 if (pci_hdr0_status_rd(&devhdr).caplist) {
 780                     uint8_t cap_ptr = pci_hdr0_cap_ptr_rd(&devhdr);
 781
 782                     // Walk capabilities list
 783                     while (cap_ptr != 0) {
 784                         assert(cap_ptr % 4 == 0 && cap_ptr >= 0x40);
 785                         uint32_t capword = pci_read_conf_header(&addr,
 786                                                                 cap_ptr / 4);
 787
 788                         switch (capword & 0xff) {
 789                             case 0x10:  // PCI Express
 790                                 PCI_DEBUG("PCI Express device\n");
 791                                 extended_caps = true;
 792                                 break;
 793
 794                             default:
 795                                 PCI_DEBUG("Unknown PCI device capability 0x%x at 0x%x\n",
 796                                           capword & 0xff, cap_ptr);
 797                                 break;
 798                         }
 799
 800                         cap_ptr = (capword >> 8) & 0xff;
 801                     }
 802                 }
 803
 804                 // Process extended device capabilities if existing
 805                 if (pcie && extended_caps && addr.bus < pcie_get_endbus()) {
 806                     uint32_t *ad = (uint32_t *) pcie_confspace_access(addr);
 807                     assert(ad != NULL);
 808                     uint16_t cap_ptr = 0x100;
 809
 810                     while (cap_ptr != 0) {
 811                         uint32_t capword = *(ad + (cap_ptr / 4));
 812                         assert(cap_ptr % 4 == 0 && cap_ptr >= 0x100
 813                                && cap_ptr < 0x1000);
 814
 815                         switch (capword & 0xffff) {  // Switch on capability ID
 816                             case 0:
 817                                 // No extended caps
 818                                 break;
 819
 820                             case 16:
 821                                 // SR-IOV capability
 822                                 {
 823                                 /*
 824                                  * XXX: When using our e1000 driver with the
 825                                  *      I350 network card (device id 0x152x),
 826                                  *      the configuration fails when VF are
 827                                  *      enabled: Legacy descriptors are ignored
 828                                  *      when VF are enabled.
 829                                  */
 830                                 if (vendor == 0x8086 && (device_id & 0xFFF0) == 0x1520) {
 831                                     debug_printf("skipping SR IOV initialization"
 832                                                     "for e1000 card.\n");
 833                                     break;
 834                                 }
 835                                 pci_sr_iov_cap_t sr_iov_cap;
 836                                 pci_sr_iov_cap_initialize(&sr_iov_cap,
 837                                      (mackerel_addr_t) (ad + (cap_ptr / 4)));
 838
 839                                 PCI_DEBUG("Found SR-IOV capability\n");
 840
 841                                 // Support version 1 for the moment
 842                                 assert(pci_sr_iov_cap_hdr_ver_rdf(&sr_iov_cap) == 1);
 843
 844                                 // Support system page size of 4K at the moment
 845                                 assert(pci_sr_iov_cap_sys_psize_rd(&sr_iov_cap)
 846                                        == 1);
 847
 848 #if 0   // Dump cap contents
 849                                 pci_sr_iov_cap_caps_pr(str, 256, &sr_iov_cap);
 850                                 PCI_DEBUG("%s\n", str);
 851                                 pci_sr_iov_cap_ctrl_pr(str, 256, &sr_iov_cap);
 852                                 PCI_DEBUG("%s\n", str);
 853                                 pci_sr_iov_cap_status_pr(str, 256, &sr_iov_cap);
 854                                 PCI_DEBUG("%s\n", str);
 855                                 pci_sr_iov_cap_initialvfs_pr(str, 256, &sr_iov_cap);
 856                                 PCI_DEBUG("%s\n", str);
 857                                 pci_sr_iov_cap_totalvfs_pr(str, 256, &sr_iov_cap);
 858                                 PCI_DEBUG("%s\n", str);
 859                                 pci_sr_iov_cap_numvfs_pr(str, 256, &sr_iov_cap);
 860                                 PCI_DEBUG("%s\n", str);
 861                                 pci_sr_iov_cap_fdl_pr(str, 256, &sr_iov_cap);
 862                                 PCI_DEBUG("%s\n", str);
 863                                 pci_sr_iov_cap_offset_pr(str, 256, &sr_iov_cap);
 864                                 PCI_DEBUG("%s\n", str);
 865                                 pci_sr_iov_cap_stride_pr(str, 256, &sr_iov_cap);
 866                                 PCI_DEBUG("%s\n", str);
 867                                 pci_sr_iov_cap_devid_pr(str, 256, &sr_iov_cap);
 868                                 PCI_DEBUG("%s\n", str);
 869                                 pci_sr_iov_cap_sup_psize_pr(str, 256, &sr_iov_cap);
 870                                 PCI_DEBUG("%s\n", str);
 871                                 pci_sr_iov_cap_sys_psize_pr(str, 256, &sr_iov_cap);
 872                                 PCI_DEBUG("%s\n", str);
 873 #endif
 874
 875                                 if (max_numvfs > 0) {
 876                                     // Set maximum number of VFs
 877                                     uint16_t totalvfs = pci_sr_iov_cap_totalvfs_rd( &sr_iov_cap);
 878                                     uint16_t numvfs = MIN(totalvfs, max_numvfs);
 879                                     //                  uint16_t numvfs = 8;
 880                                     PCI_DEBUG("Maximum supported VFs: %u. Enabling: %u\n",
 881                                               totalvfs, numvfs);
 882                                     pci_sr_iov_cap_numvfs_wr(&sr_iov_cap, numvfs);
 883
 884                                     uint16_t offset = pci_sr_iov_cap_offset_rd(&sr_iov_cap);
 885                                     uint16_t stride = pci_sr_iov_cap_stride_rd(&sr_iov_cap);
 886                                     uint16_t vf_devid = pci_sr_iov_cap_devid_rd(&sr_iov_cap);
 887
 888                                     PCI_DEBUG("VF offset is 0x%x, stride is 0x%x, "
 889                                               "device ID is 0x%x\n",
 890                                               offset, stride, vf_devid);
 891
 892 #if 0
 893                                     // Make sure we enable the PF
 894                                     cmd = pci_hdr0_command_rd(&hdr);
 895                                     cmd.mem_space = 1;
 896                                     cmd.io_space = 1;
 897                                     /* cmd.master = 1; */
 898                                     pci_hdr0_command_wr(&hdr, cmd);
 899 #endif
 900
 901                                     // Start VFs (including memory spaces)
 902                                     pci_sr_iov_cap_ctrl_vf_mse_wrf(&sr_iov_cap, 1);
 903                                     pci_sr_iov_cap_ctrl_vf_enable_wrf(&sr_iov_cap, 1);
 904
 905                                     // Spec says to wait here for at least 100ms
 906                                     err = barrelfish_usleep(100000);
 907                                     assert(err_is_ok(err));
 908
 909                                     // Add all VFs
 910                                     for (int vfn = 0; vfn < numvfs; vfn++) {
 911                                         uint8_t busnr = addr.bus + ((((addr.device << 3)
 912                                                                  + addr.function)
 913                                                                  + offset
 914                                                                  + stride * vfn)
 915                                                                  >> 8);
 916                                         uint8_t devfn = (((addr.device << 3)
 917                                                         + addr.function)
 918                                                         + offset
 919                                                         + stride * vfn)
 920                                                         & 0xff;
 921                                         struct pci_address vf_addr = {
 922                                             .bus = busnr,
 923                                             .device = devfn >> 3,
 924                                             .function = devfn & 7,
 925                                         };
 926
 927                                         PCI_DEBUG("Adding VF (%u, %u, %u)\n",
 928                                                   vf_addr.bus, vf_addr.device,
 929                                                   vf_addr.function);
 930
 931                                         skb_add_fact("device(%s,addr(%u,%u,%u),%u,%u,%u, %u, %u, %d).",
 932                                                      (pcie ? "pcie" : "pci"),
 933                                                      vf_addr.bus,
 934                                                      vf_addr.device,
 935                                                      vf_addr.function, vendor,
 936                                                      vf_devid, classcode.clss,
 937                                                      classcode.subclss,
 938                                                      classcode.prog_if, 0);
 939
 940                                         // octopus start
 941                                         device_fmt ="hw.pci.device. { "
 942                                                      "bus: %u, device: %u, function: %u, "
 943                                                      "vendor: %u, device_id: %u, class: %u, "
 944                                                      "subclass: %u, prog_if: %u }";
 945                                         err = oct_mset(SET_SEQUENTIAL,
 946                                                        device_fmt,
 947                                                        vf_addr.bus,
 948                                                        vf_addr.device,
 949                                                        vf_addr.function,
 950                                                        vendor, vf_devid,
 951                                                        classcode.clss,
 952                                                        classcode.subclss,
 953                                                        classcode.prog_if);
 954
 955                                         assert(err_is_ok(err));
 956                                         // end octopus
 957
 958                                         // We probe the BARs several times. Strictly
 959                                         // speaking, this is not necessary, as we
 960                                         // can calculate all offsets, but we're
 961                                         // lazy...
 962                                         pci_hdr0_bar32_t bar, barorigaddr;
 963                                         for (int i = 0; i < pci_sr_iov_cap_vf_bar_length; i++) {
 964                                             union pci_hdr0_bar32_un orig_value;
 965                                             orig_value.raw = pci_sr_iov_cap_vf_bar_rd(&sr_iov_cap, i);
 966                                             barorigaddr = orig_value.val;
 967
 968                                             // probe BAR to see if it is implemented
 969                                             pci_sr_iov_cap_vf_bar_wr(&sr_iov_cap, i, BAR_PROBE);
 970
 971                                             union pci_hdr0_bar32_un bar_value;
 972                                             bar_value.raw = pci_sr_iov_cap_vf_bar_rd(&sr_iov_cap, i);
 973                                             bar = (union pci_hdr0_bar32_un ) {
 974                                                         .raw =bar_value.raw
 975                                                    }.val;
 976
 977                                             //write original value back to the BAR
 978                                             pci_sr_iov_cap_vf_bar_wr(&sr_iov_cap,
 979                                                                  i, orig_value.raw);
 980
 981                                             /*
 982                                              * We need to check the entire register
 983                                              * here to make sure the bar is not
 984                                              * implemented as it could lie in the
 985                                              * high 64 bit range...
 986                                              */
 987                                             if (bar_value.raw == 0) {
 988                                                 // BAR not implemented
 989                                                 continue;
 990                                             }
 991
 992                                             // SR-IOV doesn't support IO space BARs
 993                                             assert(bar.space == 0);
 994                                             int type = -1;
 995                                             if (bar.tpe == pci_hdr0_bar_32bit) {
 996                                                 type = 32;
 997                                             }
 998                                             if (bar.tpe == pci_hdr0_bar_64bit) {
 999                                                 type = 64;
1000                                             }
1001
1002                                             if (bar.tpe == pci_hdr0_bar_64bit) {
1003                                                 //read the upper 32bits of the address
1004                                                 pci_hdr0_bar32_t bar_high, barorigaddr_high;
1005                                                 union pci_hdr0_bar32_un orig_value_high;
1006                                                 orig_value_high.raw = pci_sr_iov_cap_vf_bar_rd(&sr_iov_cap, i + 1);
1007                                                 barorigaddr_high = orig_value_high.val;
1008
1009                                                 // probe BAR to determine the mapping size
1010                                                 pci_sr_iov_cap_vf_bar_wr(&sr_iov_cap, i + 1, BAR_PROBE);
1011
1012                                                 bar_high = (union pci_hdr0_bar32_un ) {
1013                                                               .raw =pci_sr_iov_cap_vf_bar_rd(&sr_iov_cap,i + 1)
1014                                                             }.val;
1015
1016                                                 //write original value back to the BAR
1017                                                 pci_sr_iov_cap_vf_bar_wr(&sr_iov_cap,
1018                                                           i + 1, orig_value_high.raw);
1019
1020                                                 pciaddr_t base64 = bar_high.base;
1021                                                 base64 <<= 32;
1022                                                 base64 |= bar.base << 7;
1023
1024                                                 pciaddr_t origbase64 = barorigaddr_high.base;
1025                                                 origbase64 <<= 32;
1026                                                 origbase64 |= barorigaddr.base << 7;
1027
1028                                                 PCI_DEBUG("(%u,%u,%u): 64bit BAR %d at 0x%"
1029                                                           PRIxPCIADDR ", size %" PRIx64 ", %s\n",
1030                                                           vf_addr.bus, vf_addr.device,
1031                                                           vf_addr.function, i,
1032                                                           (origbase64 << 7) + bar_mapping_size64(base64) * vfn,
1033                                                           bar_mapping_size64(base64),
1034                                                           (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"));
1035
1036                                                 skb_add_fact("bar(addr(%u, %u, %u), %d, 16'%"
1037                                                              PRIxPCIADDR", ""16'%" PRIx64 ", vf, %s, %d).",
1038                                                              vf_addr.bus, vf_addr.device, vf_addr.function, i,
1039                                                              (origbase64 << 7) + bar_mapping_size64(base64) * vfn,
1040                                                              bar_mapping_size64(base64),
1041                                                              (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"),
1042                                                              type);
1043
1044                                                 i++;  //step one forward, because it is a 64bit BAR
1045                                             } else {
1046                                                 PCI_DEBUG("(%u,%u,%u): 32bit BAR %d at 0x%" PRIx32 ", size %x, %s\n",
1047                                                           vf_addr.bus, vf_addr.device, vf_addr.function, i,
1048                                                           (barorigaddr.base << 7) + bar_mapping_size(bar) * vfn,
1049                                                           bar_mapping_size(bar),
1050                                                           (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"));
1051
1052                                                 //32bit BAR
1053                                                 skb_add_fact("bar(addr(%u, %u, %u), %d, 16'%"PRIx32", 16'%"
1054                                                              PRIx32 ", vf, %s, %d).", vf_addr.bus,
1055                                                              vf_addr.device, vf_addr.function, i,
1056                                                              (uint32_t) ((barorigaddr.base << 7)
1057                                                                          + bar_mapping_size( bar) * vfn),
1058                                                              (uint32_t) bar_mapping_size(bar),
1059                                                              (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"),
1060                                                              type);
1061                                             }
1062                                         }
1063                                     }
1064                                 }
1065                             }
1066                                 break;
1067
1068                             default:
1069                                 PCI_DEBUG("Unknown extended PCI device capability 0x%x at 0x%x\n",
1070                                           capword & 0xffff, cap_ptr);
1071                                 break;
1072                         }
1073
1074                         cap_ptr = capword >> 20;
1075                     }
1076                 }
1077             }
1078
1079             // is this a multi-function device?
1080             if (addr.function == 0 && !hdr_type.multi) {
1081                 break;
1082             }
1083         }
1084     }
1085
1086     free(handle);
1087 }
1088
1089 #if 0
1090 static void get_bridges(struct pci_address myad)
1091 {
1092     struct pci_address addr = {.bus = myad.bus};
1093
1094     pcie_enable();
1095
1096     // First go through all bridges on this bus and disable them
1097     for (addr.device = 0; addr.device < PCI_NDEVICES; addr.device++) {
1098         for (addr.function = 0; addr.function < PCI_NFUNCTIONS; addr.function++) {
1099             pci_hdr1_t bhdr;
1100             pci_hdr1_initialize(&bhdr, addr);
1101
1102             uint16_t vendor = pci_hdr1_vendor_id_rd(&bhdr);
1103
1104             if (vendor == 0xffff) {
1105                 if (addr.function == 0) {
1106                     // this device doesn't exist at all
1107                     break;
1108                 } else {
1109                     // this function doesn't exist, but there may be others
1110                     continue;
1111                 }
1112             }
1113
1114             pci_hdr1_hdr_type_t hdr_type = pci_hdr1_hdr_type_rd(&bhdr);
1115             if (hdr_type.fmt == pci_hdr1_pci2pci) {
1116                 pci_hdr1_bcfg_t bcfg = pci_hdr1_bcfg_rd(&bhdr);
1117
1118                 PCI_DEBUG("Found bridge (%u,%u,%u), primary %u, secondary %u, subordinate %u\n",
1119                                 addr.bus, addr.device, addr.function,
1120                                 bcfg.pri_bus, bcfg.sec_bus, bcfg.sub_bus);
1121
1122                 struct pci_address bridge_addr= {
1123                     .bus = bcfg.sec_bus, .device = addr.device,
1124                     .function = addr.function
1125                 };
1126
1127                 get_bridges(bridge_addr);
1128             }
1129         }
1130     }
1131 }
1132 #endif
1133
1134 void pci_add_root(struct pci_address addr,
1135                   uint8_t maxchild,
1136                   char* handle)
1137 {
1138     uint8_t busnum = addr.bus;
1139     /* get_bridges(addr); */
1140     assign_bus_numbers(addr, &busnum, maxchild, handle);
1141     /* get_bridges(addr); */
1142 }
1143
1144 errval_t pci_setup_root_complex(void)
1145 {
1146     errval_t err;
1147     char* record = NULL;
1148     char** names = NULL;
1149     size_t len = 0;
1150
1151     // TODO: react to new rootbridges
1152     err = oct_get_names(&names, &len, "r'hw.pci.rootbridge.[0-9]+' "
1153                         "{ acpi_node: _, bus: _, device: _, function: _, maxbus: _ }");
1154     if (err_is_fail(err)) {
1155         DEBUG_ERR(err, "get names");
1156         goto out;
1157     }
1158
1159     for (size_t i = 0; i < len; i++) {
1160         err = oct_get(&record, names[i]);
1161         if (err_is_fail(err)) {
1162             goto out;
1163         }
1164
1165         PCI_DEBUG("found new root complex: %s\n", record);
1166
1167         char* acpi_node = NULL;  // freed in pci_add_root
1168         int64_t bus, device, function, maxbus;
1169         static char* format =
1170                         "_ { acpi_node: %s, bus: %d, device: %d, function: %d, maxbus: %d }";
1171         err = oct_read(record, format, &acpi_node, &bus, &device, &function,
1172                        &maxbus);
1173         if (err_is_fail(err)) {
1174             free(acpi_node);
1175             free(record);
1176             goto out;
1177         }
1178
1179         struct pci_address addr;
1180         addr.bus = (uint8_t) bus;
1181         addr.device = (uint8_t) device;
1182         addr.function = (uint8_t) function;
1183
1184         pcie_enable();
1185         pci_add_root(addr, maxbus, acpi_node);
1186         pcie_disable();
1187
1188         free(record);
1189     }
1190
1191     out: oct_free_names(names, len);
1192     return err;
1193 }
1194
1195 //query all BARs. That means, get the original address, the mapping size
1196 //and all attributes.
1197
1198 // XXX: asq: We are using this function to program also the _two_ BARs
1199 //           of a PCI-to-PCI bridge. They are at the same offset within the
1200 //           PCI header like for any PCI device. PCI HDR0 is misused
1201 //           here for the bridges.
1202
1203 static void query_bars(pci_hdr0_t devhdr,
1204                        struct pci_address addr,
1205                        bool pci2pci_bridge)
1206 {
1207     pci_hdr0_bar32_t bar, barorigaddr;
1208
1209     int maxbars = pci2pci_bridge ? 1 : pci_hdr0_bars_length;
1210     for (int i = 0; i <= maxbars; i++) {
1211         union pci_hdr0_bar32_un orig_value;
1212         orig_value.raw = pci_hdr0_bars_rd(&devhdr, i);
1213         barorigaddr = orig_value.val;
1214
1215         // probe BAR to determine the mapping size
1216         pci_hdr0_bars_wr(&devhdr, i, BAR_PROBE);
1217
1218         uint32_t bar_value = pci_hdr0_bars_rd(&devhdr, i);
1219
1220         bar = (union pci_hdr0_bar32_un ) { .raw = bar_value }.val;
1221
1222         //write original value back to the BAR
1223         pci_hdr0_bars_wr(&devhdr, i, orig_value.raw);
1224
1225         /*
1226          * Cannot just compare the base value, with addresses over 4G there
1227          * will be a problem. Thus we need to check if the entire register is
1228          * zero. If it is a 32bit register, then the address part will be filled.
1229          * If it is a 64bit register, the type will contain a nonzero value.
1230          * - 2014-05-02, RA
1231          */
1232         if (bar_value == 0) {
1233             // BAR not implemented
1234             continue;
1235         }
1236
1237         if (bar.space == 0) {  // memory mapped
1238             //bar(addr(bus, device, function), barnr, orig address, size, space,
1239             //         prefetchable?, 64bit?).
1240             //where space = mem | io, prefetchable= prefetchable | nonprefetchable,
1241             //64bit = 64bit | 32bit.
1242
1243             int type = -1;
1244             if (bar.tpe == pci_hdr0_bar_32bit) {
1245                 type = 32;
1246             }
1247             if (bar.tpe == pci_hdr0_bar_64bit) {
1248                 type = 64;
1249             }
1250
1251             if (bar.tpe == pci_hdr0_bar_64bit) {
1252                 //we must take the next BAR into account and do the same
1253                 //tests like in the 32bit case, but this time with the combined
1254                 //value from the current and the next BAR, since a 64bit BAR
1255                 //is constructed out of two consequtive 32bit BARs
1256
1257                 //read the upper 32bits of the address
1258                 uint32_t orig_value_high = pci_hdr0_bars_rd(&devhdr, i + 1);
1259
1260                 // probe BAR to determine the mapping size
1261                 pci_hdr0_bars_wr(&devhdr, i + 1, BAR_PROBE);
1262
1263                 // read the size information of the bar
1264                 uint32_t bar_value_high = pci_hdr0_bars_rd(&devhdr, i + 1);
1265
1266                 //write original value back to the BAR
1267                 pci_hdr0_bars_wr(&devhdr, i + 1, orig_value_high);
1268
1269                 pciaddr_t base64 = 0, origbase64 = 0;
1270                 base64 = bar_value_high;
1271                 base64 <<= 32;
1272                 base64 |= (uint32_t) (bar.base << 7);
1273
1274                 origbase64 = orig_value_high;
1275                 origbase64 <<= 32;
1276                 origbase64 |= (uint32_t) (barorigaddr.base << 7);
1277
1278                 PCI_DEBUG("(%u,%u,%u): 64bit BAR %d at 0x%" PRIxPCIADDR ", size %"
1279                           PRIx64 ", %s\n", addr.bus, addr.device, addr.function,
1280                           i, origbase64, bar_mapping_size64(base64),
1281                           (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"));
1282
1283               PCI_DEBUG("(%u,%u,%u): 64bit BAR %d at 0x%" PRIxPCIADDR ", size %" PRIx64 ", %s\n",
1284                         addr.bus, addr.device, addr.function,
1285                         i, origbase64 << 7, bar_mapping_size64(base64),
1286                         (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"));
1287
1288                 skb_add_fact("bar(addr(%u, %u, %u), %d, 16'%"PRIxPCIADDR", "
1289                              "16'%" PRIx64 ", mem, %s, %d).", addr.bus,
1290                              addr.device, addr.function, i, origbase64,
1291                              bar_mapping_size64(base64),
1292                              (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"),
1293                              type);
1294
1295                 i++;  //step one forward, because it is a 64bit BAR
1296             } else {
1297               PCI_DEBUG("(%u,%u,%u): 32bit BAR %d at 0x%" PRIx32 ", size %x, %s\n",
1298                         addr.bus, addr.device, addr.function,
1299                         i, barorigaddr.base << 7, bar_mapping_size(bar),
1300                         (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"));
1301
1302                 //32bit BAR
1303                 skb_add_fact("bar(addr(%u, %u, %u), %d, 16'%"PRIx32", 16'%" PRIx32
1304                              ", mem, %s, %d).", addr.bus, addr.device, addr.function,
1305                              i, (uint32_t) (barorigaddr.base << 7),
1306                              (uint32_t) bar_mapping_size(bar),
1307                              (bar.prefetch == 1 ? "prefetchable" : "nonprefetchable"),
1308                              type);
1309             }
1310         } else {
1311           PCI_DEBUG("(%u,%u,%u): IO BAR %d at 0x%x, size %x\n",
1312                     addr.bus, addr.device, addr.function,
1313                     i, barorigaddr.base << 7, bar_mapping_size(bar));
1314             //bar(addr(bus, device, function), barnr, orig address, size, space).
1315             //where space = mem | io
1316             skb_add_fact("bar(addr(%u, %u, %u), %d, 16'%"PRIx32", 16'%" PRIx32 ", io, "
1317                          "nonprefetchable, 32).", addr.bus, addr.device, addr.function, i,
1318                          (uint32_t) (barorigaddr.base << 7), (uint32_t) bar_mapping_size(bar));
1319         }
1320     }
1321 }
1322
1323 static void program_bridge_window(uint8_t bus,
1324                                   uint8_t dev,
1325                                   uint8_t fun,
1326                                   pciaddr_t base,
1327                                   pciaddr_t high,
1328                                   bool pcie,
1329                                   bool mem,
1330                                   bool pref)
1331 {
1332     struct pci_address addr;
1333     pci_hdr1_prefbl_t pref_reg;
1334     pci_hdr1_command_t cmd;
1335
1336     if (pcie) {
1337         pcie_enable();
1338     } else {
1339         pcie_disable();
1340     }
1341
1342     assert((base & 0x000fffff) == 0);
1343     assert((high & 0x000fffff) == 0x000fffff);
1344
1345     addr.bus = bus;
1346     addr.device = dev;
1347     addr.function = fun;
1348
1349     pci_hdr1_t bridgehdr;
1350     pci_hdr1_initialize(&bridgehdr, addr);
1351
1352     cmd = pci_hdr1_command_rd(&bridgehdr);
1353
1354     if (mem) {
1355         if (pref) {
1356             pci_hdr1_pref_base_upper_wr(&bridgehdr, base >> 32);
1357             pci_hdr1_pref_limit_upper_wr(&bridgehdr, high >> 32);
1358             /*
1359              * The least significant nibble of this register value (1h)
1360              * indicates that a 64 bit address decoder is supported and
1361              * that the Upper Base/Limit Registers are also used.
1362              */
1363             if ((base >> 32)) {
1364                 pref_reg.tpe = pci_hdr1_mem_64bit;
1365             } else {
1366                 pref_reg.tpe = pci_hdr1_mem_32bit;
1367             }
1368             pref_reg.val = base >> 20;
1369             pci_hdr1_pref_base_wr(&bridgehdr, pref_reg);
1370             if ((high >> 32)) {
1371                 pref_reg.tpe = pci_hdr1_mem_64bit;
1372             } else {
1373                 pref_reg.tpe = pci_hdr1_mem_32bit;
1374             }
1375             pref_reg.val = high >> 20;
1376             pci_hdr1_pref_limit_wr(&bridgehdr, pref_reg);
1377         } else {
1378             assert((base & 0xffffffff00000000) == 0);
1379             assert((high & 0xffffffff00000000) == 0);
1380             pci_hdr1_membl_t membl = {
1381                 .base = base >> 16,
1382                 .limit = high >> 16,
1383             };
1384             pci_hdr1_membl_wr(&bridgehdr, membl);
1385             /* pci_hdr1_mem_base_wr(&bridgehdr, base >> 16); */
1386             /* pci_hdr1_mem_limit_wr(&bridgehdr, high >> 16); */
1387         }
1388         // enable the memory decoder
1389         cmd.mem_space = 1;
1390     } else {
1391         // I/O
1392     }
1393
1394     cmd.int_dis = 0;
1395     cmd.master = 1;
1396     pci_hdr1_command_wr(&bridgehdr, cmd);
1397 }
1398
1399 static void program_device_bar(uint8_t bus,
1400                                uint8_t dev,
1401                                uint8_t fun,
1402                                int bar,
1403                                pciaddr_t base,
1404                                pcisize_t size,
1405                                int bits,
1406                                bool memspace,
1407                                bool pcie)
1408 {
1409     struct pci_address addr;
1410     addr.bus = bus;
1411     addr.device = dev;
1412     addr.function = fun;
1413
1414     if (pcie) {
1415         pcie_enable();
1416     } else {
1417         pcie_disable();
1418     }
1419
1420     pci_hdr0_t devhdr;
1421     pci_hdr0_initialize(&devhdr, addr);
1422
1423     //disable the address decoder for programming the BARs
1424     pci_hdr0_command_t cmd = pci_hdr0_command_rd(&devhdr);
1425     if (memspace) {
1426         cmd.mem_space = 0;
1427     } else {
1428         cmd.io_space = 0;
1429     }
1430     //disbale interrupts here. enable them as soon as a driver requests
1431     //interrupts
1432     cmd.int_dis = 1;
1433     pci_hdr0_command_wr(&devhdr, cmd);
1434
1435     if (bits == 64) {
1436         pci_hdr0_bars_wr(&devhdr, bar, base & 0xffffffff);
1437         pci_hdr0_bars_wr(&devhdr, bar + 1, base >> 32);
1438     } else {  // 32-bit
1439         assert(base + size <= 0xffffffff);  // 32-bit BAR
1440         pci_hdr0_bars_wr(&devhdr, bar, base);
1441     }
1442
1443     //re-enable the decoder for the BARs
1444     if (memspace) {
1445         cmd.mem_space = 1;
1446     } else {
1447         cmd.io_space = 1;
1448     }
1449     pci_hdr0_command_wr(&devhdr, cmd);
1450 }
1451
1452 static void enable_busmaster(uint8_t bus,
1453                              uint8_t dev,
1454                              uint8_t fun,
1455                              bool pcie)
1456 {
1457     struct pci_address addr;
1458     addr.bus = bus;
1459     addr.device = dev;
1460     addr.function = fun;
1461
1462     if (pcie) {
1463         pcie_enable();
1464     } else {
1465         pcie_disable();
1466     }
1467
1468     pci_hdr0_t devhdr;
1469     pci_hdr0_initialize(&devhdr, addr);
1470
1471     //enable bus master
1472     pci_hdr0_command_t cmd = pci_hdr0_command_rd(&devhdr);
1473     cmd.master = 1;
1474     pci_hdr0_command_wr(&devhdr, cmd);
1475 }
1476
1477 void pci_program_bridges(void)
1478 {
1479     char element_type[7];  // "device" | "bridge"
1480     char bar_secondary[16];  //[0-6] | secondary(<0-255>)
1481     char space[4];  // "mem" | "io"
1482     char prefetch[16];  // "prefetchable" | "nonprefetchable"
1483     char pcie_pci[5];  // "pcie" | "pci"
1484     int bar;  // the value of bar_secondary after parsing secondary(<nr>) to <nr>
1485     uint8_t bus, dev, fun;
1486     pciaddr_t base, high;
1487     pcisize_t size;
1488     int bits;
1489     bool mem, pcie, pref;
1490     char *output = NULL;
1491     int output_length = 0;
1492     int error_code = 0;
1493
1494     /*
1495      output = NULL;
1496      output_length = 0;
1497      skb_execute("listing.");
1498      output = skb_get_output();
1499      assert(output != NULL);
1500      output_length = strlen(output);
1501      PCI_DEBUG("pci_program_bridges: output = %s\n", output);
1502      PCI_DEBUG("pci_program_bridges: output length = %d\n", output_length);
1503
1504      error_code = skb_read_error_code();
1505      if (error_code != 0) {
1506      printf("pci.c: pci_program_bridges(): SKB returnd error code %d\n",
1507      error_code);
1508
1509      const char *errout = skb_get_error_output();
1510      printf("\nSKB error returned: %s\n", errout);
1511      printf("\nSKB output: %s\n", output);
1512      // XXX: no device can be used...
1513      return;
1514      }
1515      */
1516
1517     output = NULL;
1518     output_length = 0;
1519     char bridge_program[512];
1520     snprintf(bridge_program, 512, "[%s], bridge_programming(P, Nr),"
1521              "flatten(P, F),replace_current_BAR_values(F),"
1522              "write(nrelements(Nr)),writeln(P).",
1523              skb_bridge_program);
1524     skb_execute(bridge_program);
1525     output = skb_get_output();
1526     assert(output != NULL);
1527     output_length = strlen(output);
1528     PCI_DEBUG("pci_program_bridges: output = %s\n", output);
1529     PCI_DEBUG("pci_program_bridges: output length = %d\n", output_length);
1530
1531     error_code = skb_read_error_code();
1532     if (error_code != 0) {
1533         printf("pci.c: pci_program_bridges(): SKB returned error code %d\n",
1534                error_code);
1535
1536         const char *errout = skb_get_error_output();
1537         printf("SKB error returned: %s\n", errout);
1538         printf("SKB output: %s\n", output);
1539         // XXX: no device can be used...
1540         printf("WARNING: CONTINUING, HOWEVER PCI DEVICES WILL BE UNUSABLE\n");
1541         // except IO-space devices which aren't yet affected by bridge programming
1542         return;
1543     }
1544
1545     /*
1546      ********************************************************************************
1547      //for the ASPLOS11 paper:
1548      skb_execute("[bridge_page].");
1549      while (skb_read_error_code() == SKB_PROCESSING) messages_wait_and_handle_next();
1550      char *output = skb_get_output();
1551      assert(output != NULL);
1552      int output_length = strlen(output);
1553      PCI_DEBUG("pci_program_bridges: output = %s\n", output);
1554      PCI_DEBUG("pci_program_bridges: output length = %d\n", output_length);
1555
1556      int error_code = skb_read_error_code();
1557      if (error_code != 0) {
1558      printf("pci.c: pci_program_bridges() <2>: SKB returnd error code %d\n",
1559      error_code);
1560
1561      const char *errout = skb_get_error_output();
1562      printf("\nSKB error returned <2>: %s\n", errout);
1563      printf("\nSKB output <2>: %s\n", output);
1564      // XXX: no device can be used...
1565      return;
1566      }
1567      uint64_t start =rdtsc();
1568      //    uint64_t start =rdtscp();
1569      skb_execute("bridge_programming(P, Nr),write(nrelements(Nr)),writeln(P).");
1570      uint64_t end =rdtsc();
1571      //    uint64_t end =rdtscp();
1572      assert(end >= start);
1573
1574      printf("\n\nTicks: %lu\n\n", end - start);
1575      while (skb_read_error_code() == SKB_PROCESSING) messages_wait_and_handle_next();
1576      output = skb_get_output();
1577      assert(output != NULL);
1578      output_length = strlen(output);
1579      printf("pci_program_bridges: output = %s\n", output);
1580      PCI_DEBUG("pci_program_bridges: output length = %d\n", output_length);
1581
1582      error_code = skb_read_error_code();
1583      if (error_code != 0) {
1584      printf("pci.c: pci_program_bridges() <3>: SKB returnd error code %d\n",
1585      error_code);
1586
1587      const char *errout = skb_get_error_output();
1588      printf("\nSKB error returned <3>: %s\n", errout);
1589      printf("\nSKB output <3>: %s\n", output);
1590      // XXX: no device can be used...
1591      return;
1592      }
1593      ********************************************************************************
1594      */
1595
1596     //get the number of buselements from the output
1597     int nr_elements;
1598     int nr_conversions;
1599     nr_conversions = sscanf(output, "nrelements(%d)", &nr_elements);
1600     if (nr_conversions != 1) {
1601         printf("pci.c: No valid pci plan returned by the SKB\n.");
1602         //XXX: no device can be used
1603         return;
1604     }
1605
1606     //keep a pointer to the current location within the output
1607     char *conv_ptr = output;
1608
1609     //iterate over all buselements
1610     for (int i = 0; i < nr_elements; i++) {
1611         // search the beginning of the next buselement
1612         while ((conv_ptr < output + output_length) && (strncmp(
1613                         conv_ptr, "buselement", strlen("buselement"))
1614                                                        != 0)) {
1615             conv_ptr++;
1616         }
1617         //convert the string to single elements and numbers
1618         nr_conversions = sscanf(conv_ptr, "buselement(%[a-z], addr(%hhu, %hhu, %hhu), "
1619                                 "%[a-z0-9()], %"PRIuPCIADDR", %"PRIuPCIADDR", "
1620                                 "%"PRIuPCISIZE", %[a-z], %[a-z], %[a-z], %d",
1621                                 element_type, &bus, &dev, &fun, bar_secondary,
1622                                 &base, &high, &size, space, prefetch, pcie_pci,
1623                                 &bits);
1624         conv_ptr++;
1625         if (nr_conversions != 12) {
1626             printf("Could not parse output for device or bridge number %d\n"
1627                    "nr conversions: %d\n",
1628                    i, nr_conversions);
1629             continue;
1630         }
1631         if (strncmp(space, "mem", strlen("mem")) == 0) {
1632             mem = true;
1633         } else {
1634             mem = false;
1635         }
1636         if (strncmp(pcie_pci, "pcie", strlen("pcie")) == 0) {
1637             pcie = true;
1638         } else {
1639             pcie = false;
1640         }
1641         if (strncmp(prefetch, "prefetchable", strlen("prefetchable")) == 0) {
1642             pref = true;
1643         } else {
1644             pref = false;
1645         }
1646
1647         // Skip virtual functions
1648         if (strncmp(space, "vf", strlen("vf")) == 0) {
1649             /* PCI_DEBUG("Skipping VF addr(%hhu, %hhu, %hhu)\n", */
1650             /*      bus, dev, fun); */
1651             continue;
1652         }
1653
1654         if (strncmp(element_type, "device", strlen("device")) == 0) {
1655             nr_conversions = sscanf(bar_secondary, "%d", &bar);
1656             if (nr_conversions != 1) {
1657                 printf("Could not determine BAR number while programming BAR\n");
1658                 continue;
1659             }
1660             PCI_DEBUG("programming %s addr(%hhu, %hhu, %hhu), BAR %d, with base = "
1661                       "%"PRIxPCIADDR", high = %"PRIxPCIADDR", size = %"PRIxPCISIZE
1662                       " in" "space = %s, prefetch = %s, %s...\n",
1663                       element_type, bus, dev, fun, bar, base, high, size, space,
1664                       prefetch, pcie ? "PCIe" : "PCI");
1665             program_device_bar(bus, dev, fun, bar, base, size, bits, mem, pcie);
1666
1667         } else {
1668             PCI_DEBUG("programming %s addr(%hhu, %hhu, %hhu), with base = "
1669                       "%"PRIxPCIADDR", high = %"PRIxPCIADDR", size = %"PRIxPCISIZE
1670                       " in space = %s, prefetch = %s...\n",
1671                       element_type, bus, dev, fun, base, high, size, space,
1672                       prefetch);
1673             //a bridge expects the high address excluding the last byte which
1674             //is the base for the next bridge => decrement by one
1675             high--;
1676             program_bridge_window(bus, dev, fun, base, high, pcie, mem, pref);
1677         }
1678     }
1679 }
1680
1681 static uint32_t setup_interrupt(uint32_t bus,
1682                                 uint32_t dev,
1683                                 uint32_t fun)
1684 {
1685     char str[256], ldev[128];
1686
1687     snprintf(str, 256, "[\"irq_routing.pl\"], assigndeviceirq(addr(%"PRIu32
1688                        ", %"PRIu32", %"PRIu32")).",
1689                        bus, dev, fun);
1690     char *output, *error_out;
1691     int32_t int_err;
1692     errval_t err = skb_evaluate(str, &output, &error_out, &int_err);
1693     assert(output != NULL);
1694     assert(err_is_ok(err));
1695
1696     uint8_t irq;
1697     sscanf(output, "%s %hhu", ldev, &irq);
1698
1699     // It's a GSI
1700     if (strcmp(ldev, "fixedGsi") == 0) {
1701         printf("Got GSI %u\n", irq);
1702         return irq;
1703     }
1704
1705     struct acpi_rpc_client* cl = get_acpi_rpc_client();
1706     errval_t error_code;
1707     err = cl->vtbl.set_device_irq(cl, ldev, irq, &error_code);
1708     assert(err_is_ok(err));
1709     if (err_is_fail(error_code)) {
1710         //DEBUG_ERR(error_code, "set device irq failed.");
1711         return 0;
1712     }
1713
1714     return irq;
1715 }