net: Add network_offset to blocks
[akaros.git] / kern / arch / x86 / pci.c
1 /* Copyright (c) 2009, 2010 The Regents of the University of California
2  * See LICENSE for details.
3  *
4  * Barret Rhoden <brho@cs.berkeley.edu>
5  * Original by Paul Pearce <pearce@eecs.berkeley.edu> */
6
7 #include <arch/x86.h>
8 #include <arch/pci.h>
9 #include <trap.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include <assert.h>
13 #include <kmalloc.h>
14 #include <mm.h>
15 #include <arch/pci_defs.h>
16 #include <ros/errno.h>
17
18 /* List of all discovered devices */
19 struct pcidev_stailq pci_devices = STAILQ_HEAD_INITIALIZER(pci_devices);
20
21 /* PCI accesses are two-stage PIO, which need to complete atomically */
22 spinlock_t pci_lock = SPINLOCK_INITIALIZER_IRQSAVE;
23
24 static char STD_PCI_DEV[] = "Standard PCI Device";
25 static char PCI2PCI[] = "PCI-to-PCI Bridge";
26 static char PCI2CARDBUS[] = "PCI-Cardbus Bridge";
27
28 /* Gets any old raw bar, with some catches based on type. */
29 static uint32_t pci_getbar(struct pci_device *pcidev, unsigned int bar)
30 {
31         uint8_t type;
32         if (bar >= MAX_PCI_BAR)
33                 panic("Nonexistant bar requested!");
34         type = pcidev_read8(pcidev, PCI_HEADER_REG);
35         type &= ~0x80;  /* drop the MF bit */
36         /* Only types 0 and 1 have BARS */
37         if ((type != 0x00) && (type != 0x01))
38                 return 0;
39         /* Only type 0 has BAR2 - BAR5 */
40         if ((bar > 1) && (type != 0x00))
41                 return 0;
42         return pcidev_read32(pcidev, PCI_BAR0_STD + bar * PCI_BAR_OFF);
43 }
44
45 /* Determines if a given bar is IO (o/w, it's mem) */
46 static bool pci_is_iobar(uint32_t bar)
47 {
48         return bar & PCI_BAR_IO;
49 }
50
51 static bool pci_is_membar32(uint32_t bar)
52 {
53         if (pci_is_iobar(bar))
54                 return FALSE;
55         return (bar & PCI_MEMBAR_TYPE) == PCI_MEMBAR_32BIT;
56 }
57
58 static bool pci_is_membar64(uint32_t bar)
59 {
60         if (pci_is_iobar(bar))
61                 return FALSE;
62         return (bar & PCI_MEMBAR_TYPE) == PCI_MEMBAR_64BIT;
63 }
64
65 /* Helper to get the address from a membar.  Check the type beforehand */
66 static uint32_t pci_getmembar32(uint32_t bar)
67 {
68         uint8_t type = bar & PCI_MEMBAR_TYPE;
69         if (type != PCI_MEMBAR_32BIT) {
70                 warn("Unhandled PCI membar type: %02p\n", type >> 1);
71                 return 0;
72         }
73         return bar & 0xfffffff0;
74 }
75
76 /* Helper to get the address from an IObar.  Check the type beforehand */
77 static uint32_t pci_getiobar32(uint32_t bar)
78 {
79         return bar & 0xfffffffc;
80 }
81
82 /* memory bars have a little dance you go through to detect what the size of the
83  * memory region is.  for 64 bit bars, i'm assuming you only need to do this to
84  * the lower part (no device will need > 4GB, right?).
85  *
86  * Hold the dev's lock, or o/w avoid sync issues. */
87 static uint32_t __pci_membar_get_sz(struct pci_device *pcidev, int bar)
88 {
89         /* save the old value, write all 1s, invert, add 1, restore.
90          * http://wiki.osdev.org/PCI for details. */
91         uint32_t bar_off = PCI_BAR0_STD + bar * PCI_BAR_OFF;
92         uint32_t old_val = pcidev_read32(pcidev, bar_off);
93         uint32_t retval;
94         pcidev_write32(pcidev, bar_off, 0xffffffff);
95         /* Don't forget to mask the lower 3 bits! */
96         retval = pcidev_read32(pcidev, bar_off) & PCI_BAR_MEM_MASK;
97         retval = ~retval + 1;
98         pcidev_write32(pcidev, bar_off, old_val);
99         return retval;
100 }
101
102 /* process the bars.  these will tell us what address space (PIO or memory) and
103  * where the base is.  fills results into pcidev.  i don't know if you can have
104  * multiple bars with conflicting/different regions (like two separate PIO
105  * ranges).  I'm assuming you don't, and will warn if we see one. */
106 static void __pci_handle_bars(struct pci_device *pcidev)
107 {
108         uint32_t bar_val;
109         int max_bars;
110         if (pcidev->header_type == STD_PCI_DEV)
111                 max_bars = MAX_PCI_BAR;
112         else if (pcidev->header_type == PCI2PCI)
113                 max_bars = 2;
114         else
115                 max_bars = 0;
116         /* TODO: consider aborting for classes 00, 05 (memory ctlr), 06 (bridge) */
117         for (int i = 0; i < max_bars; i++) {
118                 bar_val = pci_getbar(pcidev, i);
119                 pcidev->bar[i].raw_bar = bar_val;
120                 if (!bar_val)   /* (0 denotes no valid data) */
121                         continue;
122                 if (pci_is_iobar(bar_val)) {
123                         pcidev->bar[i].pio_base = pci_getiobar32(bar_val);
124                 } else {
125                         if (pci_is_membar32(bar_val)) {
126                                 pcidev->bar[i].mmio_base32 = bar_val & PCI_BAR_MEM_MASK;
127                                 pcidev->bar[i].mmio_sz = __pci_membar_get_sz(pcidev, i);
128                         } else if (pci_is_membar64(bar_val)) {
129                                 /* 64 bit, the lower 32 are in this bar, the upper
130                                  * are in the next bar */
131                                 pcidev->bar[i].mmio_base64 = bar_val & PCI_BAR_MEM_MASK;
132                                 assert(i < max_bars - 1);
133                                 bar_val = pci_getbar(pcidev, i + 1);    /* read next bar */
134                                 /* note we don't check for IO or memsize.  the entire next bar
135                                  * is supposed to be for the upper 32 bits. */
136                                 pcidev->bar[i].mmio_base64 |= (uint64_t)bar_val << 32;
137                                 pcidev->bar[i].mmio_sz = __pci_membar_get_sz(pcidev, i);
138                                 i++;
139                         }
140                 }
141                 /* this will track the maximum bar we've had.  it'll include the 64 bit
142                  * uppers, as well as devices that have only higher numbered bars. */
143                 pcidev->nr_bars = i + 1;
144         }
145 }
146
147 static void __pci_parse_caps(struct pci_device *pcidev)
148 {
149         uint32_t cap_off;       /* not sure if this can be extended from u8 */
150         uint8_t cap_id;
151         if (!(pcidev_read16(pcidev, PCI_STATUS_REG) & (1 << 4)))
152                 return;
153         switch (pcidev_read8(pcidev, PCI_HEADER_REG) & 0x7f) {
154                 case 0:                         /* etc */
155                 case 1:                         /* pci to pci bridge */
156                         cap_off = 0x34;
157                         break;
158                 case 2:                         /* cardbus bridge */
159                         cap_off = 0x14;
160                         break;
161                 default:
162                         return;
163         }
164         /* initial offset points to the addr of the first cap */
165         cap_off = pcidev_read8(pcidev, cap_off);
166         cap_off &= ~0x3;        /* osdev says the lower 2 bits are reserved */
167         while (cap_off) {
168                 cap_id = pcidev_read8(pcidev, cap_off);
169                 if (cap_id > PCI_CAP_ID_MAX) {
170                         printk("PCI %x:%x:%x had bad cap 0x%x\n", pcidev->bus, pcidev->dev,
171                                pcidev->func, cap_id);
172                         return;
173                 }
174                 pcidev->caps[cap_id] = cap_off;
175                 cap_off = pcidev_read8(pcidev, cap_off + 1);
176                 /* not sure if subsequent caps must be aligned or not */
177                 if (cap_off & 0x3)
178                         printk("PCI %x:%x:%x had unaligned cap offset 0x%x\n", pcidev->bus,
179                                pcidev->dev, pcidev->func, cap_off);
180         }
181 }
182
183 /* Scans the PCI bus.  Won't actually work for anything other than bus 0, til we
184  * sort out how to handle bridge devices. */
185 void pci_init(void)
186 {
187         uint32_t result = 0;
188         uint16_t dev_id, ven_id;
189         struct pci_device *pcidev;
190         int max_nr_func;
191         /* In earlier days bus address 0xff caused problems so we only iterated to
192          * PCI_MAX_BUS - 1, but this should no longer be an issue.
193          * Old comment: phantoms at 0xff */
194         for (int i = 0; i < PCI_MAX_BUS; i++) {
195                 for (int j = 0; j < PCI_MAX_DEV; j++) {
196                         max_nr_func = 1;
197                         for (int k = 0; k < max_nr_func; k++) {
198                                 result = pci_read32(i, j, k, PCI_DEV_VEND_REG);
199                                 dev_id = result >> 16;
200                                 ven_id = result & 0xffff;
201                                 /* Skip invalid IDs (not a device)
202                                  * If the first function doesn't exist then no device is
203                                  * connected, but there can be gaps in the other function
204                                  * numbers. Eg. 0,2,3 is ok. */
205                                 if (ven_id == INVALID_VENDOR_ID) {
206                                         if (k == 0)
207                                                 break;
208                                         continue;
209                                 }
210                                 pcidev = kzmalloc(sizeof(struct pci_device), 0);
211                                 /* we don't need to lock it til we post the pcidev to the list*/
212                                 spinlock_init_irqsave(&pcidev->lock);
213                                 pcidev->bus = i;
214                                 pcidev->dev = j;
215                                 pcidev->func = k;
216                                 snprintf(pcidev->name, sizeof(pcidev->name),
217                                          "%02x:%02x.%x", pcidev->bus,
218                                          pcidev->dev, pcidev->func);
219                                 pcidev->dev_id = dev_id;
220                                 pcidev->ven_id = ven_id;
221                                 /* Get the Class/subclass */
222                                 pcidev->class = pcidev_read8(pcidev, PCI_CLASS_REG);
223                                 pcidev->subclass = pcidev_read8(pcidev, PCI_SUBCLASS_REG);
224                                 pcidev->progif = pcidev_read8(pcidev, PCI_PROGIF_REG);
225                                 /* All device types (0, 1, 2) have the IRQ in the same place */
226                                 /* This is the PIC IRQ the device is wired to */
227                                 pcidev->irqline = pcidev_read8(pcidev, PCI_IRQLINE_STD);
228                                 /* This is the interrupt pin the device uses (INTA# - INTD#) */
229                                 pcidev->irqpin = pcidev_read8(pcidev, PCI_IRQPIN_STD);
230                                 /* bottom 7 bits are header type */
231                                 switch (pcidev_read8(pcidev, PCI_HEADER_REG) & 0x7c) {
232                                         case 0x00:
233                                                 pcidev->header_type = STD_PCI_DEV;
234                                                 break;
235                                         case 0x01:
236                                                 pcidev->header_type = PCI2PCI;
237                                                 break;
238                                         case 0x02:
239                                                 pcidev->header_type = PCI2CARDBUS;
240                                                 break;
241                                         default:
242                                                 pcidev->header_type = "Unknown Header Type";
243                                 }
244                                 __pci_handle_bars(pcidev);
245                                 __pci_parse_caps(pcidev);
246                                 /* we're the only writer at this point in the boot process */
247                                 STAILQ_INSERT_TAIL(&pci_devices, pcidev, all_dev);
248                                 #ifdef CONFIG_PCI_VERBOSE
249                                 pcidev_print_info(pcidev, 4);
250                                 #else
251                                 pcidev_print_info(pcidev, 0);
252                                 #endif /* CONFIG_PCI_VERBOSE */
253                                 /* Top bit determines if we have multiple functions on this
254                                  * device.  We can't just check for more functions, since
255                                  * non-multifunction devices exist that respond to different
256                                  * functions with the same underlying device (same bars etc).
257                                  * Note that this style allows for devices that only report
258                                  * multifunction in the first function's header. */
259                                 if (pcidev_read8(pcidev, PCI_HEADER_REG) & 0x80)
260                                         max_nr_func = PCI_MAX_FUNC;
261                         }
262                 }
263         }
264 }
265
266 uint32_t pci_config_addr(uint8_t bus, uint8_t dev, uint8_t func, uint32_t reg)
267 {
268         return (uint32_t)(((uint32_t)bus << 16) |
269                           ((uint32_t)dev << 11) |
270                           ((uint32_t)func << 8) |
271                           (reg & 0xfc) |
272                           ((reg & 0xf00) << 16) |       /* extended PCI CFG space... */
273                                           0x80000000);
274 }
275
276 /* Helper to read 32 bits from the config space of B:D:F.  'Offset' is how far
277  * into the config space we offset before reading, aka: where we are reading. */
278 uint32_t pci_read32(uint8_t bus, uint8_t dev, uint8_t func, uint32_t offset)
279 {
280         uint32_t ret;
281         spin_lock_irqsave(&pci_lock);
282         outl(PCI_CONFIG_ADDR, pci_config_addr(bus, dev, func, offset));
283         ret = inl(PCI_CONFIG_DATA);
284         spin_unlock_irqsave(&pci_lock);
285         return ret;
286 }
287
288 /* Same, but writes (doing 32bit at a time).  Never actually tested (not sure if
289  * PCI lets you write back). */
290 void pci_write32(uint8_t bus, uint8_t dev, uint8_t func, uint32_t offset,
291                  uint32_t value)
292 {
293         spin_lock_irqsave(&pci_lock);
294         outl(PCI_CONFIG_ADDR, pci_config_addr(bus, dev, func, offset));
295         outl(PCI_CONFIG_DATA, value);
296         spin_unlock_irqsave(&pci_lock);
297 }
298
299 uint16_t pci_read16(uint8_t bus, uint8_t dev, uint8_t func, uint32_t offset)
300 {
301         uint16_t ret;
302         spin_lock_irqsave(&pci_lock);
303         outl(PCI_CONFIG_ADDR, pci_config_addr(bus, dev, func, offset));
304         ret = inw(PCI_CONFIG_DATA + (offset & 2));
305         spin_unlock_irqsave(&pci_lock);
306         return ret;
307 }
308
309 void pci_write16(uint8_t bus, uint8_t dev, uint8_t func, uint32_t offset,
310                  uint16_t value)
311 {
312         spin_lock_irqsave(&pci_lock);
313         outl(PCI_CONFIG_ADDR, pci_config_addr(bus, dev, func, offset));
314         outw(PCI_CONFIG_DATA + (offset & 2), value);
315         spin_unlock_irqsave(&pci_lock);
316 }
317
318 uint8_t pci_read8(uint8_t bus, uint8_t dev, uint8_t func, uint32_t offset)
319 {
320         uint8_t ret;
321         spin_lock_irqsave(&pci_lock);
322         outl(PCI_CONFIG_ADDR, pci_config_addr(bus, dev, func, offset));
323         ret = inb(PCI_CONFIG_DATA + (offset & 3));
324         spin_unlock_irqsave(&pci_lock);
325         return ret;
326 }
327
328 void pci_write8(uint8_t bus, uint8_t dev, uint8_t func, uint32_t offset,
329                 uint8_t value)
330 {
331         spin_lock_irqsave(&pci_lock);
332         outl(PCI_CONFIG_ADDR, pci_config_addr(bus, dev, func, offset));
333         outb(PCI_CONFIG_DATA + (offset & 3), value);
334         spin_unlock_irqsave(&pci_lock);
335 }
336
337 uint32_t pcidev_read32(struct pci_device *pcidev, uint32_t offset)
338 {
339         return pci_read32(pcidev->bus, pcidev->dev, pcidev->func, offset);
340 }
341
342 void pcidev_write32(struct pci_device *pcidev, uint32_t offset, uint32_t value)
343 {
344         pci_write32(pcidev->bus, pcidev->dev, pcidev->func, offset, value);
345 }
346
347 uint16_t pcidev_read16(struct pci_device *pcidev, uint32_t offset)
348 {
349         return pci_read16(pcidev->bus, pcidev->dev, pcidev->func, offset);
350 }
351
352 void pcidev_write16(struct pci_device *pcidev, uint32_t offset, uint16_t value)
353 {
354         pci_write16(pcidev->bus, pcidev->dev, pcidev->func, offset, value);
355 }
356
357 uint8_t pcidev_read8(struct pci_device *pcidev, uint32_t offset)
358 {
359         return pci_read8(pcidev->bus, pcidev->dev, pcidev->func, offset);
360 }
361
362 void pcidev_write8(struct pci_device *pcidev, uint32_t offset, uint8_t value)
363 {
364         pci_write8(pcidev->bus, pcidev->dev, pcidev->func, offset, value);
365 }
366
367 /* Helper to get the class description strings.  Adapted from
368  * http://www.pcidatabase.com/reports.php?type=c-header */
369 static void pcidev_get_cldesc(struct pci_device *pcidev, char **class,
370                               char **subclass, char **progif)
371 {
372         int     i ;
373         *class = *subclass = *progif = "";
374
375         for (i = 0; i < PCI_CLASSCODETABLE_LEN; i++) {
376                 if (PciClassCodeTable[i].BaseClass == pcidev->class) {
377                         if (!(**class))
378                                 *class = PciClassCodeTable[i].BaseDesc;
379                         if (PciClassCodeTable[i].SubClass == pcidev->subclass) {
380                                 if (!(**subclass))
381                                         *subclass = PciClassCodeTable[i].SubDesc;
382                                 if (PciClassCodeTable[i].ProgIf == pcidev->progif) {
383                                         *progif = PciClassCodeTable[i].ProgDesc;
384                                         break ;
385                                 }
386                         }
387                 }
388         }
389 }
390
391 /* Helper to get the vendor and device description strings */
392 static void pcidev_get_devdesc(struct pci_device *pcidev, char **vend_short,
393                                char **vend_full, char **chip, char **chip_desc)
394 {
395         int     i ;
396         *vend_short = *vend_full = *chip = *chip_desc = "";
397
398         for (i = 0; i < PCI_VENTABLE_LEN; i++) {
399                 if (PciVenTable[i].VenId == pcidev->ven_id) {
400                         *vend_short = PciVenTable[i].VenShort;
401                         *vend_full = PciVenTable[i].VenFull;
402                         break ;
403                 }
404         }
405         for (i = 0; i < PCI_DEVTABLE_LEN; i++) {
406                 if ((PciDevTable[i].VenId == pcidev->ven_id) &&
407                    (PciDevTable[i].DevId == pcidev->dev_id)) {
408                         *chip = PciDevTable[i].Chip;
409                         *chip_desc = PciDevTable[i].ChipDesc;
410                         break ;
411                 }
412         }
413 }
414
415 /* Prints info (like lspci) for a device */
416 void pcidev_print_info(struct pci_device *pcidev, int verbosity)
417 {
418         char *ven_sht, *ven_fl, *chip, *chip_txt, *class, *subcl, *progif;
419         pcidev_get_cldesc(pcidev, &class, &subcl, &progif);
420         pcidev_get_devdesc(pcidev, &ven_sht, &ven_fl, &chip, &chip_txt);
421
422         printk("%02x:%02x.%x %s: %s %s %s: %s\n",
423                pcidev->bus,
424                pcidev->dev,
425                pcidev->func,
426                subcl,
427                ven_sht,
428                chip,
429                chip_txt,
430                    pcidev->header_type);
431         if (verbosity < 1)      /* whatever */
432                 return;
433         printk("\tIRQ: %02d IRQ pin: 0x%02x\n",
434                pcidev->irqline,
435                pcidev->irqpin);
436         printk("\tVendor Id: 0x%04x Device Id: 0x%04x\n",
437                pcidev->ven_id,
438                pcidev->dev_id);
439         printk("\t%s %s %s\n",
440                class,
441                progif,
442                ven_fl);
443         for (int i = 0; i < pcidev->nr_bars; i++) {
444                 if (pcidev->bar[i].raw_bar == 0)
445                         continue;
446                 printk("\tBAR %d: ", i);
447                 if (pci_is_iobar(pcidev->bar[i].raw_bar)) {
448                         assert(pcidev->bar[i].pio_base);
449                         printk("IO port 0x%04x\n", pcidev->bar[i].pio_base);
450                 } else {
451                         bool bar_is_64 = pci_is_membar64(pcidev->bar[i].raw_bar);
452                         printk("MMIO Base%s %p, MMIO Size %p\n",
453                                bar_is_64 ? "64" : "32",
454                                bar_is_64 ? pcidev->bar[i].mmio_base64 :
455                                            pcidev->bar[i].mmio_base32,
456                                pcidev->bar[i].mmio_sz);
457                         /* Takes up two bars */
458                         if (bar_is_64) {
459                                 assert(!pcidev->bar[i].mmio_base32);    /* double-check */
460                                 i++;
461                         }
462                 }
463         }
464         printk("\tCapabilities:");
465         for (int i = 0; i < PCI_CAP_ID_MAX + 1; i++) {
466                 if (pcidev->caps[i])
467                         printk(" 0x%02x", i);
468         }
469         printk("\n");
470 }
471
472 void pci_set_bus_master(struct pci_device *pcidev)
473 {
474         spin_lock_irqsave(&pcidev->lock);
475         pcidev_write16(pcidev, PCI_CMD_REG, pcidev_read16(pcidev, PCI_CMD_REG) |
476                                             PCI_CMD_BUS_MAS);
477         spin_unlock_irqsave(&pcidev->lock);
478 }
479
480 void pci_clr_bus_master(struct pci_device *pcidev)
481 {
482         uint16_t reg;
483         spin_lock_irqsave(&pcidev->lock);
484         reg = pcidev_read16(pcidev, PCI_CMD_REG);
485         reg &= ~PCI_CMD_BUS_MAS;
486         pcidev_write16(pcidev, PCI_CMD_REG, reg);
487         spin_unlock_irqsave(&pcidev->lock);
488 }
489
490 struct pci_device *pci_match_tbdf(int tbdf)
491 {
492         struct pci_device *search;
493         int bus, dev, func;
494         bus = BUSBNO(tbdf);
495         dev = BUSDNO(tbdf);
496         func = BUSFNO(tbdf);
497
498         STAILQ_FOREACH(search, &pci_devices, all_dev) {
499                 if ((search->bus == bus) &&
500                     (search->dev == dev) &&
501                     (search->func == func))
502                         return search;
503         }
504         return NULL;
505 }
506
507 /* Helper to get the membar value for BAR index bir */
508 uintptr_t pci_get_membar(struct pci_device *pcidev, int bir)
509 {
510         if (bir >= pcidev->nr_bars)
511                 return 0;
512         if (pcidev->bar[bir].mmio_base64) {
513                 assert(pci_is_membar64(pcidev->bar[bir].raw_bar));
514                 return pcidev->bar[bir].mmio_base64;
515         }
516         /* we can just return mmio_base32, even if it's 0.  but i'd like to do the
517          * assert too. */
518         if (pcidev->bar[bir].mmio_base32) {
519                 assert(pci_is_membar32(pcidev->bar[bir].raw_bar));
520                 return pcidev->bar[bir].mmio_base32;
521         }
522         return 0;
523 }
524
525 uintptr_t pci_get_iobar(struct pci_device *pcidev, int bir)
526 {
527         if (bir >= pcidev->nr_bars)
528                 return 0;
529         /* we can just return pio_base, even if it's 0.  but i'd like to do the
530          * assert too. */
531         if (pcidev->bar[bir].pio_base) {
532                 assert(pci_is_iobar(pcidev->bar[bir].raw_bar));
533                 return pcidev->bar[bir].pio_base;
534         }
535         return 0;
536 }
537
538 uint32_t pci_get_membar_sz(struct pci_device *pcidev, int bir)
539 {
540         if (bir >= pcidev->nr_bars)
541                 return 0;
542         return pcidev->bar[bir].mmio_sz;
543 }
544
545 uint16_t pci_get_vendor(struct pci_device *pcidev)
546 {
547         return pcidev->ven_id;
548 }
549
550 uint16_t pci_get_device(struct pci_device *pcidev)
551 {
552         return pcidev->dev_id;
553 }
554
555 uint16_t pci_get_subvendor(struct pci_device *pcidev)
556 {
557         uint8_t header_type = pcidev_read8(pcidev, PCI_HEADER_REG) & 0x7c;
558         switch (header_type) {
559                 case 0x00: /* STD_PCI_DEV */
560                         return pcidev_read16(pcidev, PCI_SUBSYSVEN_STD);
561                 case 0x01: /* PCI2PCI */
562                         return -1;
563                 case 0x02: /* PCI2CARDBUS */
564                         return pcidev_read16(pcidev, PCI_SUBVENID_CB);
565                 default:
566                         warn("Unknown Header Type, %d", header_type);
567         }
568         return -1;
569 }
570
571 uint16_t pci_get_subdevice(struct pci_device *pcidev)
572 {
573         uint8_t header_type = pcidev_read8(pcidev, PCI_HEADER_REG) & 0x7c;
574         switch (header_type) {
575                 case 0x00: /* STD_PCI_DEV */
576                         return pcidev_read16(pcidev, PCI_SUBSYSID_STD);
577                 case 0x01: /* PCI2PCI */
578                         return -1;
579                 case 0x02: /* PCI2CARDBUS */
580                         return pcidev_read16(pcidev, PCI_SUBDEVID_CB);
581                 default:
582                         warn("Unknown Header Type, %d", header_type);
583         }
584         return -1;
585 }
586
587 void pci_dump_config(struct pci_device *pcidev, size_t len)
588 {
589         if (len > 256)
590                 printk("FYI, printing more than 256 bytes of PCI space\n");
591         printk("PCI Config space for %02x:%02x:%02x\n---------------------\n",
592                pcidev->bus, pcidev->dev, pcidev->func);
593         for (int i = 0; i < len; i += 4)
594                 printk("0x%03x | %08x\n", i, pcidev_read32(pcidev, i));
595 }
596
597 int pci_find_cap(struct pci_device *pcidev, uint8_t cap_id, uint32_t *cap_reg)
598 {
599         if (cap_id > PCI_CAP_ID_MAX)
600                 return -EINVAL;
601         if (!pcidev->caps[cap_id])
602                 return -ENOENT;
603         /* The actual value at caps[id] is the offset in the PCI config space where
604          * that ID was stored.  That's needed for accessing the capability. */
605         if (cap_reg)
606                 *cap_reg = pcidev->caps[cap_id];
607         return 0;
608 }
609
610 unsigned int pci_to_tbdf(struct pci_device *pcidev)
611 {
612         return MKBUS(BusPCI, pcidev->bus, pcidev->dev, pcidev->func);
613 }
614
615 uintptr_t pci_map_membar(struct pci_device *dev, int bir)
616 {
617         uintptr_t paddr = pci_get_membar(dev, bir);
618         size_t sz = pci_get_membar_sz(dev, bir);
619         if (!paddr || !sz)
620                 return 0;
621         return vmap_pmem_nocache(paddr, sz);
622 }
623
624 /* The following were ported from Linux:
625  *
626  * pci_set_cacheline_size
627  * pci_set_mwi
628  * pci_clear_mwi
629  */
630 int pci_set_cacheline_size(struct pci_device *dev)
631 {
632         uint8_t cl_sz;
633         uint8_t pci_cache_line_size = ARCH_CL_SIZE >> 2;
634
635         cl_sz = pcidev_read8(dev, PCI_CACHE_LINE_SIZE);
636         /* Validate current setting: the PCI_CACHE_LINE_SIZE must be equal to or
637          * multiple of the right value. */
638         if (cl_sz >= pci_cache_line_size && (cl_sz % pci_cache_line_size) == 0)
639                 return 0;
640         pcidev_write8(dev, PCI_CACHE_LINE_SIZE, pci_cache_line_size);
641         cl_sz = pcidev_read8(dev, PCI_CACHE_LINE_SIZE);
642         if (cl_sz == pci_cache_line_size)
643                 return 0;
644         printk("PCI device %s does not support cache line size of %d\n",
645                dev->name, pci_cache_line_size << 2);
646         return -EINVAL;
647 }
648
649 int pci_set_mwi(struct pci_device *dev)
650 {
651         int rc;
652         uint16_t cmd;
653
654         rc = pci_set_cacheline_size(dev);
655         if (rc)
656                 return rc;
657         cmd = pcidev_read16(dev, PCI_COMMAND);
658         if (!(cmd & PCI_COMMAND_INVALIDATE)) {
659                 cmd |= PCI_COMMAND_INVALIDATE;
660                 pcidev_write16(dev, PCI_COMMAND, cmd);
661         }
662         return 0;
663 }
664
665 void pci_clear_mwi(struct pci_device *dev)
666 {
667         uint16_t cmd;
668
669         cmd = pcidev_read16(dev, PCI_COMMAND);
670         if (cmd & PCI_COMMAND_INVALIDATE) {
671                 cmd &= ~PCI_COMMAND_INVALIDATE;
672                 pcidev_write16(dev, PCI_COMMAND, cmd);
673         }
674 }