1 /*
2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3 * Copyright (c) 2016 Netflix, Inc
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29
30 /*
31 * PnP enumerator using the PCI BIOS.
32 */
33
34 #include <stand.h>
35 #include <machine/stdarg.h>
36 #include <machine/cpufunc.h>
37 #include <bootstrap.h>
38 #include <isapnp.h>
39 #include <btxv86.h>
40 #include "libi386.h"
41 #include "ficl.h"
42
43 /*
44 * Stupid PCI BIOS interface doesn't let you simply enumerate everything
45 * that's there, instead you have to ask it if it has something.
46 *
47 * So we have to scan by class code, subclass code and sometimes programming
48 * interface.
49 */
50
51 struct pci_progif
52 {
53 int pi_code;
54 const char *pi_name;
55 };
56
57 static struct pci_progif progif_null[] = {
58 {0x0, NULL},
59 {-1, NULL}
60 };
61
62 static struct pci_progif progif_display[] = {
63 {0x0, "VGA"},
64 {0x1, "8514"},
65 {-1, NULL}
66 };
67
68 static struct pci_progif progif_ide[] = {
69 {0x00, NULL},
70 {0x01, NULL},
71 {0x02, NULL},
72 {0x03, NULL},
73 {0x04, NULL},
74 {0x05, NULL},
75 {0x06, NULL},
76 {0x07, NULL},
77 {0x08, NULL},
78 {0x09, NULL},
79 {0x0a, NULL},
80 {0x0b, NULL},
81 {0x0c, NULL},
82 {0x0d, NULL},
83 {0x0e, NULL},
84 {0x0f, NULL},
85 {0x80, NULL},
86 {0x81, NULL},
87 {0x82, NULL},
88 {0x83, NULL},
89 {0x84, NULL},
90 {0x85, NULL},
91 {0x86, NULL},
92 {0x87, NULL},
93 {0x88, NULL},
94 {0x89, NULL},
95 {0x8a, NULL},
96 {0x8b, NULL},
97 {0x8c, NULL},
98 {0x8d, NULL},
99 {0x8e, NULL},
100 {0x8f, NULL},
101 {-1, NULL}
102 };
103
104 static struct pci_progif progif_serial[] = {
105 {0x0, "8250"},
106 {0x1, "16450"},
107 {0x2, "16550"},
108 {-1, NULL}
109 };
110
111 static struct pci_progif progif_parallel[] = {
112 {0x0, "Standard"},
113 {0x1, "Bidirectional"},
114 {0x2, "ECP"},
115 {-1, NULL}
116 };
117
118 static struct pci_progif progif_firewire[] = {
119 {0x10, "OHCI"},
120 {-1, NULL}
121 };
122
123 struct pci_subclass
124 {
125 int ps_subclass;
126 const char *ps_name;
127 /* if set, use for programming interface value(s) */
128 struct pci_progif *ps_progif;
129 };
130
131 static struct pci_subclass subclass_old[] = {
132 {0x0, "Old non-VGA", progif_null},
133 {0x1, "Old VGA", progif_null},
134 {-1, NULL, NULL}
135 };
136
137 static struct pci_subclass subclass_mass[] = {
138 {0x0, "SCSI", progif_null},
139 {0x1, "IDE", progif_ide},
140 {0x2, "Floppy disk", progif_null},
141 {0x3, "IPI", progif_null},
142 {0x4, "RAID", progif_null},
143 {0x80, "mass storage", progif_null},
144 {-1, NULL, NULL}
145 };
146
147 static struct pci_subclass subclass_net[] = {
148 {0x0, "Ethernet", progif_null},
149 {0x1, "Token ring", progif_null},
150 {0x2, "FDDI", progif_null},
151 {0x3, "ATM", progif_null},
152 {0x80, "network", progif_null},
153 {-1, NULL, NULL}
154 };
155
156 static struct pci_subclass subclass_display[] = {
157 {0x0, NULL, progif_display},
158 {0x1, "XGA", progif_null},
159 {0x80, "other", progif_null},
160 {-1, NULL, NULL}
161 };
162
163 static struct pci_subclass subclass_comms[] = {
164 {0x0, "serial", progif_serial},
165 {0x1, "parallel", progif_parallel},
166 {0x80, "communications", progif_null},
167 {-1, NULL, NULL}
168 };
169
170 static struct pci_subclass subclass_serial[] = {
171 {0x0, "FireWire", progif_firewire},
172 {0x1, "ACCESS.bus", progif_null},
173 {0x2, "SSA", progif_null},
174 {0x3, "USB", progif_null},
175 {0x4, "Fibrechannel", progif_null},
176 {-1, NULL, NULL}
177 };
178
179 static struct pci_class
180 {
181 int pc_class;
182 const char *pc_name;
183 struct pci_subclass *pc_subclass;
184 } pci_classes[] = {
185 {0x0, "device", subclass_old},
186 {0x1, "controller", subclass_mass},
187 {0x2, "controller", subclass_net},
188 {0x3, "display", subclass_display},
189 {0x7, "controller", subclass_comms},
190 {0xc, "controller", subclass_serial},
191 {-1, NULL, NULL}
192 };
193
194
195 static void biospci_enumerate(void);
196 static void biospci_addinfo(int, struct pci_class *, struct pci_subclass *,
197 struct pci_progif *);
198
199 struct pnphandler biospcihandler =
200 {
201 "PCI BIOS",
202 biospci_enumerate
203 };
204
205 #define PCI_BIOS_PRESENT 0xb101
206 #define FIND_PCI_DEVICE 0xb102
207 #define FIND_PCI_CLASS_CODE 0xb103
208 #define GENERATE_SPECIAL_CYCLE 0xb106
209 #define READ_CONFIG_BYTE 0xb108
210 #define READ_CONFIG_WORD 0xb109
211 #define READ_CONFIG_DWORD 0xb10a
212 #define WRITE_CONFIG_BYTE 0xb10b
213 #define WRITE_CONFIG_WORD 0xb10c
214 #define WRITE_CONFIG_DWORD 0xb10d
215 #define GET_IRQ_ROUTING_OPTIONS 0xb10e
216 #define SET_PCI_IRQ 0xb10f
217
218 #define PCI_INT 0x1a
219
220 #define PCI_SIGNATURE 0x20494350 /* AKA "PCI " */
221
222 void
biospci_detect(void)223 biospci_detect(void)
224 {
225 uint16_t version, hwcap, maxbus;
226 char buf[24];
227
228 /* Find the PCI BIOS */
229 v86.ctl = V86_FLAGS;
230 v86.addr = PCI_INT;
231 v86.eax = PCI_BIOS_PRESENT;
232 v86.edi = 0x0;
233 v86int();
234
235 /* Check for OK response */
236 if (V86_CY(v86.efl) || ((v86.eax & 0xff00) != 0) ||
237 (v86.edx != PCI_SIGNATURE))
238 return;
239
240 version = v86.ebx & 0xffff;
241 hwcap = v86.eax & 0xff;
242 maxbus = v86.ecx & 0xff;
243 #if 0
244 printf("PCI BIOS %d.%d%s%s maxbus %d\n",
245 bcd2bin((version >> 8) & 0xf), bcd2bin(version & 0xf),
246 (hwcap & 1) ? " config1" : "", (hwcap & 2) ? " config2" : "",
247 maxbus);
248 #endif
249 sprintf(buf, "%d", bcd2bin((version >> 8) & 0xf));
250 setenv("pcibios.major", buf, 1);
251 sprintf(buf, "%d", bcd2bin(version & 0xf));
252 setenv("pcibios.minor", buf, 1);
253 sprintf(buf, "%d", !!(hwcap & 1));
254 setenv("pcibios.config1", buf, 1);
255 sprintf(buf, "%d", !!(hwcap & 2));
256 setenv("pcibios.config2", buf, 1);
257 sprintf(buf, "%d", maxbus);
258 setenv("pcibios.maxbus", buf, 1);
259 }
260
261 static void
biospci_enumerate(void)262 biospci_enumerate(void)
263 {
264 int device_index, err;
265 uint32_t locator, devid;
266 struct pci_class *pc;
267 struct pci_subclass *psc;
268 struct pci_progif *ppi;
269
270 /* Iterate over known classes */
271 for (pc = pci_classes; pc->pc_class >= 0; pc++) {
272 /* Iterate over subclasses */
273 for (psc = pc->pc_subclass; psc->ps_subclass >= 0; psc++) {
274 /* Iterate over programming interfaces */
275 for (ppi = psc->ps_progif; ppi->pi_code >= 0; ppi++) {
276
277 /* Scan for matches */
278 for (device_index = 0; ; device_index++) {
279 /* Look for a match */
280 err = biospci_find_devclass(
281 (pc->pc_class << 16) +
282 (psc->ps_subclass << 8) +
283 ppi->pi_code,
284 device_index, &locator);
285 if (err != 0)
286 break;
287
288 /*
289 * Read the device identifier from
290 * the nominated device
291 */
292 err = biospci_read_config(locator,
293 0, 2, &devid);
294 if (err != 0)
295 break;
296
297 /*
298 * We have the device ID, create a PnP
299 * object and save everything
300 */
301 biospci_addinfo(devid, pc, psc, ppi);
302 }
303 }
304 }
305 }
306 }
307
308 static void
biospci_addinfo(int devid,struct pci_class * pc,struct pci_subclass * psc,struct pci_progif * ppi)309 biospci_addinfo(int devid, struct pci_class *pc, struct pci_subclass *psc,
310 struct pci_progif *ppi)
311 {
312 struct pnpinfo *pi;
313 char desc[80];
314
315
316 /* build the description */
317 desc[0] = 0;
318 if (ppi->pi_name != NULL) {
319 strcat(desc, ppi->pi_name);
320 strcat(desc, " ");
321 }
322 if (psc->ps_name != NULL) {
323 strcat(desc, psc->ps_name);
324 strcat(desc, " ");
325 }
326 if (pc->pc_name != NULL)
327 strcat(desc, pc->pc_name);
328
329 pi = pnp_allocinfo();
330 pi->pi_desc = strdup(desc);
331 sprintf(desc, "0x%08x", devid);
332 pnp_addident(pi, desc);
333 pnp_addinfo(pi);
334 }
335
336 int
biospci_find_devclass(uint32_t class,int index,uint32_t * locator)337 biospci_find_devclass(uint32_t class, int index, uint32_t *locator)
338 {
339 v86.ctl = V86_FLAGS;
340 v86.addr = PCI_INT;
341 v86.eax = FIND_PCI_CLASS_CODE;
342 v86.ecx = class;
343 v86.esi = index;
344 v86int();
345
346 /* error */
347 if (V86_CY(v86.efl) || (v86.eax & 0xff00))
348 return (-1);
349
350 *locator = v86.ebx;
351 return (0);
352 }
353
354 static int
biospci_find_device(uint32_t devid,int index,uint32_t * locator)355 biospci_find_device(uint32_t devid, int index, uint32_t *locator)
356 {
357 v86.ctl = V86_FLAGS;
358 v86.addr = PCI_INT;
359 v86.eax = FIND_PCI_DEVICE;
360 v86.edx = devid & 0xffff; /* EDX - Vendor ID */
361 v86.ecx = (devid >> 16) & 0xffff; /* ECX - Device ID */
362 v86.esi = index;
363 v86int();
364
365 /* error */
366 if (V86_CY(v86.efl) || (v86.eax & 0xff00))
367 return (-1);
368
369 *locator = v86.ebx;
370 return (0);
371 }
372 /*
373 * Configuration space access methods.
374 * width = 0(byte), 1(word) or 2(dword).
375 */
376 int
biospci_write_config(uint32_t locator,int offset,int width,uint32_t val)377 biospci_write_config(uint32_t locator, int offset, int width, uint32_t val)
378 {
379 v86.ctl = V86_FLAGS;
380 v86.addr = PCI_INT;
381 v86.eax = WRITE_CONFIG_BYTE + width;
382 v86.ebx = locator;
383 v86.edi = offset;
384 v86.ecx = val;
385 v86int();
386
387 /* error */
388 if (V86_CY(v86.efl) || (v86.eax & 0xff00))
389 return (-1);
390
391 return (0);
392 }
393
394 int
biospci_read_config(uint32_t locator,int offset,int width,uint32_t * val)395 biospci_read_config(uint32_t locator, int offset, int width, uint32_t *val)
396 {
397 v86.ctl = V86_FLAGS;
398 v86.addr = PCI_INT;
399 v86.eax = READ_CONFIG_BYTE + width;
400 v86.ebx = locator;
401 v86.edi = offset;
402 v86int();
403
404 /* error */
405 if (V86_CY(v86.efl) || (v86.eax & 0xff00))
406 return (-1);
407
408 *val = v86.ecx;
409 return (0);
410 }
411
412 uint32_t
biospci_locator(int8_t bus,uint8_t device,uint8_t function)413 biospci_locator(int8_t bus, uint8_t device, uint8_t function)
414 {
415
416 return ((bus << 8) | ((device & 0x1f) << 3) | (function & 0x7));
417 }
418
419 /*
420 * Counts the number of instances of devid we have in the system, as least as
421 * far as the PCI BIOS is able to tell.
422 */
423 static int
biospci_count_device_type(uint32_t devid)424 biospci_count_device_type(uint32_t devid)
425 {
426 int i;
427
428 for (i = 0; 1; i++) {
429 v86.ctl = V86_FLAGS;
430 v86.addr = PCI_INT;
431 v86.eax = FIND_PCI_DEVICE;
432 v86.edx = devid & 0xffff; /* EDX - Vendor ID */
433 v86.ecx = (devid >> 16) & 0xffff; /* ECX - Device ID */
434 v86.esi = i;
435 v86int();
436 if (V86_CY(v86.efl) || (v86.eax & 0xff00))
437 break;
438
439 }
440 return (i);
441 }
442
443 /*
444 * pcibios-device-count (devid -- count)
445 *
446 * Returns the PCI BIOS' count of how many devices matching devid are
447 * in the system. devid is the 32-bit vendor + device.
448 */
449 static void
ficlPciBiosCountDevices(ficlVm * pVM)450 ficlPciBiosCountDevices(ficlVm *pVM)
451 {
452 uint32_t devid;
453 int i;
454
455 FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 1, 1);
456
457 devid = ficlStackPopInteger(ficlVmGetDataStack(pVM));
458
459 i = biospci_count_device_type(devid);
460
461 ficlStackPushInteger(ficlVmGetDataStack(pVM), i);
462 }
463
464 /*
465 * pcibios-write-config (locator offset width value -- )
466 *
467 * Writes the specified config register.
468 * Locator is bus << 8 | device << 3 | fuction
469 * offset is the pci config register
470 * width is 0 for byte, 1 for word, 2 for dword
471 * value is the value to write
472 */
473 static void
ficlPciBiosWriteConfig(ficlVm * pVM)474 ficlPciBiosWriteConfig(ficlVm *pVM)
475 {
476 uint32_t value, width, offset, locator;
477
478 FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 4, 0);
479
480 value = ficlStackPopInteger(ficlVmGetDataStack(pVM));
481 width = ficlStackPopInteger(ficlVmGetDataStack(pVM));
482 offset = ficlStackPopInteger(ficlVmGetDataStack(pVM));
483 locator = ficlStackPopInteger(ficlVmGetDataStack(pVM));
484
485 biospci_write_config(locator, offset, width, value);
486 }
487
488 /*
489 * pcibios-read-config (locator offset width -- value)
490 *
491 * Reads the specified config register.
492 * Locator is bus << 8 | device << 3 | fuction
493 * offset is the pci config register
494 * width is 0 for byte, 1 for word, 2 for dword
495 * value is the value to read from the register
496 */
497 static void
ficlPciBiosReadConfig(ficlVm * pVM)498 ficlPciBiosReadConfig(ficlVm *pVM)
499 {
500 uint32_t value, width, offset, locator;
501
502 FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
503
504 width = ficlStackPopInteger(ficlVmGetDataStack(pVM));
505 offset = ficlStackPopInteger(ficlVmGetDataStack(pVM));
506 locator = ficlStackPopInteger(ficlVmGetDataStack(pVM));
507
508 value = 0;
509 (void) biospci_read_config(locator, offset, width, &value);
510
511 ficlStackPushInteger(ficlVmGetDataStack(pVM), value);
512 }
513
514 /*
515 * pcibios-find-devclass (class index -- locator)
516 *
517 * Finds the index'th instance of class in the pci tree.
518 * must be an exact match.
519 * class is the class to search for.
520 * index 0..N (set to 0, increment until error)
521 *
522 * Locator is bus << 8 | device << 3 | fuction (or -1 on error)
523 */
524 static void
ficlPciBiosFindDevclass(ficlVm * pVM)525 ficlPciBiosFindDevclass(ficlVm *pVM)
526 {
527 uint32_t index, class, locator;
528
529 FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 1);
530
531 index = ficlStackPopInteger(ficlVmGetDataStack(pVM));
532 class = ficlStackPopInteger(ficlVmGetDataStack(pVM));
533
534 if (biospci_find_devclass(class, index, &locator))
535 locator = 0xffffffff;
536
537 ficlStackPushInteger(ficlVmGetDataStack(pVM), locator);
538 }
539
540 /*
541 * pcibios-find-device(devid index -- locator)
542 *
543 * Finds the index'th instance of devid in the pci tree.
544 * must be an exact match.
545 * class is the class to search for.
546 * index 0..N (set to 0, increment until error)
547 *
548 * Locator is bus << 8 | device << 3 | fuction (or -1 on error)
549 */
550 static void
ficlPciBiosFindDevice(ficlVm * pVM)551 ficlPciBiosFindDevice(ficlVm *pVM)
552 {
553 uint32_t index, devid, locator;
554
555 FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 1);
556
557 index = ficlStackPopInteger(ficlVmGetDataStack(pVM));
558 devid = ficlStackPopInteger(ficlVmGetDataStack(pVM));
559
560 if (biospci_find_device(devid, index, &locator))
561 locator = 0xffffffff;
562
563 ficlStackPushInteger(ficlVmGetDataStack(pVM), locator);
564 }
565
566 /*
567 * pcibios-locator(bus device function -- locator)
568 *
569 * converts bus, device, function to locator.
570 *
571 * Locator is bus << 8 | device << 3 | fuction
572 */
573 static void
ficlPciBiosLocator(ficlVm * pVM)574 ficlPciBiosLocator(ficlVm *pVM)
575 {
576 uint32_t bus, device, function, locator;
577
578 FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 3, 1);
579
580 function = ficlStackPopInteger(ficlVmGetDataStack(pVM));
581 device = ficlStackPopInteger(ficlVmGetDataStack(pVM));
582 bus = ficlStackPopInteger(ficlVmGetDataStack(pVM));
583
584 locator = biospci_locator(bus, device, function);
585
586 ficlStackPushInteger(ficlVmGetDataStack(pVM), locator);
587 }
588
589 /*
590 * Glue function to add the appropriate forth words to access pci bios
591 * functionality.
592 */
593 static void
ficlCompilePciBios(ficlSystem * pSys)594 ficlCompilePciBios(ficlSystem *pSys)
595 {
596 ficlDictionary *dp = ficlSystemGetDictionary(pSys);
597
598 FICL_SYSTEM_ASSERT(pSys, dp);
599
600 ficlDictionarySetPrimitive(dp, "pcibios-device-count",
601 ficlPciBiosCountDevices, FICL_WORD_DEFAULT);
602 ficlDictionarySetPrimitive(dp, "pcibios-read-config",
603 ficlPciBiosReadConfig, FICL_WORD_DEFAULT);
604 ficlDictionarySetPrimitive(dp, "pcibios-write-config",
605 ficlPciBiosWriteConfig, FICL_WORD_DEFAULT);
606 ficlDictionarySetPrimitive(dp, "pcibios-find-devclass",
607 ficlPciBiosFindDevclass, FICL_WORD_DEFAULT);
608 ficlDictionarySetPrimitive(dp, "pcibios-find-device",
609 ficlPciBiosFindDevice, FICL_WORD_DEFAULT);
610 ficlDictionarySetPrimitive(dp, "pcibios-locator", ficlPciBiosLocator,
611 FICL_WORD_DEFAULT);
612 }
613
614 FICL_COMPILE_SET(ficlCompilePciBios);
615