Sync PCI code with FreeBSD 7.2
[dragonfly.git] / sys / bus / pci / i386 / pci_cfgreg.c
1 /*-
2  * Copyright (c) 1997, Stefan Esser <se@kfreebsd.org>
3  * Copyright (c) 2000, Michael Smith <msmith@kfreebsd.org>
4  * Copyright (c) 2000, BSDi
5  * Copyright (c) 2004, Scott Long <scottl@kfreebsd.org>
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice unmodified, this list of conditions, and the following
13  *    disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  * __FBSDID("$FreeBSD: src/sys/i386/pci/pci_cfgreg.c,v 1.124.2.2.6.1 2009/04/15 03:14:26 kensmith Exp $");
29  */
30
31 #if defined(__DragonFly__)
32 #define mtx_init(a, b, c, d) spin_init(a)
33 #define mtx_lock_spin(a) spin_lock_wr(a)
34 #define mtx_unlock_spin(a) spin_unlock_wr(a)
35 #endif
36
37 #include <sys/cdefs.h>
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/bus.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/thread2.h>
45 #include <sys/spinlock.h>
46 #include <sys/spinlock2.h>
47 #include <sys/queue.h>
48 #include <bus/pci/pcivar.h>
49 #include <bus/pci/pcireg.h>
50 #include "pci_cfgreg.h"
51 #include <machine/pc/bios.h>
52
53 #include <vm/vm.h>
54 #include <vm/vm_param.h>
55 #include <vm/vm_kern.h>
56 #include <vm/vm_extern.h>
57 #include <vm/pmap.h>
58 #include <machine/pmap.h>
59
60 #define PRVERB(a) do {                                                  \
61         if (bootverbose)                                                \
62                 kprintf a ;                                             \
63 } while(0)
64
65 #define PCIE_CACHE 8
66 struct pcie_cfg_elem {
67         TAILQ_ENTRY(pcie_cfg_elem)      elem;
68         vm_offset_t     vapage;
69         vm_paddr_t      papage;
70 };
71
72 enum {
73         CFGMECH_NONE = 0,
74         CFGMECH_1,
75         CFGMECH_2,
76         CFGMECH_PCIE,
77 };
78
79 static TAILQ_HEAD(pcie_cfg_list, pcie_cfg_elem) pcie_list[MAXCPU];
80 static uint32_t pciebar;
81 static int cfgmech;
82 static int devmax;
83 #if defined(__DragonFly__)
84 static struct spinlock pcicfg_mtx;
85 #else
86 static struct mtx pcicfg_mtx;
87 #endif
88
89 static int      pcireg_cfgread(int bus, int slot, int func, int reg, int bytes);
90 static void     pcireg_cfgwrite(int bus, int slot, int func, int reg, int data, int bytes);
91 static int      pcireg_cfgopen(void);
92
93 static int      pciereg_cfgopen(void);
94 static int      pciereg_cfgread(int bus, int slot, int func, int reg,
95                                 int bytes);
96 static void     pciereg_cfgwrite(int bus, int slot, int func, int reg,
97                                  int data, int bytes);
98
99 /*
100  * Some BIOS writers seem to want to ignore the spec and put
101  * 0 in the intline rather than 255 to indicate none.  Some use
102  * numbers in the range 128-254 to indicate something strange and
103  * apparently undocumented anywhere.  Assume these are completely bogus
104  * and map them to 255, which means "none".
105  */
106 static __inline int 
107 pci_i386_map_intline(int line)
108 {
109         if (line == 0 || line >= 128)
110                 return (PCI_INVALID_IRQ);
111         return (line);
112 }
113
114 static u_int16_t
115 pcibios_get_version(void)
116 {
117         struct bios_regs args;
118
119         if (PCIbios.ventry == 0) {
120                 PRVERB(("pcibios: No call entry point\n"));
121                 return (0);
122         }
123         args.eax = PCIBIOS_BIOS_PRESENT;
124         if (bios32(&args, PCIbios.ventry, GSEL(GCODE_SEL, SEL_KPL))) {
125                 PRVERB(("pcibios: BIOS_PRESENT call failed\n"));
126                 return (0);
127         }
128         if (args.edx != 0x20494350) {
129                 PRVERB(("pcibios: BIOS_PRESENT didn't return 'PCI ' in edx\n"));
130                 return (0);
131         }
132         return (args.ebx & 0xffff);
133 }
134
135 /* 
136  * Initialise access to PCI configuration space 
137  */
138 int
139 pci_cfgregopen(void)
140 {
141         static int              opened = 0;
142         u_int16_t               vid, did;
143         u_int16_t               v;
144         if (opened)
145                 return(1);
146
147         if (pcireg_cfgopen() == 0)
148                 return(0);
149
150         v = pcibios_get_version();
151         if (v > 0)
152                 PRVERB(("pcibios: BIOS version %x.%02x\n", (v & 0xff00) >> 8,
153                     v & 0xff));
154         mtx_init(&pcicfg_mtx, "pcicfg", NULL, MTX_SPIN);
155         opened = 1;
156
157         /* $PIR requires PCI BIOS 2.10 or greater. */
158         if (v >= 0x0210)
159                 pci_pir_open();
160
161         /*
162          * Grope around in the PCI config space to see if this is a
163          * chipset that is capable of doing memory-mapped config cycles.
164          * This also implies that it can do PCIe extended config cycles.
165          */
166
167         /* Check for supported chipsets */
168         vid = pci_cfgregread(0, 0, 0, PCIR_VENDOR, 2);
169         did = pci_cfgregread(0, 0, 0, PCIR_DEVICE, 2);
170         if (vid == 0x8086) {
171                 if (did == 0x3590 || did == 0x3592) {
172                         /* Intel 7520 or 7320 */
173                         pciebar = pci_cfgregread(0, 0, 0, 0xce, 2) << 16;
174                         pciereg_cfgopen();
175                 } else if (did == 0x2580 || did == 0x2584) {
176                         /* Intel 915 or 925 */
177                         pciebar = pci_cfgregread(0, 0, 0, 0x48, 4);
178                         pciereg_cfgopen();
179                 }
180         }
181
182         return(1);
183 }
184
185 /* 
186  * Read configuration space register
187  */
188 u_int32_t
189 pci_cfgregread(int bus, int slot, int func, int reg, int bytes)
190 {
191         uint32_t line;
192
193         /*
194          * Some BIOS writers seem to want to ignore the spec and put
195          * 0 in the intline rather than 255 to indicate none.  The rest of
196          * the code uses 255 as an invalid IRQ.
197          */
198         if (reg == PCIR_INTLINE && bytes == 1) {
199                 line = pcireg_cfgread(bus, slot, func, PCIR_INTLINE, 1);
200                 return (pci_i386_map_intline(line));
201         }
202         return (pcireg_cfgread(bus, slot, func, reg, bytes));
203 }
204
205 /* 
206  * Write configuration space register 
207  */
208 void
209 pci_cfgregwrite(int bus, int slot, int func, int reg, u_int32_t data, int bytes)
210 {
211
212         pcireg_cfgwrite(bus, slot, func, reg, data, bytes);
213 }
214
215 /* 
216  * Configuration space access using direct register operations
217  */
218
219 /* enable configuration space accesses and return data port address */
220 static int
221 pci_cfgenable(unsigned bus, unsigned slot, unsigned func, int reg, int bytes)
222 {
223         int dataport = 0;
224
225 #ifdef XBOX
226         if (arch_i386_is_xbox) {
227                 /*
228                  * The Xbox MCPX chipset is a derivative of the nForce 1
229                  * chipset. It almost has the same bus layout; some devices
230                  * cannot be used, because they have been removed.
231                  */
232
233                 /*
234                  * Devices 00:00.1 and 00:00.2 used to be memory controllers on
235                  * the nForce chipset, but on the Xbox, using them will lockup
236                  * the chipset.
237                  */
238                 if (bus == 0 && slot == 0 && (func == 1 || func == 2))
239                         return dataport;
240                 
241                 /*
242                  * Bus 1 only contains a VGA controller at 01:00.0. When you try
243                  * to probe beyond that device, you only get garbage, which
244                  * could cause lockups.
245                  */
246                 if (bus == 1 && (slot != 0 || func != 0))
247                         return dataport;
248                 
249                 /*
250                  * Bus 2 used to contain the AGP controller, but the Xbox MCPX
251                  * doesn't have one. Probing it can cause lockups.
252                  */
253                 if (bus >= 2)
254                         return dataport;
255         }
256 #endif
257
258         if (bus <= PCI_BUSMAX
259             && slot < devmax
260             && func <= PCI_FUNCMAX
261             && reg <= PCI_REGMAX
262             && bytes != 3
263             && (unsigned) bytes <= 4
264             && (reg & (bytes - 1)) == 0) {
265                 switch (cfgmech) {
266                 case CFGMECH_1:
267                         outl(CONF1_ADDR_PORT, (1 << 31)
268                             | (bus << 16) | (slot << 11) 
269                             | (func << 8) | (reg & ~0x03));
270                         dataport = CONF1_DATA_PORT + (reg & 0x03);
271                         break;
272                 case CFGMECH_2:
273                         outb(CONF2_ENABLE_PORT, 0xf0 | (func << 1));
274                         outb(CONF2_FORWARD_PORT, bus);
275                         dataport = 0xc000 | (slot << 8) | reg;
276                         break;
277                 }
278         }
279         return (dataport);
280 }
281
282 /* disable configuration space accesses */
283 static void
284 pci_cfgdisable(void)
285 {
286         switch (cfgmech) {
287         case CFGMECH_1:
288                 /*
289                  * Do nothing for the config mechanism 1 case.
290                  * Writing a 0 to the address port can apparently
291                  * confuse some bridges and cause spurious
292                  * access failures.
293                  */
294                 break;
295         case CFGMECH_2:
296                 outb(CONF2_ENABLE_PORT, 0);
297                 break;
298         }
299 }
300
301 static int
302 pcireg_cfgread(int bus, int slot, int func, int reg, int bytes)
303 {
304         int data = -1;
305         int port;
306
307         if (cfgmech == CFGMECH_PCIE) {
308                 data = pciereg_cfgread(bus, slot, func, reg, bytes);
309                 return (data);
310         }
311
312         mtx_lock_spin(&pcicfg_mtx);
313         port = pci_cfgenable(bus, slot, func, reg, bytes);
314         if (port != 0) {
315                 switch (bytes) {
316                 case 1:
317                         data = inb(port);
318                         break;
319                 case 2:
320                         data = inw(port);
321                         break;
322                 case 4:
323                         data = inl(port);
324                         break;
325                 }
326                 pci_cfgdisable();
327         }
328         mtx_unlock_spin(&pcicfg_mtx);
329         return (data);
330 }
331
332 static void
333 pcireg_cfgwrite(int bus, int slot, int func, int reg, int data, int bytes)
334 {
335         int port;
336
337         if (cfgmech == CFGMECH_PCIE) {
338                 pciereg_cfgwrite(bus, slot, func, reg, data, bytes);
339                 return;
340         }
341
342         mtx_lock_spin(&pcicfg_mtx);
343         port = pci_cfgenable(bus, slot, func, reg, bytes);
344         if (port != 0) {
345                 switch (bytes) {
346                 case 1:
347                         outb(port, data);
348                         break;
349                 case 2:
350                         outw(port, data);
351                         break;
352                 case 4:
353                         outl(port, data);
354                         break;
355                 }
356                 pci_cfgdisable();
357         }
358         mtx_unlock_spin(&pcicfg_mtx);
359 }
360
361 /* check whether the configuration mechanism has been correctly identified */
362 static int
363 pci_cfgcheck(int maxdev)
364 {
365         uint32_t id, class;
366         uint8_t header;
367         uint8_t device;
368         int port;
369
370         if (bootverbose) 
371                 kprintf("pci_cfgcheck:\tdevice ");
372
373         for (device = 0; device < maxdev; device++) {
374                 if (bootverbose) 
375                         kprintf("%d ", device);
376
377                 port = pci_cfgenable(0, device, 0, 0, 4);
378                 id = inl(port);
379                 if (id == 0 || id == 0xffffffff)
380                         continue;
381
382                 port = pci_cfgenable(0, device, 0, 8, 4);
383                 class = inl(port) >> 8;
384                 if (bootverbose)
385                         kprintf("[class=%06x] ", class);
386                 if (class == 0 || (class & 0xf870ff) != 0)
387                         continue;
388
389                 port = pci_cfgenable(0, device, 0, 14, 1);
390                 header = inb(port);
391                 if (bootverbose)
392                         kprintf("[hdr=%02x] ", header);
393                 if ((header & 0x7e) != 0)
394                         continue;
395
396                 if (bootverbose)
397                         kprintf("is there (id=%08x)\n", id);
398
399                 pci_cfgdisable();
400                 return (1);
401         }
402         if (bootverbose) 
403                 kprintf("-- nothing found\n");
404
405         pci_cfgdisable();
406         return (0);
407 }
408
409 static int
410 pcireg_cfgopen(void)
411 {
412         uint32_t mode1res, oldval1;
413         uint8_t mode2res, oldval2;
414
415         /* Check for type #1 first. */
416         oldval1 = inl(CONF1_ADDR_PORT);
417
418         if (bootverbose) {
419                 kprintf("pci_open(1):\tmode 1 addr port (0x0cf8) is 0x%08x\n",
420                     oldval1);
421         }
422
423         cfgmech = CFGMECH_1;
424         devmax = 32;
425
426         outl(CONF1_ADDR_PORT, CONF1_ENABLE_CHK);
427         DELAY(1);
428         mode1res = inl(CONF1_ADDR_PORT);
429         outl(CONF1_ADDR_PORT, oldval1);
430
431         if (bootverbose)
432                 kprintf("pci_open(1a):\tmode1res=0x%08x (0x%08lx)\n",  mode1res,
433                     CONF1_ENABLE_CHK);
434
435         if (mode1res) {
436                 if (pci_cfgcheck(32)) 
437                         return (cfgmech);
438         }
439
440         outl(CONF1_ADDR_PORT, CONF1_ENABLE_CHK1);
441         mode1res = inl(CONF1_ADDR_PORT);
442         outl(CONF1_ADDR_PORT, oldval1);
443
444         if (bootverbose)
445                 kprintf("pci_open(1b):\tmode1res=0x%08x (0x%08lx)\n",  mode1res,
446                     CONF1_ENABLE_CHK1);
447
448         if ((mode1res & CONF1_ENABLE_MSK1) == CONF1_ENABLE_RES1) {
449                 if (pci_cfgcheck(32)) 
450                         return (cfgmech);
451         }
452
453         /* Type #1 didn't work, so try type #2. */
454         oldval2 = inb(CONF2_ENABLE_PORT);
455
456         if (bootverbose) {
457                 kprintf("pci_open(2):\tmode 2 enable port (0x0cf8) is 0x%02x\n",
458                     oldval2);
459         }
460
461         if ((oldval2 & 0xf0) == 0) {
462
463                 cfgmech = CFGMECH_2;
464                 devmax = 16;
465
466                 outb(CONF2_ENABLE_PORT, CONF2_ENABLE_CHK);
467                 mode2res = inb(CONF2_ENABLE_PORT);
468                 outb(CONF2_ENABLE_PORT, oldval2);
469
470                 if (bootverbose)
471                         kprintf("pci_open(2a):\tmode2res=0x%02x (0x%02x)\n",
472                             mode2res, CONF2_ENABLE_CHK);
473
474                 if (mode2res == CONF2_ENABLE_RES) {
475                         if (bootverbose)
476                                 kprintf("pci_open(2a):\tnow trying mechanism 2\n");
477
478                         if (pci_cfgcheck(16)) 
479                                 return (cfgmech);
480                 }
481         }
482
483         /* Nothing worked, so punt. */
484         cfgmech = CFGMECH_NONE;
485         devmax = 0;
486         return (cfgmech);
487 }
488
489 static int
490 pciereg_cfgopen(void)
491 {
492 #ifdef PCIE_CFG_MECH
493         struct pcie_cfg_list *pcielist;
494         struct pcie_cfg_elem *pcie_array, *elem;
495 #ifdef SMP
496         struct pcpu *pc;
497 #endif
498         vm_offset_t va;
499         int i;
500
501         if (bootverbose)
502                 kprintf("Setting up PCIe mappings for BAR 0x%x\n", pciebar);
503
504 #ifdef SMP
505         SLIST_FOREACH(pc, &cpuhead, pc_allcpu)
506 #endif
507         {
508
509                 pcie_array = kmalloc(sizeof(struct pcie_cfg_elem) * PCIE_CACHE,
510                     M_DEVBUF, M_NOWAIT);
511                 if (pcie_array == NULL)
512                         return (0);
513
514                 va = kmem_alloc_nofault(&kernel_map, PCIE_CACHE * PAGE_SIZE);
515                 if (va == 0) {
516                         kfree(pcie_array, M_DEVBUF);
517                         return (0);
518                 }
519
520 #ifdef SMP
521                 pcielist = &pcie_list[pc->pc_cpuid];
522 #else
523                 pcielist = &pcie_list[0];
524 #endif
525                 TAILQ_INIT(pcielist);
526                 for (i = 0; i < PCIE_CACHE; i++) {
527                         elem = &pcie_array[i];
528                         elem->vapage = va + (i * PAGE_SIZE);
529                         elem->papage = 0;
530                         TAILQ_INSERT_HEAD(pcielist, elem, elem);
531                 }
532         }
533
534         
535         cfgmech = CFGMECH_PCIE;
536         devmax = 32;
537         return (1);
538 #else   /* !PCIE_CFG_MECH */
539         return (0);
540 #endif  /* PCIE_CFG_MECH */
541 }
542
543 #define PCIE_PADDR(bar, reg, bus, slot, func)   \
544         ((bar)                          |       \
545         (((bus) & 0xff) << 20)          |       \
546         (((slot) & 0x1f) << 15)         |       \
547         (((func) & 0x7) << 12)          |       \
548         ((reg) & 0xfff))
549
550 /*
551  * Find an element in the cache that matches the physical page desired, or
552  * create a new mapping from the least recently used element.
553  * A very simple LRU algorithm is used here, does it need to be more
554  * efficient?
555  */
556 static __inline struct pcie_cfg_elem *
557 pciereg_findelem(vm_paddr_t papage)
558 {
559         struct pcie_cfg_list *pcielist;
560         struct pcie_cfg_elem *elem;
561         pcielist = &pcie_list[mycpuid];
562         TAILQ_FOREACH(elem, pcielist, elem) {
563                 if (elem->papage == papage)
564                         break;
565         }
566
567         if (elem == NULL) {
568                 elem = TAILQ_LAST(pcielist, pcie_cfg_list);
569                 if (elem->papage != 0) {
570                         pmap_kremove(elem->vapage);
571                         cpu_invlpg(&elem->vapage);
572                 }
573                 pmap_kenter(elem->vapage, papage);
574                 elem->papage = papage;
575         }
576
577         if (elem != TAILQ_FIRST(pcielist)) {
578                 TAILQ_REMOVE(pcielist, elem, elem);
579                 TAILQ_INSERT_HEAD(pcielist, elem, elem);
580         }
581         return (elem);
582 }
583
584 static int
585 pciereg_cfgread(int bus, int slot, int func, int reg, int bytes)
586 {
587         struct pcie_cfg_elem *elem;
588         volatile vm_offset_t va;
589         vm_paddr_t pa, papage;
590         int data;
591
592         crit_enter();
593         pa = PCIE_PADDR(pciebar, reg, bus, slot, func);
594         papage = pa & ~PAGE_MASK;
595         elem = pciereg_findelem(papage);
596         va = elem->vapage | (pa & PAGE_MASK);
597
598         switch (bytes) {
599         case 4:
600                 data = *(volatile uint32_t *)(va);
601                 break;
602         case 2:
603                 data = *(volatile uint16_t *)(va);
604                 break;
605         case 1:
606                 data = *(volatile uint8_t *)(va);
607                 break;
608         default:
609                 panic("pciereg_cfgread: invalid width");
610         }
611
612         crit_exit();
613         return (data);
614 }
615
616 static void
617 pciereg_cfgwrite(int bus, int slot, int func, int reg, int data, int bytes)
618 {
619         struct pcie_cfg_elem *elem;
620         volatile vm_offset_t va;
621         vm_paddr_t pa, papage;
622
623         crit_enter();
624         pa = PCIE_PADDR(pciebar, reg, bus, slot, func);
625         papage = pa & ~PAGE_MASK;
626         elem = pciereg_findelem(papage);
627         va = elem->vapage | (pa & PAGE_MASK);
628
629         switch (bytes) {
630         case 4:
631                 *(volatile uint32_t *)(va) = data;
632                 break;
633         case 2:
634                 *(volatile uint16_t *)(va) = data;
635                 break;
636         case 1:
637                 *(volatile uint8_t *)(va) = data;
638                 break;
639         default:
640                 panic("pciereg_cfgwrite: invalid width");
641         }
642
643         crit_exit();
644 }