?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
9597 Want hypervisor API for FPU management
[unleashed.git] / usr / src / uts / i86pc / io / immu_dmar.c
blob384f16e554ce24615100d1ff4008a0979efed337
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * Copyright (c) 2009, Intel Corporation.
27 * All rights reserved.
28 */
29
30
31 #include <sys/debug.h>
32 #include <sys/sysmacros.h>
33 #include <sys/types.h>
34 #include <sys/kmem.h>
35 #include <sys/sunddi.h>
36 #include <sys/list.h>
37 #include <sys/pci.h>
38 #include <sys/pci_cfgspace.h>
39 #include <sys/pci_impl.h>
40 #include <sys/sunndi.h>
41 #include <sys/ksynch.h>
42 #include <sys/cmn_err.h>
43 #include <sys/bootconf.h>
44 #include <sys/int_fmtio.h>
45 #include <sys/smbios.h>
46 #include <sys/apic.h>
47 #include <sys/acpi/acpi.h>
48 #include <sys/acpica.h>
49 #include <sys/immu.h>
50 #include <sys/smp_impldefs.h>
51
52 static void dmar_table_destroy(dmar_table_t *tbl);
53
54 /*
55 * internal global variables
56 */
57 static char *dmar_raw; /* raw DMAR ACPI table */
58 static dmar_table_t *dmar_table; /* converted form of DMAR table */
59
60 /*
61 * global variables exported outside this file
62 */
63 boolean_t dmar_print = B_FALSE;
64 kmutex_t ioapic_drhd_lock;
65 list_t ioapic_drhd_list;
66
67 /* ######################################################################### */
68
69 /*
70 * helper functions to read the "raw" DMAR table
71 */
72
73 static uint8_t
74 get_uint8(char *cp)
75 {
76 uint8_t val = *((uint8_t *)cp);
77 return (val);
78 }
79
80 static uint16_t
81 get_uint16(char *cp)
82 {
83 uint16_t val = *((uint16_t *)cp);
84 return (val);
85 }
86
87 static uint32_t
88 get_uint32(char *cp)
89 {
90 uint32_t val = *((uint32_t *)cp);
91 return (val);
92 }
93
94 static uint64_t
95 get_uint64(char *cp)
96 {
97 uint64_t val = *((uint64_t *)cp);
98 return (val);
99 }
100
101 static char *
102 get_str(char *cp, uint_t len)
103 {
104 char *str = kmem_alloc(len + 1, KM_SLEEP);
105
106 (void) strlcpy(str, cp, len + 1);
107
108 return (str);
109 }
110
111 static void
112 scope_list_free(list_t *scope_list)
113 {
114 scope_t *scope;
115
116 if (list_is_empty(scope_list)) {
117 list_destroy(scope_list);
118 return;
119 }
120
121 while ((scope = list_remove_head(scope_list)) != NULL) {
122 kmem_free(scope, sizeof (scope_t));
123 }
124
125 ASSERT(list_is_empty(scope_list));
126 list_destroy(scope_list);
127 }
128
129 static void
130 drhd_list_destroy(list_t *drhd_list)
131 {
132 drhd_t *drhd;
133
134 ASSERT(drhd_list);
135
136 if (list_is_empty(drhd_list)) {
137 list_destroy(drhd_list);
138 return;
139 }
140
141 while ((drhd = list_remove_head(drhd_list)) != NULL) {
142 scope_list_free(&(drhd->dr_scope_list));
143 kmem_free(drhd, sizeof (drhd_t));
144 }
145
146 ASSERT(list_is_empty(drhd_list));
147 list_destroy(drhd_list);
148 }
149
150 static void
151 rmrr_list_destroy(list_t *rmrr_list)
152 {
153 rmrr_t *rmrr;
154
155 ASSERT(rmrr_list);
156
157 if (list_is_empty(rmrr_list)) {
158 list_destroy(rmrr_list);
159 return;
160 }
161
162 while ((rmrr = list_remove_head(rmrr_list)) != NULL) {
163 scope_list_free(&(rmrr->rm_scope_list));
164 kmem_free(rmrr, sizeof (rmrr_t));
165 }
166
167 ASSERT(list_is_empty(rmrr_list));
168 list_destroy(rmrr_list);
169 }
170
171 /*
172 * parse_scope()
173 * parse a scope structure in the "raw" table
174 */
175 static scope_t *
176 parse_scope(char *shead)
177 {
178 scope_t *scope;
179 char *phead;
180 int bus, dev, func;
181 uint8_t startbus;
182 uint8_t len;
183 int depth;
184
185 ASSERT(shead);
186
187 scope = kmem_zalloc(sizeof (scope_t), KM_SLEEP);
188 scope->scp_type = get_uint8(&shead[0]);
189 scope->scp_enumid = get_uint8(&shead[4]);
190
191 len = get_uint8(&shead[1]);
192 startbus = get_uint8(&shead[5]);
193 depth = (len - 6)/2;
194 ASSERT(depth >= 1);
195
196 phead = &shead[6];
197
198 bus = startbus;
199 dev = get_uint8(phead++);
200 func = get_uint8(phead++);
201
202 for (depth--; depth > 0; depth--) {
203 bus = pci_getb_func(bus, dev, func, PCI_BCNF_SECBUS);
204 dev = get_uint8(phead++);
205 func = get_uint8(phead++);
206 }
207
208 ASSERT(bus >= 0 && bus < 256);
209 ASSERT(dev >= 0 && dev < 32);
210 ASSERT(func >= 0 && func < 8);
211
212 /* ok we got the device BDF */
213 scope->scp_bus = bus;
214 scope->scp_dev = dev;
215 scope->scp_func = func;
216
217 return (scope);
218 }
219
220
221 /* setup the ioapic_drhd structure */
222 static void
223 ioapic_drhd_setup(void)
224 {
225 mutex_init(&(ioapic_drhd_lock), NULL, MUTEX_DEFAULT, NULL);
226
227 mutex_enter(&(ioapic_drhd_lock));
228 list_create(&(ioapic_drhd_list), sizeof (ioapic_drhd_t),
229 offsetof(ioapic_drhd_t, ioapic_node));
230 mutex_exit(&(ioapic_drhd_lock));
231 }
232
233 /* get ioapic source id for interrupt remapping */
234 static void
235 ioapic_drhd_insert(scope_t *scope, drhd_t *drhd)
236 {
237 ioapic_drhd_t *idt;
238
239 idt = kmem_zalloc(sizeof (ioapic_drhd_t), KM_SLEEP);
240 idt->ioapic_ioapicid = scope->scp_enumid;
241 idt->ioapic_sid = ((scope->scp_bus << 8) | (scope->scp_dev << 3) |
242 (scope->scp_func));
243 idt->ioapic_drhd = drhd;
244
245 mutex_enter(&ioapic_drhd_lock);
246 list_insert_tail(&ioapic_drhd_list, idt);
247 mutex_exit(&ioapic_drhd_lock);
248 }
249
250 static ioapic_drhd_t *
251 ioapic_drhd_lookup(int ioapicid)
252 {
253 ioapic_drhd_t *idt;
254
255 mutex_enter(&ioapic_drhd_lock);
256 idt = list_head(&ioapic_drhd_list);
257 for (; idt; idt = list_next(&ioapic_drhd_list, idt)) {
258 if (idt->ioapic_ioapicid == ioapicid) {
259 break;
260 }
261 }
262 mutex_exit(&ioapic_drhd_lock);
263
264 return (idt);
265 }
266
267 static void
268 ioapic_drhd_destroy(void)
269 {
270 ioapic_drhd_t *idt;
271
272 mutex_enter(&ioapic_drhd_lock);
273 while (idt = list_remove_head(&ioapic_drhd_list)) {
274 kmem_free(idt, sizeof (ioapic_drhd_t));
275 }
276 list_destroy(&ioapic_drhd_list);
277 mutex_exit(&(ioapic_drhd_lock));
278
279 mutex_destroy(&(ioapic_drhd_lock));
280 }
281
282 /*
283 * parse_drhd()
284 * parse the drhd uints in dmar table
285 */
286 static int
287 parse_drhd(char *uhead, dmar_table_t *tbl)
288 {
289 drhd_t *drhd;
290 int seg;
291 int len;
292 char *shead;
293 scope_t *scope;
294
295 ASSERT(uhead);
296 ASSERT(tbl);
297 ASSERT(get_uint16(&uhead[0]) == DMAR_DRHD);
298
299 seg = get_uint16(&uhead[6]);
300 if (seg < 0 || seg >= IMMU_MAXSEG) {
301 ddi_err(DER_WARN, NULL, "invalid segment# <%d>"
302 "in DRHD unit in ACPI DMAR table", seg);
303 return (DDI_FAILURE);
304 }
305
306 drhd = kmem_zalloc(sizeof (drhd_t), KM_SLEEP);
307 mutex_init(&(drhd->dr_lock), NULL, MUTEX_DEFAULT, NULL);
308 list_create(&(drhd->dr_scope_list), sizeof (scope_t),
309 offsetof(scope_t, scp_node));
310
311 len = get_uint16(&uhead[2]);
312 drhd->dr_include_all =
313 (get_uint8(&uhead[4]) & DMAR_INCLUDE_ALL) ? B_TRUE : B_FALSE;
314 drhd->dr_seg = seg;
315 drhd->dr_regs = get_uint64(&uhead[8]);
316
317 /*
318 * parse each scope.
319 */
320 shead = &uhead[16];
321 while (shead < &uhead[len - 1]) {
322 scope = parse_scope(shead);
323 if (scope == NULL) {
324 return (DDI_FAILURE);
325 }
326
327 if (scope->scp_type == DMAR_IOAPIC) {
328 ioapic_drhd_insert(scope, drhd);
329 }
330
331 list_insert_tail(&(drhd->dr_scope_list), scope);
332 shead += get_uint8(&shead[1]);
333 }
334
335 list_insert_tail(&(tbl->tbl_drhd_list[drhd->dr_seg]), drhd);
336
337 return (DDI_SUCCESS);
338 }
339
340 /*
341 * parse_rmrr()
342 * parse the rmrr units in dmar table
343 */
344 static int
345 parse_rmrr(char *uhead, dmar_table_t *tbl)
346 {
347 rmrr_t *rmrr;
348 int seg;
349 int len;
350 char *shead;
351 scope_t *scope;
352
353 ASSERT(uhead);
354 ASSERT(tbl);
355 ASSERT(get_uint16(&uhead[0]) == DMAR_RMRR);
356
357 seg = get_uint16(&uhead[6]);
358 if (seg < 0 || seg >= IMMU_MAXSEG) {
359 ddi_err(DER_WARN, NULL, "invalid segment# <%d>"
360 "in RMRR unit in ACPI DMAR table", seg);
361 return (DDI_FAILURE);
362 }
363
364 rmrr = kmem_zalloc(sizeof (rmrr_t), KM_SLEEP);
365 mutex_init(&(rmrr->rm_lock), NULL, MUTEX_DEFAULT, NULL);
366 list_create(&(rmrr->rm_scope_list), sizeof (scope_t),
367 offsetof(scope_t, scp_node));
368
369 /* RMRR region is [base,limit] */
370 len = get_uint16(&uhead[2]);
371 rmrr->rm_seg = get_uint16(&uhead[6]);
372 rmrr->rm_base = get_uint64(&uhead[8]);
373 rmrr->rm_limit = get_uint64(&uhead[16]);
374
375 if (rmrr->rm_base > rmrr->rm_limit) {
376 ddi_err(DER_WARN, NULL, "IMMU: BIOS bug detected: "
377 "RMRR: base (%lx) > limit (%lx)",
378 rmrr->rm_base, rmrr->rm_limit);
379 list_destroy(&(rmrr->rm_scope_list));
380 mutex_destroy(&(rmrr->rm_lock));
381 kmem_free(rmrr, sizeof (rmrr_t));
382 return (DDI_SUCCESS);
383 }
384
385 /*
386 * parse each scope in RMRR
387 */
388 shead = &uhead[24];
389 while (shead < &uhead[len - 1]) {
390 scope = parse_scope(shead);
391 if (scope == NULL) {
392 return (DDI_FAILURE);
393 }
394 list_insert_tail(&(rmrr->rm_scope_list), scope);
395 shead += get_uint8(&shead[1]);
396 }
397
398 list_insert_tail(&(tbl->tbl_rmrr_list[rmrr->rm_seg]), rmrr);
399
400 return (DDI_SUCCESS);
401 }
402
403 #define TBL_OEM_ID_SZ (6)
404 #define TBL_OEM_TBLID_SZ (8)
405
406 /*
407 * parse the "raw" DMAR table and convert it
408 * into a useful form.
409 */
410 static int
411 dmar_parse(dmar_table_t **tblpp, char *raw)
412 {
413 char *uhead;
414 dmar_table_t *tbl;
415 int i;
416 char *unmstr;
417
418 ASSERT(raw);
419 ASSERT(tblpp);
420
421 *tblpp = NULL;
422
423 /*
424 * do a sanity check. make sure the raw table
425 * has the right signature
426 */
427 if (raw[0] != 'D' || raw[1] != 'M' ||
428 raw[2] != 'A' || raw[3] != 'R') {
429 ddi_err(DER_WARN, NULL, "IOMMU ACPI "
430 "signature != \"DMAR\"");
431 return (DDI_FAILURE);
432 }
433
434 /*
435 * the platform has intel iommu, create processed ACPI struct
436 */
437 tbl = kmem_zalloc(sizeof (dmar_table_t), KM_SLEEP);
438 mutex_init(&(tbl->tbl_lock), NULL, MUTEX_DEFAULT, NULL);
439
440 tbl->tbl_raw = raw;
441
442 /*
443 * Note we explicitly show offsets for clarity
444 */
445 tbl->tbl_rawlen = get_uint32(&raw[4]);
446
447 /* XXX TO DO verify checksum of table */
448 tbl->tbl_oem_id = get_str(&raw[10], TBL_OEM_ID_SZ);
449 tbl->tbl_oem_tblid = get_str(&raw[16], TBL_OEM_TBLID_SZ);
450 tbl->tbl_oem_rev = get_uint32(&raw[24]);
451 tbl->tbl_haw = get_uint8(&raw[36]) + 1;
452 tbl->tbl_intrmap = (get_uint8(&raw[37]) & DMAR_INTRMAP_SUPPORT)
453 ? B_TRUE : B_FALSE;
454
455 /* create lists for DRHD and RMRR */
456 for (i = 0; i < IMMU_MAXSEG; i++) {
457 list_create(&(tbl->tbl_drhd_list[i]), sizeof (drhd_t),
458 offsetof(drhd_t, dr_node));
459 list_create(&(tbl->tbl_rmrr_list[i]), sizeof (rmrr_t),
460 offsetof(rmrr_t, rm_node));
461 }
462
463 ioapic_drhd_setup();
464
465 /*
466 * parse each unit. Currently only DRHD and RMRR types
467 * are parsed. We ignore all other types of units.
468 */
469 uhead = &raw[48];
470 while (uhead < &raw[tbl->tbl_rawlen - 1]) {
471 unmstr = NULL;
472 switch (get_uint16(uhead)) {
473 case DMAR_DRHD:
474 if (parse_drhd(uhead, tbl) != DDI_SUCCESS) {
475 goto failed;
476 }
477 break;
478 case DMAR_RMRR:
479 if (parse_rmrr(uhead, tbl) != DDI_SUCCESS) {
480 goto failed;
481 }
482 break;
483 case DMAR_ATSR:
484 unmstr = "ATSR";
485 break;
486 case DMAR_RHSA:
487 unmstr = "RHSA";
488 break;
489 default:
490 unmstr = "unknown unity type";
491 break;
492 }
493 if (unmstr) {
494 ddi_err(DER_NOTE, NULL, "DMAR ACPI table: "
495 "skipping unsupported unit type %s", unmstr);
496 }
497 uhead += get_uint16(&uhead[2]);
498 }
499
500 *tblpp = tbl;
501 return (DDI_SUCCESS);
502
503 failed:
504 dmar_table_destroy(tbl);
505 return (DDI_FAILURE);
506 }
507
508 static char *
509 scope_type(int devtype)
510 {
511 char *typestr;
512
513 switch (devtype) {
514 case DMAR_ENDPOINT:
515 typestr = "endpoint-device";
516 break;
517 case DMAR_SUBTREE:
518 typestr = "subtree-device";
519 break;
520 case DMAR_IOAPIC:
521 typestr = "IOAPIC";
522 break;
523 case DMAR_HPET:
524 typestr = "HPET";
525 break;
526 default:
527 typestr = "Unknown device";
528 break;
529 }
530
531 return (typestr);
532 }
533
534 static void
535 print_scope_list(list_t *scope_list)
536 {
537 scope_t *scope;
538
539 if (list_is_empty(scope_list))
540 return;
541
542 ddi_err(DER_CONT, NULL, "\tdevice list:\n");
543
544 for (scope = list_head(scope_list); scope;
545 scope = list_next(scope_list, scope)) {
546 ddi_err(DER_CONT, NULL, "\t\ttype = %s\n",
547 scope_type(scope->scp_type));
548 ddi_err(DER_CONT, NULL, "\n\t\tbus = %d\n",
549 scope->scp_bus);
550 ddi_err(DER_CONT, NULL, "\t\tdev = %d\n",
551 scope->scp_dev);
552 ddi_err(DER_CONT, NULL, "\t\tfunc = %d\n",
553 scope->scp_func);
554 }
555 }
556
557 static void
558 print_drhd_list(list_t *drhd_list)
559 {
560 drhd_t *drhd;
561
562 if (list_is_empty(drhd_list))
563 return;
564
565 ddi_err(DER_CONT, NULL, "\ndrhd list:\n");
566
567 for (drhd = list_head(drhd_list); drhd;
568 drhd = list_next(drhd_list, drhd)) {
569
570 ddi_err(DER_CONT, NULL, "\n\tsegment = %d\n",
571 drhd->dr_seg);
572 ddi_err(DER_CONT, NULL, "\treg_base = 0x%" PRIx64 "\n",
573 drhd->dr_regs);
574 ddi_err(DER_CONT, NULL, "\tinclude_all = %s\n",
575 drhd->dr_include_all == B_TRUE ? "TRUE" : "FALSE");
576 ddi_err(DER_CONT, NULL, "\tdip = 0x%p\n",
577 (void *)drhd->dr_dip);
578
579 print_scope_list(&(drhd->dr_scope_list));
580 }
581 }
582
583
584 static void
585 print_rmrr_list(list_t *rmrr_list)
586 {
587 rmrr_t *rmrr;
588
589 if (list_is_empty(rmrr_list))
590 return;
591
592 ddi_err(DER_CONT, NULL, "\nrmrr list:\n");
593
594 for (rmrr = list_head(rmrr_list); rmrr;
595 rmrr = list_next(rmrr_list, rmrr)) {
596
597 ddi_err(DER_CONT, NULL, "\n\tsegment = %d\n",
598 rmrr->rm_seg);
599 ddi_err(DER_CONT, NULL, "\tbase = 0x%lx\n",
600 rmrr->rm_base);
601 ddi_err(DER_CONT, NULL, "\tlimit = 0x%lx\n",
602 rmrr->rm_limit);
603
604 print_scope_list(&(rmrr->rm_scope_list));
605 }
606 }
607
608 /*
609 * print DMAR table
610 */
611 static void
612 dmar_table_print(dmar_table_t *tbl)
613 {
614 int i;
615
616 if (dmar_print == B_FALSE) {
617 return;
618 }
619
620 /* print the title */
621 ddi_err(DER_CONT, NULL, "#### Start of dmar_table ####\n");
622 ddi_err(DER_CONT, NULL, "\thaw = %d\n", tbl->tbl_haw);
623 ddi_err(DER_CONT, NULL, "\tintr_remap = %s\n",
624 tbl->tbl_intrmap == B_TRUE ? "<true>" : "<false>");
625
626 /* print drhd list */
627 for (i = 0; i < IMMU_MAXSEG; i++) {
628 print_drhd_list(&(tbl->tbl_drhd_list[i]));
629 }
630
631
632 /* print rmrr list */
633 for (i = 0; i < IMMU_MAXSEG; i++) {
634 print_rmrr_list(&(tbl->tbl_rmrr_list[i]));
635 }
636
637 ddi_err(DER_CONT, NULL, "#### END of dmar_table ####\n");
638 }
639
640 static void
641 drhd_devi_create(drhd_t *drhd, int unit)
642 {
643 struct ddi_parent_private_data *pdptr;
644 struct regspec reg;
645 dev_info_t *dip;
646
647 dip = ddi_add_child(root_devinfo, IMMU_UNIT_NAME,
648 DEVI_SID_NODEID, unit);
649
650 drhd->dr_dip = dip;
651
652 reg.regspec_bustype = 0;
653 reg.regspec_addr = drhd->dr_regs;
654 reg.regspec_size = IMMU_REGSZ;
655
656 /*
657 * update the reg properties
658 *
659 * reg property will be used for register
660 * set access
661 *
662 * refer to the bus_map of root nexus driver
663 * I/O or memory mapping:
664 *
665 * <bustype=0, addr=x, len=x>: memory
666 * <bustype=1, addr=x, len=x>: i/o
667 * <bustype>1, addr=0, len=x>: x86-compatibility i/o
668 */
669 (void) ndi_prop_update_int_array(DDI_DEV_T_NONE,
670 dip, "reg", (int *)&reg,
671 sizeof (struct regspec) / sizeof (int));
672
673 /*
674 * This is an artificially constructed dev_info, and we
675 * need to set a few more things to be able to use it
676 * for ddi_dma_alloc_handle/free_handle.
677 */
678 ddi_set_driver(dip, ddi_get_driver(ddi_root_node()));
679 DEVI(dip)->devi_bus_dma_allochdl =
680 DEVI(ddi_get_driver((ddi_root_node())));
681
682 pdptr = kmem_zalloc(sizeof (struct ddi_parent_private_data)
683 + sizeof (struct regspec), KM_SLEEP);
684 pdptr->par_nreg = 1;
685 pdptr->par_reg = (struct regspec *)(pdptr + 1);
686 pdptr->par_reg->regspec_bustype = 0;
687 pdptr->par_reg->regspec_addr = drhd->dr_regs;
688 pdptr->par_reg->regspec_size = IMMU_REGSZ;
689 ddi_set_parent_data(dip, pdptr);
690 }
691
692 /*
693 * dmar_devinfos_create()
694 *
695 * create the dev_info node in the device tree,
696 * the info node is a nuxus child of the root
697 * nexus
698 */
699 static void
700 dmar_devinfos_create(dmar_table_t *tbl)
701 {
702 list_t *drhd_list;
703 drhd_t *drhd;
704 int i, unit;
705
706 for (i = 0; i < IMMU_MAXSEG; i++) {
707
708 drhd_list = &(tbl->tbl_drhd_list[i]);
709
710 if (list_is_empty(drhd_list))
711 continue;
712
713 drhd = list_head(drhd_list);
714 for (unit = 0; drhd;
715 drhd = list_next(drhd_list, drhd), unit++) {
716 drhd_devi_create(drhd, unit);
717 }
718 }
719 }
720
721 static void
722 drhd_devi_destroy(drhd_t *drhd)
723 {
724 dev_info_t *dip;
725 int count;
726
727 dip = drhd->dr_dip;
728 ASSERT(dip);
729
730 ndi_devi_enter(root_devinfo, &count);
731 if (ndi_devi_offline(dip, NDI_DEVI_REMOVE) != DDI_SUCCESS) {
732 ddi_err(DER_WARN, dip, "Failed to destroy");
733 }
734 ndi_devi_exit(root_devinfo, count);
735 drhd->dr_dip = NULL;
736 }
737
738 /*
739 * dmar_devi_destroy()
740 *
741 * destroy dev_info nodes for all drhd units
742 */
743 static void
744 dmar_devi_destroy(dmar_table_t *tbl)
745 {
746 drhd_t *drhd;
747 list_t *drhd_list;
748 int i;
749
750 for (i = 0; i < IMMU_MAXSEG; i++) {
751 drhd_list = &(tbl->tbl_drhd_list[i]);
752 if (list_is_empty(drhd_list))
753 continue;
754
755 drhd = list_head(drhd_list);
756 for (; drhd; drhd = list_next(drhd_list, drhd)) {
757 drhd_devi_destroy(drhd);
758 }
759 }
760 }
761
762 static int
763 match_bdf(dev_info_t *ddip, void *arg)
764 {
765 immu_arg_t *imarg = (immu_arg_t *)arg;
766 immu_devi_t *immu_devi;
767
768 ASSERT(ddip);
769 ASSERT(imarg);
770 ASSERT(imarg->ima_seg == 0);
771 ASSERT(imarg->ima_bus >= 0);
772 ASSERT(imarg->ima_devfunc >= 0);
773 ASSERT(imarg->ima_ddip == NULL);
774
775 /* rdip can be NULL */
776
777 mutex_enter(&(DEVI(ddip)->devi_lock));
778
779 immu_devi = IMMU_DEVI(ddip);
780 ASSERT(immu_devi);
781
782 if (immu_devi->imd_seg == imarg->ima_seg &&
783 immu_devi->imd_bus == imarg->ima_bus &&
784 immu_devi->imd_devfunc == imarg->ima_devfunc) {
785 imarg->ima_ddip = ddip;
786 }
787
788 mutex_exit(&(DEVI(ddip)->devi_lock));
789
790 return (imarg->ima_ddip ? DDI_WALK_TERMINATE : DDI_WALK_CONTINUE);
791 }
792 static void
793 dmar_table_destroy(dmar_table_t *tbl)
794 {
795 int i;
796
797 ASSERT(tbl);
798
799 /* destroy lists for DRHD and RMRR */
800 for (i = 0; i < IMMU_MAXSEG; i++) {
801 rmrr_list_destroy(&(tbl->tbl_rmrr_list[i]));
802 drhd_list_destroy(&(tbl->tbl_drhd_list[i]));
803 }
804
805 /* free strings */
806 kmem_free(tbl->tbl_oem_tblid, TBL_OEM_TBLID_SZ + 1);
807 kmem_free(tbl->tbl_oem_id, TBL_OEM_ID_SZ + 1);
808 tbl->tbl_raw = NULL; /* raw ACPI table doesn't have to be freed */
809 mutex_destroy(&(tbl->tbl_lock));
810 kmem_free(tbl, sizeof (dmar_table_t));
811 }
812
813 /*
814 * #########################################################################
815 * Functions exported by dmar.c
816 * This file deals with reading and processing the DMAR ACPI table
817 * #########################################################################
818 */
819
820 /*
821 * immu_dmar_setup()
822 * Check if the system has a DMAR ACPI table. If yes, the system
823 * has Intel IOMMU hardware
824 */
825 int
826 immu_dmar_setup(void)
827 {
828 if (AcpiGetTable("DMAR", 1, (ACPI_TABLE_HEADER **)&dmar_raw) != AE_OK) {
829 ddi_err(DER_LOG, NULL,
830 "No DMAR ACPI table. No Intel IOMMU present\n");
831 dmar_raw = NULL;
832 return (DDI_FAILURE);
833 }
834 ASSERT(dmar_raw);
835 return (DDI_SUCCESS);
836 }
837
838 /*
839 * immu_dmar_parse()
840 * Called by immu.c to parse and convert "raw" ACPI DMAR table
841 */
842 int
843 immu_dmar_parse(void)
844 {
845 dmar_table_t *tbl = NULL;
846
847 /* we should already have found the "raw" table */
848 ASSERT(dmar_raw);
849
850 ddi_err(DER_CONT, NULL, "?Processing DMAR ACPI table\n");
851
852 dmar_table = NULL;
853
854 /*
855 * parse DMAR ACPI table
856 */
857 if (dmar_parse(&tbl, dmar_raw) != DDI_SUCCESS) {
858 ASSERT(tbl == NULL);
859 return (DDI_FAILURE);
860 }
861
862 ASSERT(tbl);
863
864 /*
865 * create one devinfo for every drhd unit
866 * in the DMAR table
867 */
868 dmar_devinfos_create(tbl);
869
870 /*
871 * print the dmar table if the debug option is set
872 */
873 dmar_table_print(tbl);
874
875 dmar_table = tbl;
876
877 return (DDI_SUCCESS);
878 }
879
880 void
881 immu_dmar_startup(void)
882 {
883 /* nothing to do */
884 }
885
886 void
887 immu_dmar_shutdown(void)
888 {
889 /* nothing to do */
890 }
891
892 void
893 immu_dmar_destroy(void)
894 {
895 dmar_devi_destroy(dmar_table);
896 dmar_table_destroy(dmar_table);
897 ioapic_drhd_destroy();
898 dmar_table = NULL;
899 dmar_raw = NULL;
900 }
901
902 boolean_t
903 immu_dmar_blacklisted(char **strptr, uint_t nstrs)
904 {
905 dmar_table_t *tbl = dmar_table;
906 int i;
907 char oem_rev[IMMU_MAXNAMELEN];
908
909 ASSERT(tbl);
910
911 ASSERT((strptr == NULL) ^ (nstrs != 0));
912
913 /*
914 * Must be a minimum of 4
915 */
916 if (nstrs < 4) {
917 return (B_FALSE);
918 }
919
920 ddi_err(DER_CONT, NULL, "?System DMAR ACPI table information:\n");
921 ddi_err(DER_CONT, NULL, "?OEM-ID = <%s>\n", tbl->tbl_oem_id);
922 ddi_err(DER_CONT, NULL, "?Table-ID = <%s>\n", tbl->tbl_oem_tblid);
923 (void) snprintf(oem_rev, sizeof (oem_rev), "%d", tbl->tbl_oem_rev);
924 ddi_err(DER_CONT, NULL, "?Revision = <%s>\n", oem_rev);
925
926 for (i = 0; nstrs - i >= 4; i++) {
927 if (strcmp(*strptr++, "DMAR") == 0) {
928 if (strcmp(*strptr++, tbl->tbl_oem_id) == 0 &&
929 (*strptr[0] == '\0' ||
930 strcmp(*strptr++, tbl->tbl_oem_tblid) == 0) &&
931 (*strptr[0] == '\0' ||
932 strcmp(*strptr++, oem_rev) == 0)) {
933 return (B_TRUE);
934 }
935 i += 3; /* for loops adds 1 as well, so only 3 here */
936 }
937 }
938 return (B_FALSE);
939 }
940
941 void
942 immu_dmar_rmrr_map(void)
943 {
944 int seg;
945 int count;
946 dev_info_t *rdip;
947 scope_t *scope;
948 rmrr_t *rmrr;
949 dmar_table_t *tbl;
950
951 ASSERT(dmar_table);
952
953 tbl = dmar_table;
954
955 /* called during boot, when kernel is single threaded. No lock */
956
957 /*
958 * for each segment, walk the rmrr list looking for an exact match
959 */
960 for (seg = 0; seg < IMMU_MAXSEG; seg++) {
961 rmrr = list_head(&(tbl->tbl_rmrr_list)[seg]);
962 for (; rmrr; rmrr = list_next(&(tbl->tbl_rmrr_list)[seg],
963 rmrr)) {
964
965 /*
966 * try to match BDF *exactly* to a device scope.
967 */
968 scope = list_head(&(rmrr->rm_scope_list));
969 for (; scope;
970 scope = list_next(&(rmrr->rm_scope_list), scope)) {
971 immu_arg_t imarg = {0};
972 memrng_t mrng = {0};
973
974 /* PCI endpoint devices only */
975 if (scope->scp_type != DMAR_ENDPOINT)
976 continue;
977
978 imarg.ima_seg = seg;
979 imarg.ima_bus = scope->scp_bus;
980 imarg.ima_devfunc =
981 IMMU_PCI_DEVFUNC(scope->scp_dev,
982 scope->scp_func);
983 imarg.ima_ddip = NULL;
984 imarg.ima_rdip = NULL;
985
986 ASSERT(root_devinfo);
987 /* XXX should be optimized */
988 ndi_devi_enter(root_devinfo, &count);
989 ddi_walk_devs(ddi_get_child(root_devinfo),
990 match_bdf, &imarg);
991 ndi_devi_exit(root_devinfo, count);
992
993 if (imarg.ima_ddip == NULL) {
994 ddi_err(DER_WARN, NULL,
995 "No dip found for "
996 "bus=0x%x, dev=0x%x, func= 0x%x",
997 scope->scp_bus, scope->scp_dev,
998 scope->scp_func);
999 continue;
1000 }
1001
1002 rdip = imarg.ima_ddip;
1003 /*
1004 * This address must be in the BIOS reserved
1005 * map
1006 */
1007 if (!address_in_memlist(bios_rsvd,
1008 (uint64_t)rmrr->rm_base, rmrr->rm_limit -
1009 rmrr->rm_base + 1)) {
1010 ddi_err(DER_WARN, rdip, "RMRR range "
1011 " [0x%" PRIx64 " - 0x%" PRIx64 "]"
1012 " not in BIOS reserved map",
1013 rmrr->rm_base, rmrr->rm_limit);
1014 }
1015
1016 /* XXX could be more efficient */
1017 memlist_read_lock();
1018 if (address_in_memlist(phys_install,
1019 (uint64_t)rmrr->rm_base, rmrr->rm_limit -
1020 rmrr->rm_base + 1)) {
1021 ddi_err(DER_WARN, rdip, "RMRR range "
1022 " [0x%" PRIx64 " - 0x%" PRIx64 "]"
1023 " is in physinstall map",
1024 rmrr->rm_base, rmrr->rm_limit);
1025 }
1026 memlist_read_unlock();
1027
1028 (void) immu_dvma_device_setup(rdip, 0);
1029
1030 ddi_err(DER_LOG, rdip,
1031 "IMMU: Mapping RMRR range "
1032 "[0x%" PRIx64 " - 0x%"PRIx64 "]",
1033 rmrr->rm_base, rmrr->rm_limit);
1034
1035 mrng.mrng_start =
1036 IMMU_ROUNDOWN((uintptr_t)rmrr->rm_base);
1037 mrng.mrng_npages =
1038 IMMU_ROUNDUP((uintptr_t)rmrr->rm_limit -
1039 (uintptr_t)rmrr->rm_base + 1) /
1040 IMMU_PAGESIZE;
1041
1042 (void) immu_map_memrange(rdip, &mrng);
1043 }
1044 }
1045 }
1046
1047 }
1048
1049 immu_t *
1050 immu_dmar_get_immu(dev_info_t *rdip)
1051 {
1052 int seg;
1053 int tlevel;
1054 int level;
1055 drhd_t *drhd;
1056 drhd_t *tdrhd;
1057 scope_t *scope;
1058 dmar_table_t *tbl;
1059
1060 ASSERT(dmar_table);
1061
1062 tbl = dmar_table;
1063
1064 mutex_enter(&(tbl->tbl_lock));
1065
1066 /*
1067 * for each segment, walk the drhd list looking for an exact match
1068 */
1069 for (seg = 0; seg < IMMU_MAXSEG; seg++) {
1070 drhd = list_head(&(tbl->tbl_drhd_list)[seg]);
1071 for (; drhd; drhd = list_next(&(tbl->tbl_drhd_list)[seg],
1072 drhd)) {
1073
1074 /*
1075 * we are currently searching for exact matches so
1076 * skip "include all" (catchall) and subtree matches
1077 */
1078 if (drhd->dr_include_all == B_TRUE)
1079 continue;
1080
1081 /*
1082 * try to match BDF *exactly* to a device scope.
1083 */
1084 scope = list_head(&(drhd->dr_scope_list));
1085 for (; scope;
1086 scope = list_next(&(drhd->dr_scope_list), scope)) {
1087 immu_arg_t imarg = {0};
1088
1089 /* PCI endpoint devices only */
1090 if (scope->scp_type != DMAR_ENDPOINT)
1091 continue;
1092
1093 imarg.ima_seg = seg;
1094 imarg.ima_bus = scope->scp_bus;
1095 imarg.ima_devfunc =
1096 IMMU_PCI_DEVFUNC(scope->scp_dev,
1097 scope->scp_func);
1098 imarg.ima_ddip = NULL;
1099 imarg.ima_rdip = rdip;
1100 level = 0;
1101 if (immu_walk_ancestor(rdip, NULL, match_bdf,
1102 &imarg, &level, IMMU_FLAGS_DONTPASS)
1103 != DDI_SUCCESS) {
1104 /* skip - nothing else we can do */
1105 continue;
1106 }
1107
1108 /* Should have walked only 1 level i.e. rdip */
1109 ASSERT(level == 1);
1110
1111 if (imarg.ima_ddip) {
1112 ASSERT(imarg.ima_ddip == rdip);
1113 goto found;
1114 }
1115 }
1116 }
1117 }
1118
1119 /*
1120 * walk the drhd list looking for subtree match
1121 * i.e. is the device a descendant of a devscope BDF.
1122 * We want the lowest subtree.
1123 */
1124 tdrhd = NULL;
1125 tlevel = 0;
1126 for (seg = 0; seg < IMMU_MAXSEG; seg++) {
1127 drhd = list_head(&(tbl->tbl_drhd_list)[seg]);
1128 for (; drhd; drhd = list_next(&(tbl->tbl_drhd_list)[seg],
1129 drhd)) {
1130
1131 /* looking for subtree match */
1132 if (drhd->dr_include_all == B_TRUE)
1133 continue;
1134
1135 /*
1136 * try to match the device scope
1137 */
1138 scope = list_head(&(drhd->dr_scope_list));
1139 for (; scope;
1140 scope = list_next(&(drhd->dr_scope_list), scope)) {
1141 immu_arg_t imarg = {0};
1142
1143 /* PCI subtree only */
1144 if (scope->scp_type != DMAR_SUBTREE)
1145 continue;
1146
1147 imarg.ima_seg = seg;
1148 imarg.ima_bus = scope->scp_bus;
1149 imarg.ima_devfunc =
1150 IMMU_PCI_DEVFUNC(scope->scp_dev,
1151 scope->scp_func);
1152
1153 imarg.ima_ddip = NULL;
1154 imarg.ima_rdip = rdip;
1155 level = 0;
1156 if (immu_walk_ancestor(rdip, NULL, match_bdf,
1157 &imarg, &level, 0) != DDI_SUCCESS) {
1158 /* skip - nothing else we can do */
1159 continue;
1160 }
1161
1162 /* should have walked 1 level i.e. rdip */
1163 ASSERT(level > 0);
1164
1165 /* look for lowest ancestor matching drhd */
1166 if (imarg.ima_ddip && (tdrhd == NULL ||
1167 level < tlevel)) {
1168 tdrhd = drhd;
1169 tlevel = level;
1170 }
1171 }
1172 }
1173 }
1174
1175 if ((drhd = tdrhd) != NULL) {
1176 goto found;
1177 }
1178
1179 for (seg = 0; seg < IMMU_MAXSEG; seg++) {
1180 drhd = list_head(&(tbl->tbl_drhd_list[seg]));
1181 for (; drhd; drhd = list_next(&(tbl->tbl_drhd_list)[seg],
1182 drhd)) {
1183 /* Look for include all */
1184 if (drhd->dr_include_all == B_TRUE) {
1185 break;
1186 }
1187 }
1188 }
1189
1190 /*FALLTHRU*/
1191
1192 found:
1193 mutex_exit(&(tbl->tbl_lock));
1194
1195 /*
1196 * No drhd (dmar unit) found for this device in the ACPI DMAR tables.
1197 * This may happen with buggy versions of BIOSes. Just warn instead
1198 * of panic as we don't want whole system to go down because of one
1199 * device.
1200 */
1201 if (drhd == NULL) {
1202 ddi_err(DER_WARN, rdip, "can't find Intel IOMMU unit for "
1203 "device in ACPI DMAR table.");
1204 return (NULL);
1205 }
1206
1207 return (drhd->dr_immu);
1208 }
1209
1210 dev_info_t *
1211 immu_dmar_unit_dip(void *dmar_unit)
1212 {
1213 drhd_t *drhd = (drhd_t *)dmar_unit;
1214 return (drhd->dr_dip);
1215 }
1216
1217 void *
1218 immu_dmar_walk_units(int seg, void *dmar_unit)
1219 {
1220 list_t *drhd_list;
1221 drhd_t *drhd = (drhd_t *)dmar_unit;
1222
1223 drhd_list = &(dmar_table->tbl_drhd_list[seg]);
1224
1225 if (drhd == NULL) {
1226 return ((void *)list_head(drhd_list));
1227 } else {
1228 return ((void *)list_next(drhd_list, drhd));
1229 }
1230 }
1231
1232 void
1233 immu_dmar_set_immu(void *dmar_unit, immu_t *immu)
1234 {
1235 drhd_t *drhd = (drhd_t *)dmar_unit;
1236
1237 ASSERT(drhd);
1238 ASSERT(immu);
1239
1240 drhd->dr_immu = immu;
1241 }
1242
1243 boolean_t
1244 immu_dmar_intrmap_supported(void)
1245 {
1246 ASSERT(dmar_table);
1247 return (dmar_table->tbl_intrmap);
1248 }
1249
1250 /* for a given ioapicid, find the source id and immu */
1251 uint16_t
1252 immu_dmar_ioapic_sid(int ioapic_ix)
1253 {
1254 ioapic_drhd_t *idt;
1255
1256 idt = ioapic_drhd_lookup(psm_get_ioapicid(ioapic_ix));
1257 if (idt == NULL) {
1258 ddi_err(DER_PANIC, NULL, "cannot determine source-id for "
1259 "IOAPIC (index = %d)", ioapic_ix);
1260 /*NOTREACHED*/
1261 }
1262
1263 return (idt->ioapic_sid);
1264 }
1265
1266 /* for a given ioapicid, find the source id and immu */
1267 immu_t *
1268 immu_dmar_ioapic_immu(int ioapic_ix)
1269 {
1270 ioapic_drhd_t *idt;
1271
1272 idt = ioapic_drhd_lookup(psm_get_ioapicid(ioapic_ix));
1273 if (idt) {
1274 return (idt->ioapic_drhd ? idt->ioapic_drhd->dr_immu : NULL);
1275 }
1276 return (NULL);
1277 }
Unleashed OS