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