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 /*
23 * Copyright (c) 2010, Intel Corporation.
24 * All rights reserved.
25 */
26
27 #include <sys/types.h>
28 #include <sys/atomic.h>
29 #include <sys/cmn_err.h>
30 #include <sys/cpuvar.h>
31 #include <sys/memlist.h>
32 #include <sys/memlist_impl.h>
33 #include <sys/note.h>
34 #include <sys/obpdefs.h>
35 #include <sys/synch.h>
36 #include <sys/sysmacros.h>
37 #include <sys/sunddi.h>
38 #include <sys/sunndi.h>
39 #include <sys/x86_archext.h>
40 #include <sys/machsystm.h>
41 #include <sys/memnode.h> /* for lgrp_plat_node_cnt */
42 #include <sys/psm_types.h>
43 #include <acpica/include/acpi.h>
44 #include <sys/acpica.h>
45 #include <sys/acpidev.h>
46 #include <sys/acpidev_rsc.h>
47 #include <sys/acpidev_dr.h>
48 #include <sys/acpidev_impl.h>
49
50 struct acpidev_dr_set_prop_arg {
51 uint32_t level;
52 uint32_t bdnum;
53 uint32_t cpu_id;
54 uint32_t mem_id;
55 uint32_t io_id;
56 uint32_t mod_id;
57 };
58
59 struct acpidev_dr_device_remove_arg {
60 uint32_t level;
61 };
62
63 extern int acpidev_options;
64
65 /* User configurable option to enable/disable ACPI based DR operations. */
66 int acpidev_dr_enable = 1;
67 int acpidev_dr_hierarchy_name = 1;
68 uint32_t acpidev_dr_max_segs_per_mem_device = ACPIDEV_DR_SEGS_PER_MEM_DEV;
69 uint32_t acpidev_dr_max_memlists_per_seg = ACPIDEV_DR_MEMLISTS_PER_SEG;
70
71 ACPI_TABLE_SRAT *acpidev_srat_tbl_ptr;
72 ACPI_TABLE_SLIT *acpidev_slit_tbl_ptr;
73
74 /* ACPI based DR operations are unsupported if zero. */
75 static int acpidev_dr_supported = -1;
76
77 /* Failed to initialize support of DR operations if non-zero. */
78 static int acpidev_dr_failed;
79
80 static volatile uint32_t acpidev_dr_boards;
81 static volatile uint32_t acpidev_dr_board_index;
82 static uint32_t acpidev_dr_max_cmp_per_board;
83 static uint32_t acpidev_dr_max_memory_per_board;
84 static uint32_t acpidev_dr_max_io_per_board;
85 static uint32_t acpidev_dr_memory_device_cnt;
86
87 static ACPI_HANDLE *acpidev_dr_board_handles[ACPIDEV_DR_MAX_BOARDS];
88
89 /* Lock to protect/block DR operations at runtime. */
90 static kmutex_t acpidev_dr_lock;
91
92 static acpidev_dr_capacity_t acpidev_dr_capacities[] = {
93 { /* Nehalem-EX */
94 X86_VENDOR_Intel, 0x6, 0x2e, 0x2e, 0, UINT_MAX,
95 B_TRUE, /* Hotplug capable */
96 1ULL << 30, /* Align on 1GB boundary */
97 },
98 { /* the last item is used to mark end of the table */
99 UINT_MAX, UINT_MAX, UINT_MAX, 0, UINT_MAX, 0,
100 B_FALSE,
101 0,
102 },
103 };
104
105 static ACPI_STATUS acpidev_dr_scan_topo(ACPI_HANDLE hdl, UINT32 lvl, void *arg,
106 void **retval);
107
108 static acpidev_dr_capacity_t *
109 acpidev_dr_get_capacity(void)
110 {
111 acpidev_dr_capacity_t *cp, *cp1;
112 uint_t vendor, family, model, step;
113 static acpidev_dr_capacity_t *acpidev_dr_capacity_curr = NULL;
114
115 if (acpidev_dr_capacity_curr != NULL) {
116 return (acpidev_dr_capacity_curr);
117 }
118
119 kpreempt_disable();
120 vendor = cpuid_getvendor(CPU);
121 family = cpuid_getfamily(CPU);
122 model = cpuid_getmodel(CPU);
123 step = cpuid_getstep(CPU);
124 kpreempt_enable();
125
126 for (cp = acpidev_dr_capacities; ; cp++) {
127 ASSERT(cp < acpidev_dr_capacities +
128 sizeof (acpidev_dr_capacities) / sizeof (*cp));
129
130 /* Check whether it reaches the last item of the table. */
131 if (cp->cpu_vendor == UINT_MAX && cp->cpu_family == UINT_MAX &&
132 cp->cpu_model_min == UINT_MAX && cp->cpu_model_max == 0 &&
133 cp->cpu_step_min == UINT_MAX && cp->cpu_step_max == 0) {
134 break;
135 }
136 if (cp->cpu_vendor == vendor && cp->cpu_family == family &&
137 model >= cp->cpu_model_min && model <= cp->cpu_model_max &&
138 step >= cp->cpu_step_min && step <= cp->cpu_step_max) {
139 break;
140 }
141 }
142
143 /* Assume all CPUs in system are homogeneous. */
144 cp1 = atomic_cas_ptr(&acpidev_dr_capacity_curr, NULL, cp);
145 ASSERT(cp1 == NULL || cp1 == cp);
146 if (cp1 != NULL && cp1 != cp) {
147 return (NULL);
148 }
149
150 return (cp);
151 }
152
153 int
154 acpidev_dr_capable(void)
155 {
156 uint64_t flags1, flags2;
157 acpidev_dr_capacity_t *cp;
158
159 /*
160 * Disable support of DR operations if:
161 * 1) acpidev fails to initialize DR interfaces.
162 * 2) ACPI based DR has been disabled by user.
163 * 3) No DR capable devices have been detected.
164 * 4) The system doesn't support DR operations.
165 * 5) Some acpidev features have been disabled by user.
166 */
167 if (acpidev_dr_failed != 0 || acpidev_dr_enable == 0 ||
168 acpidev_dr_supported == 0) {
169 return (0);
170 }
171
172 flags1 = ACPI_FEATURE_DEVCFG | ACPI_FEATURE_OSI_MODULE;
173 flags2 = ACPI_DEVCFG_CPU | ACPI_DEVCFG_MEMORY |
174 ACPI_DEVCFG_CONTAINER | ACPI_DEVCFG_PCI;
175 if (acpica_get_core_feature(flags1) != flags1 ||
176 acpica_get_devcfg_feature(flags2) != flags2) {
177 cmn_err(CE_CONT,
178 "?acpidev: disable support of ACPI based DR because "
179 "some acpidev features have been disabled by user.\n");
180 acpidev_dr_supported = 0;
181 return (0);
182 }
183
184 cp = acpidev_dr_get_capacity();
185 if (cp == NULL || cp->hotplug_supported == B_FALSE) {
186 return (0);
187 }
188
189 return (1);
190 }
191
192 uint32_t
193 acpidev_dr_max_boards(void)
194 {
195 return (acpidev_dr_boards);
196 }
197
198 uint32_t
199 acpidev_dr_max_io_units_per_board(void)
200 {
201 return (acpidev_dr_max_io_per_board);
202 }
203
204 uint32_t
205 acpidev_dr_max_mem_units_per_board(void)
206 {
207 return (acpidev_dr_max_memory_per_board);
208 }
209
210 uint32_t
211 acpidev_dr_max_cmp_units_per_board(void)
212 {
213 return (acpidev_dr_max_cmp_per_board);
214 }
215
216 uint32_t
217 acpidev_dr_max_cpu_units_per_cmp(void)
218 {
219 static int max_cnt;
220
221 if (max_cnt == 0) {
222 kpreempt_disable();
223 max_cnt = cpuid_get_ncpu_per_chip(CPU);
224 kpreempt_enable();
225 }
226
227 return (max_cnt);
228 }
229
230 uint32_t
231 acpidev_dr_max_segments_per_mem_device(void)
232 {
233 if (acpidev_dr_max_segs_per_mem_device < 1) {
234 return (ACPIDEV_DR_SEGS_PER_MEM_DEV);
235 } else {
236 return (acpidev_dr_max_segs_per_mem_device);
237 }
238 }
239
240 uint32_t
241 acpidev_dr_max_memlists_per_segment(void)
242 {
243 if (acpidev_dr_max_memlists_per_seg < ACPIDEV_DR_MEMLISTS_PER_SEG) {
244 return (ACPIDEV_DR_MEMLISTS_PER_SEG);
245 } else {
246 return (acpidev_dr_max_memlists_per_seg);
247 }
248 }
249
250 void
251 acpidev_dr_init(void)
252 {
253 mutex_init(&acpidev_dr_lock, NULL, MUTEX_DRIVER, NULL);
254 }
255
256 static void
257 acpidev_dr_check_board_type(acpidev_data_handle_t dhdl,
258 struct acpidev_dr_set_prop_arg *ap, char *objname)
259 {
260 if (dhdl->aod_class_id == ACPIDEV_CLASS_ID_MEMORY) {
261 /* Memory board should have only one memory device. */
262 ASSERT(ap->cpu_id == 0);
263 ASSERT(ap->mem_id == 1);
264 ASSERT(ap->io_id == 0);
265 ASSERT(ap->mod_id == 0);
266 dhdl->aod_bdtype = ACPIDEV_MEMORY_BOARD;
267 } else if (dhdl->aod_class_id == ACPIDEV_CLASS_ID_PCI ||
268 dhdl->aod_class_id == ACPIDEV_CLASS_ID_PCIEX) {
269 /* IO board should have only one IO device. */
270 ASSERT(ap->cpu_id == 0);
271 ASSERT(ap->mem_id == 0);
272 ASSERT(ap->io_id == 1);
273 ASSERT(ap->mod_id == 0);
274 dhdl->aod_bdtype = ACPIDEV_IO_BOARD;
275 } else if (dhdl->aod_class_id == ACPIDEV_CLASS_ID_CONTAINER) {
276 if (ap->mod_id == 1 && ap->mem_id == 0) {
277 dhdl->aod_bdtype = ACPIDEV_CPU_BOARD;
278 } else {
279 dhdl->aod_bdtype = ACPIDEV_SYSTEM_BOARD;
280 }
281 } else {
282 cmn_err(CE_WARN,
283 "!acpidev: unknown type of hotplug capable board %s.",
284 objname);
285 ASSERT(0);
286 }
287 }
288
289 /*
290 * Check for hotplug capable boards and create environment to support
291 * ACPI based DR operations. No need to acquire lock here, it's called
292 * from single-threaded context during boot.
293 */
294 void
295 acpidev_dr_check(acpidev_walk_info_t *infop)
296 {
297 uint_t cmp;
298 boolean_t found = B_FALSE;
299 ACPI_HANDLE phdl;
300 acpidev_data_handle_t dhdl, pdhdl;
301 struct acpidev_dr_set_prop_arg arg;
302
303 if (infop == NULL ||
304 infop->awi_op_type != ACPIDEV_OP_BOOT_PROBE) {
305 ACPIDEV_DEBUG(CE_WARN,
306 "!acpidev: invalid parameter to acpidev_dr_check().");
307 return;
308 }
309
310 if (acpidev_dr_capable() == 0) {
311 return;
312 }
313
314 dhdl = infop->awi_data;
315 ASSERT(dhdl != NULL);
316
317 /* This device has already been handled before. */
318 if (ACPIDEV_DR_IS_PROCESSED(dhdl)) {
319 return;
320 }
321
322 /*
323 * It implies that the device is hotplug capable if ACPI _EJ0 method
324 * is available.
325 */
326 if (!ACPIDEV_DR_IS_BOARD(dhdl) &&
327 acpidev_dr_device_hotplug_capable(infop->awi_hdl)) {
328 ACPIDEV_DR_SET_BOARD(dhdl);
329 }
330
331 /* All things are done if the device isn't hotplug capable. */
332 if (!ACPIDEV_DR_IS_BOARD(dhdl)) {
333 return;
334 }
335
336 /* Check whether hardware topology is supported or not. */
337 if (ACPI_FAILURE(acpidev_dr_scan_topo(infop->awi_hdl, 0, NULL,
338 NULL))) {
339 ACPIDEV_DR_SET_FAILED(dhdl);
340 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: hardware topology under %s "
341 "is unsupported for DR operations.", infop->awi_name);
342 return;
343 }
344
345 /* Generate board/index/port number for the hotplug capable board. */
346 dhdl->aod_bdnum = atomic_inc_32_nv(&acpidev_dr_boards) - 1;
347 dhdl->aod_portid = 0;
348 phdl = infop->awi_hdl;
349 while (ACPI_SUCCESS(AcpiGetParent(phdl, &phdl)) &&
350 phdl != ACPI_ROOT_OBJECT) {
351 pdhdl = acpidev_data_get_handle(phdl);
352 if (pdhdl != NULL && ACPIDEV_DR_IS_BOARD(pdhdl)) {
353 dhdl->aod_bdidx = atomic_inc_32_nv(&pdhdl->aod_chidx);
354 found = B_TRUE;
355 break;
356 }
357 }
358 if (found == B_FALSE) {
359 dhdl->aod_bdidx = atomic_inc_32_nv(&acpidev_dr_board_index);
360 }
361 dhdl->aod_bdidx -= 1;
362
363 /* Found too many hotplug capable boards. */
364 if (dhdl->aod_bdnum >= ACPIDEV_DR_MAX_BOARDS) {
365 ACPIDEV_DR_SET_FAILED(dhdl);
366 cmn_err(CE_WARN, "!acpidev: too many hotplug capable boards, "
367 "max %d, found %d.",
368 ACPIDEV_DR_MAX_BOARDS, dhdl->aod_bdnum + 1);
369 return;
370 }
371
372 /* Scan all descendant devices to prepare info for DR operations. */
373 bzero(&arg, sizeof (arg));
374 arg.bdnum = dhdl->aod_bdnum;
375 arg.level = infop->awi_level;
376 if (ACPI_FAILURE(acpidev_dr_scan_topo(infop->awi_hdl, 0, &arg,
377 NULL))) {
378 ACPIDEV_DR_SET_FAILED(dhdl);
379 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: failed to set DR properties "
380 "for descendants of %s.", infop->awi_name);
381 return;
382 }
383
384 /* Get type of the hotplug capable board. */
385 acpidev_dr_check_board_type(dhdl, &arg, infop->awi_name);
386
387 /*
388 * Save ACPI handle of the hotplug capable board to speed up lookup
389 * board handle if caching is enabled.
390 */
391 if ((acpidev_options & ACPIDEV_OUSER_NO_CACHE) == 0) {
392 acpidev_dr_board_handles[dhdl->aod_bdnum] = infop->awi_hdl;
393 }
394
395 /* Update system maximum DR capabilities. */
396 cmp = (arg.cpu_id + acpidev_dr_max_cpu_units_per_cmp() - 1);
397 cmp /= acpidev_dr_max_cpu_units_per_cmp();
398 if (cmp > acpidev_dr_max_cmp_per_board) {
399 acpidev_dr_max_cmp_per_board = cmp;
400 }
401 if (arg.mem_id > acpidev_dr_max_memory_per_board) {
402 acpidev_dr_max_memory_per_board = arg.mem_id;
403 }
404 if (arg.io_id > acpidev_dr_max_io_per_board) {
405 acpidev_dr_max_io_per_board = arg.io_id;
406 }
407 }
408
409 static void
410 acpidev_dr_initialize_memory_hotplug(void)
411 {
412 caddr_t buf;
413 uint32_t cnt;
414 acpidev_dr_capacity_t *cp;
415
416 /*
417 * We have already checked that the platform supports DR operations.
418 */
419 cp = acpidev_dr_get_capacity();
420 ASSERT(cp != NULL && cp->hotplug_supported);
421 ASSERT(ISP2(cp->memory_alignment));
422 ASSERT(cp->memory_alignment > MMU_PAGESIZE);
423 mem_node_physalign = cp->memory_alignment;
424
425 /* Pre-populate memlist cache. */
426 cnt = acpidev_dr_memory_device_cnt;
427 cnt *= acpidev_dr_max_segments_per_mem_device();
428 cnt *= acpidev_dr_max_memlists_per_segment();
429 if (cnt > ACPIDEV_DR_MAX_MEMLIST_ENTRIES) {
430 cmn_err(CE_WARN, "!acpidev: attempted to reserve too many "
431 "memlist entries (%u), max %u. Falling back to %u and "
432 "some memory hot add operations may fail.",
433 cnt, ACPIDEV_DR_MAX_MEMLIST_ENTRIES,
434 ACPIDEV_DR_MAX_MEMLIST_ENTRIES);
435 cnt = ACPIDEV_DR_MAX_MEMLIST_ENTRIES;
436 }
437 cnt *= sizeof (struct memlist);
438 buf = kmem_zalloc(cnt, KM_SLEEP);
439 memlist_free_block(buf, cnt);
440 }
441
442 /*
443 * Create pseudo DR control device node if the system is hotplug capable.
444 * No need to acquire lock, it's called from single-threaded context
445 * during boot. pdip has been held by the caller.
446 */
447 static ACPI_STATUS
448 acpidev_dr_create_node(dev_info_t *pdip)
449 {
450 dev_info_t *dip;
451 char unit[32];
452 char *path;
453 char *comps[] = {
454 "acpidr_sbd",
455 };
456
457 /*
458 * Disable support of DR operations if no hotplug capable board has
459 * been detected.
460 */
461 if (acpidev_dr_boards == 0) {
462 acpidev_dr_supported = 0;
463 } else {
464 acpidev_dr_supported = 1;
465 }
466
467 /*
468 * Don't create control device node if the system isn't hotplug capable.
469 */
470 if (acpidev_dr_capable() == 0) {
471 return (AE_SUPPORT);
472 }
473
474 /* Cache pointer to the ACPI SLIT table. */
475 if (ACPI_FAILURE(AcpiGetTable(ACPI_SIG_SLIT, 1,
476 (ACPI_TABLE_HEADER **)&acpidev_slit_tbl_ptr))) {
477 acpidev_slit_tbl_ptr = NULL;
478 }
479 if (acpidev_srat_tbl_ptr == NULL || acpidev_slit_tbl_ptr == NULL) {
480 if (lgrp_plat_node_cnt != 1) {
481 /*
482 * Disable support of CPU/memory DR operations if lgrp
483 * is enabled but failed to cache SRAT/SLIT table
484 * pointers.
485 */
486 cmn_err(CE_WARN,
487 "!acpidev: failed to get ACPI SRAT/SLIT table.");
488 plat_dr_disable_cpu();
489 plat_dr_disable_memory();
490 }
491 }
492
493 ndi_devi_alloc_sleep(pdip, ACPIDEV_NODE_NAME_ACPIDR,
494 (pnode_t)DEVI_PSEUDO_NODEID, &dip);
495
496 /* Set "unit-address" device property. */
497 (void) snprintf(unit, sizeof (unit), "%u", 0);
498 if (ndi_prop_update_string(DDI_DEV_T_NONE, dip,
499 ACPIDEV_PROP_NAME_UNIT_ADDR, unit) != NDI_SUCCESS) {
500 path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
501 cmn_err(CE_CONT,
502 "?acpidev: failed to set unit-address property for %s.\n",
503 ddi_pathname(dip, path));
504 kmem_free(path, MAXPATHLEN);
505 (void) ddi_remove_child(dip, 0);
506 acpidev_dr_failed = 1;
507 return (AE_ERROR);
508 }
509
510 /* Set "compatible" device property. */
511 if (ndi_prop_update_string_array(DDI_DEV_T_NONE, dip, OBP_COMPATIBLE,
512 comps, sizeof (comps) / sizeof (comps[0])) != NDI_SUCCESS) {
513 path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
514 cmn_err(CE_CONT, "?acpidev: failed to set compatible "
515 "property for %s.\n", ddi_pathname(dip, path));
516 kmem_free(path, MAXPATHLEN);
517 (void) ddi_remove_child(dip, 0);
518 acpidev_dr_failed = 1;
519 return (AE_ERROR);
520 }
521
522 (void) ndi_devi_bind_driver(dip, 0);
523
524 return (AE_OK);
525 }
526
527 ACPI_STATUS
528 acpidev_dr_initialize(dev_info_t *pdip)
529 {
530 ACPI_STATUS rc;
531
532 rc = acpidev_dr_create_node(pdip);
533 if (ACPI_FAILURE(rc)) {
534 return (rc);
535 }
536
537 /* Initialize support of memory DR operations. */
538 if (plat_dr_support_memory()) {
539 acpidev_dr_initialize_memory_hotplug();
540 }
541
542 /* Mark the DR subsystem is ready for use. */
543 plat_dr_enable();
544
545 return (AE_OK);
546 }
547
548 static ACPI_STATUS
549 acpidev_dr_find_board(ACPI_HANDLE hdl, uint_t lvl, void *ctx, void **retval)
550 {
551 _NOTE(ARGUNUSED(lvl));
552
553 acpidev_data_handle_t dhdl;
554
555 ASSERT(hdl != NULL);
556 dhdl = acpidev_data_get_handle(hdl);
557 if (dhdl == NULL) {
558 /* No data handle available, not ready for DR operations. */
559 return (AE_CTRL_DEPTH);
560 } else if (ACPIDEV_DR_IS_BOARD(dhdl) && ACPIDEV_DR_IS_WORKING(dhdl) &&
561 dhdl->aod_bdnum == (intptr_t)ctx) {
562 ASSERT(retval != NULL);
563 *(ACPI_HANDLE *)retval = hdl;
564 return (AE_CTRL_TERMINATE);
565 }
566
567 return (AE_OK);
568 }
569
570 ACPI_STATUS
571 acpidev_dr_get_board_handle(uint_t board, ACPI_HANDLE *hdlp)
572 {
573 ACPI_STATUS rc = AE_OK;
574 ACPI_HANDLE hdl;
575
576 ASSERT(hdlp != NULL);
577 if (hdlp == NULL) {
578 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
579 "acpidev_dr_get_board_handle().");
580 return (AE_BAD_PARAMETER);
581 }
582
583 if (board >= acpidev_dr_boards) {
584 ACPIDEV_DEBUG(CE_NOTE,
585 "!acpidev: board number %d is out of range, max %d.",
586 board, acpidev_dr_boards);
587 return (AE_NOT_FOUND);
588 }
589
590 /* Use cached handles if caching is enabled. */
591 if ((acpidev_options & ACPIDEV_OUSER_NO_CACHE) == 0) {
592 if (acpidev_dr_board_handles[board] != NULL) {
593 hdl = acpidev_dr_board_handles[board];
594 if (ACPI_FAILURE(acpidev_dr_find_board(hdl, 1,
595 (void *)(intptr_t)board, (void **)hdlp)) &&
596 *hdlp != NULL) {
597 return (AE_OK);
598 }
599 }
600 ACPIDEV_DEBUG(CE_NOTE,
601 "!acpidev: board %d doesn't exist.", board);
602 *hdlp = NULL;
603 return (AE_NOT_FOUND);
604 }
605
606 /* All hotplug capable boards should exist under \_SB_. */
607 if (ACPI_FAILURE(AcpiGetHandle(ACPI_ROOT_OBJECT,
608 ACPIDEV_OBJECT_NAME_SB, &hdl))) {
609 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get handle of %s.",
610 ACPIDEV_OBJECT_NAME_SB);
611 return (AE_ERROR);
612 }
613
614 *hdlp = NULL;
615 if (ACPI_FAILURE(AcpiWalkNamespace(ACPI_TYPE_DEVICE, hdl,
616 ACPIDEV_MAX_ENUM_LEVELS - 1, acpidev_dr_find_board, NULL,
617 (void *)(intptr_t)board, (void **)hdlp))) {
618 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to find ACPI handle "
619 "for board %d.", board);
620 rc = AE_NOT_FOUND;
621 } else if (*hdlp == NULL) {
622 ACPIDEV_DEBUG(CE_NOTE,
623 "!acpidev: board %d doesn't exist.", board);
624 rc = AE_NOT_FOUND;
625 }
626
627 return (rc);
628 }
629
630 acpidev_board_type_t
631 acpidev_dr_get_board_type(ACPI_HANDLE hdl)
632 {
633 acpidev_data_handle_t dhdl;
634 acpidev_board_type_t type = ACPIDEV_INVALID_BOARD;
635
636 if (hdl == NULL) {
637 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
638 "acpidev_dr_get_board_type().");
639 return (type);
640 }
641
642 dhdl = acpidev_data_get_handle(hdl);
643 if (dhdl == NULL) {
644 ACPIDEV_DEBUG(CE_WARN,
645 "!acpidev: failed to get data associated with %p.", hdl);
646 } else {
647 type = dhdl->aod_bdtype;
648 }
649
650 return (type);
651 }
652
653 ACPI_STATUS
654 acpidev_dr_get_board_number(ACPI_HANDLE hdl, uint32_t *bnump)
655 {
656 acpidev_data_handle_t dhdl;
657
658 if (hdl == NULL || bnump == NULL) {
659 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
660 "acpidev_dr_get_board_number().");
661 return (AE_BAD_PARAMETER);
662 }
663
664 dhdl = acpidev_data_get_handle(hdl);
665 if (dhdl == NULL) {
666 ACPIDEV_DEBUG(CE_WARN,
667 "!acpidev: failed to get data associated with %p.", hdl);
668 return (AE_ERROR);
669 }
670 *bnump = dhdl->aod_bdnum;
671
672 return (AE_OK);
673 }
674
675 ACPI_STATUS
676 acpidev_dr_get_board_name(ACPI_HANDLE hdl, char *buf, size_t len)
677 {
678 char *fmt;
679 int count = 0;
680 size_t rlen = 0;
681 ACPI_HANDLE thdl;
682 acpidev_data_handle_t dhdl;
683 acpidev_data_handle_t dhdls[ACPIDEV_MAX_ENUM_LEVELS];
684
685 if (hdl == NULL || buf == NULL) {
686 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
687 "acpidev_dr_get_board_name().");
688 return (AE_BAD_PARAMETER);
689 }
690
691 /* Find ancestors of the device which are hotplug capable. */
692 for (thdl = hdl; thdl != NULL; ) {
693 dhdl = acpidev_data_get_handle(thdl);
694 if (dhdl == NULL) {
695 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get data "
696 "associated with %p.", thdl);
697 return (AE_ERROR);
698 }
699
700 if (!ACPIDEV_DR_IS_BOARD(dhdl)) {
701 /* The board itself should be hotplug capable. */
702 if (count == 0) {
703 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %p is "
704 "not hotplug capable.", thdl);
705 return (AE_ERROR);
706 }
707 } else {
708 if (ACPIDEV_DR_IS_FAILED(dhdl)) {
709 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %p is "
710 "in the FAILED state.", thdl);
711 }
712
713 if (count >= ACPIDEV_MAX_ENUM_LEVELS) {
714 ACPIDEV_DEBUG(CE_WARN,
715 "!acpidev: recursive level for hotplug "
716 "capable board is too deep.");
717 return (AE_ERROR);
718 }
719
720 dhdls[count] = dhdl;
721 count++;
722 }
723
724 if (acpidev_dr_hierarchy_name == 0) {
725 thdl = NULL;
726 } else if (ACPI_FAILURE(AcpiGetParent(thdl, &thdl))) {
727 thdl = NULL;
728 }
729 }
730
731 /* Generate hierarchy board name for the board. */
732 ASSERT(count > 0);
733 for (count--; count >= 0 && rlen < len; count--) {
734 dhdl = dhdls[count];
735 switch (dhdl->aod_bdtype) {
736 case ACPIDEV_CPU_BOARD:
737 fmt = ACPIDEV_DR_CPU_BD_FMT;
738 break;
739 case ACPIDEV_MEMORY_BOARD:
740 fmt = ACPIDEV_DR_MEMORY_BD_FMT;
741 break;
742 case ACPIDEV_IO_BOARD:
743 fmt = ACPIDEV_DR_IO_BD_FMT;
744 break;
745 case ACPIDEV_SYSTEM_BOARD:
746 fmt = ACPIDEV_DR_SYSTEM_BD_FMT;
747 break;
748 case ACPIDEV_INVALID_BOARD:
749 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid board type.");
750 return (AE_ERROR);
751 default:
752 ACPIDEV_DEBUG(CE_WARN,
753 "!acpidev: unknown board type %u.",
754 dhdl->aod_bdtype);
755 return (AE_ERROR);
756 }
757
758 /* Add "." before component name except first item. */
759 if (rlen != 0) {
760 rlen += snprintf(buf + rlen, len - rlen, ".");
761 }
762 if (rlen < len) {
763 rlen += snprintf(buf + rlen, len - rlen, fmt,
764 dhdl->aod_bdidx);
765 }
766 }
767
768 /* Check whether the buffer is sufficient. */
769 if (rlen >= len) {
770 ACPIDEV_DEBUG(CE_WARN, "!acpidev: buffer length to "
771 "acpidev_dr_get_board_name() is too small.");
772 return (AE_NO_MEMORY);
773 }
774
775 return (AE_OK);
776 }
777
778 ACPI_STATUS
779 acpidev_dr_get_attachment_point(ACPI_HANDLE hdl, char *buf, size_t len)
780 {
781 size_t rlen;
782
783 if (hdl == NULL || buf == NULL) {
784 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
785 "acpidev_dr_get_attachment_point().");
786 return (AE_BAD_PARAMETER);
787 }
788
789 rlen = snprintf(buf, len, "/devices/%s/%s@%u:",
790 ACPIDEV_NODE_NAME_ROOT, ACPIDEV_NODE_NAME_ACPIDR, 0);
791 if (rlen >= len) {
792 ACPIDEV_DEBUG(CE_WARN, "!acpidev: buffer to "
793 "acpidev_dr_get_attachment_point() is too small.");
794 return (AE_NO_MEMORY);
795 }
796
797 return (acpidev_dr_get_board_name(hdl, buf + rlen, len - rlen));
798 }
799
800 /*
801 * Existence of ACPI _EJ0 method implies that the device is hotplug capable.
802 */
803 int
804 acpidev_dr_device_hotplug_capable(ACPI_HANDLE hdl)
805 {
806 ACPI_HANDLE ej0;
807
808 ASSERT(hdl != NULL);
809 if (ACPI_FAILURE(AcpiGetHandle(hdl, ACPIDEV_METHOD_NAME_EJ0, &ej0))) {
810 return (0);
811 }
812
813 return (1);
814 }
815
816 int
817 acpidev_dr_device_has_edl(ACPI_HANDLE hdl)
818 {
819 ACPI_HANDLE edl;
820
821 ASSERT(hdl != NULL);
822 if (ACPI_FAILURE(AcpiGetHandle(hdl, ACPIDEV_METHOD_NAME_EDL, &edl))) {
823 return (0);
824 }
825
826 return (1);
827 }
828
829 int
830 acpidev_dr_device_is_present(ACPI_HANDLE hdl)
831 {
832 int status;
833
834 ASSERT(hdl != NULL);
835
836 status = acpidev_query_device_status(hdl);
837 if (acpidev_check_device_present(status)) {
838 return (1);
839 }
840
841 return (0);
842 }
843
844 int
845 acpidev_dr_device_is_powered(ACPI_HANDLE hdl)
846 {
847 int status;
848
849 ASSERT(hdl != NULL);
850
851 /*
852 * Check device status returned by ACPI _STA method.
853 * It implies that the device is powered if status is both PRESENT
854 * and ENABLED.
855 */
856 status = acpidev_query_device_status(hdl);
857 if (acpidev_check_device_enabled(status)) {
858 return (1);
859 }
860
861 return (0);
862 }
863
864 ACPI_STATUS
865 acpidev_dr_get_mem_alignment(ACPI_HANDLE hdl, uint64_t *ap)
866 {
867 acpidev_dr_capacity_t *cp;
868
869 ASSERT(hdl != NULL);
870 ASSERT(ap != NULL);
871 if (ap == NULL || hdl == NULL) {
872 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
873 "acpidev_dr_get_mem_alignment().");
874 return (AE_BAD_PARAMETER);
875 }
876
877 cp = acpidev_dr_get_capacity();
878 if (cp == NULL || cp->hotplug_supported == B_FALSE) {
879 ACPIDEV_DEBUG(CE_WARN,
880 "!acpidev: failed to get memory alignment.");
881 return (AE_SUPPORT);
882 }
883 *ap = cp->memory_alignment;
884
885 return (AE_OK);
886 }
887
888 /*
889 * Get the device property for the given name and store it into buf.
890 * Returns the amount of data copied to buf if len is large enough to
891 * hold all of the data. If len is not large enough, then the required
892 * len would be returned and buf would not be modified. On any errors,
893 * -1 is returned and buf is not modified.
894 */
895 ACPI_STATUS
896 acpidev_dr_device_get_regspec(ACPI_HANDLE hdl, boolean_t assigned,
897 acpidev_regspec_t **regpp, uint_t *cntp)
898 {
899 int *valp;
900 uint_t count;
901 char *propname;
902 dev_info_t *dip;
903 acpidev_data_handle_t dhdl;
904
905 ASSERT(hdl != NULL);
906 ASSERT(regpp != NULL && cntp != NULL);
907 if (hdl == NULL || regpp == NULL || cntp == NULL) {
908 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameters to "
909 "acpidev_dr_device_get_regspec().");
910 return (AE_BAD_PARAMETER);
911 }
912
913 /* Set default return value. */
914 *regpp = NULL;
915 *cntp = 0;
916
917 dhdl = acpidev_data_get_handle(hdl);
918 if (dhdl == NULL) {
919 ACPIDEV_DEBUG(CE_WARN,
920 "!acpidev: failed to get data associated with %p.", hdl);
921 return (AE_ERROR);
922 } else if ((dip = acpidev_data_get_devinfo(dhdl)) == NULL) {
923 ACPIDEV_DEBUG(CE_WARN,
924 "!acpidev: failed to get dip associated with %p.", hdl);
925 return (AE_NOT_FOUND);
926 }
927
928 propname = assigned ? "assigned-addresses" : "reg";
929 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
930 propname, &valp, &count) != DDI_PROP_SUCCESS) {
931 ACPIDEV_DEBUG(CE_WARN,
932 "!acpidev: failed to lookup device property %s.", propname);
933 return (AE_NOT_FOUND);
934 }
935
936 if (count % (sizeof (**regpp) / sizeof (int)) != 0) {
937 ACPIDEV_DEBUG(CE_WARN,
938 "!acpidev: device property %s is invalid.", propname);
939 ddi_prop_free(valp);
940 return (AE_ERROR);
941 }
942
943 *regpp = (acpidev_regspec_t *)valp;
944 *cntp = count / (sizeof (**regpp) / sizeof (int));
945
946 return (AE_OK);
947 }
948
949 void
950 acpidev_dr_device_free_regspec(acpidev_regspec_t *regp, uint_t count)
951 {
952 _NOTE(ARGUNUSED(count));
953
954 if (regp != NULL) {
955 ddi_prop_free(regp);
956 }
957 }
958
959 /*
960 * Return values
961 * . negative values on error
962 * . size of data copied to buffer if it's bigger enough
963 * . size of buffer needed if buffer is too small
964 */
965 int
966 acpidev_dr_device_getprop(ACPI_HANDLE hdl, char *name, caddr_t buf, size_t len)
967 {
968 int rlen = -1;
969 acpidev_data_handle_t dhdl;
970
971 if (hdl == NULL) {
972 return (-1);
973 }
974
975 dhdl = acpidev_data_get_handle(hdl);
976 if (dhdl == NULL) {
977 return (-1);
978 } else if (!ACPIDEV_DR_IS_WORKING(dhdl)) {
979 return (-1);
980 }
981
982 if (strcmp(name, ACPIDEV_DR_PROP_PORTID) == 0) {
983 if (len >= sizeof (uint32_t)) {
984 *(uint32_t *)(void *)buf = dhdl->aod_portid;
985 }
986 rlen = sizeof (uint32_t);
987 } else if (strcmp(name, ACPIDEV_DR_PROP_BOARDNUM) == 0) {
988 if (len >= sizeof (uint32_t)) {
989 *(uint32_t *)(void *)buf = dhdl->aod_bdnum;
990 }
991 rlen = sizeof (uint32_t);
992 } else if (strcmp(name, ACPIDEV_DR_PROP_DEVNAME) == 0) {
993 switch (dhdl->aod_class_id) {
994 case ACPIDEV_CLASS_ID_CPU:
995 if (len >= sizeof (ACPIDEV_NODE_NAME_CPU)) {
996 (void) strlcpy((char *)buf,
997 ACPIDEV_NODE_NAME_CPU, len);
998 }
999 rlen = sizeof (ACPIDEV_NODE_NAME_CPU);
1000 break;
1001
1002 case ACPIDEV_CLASS_ID_MEMORY:
1003 if (len >= sizeof (ACPIDEV_NODE_NAME_MEMORY)) {
1004 (void) strlcpy((char *)buf,
1005 ACPIDEV_NODE_NAME_MEMORY, len);
1006 }
1007 rlen = sizeof (ACPIDEV_NODE_NAME_MEMORY);
1008 break;
1009
1010 case ACPIDEV_CLASS_ID_PCI:
1011 case ACPIDEV_CLASS_ID_PCIEX:
1012 if (len >= sizeof (ACPIDEV_NODE_NAME_PCI)) {
1013 (void) strlcpy((char *)buf,
1014 ACPIDEV_NODE_NAME_PCI, len);
1015 }
1016 rlen = sizeof (ACPIDEV_NODE_NAME_PCI);
1017 break;
1018
1019 default:
1020 break;
1021 }
1022 }
1023
1024 return (rlen);
1025 }
1026
1027 /*
1028 * Figure out device class of the device.
1029 * It only supports device classes which may be involved in DR operations.
1030 */
1031 acpidev_class_id_t
1032 acpidev_dr_device_get_class(ACPI_HANDLE hdl)
1033 {
1034 ACPI_OBJECT_TYPE type;
1035 ACPI_DEVICE_INFO *infop;
1036 acpidev_class_id_t id = ACPIDEV_CLASS_ID_INVALID;
1037
1038 static char *acpidev_id_cpu[] = {
1039 ACPIDEV_HID_CPU,
1040 };
1041 static char *acpidev_id_mem[] = {
1042 ACPIDEV_HID_MEMORY,
1043 };
1044 static char *acpidev_id_mod[] = {
1045 ACPIDEV_HID_MODULE,
1046 };
1047 static char *acpidev_id_pci[] = {
1048 ACPIDEV_HID_PCI_HOSTBRIDGE,
1049 };
1050 static char *acpidev_id_pciex[] = {
1051 ACPIDEV_HID_PCIEX_HOSTBRIDGE,
1052 };
1053
1054 /* Figure out device type by checking ACPI object type. */
1055 if (ACPI_FAILURE(AcpiGetType(hdl, &type))) {
1056 return (ACPIDEV_CLASS_ID_INVALID);
1057 } else if (type == ACPI_TYPE_PROCESSOR) {
1058 return (ACPIDEV_CLASS_ID_CPU);
1059 } else if (type != ACPI_TYPE_DEVICE) {
1060 return (ACPIDEV_CLASS_ID_INVALID);
1061 }
1062
1063 if (ACPI_FAILURE(AcpiGetObjectInfo(hdl, &infop))) {
1064 return (ACPIDEV_CLASS_ID_INVALID);
1065 }
1066
1067 /* Figure out device type by checking _HID and _CID. */
1068 if (acpidev_match_device_id(infop,
1069 ACPIDEV_ARRAY_PARAM(acpidev_id_cpu))) {
1070 id = ACPIDEV_CLASS_ID_CPU;
1071 } else if (acpidev_match_device_id(infop,
1072 ACPIDEV_ARRAY_PARAM(acpidev_id_mem))) {
1073 id = ACPIDEV_CLASS_ID_MEMORY;
1074 } else if (acpidev_match_device_id(infop,
1075 ACPIDEV_ARRAY_PARAM(acpidev_id_mod))) {
1076 id = ACPIDEV_CLASS_ID_CONTAINER;
1077 } else if (acpidev_match_device_id(infop,
1078 ACPIDEV_ARRAY_PARAM(acpidev_id_pciex))) {
1079 id = ACPIDEV_CLASS_ID_PCIEX;
1080 } else if (acpidev_match_device_id(infop,
1081 ACPIDEV_ARRAY_PARAM(acpidev_id_pci))) {
1082 id = ACPIDEV_CLASS_ID_PCI;
1083 }
1084
1085 AcpiOsFree(infop);
1086
1087 return (id);
1088 }
1089
1090 ACPI_STATUS
1091 acpidev_dr_device_get_memory_index(ACPI_HANDLE hdl, uint32_t *idxp)
1092 {
1093 acpidev_data_handle_t dhdl;
1094
1095 ASSERT(idxp != NULL);
1096 ASSERT(hdl != NULL);
1097
1098 dhdl = acpidev_data_get_handle(hdl);
1099 if (dhdl == NULL) {
1100 ACPIDEV_DEBUG(CE_WARN,
1101 "!acpidev: failed to get data handle for %p.", hdl);
1102 return (AE_ERROR);
1103 } else if (dhdl->aod_class_id != ACPIDEV_CLASS_ID_MEMORY) {
1104 ACPIDEV_DEBUG(CE_WARN,
1105 "!acpidev: object %p is not a memory device.", hdl);
1106 return (AE_ERROR);
1107 } else {
1108 *idxp = dhdl->aod_memidx;
1109 }
1110
1111 return (AE_OK);
1112 }
1113
1114 int
1115 acpidev_dr_device_is_board(ACPI_HANDLE hdl)
1116 {
1117 acpidev_data_handle_t dhdl;
1118
1119 ASSERT(hdl != NULL);
1120 if (hdl == NULL) {
1121 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
1122 "acpidev_dr_is_board().");
1123 return (0);
1124 }
1125
1126 dhdl = acpidev_data_get_handle(hdl);
1127 if (dhdl == NULL) {
1128 return (0);
1129 } else if (!ACPIDEV_DR_IS_BOARD(dhdl)) {
1130 return (0);
1131 }
1132
1133 return (1);
1134 }
1135
1136 ACPI_STATUS
1137 acpidev_dr_device_walk_edl(ACPI_HANDLE hdl,
1138 ACPI_WALK_CALLBACK cb, void *arg, void **retval)
1139 {
1140 ACPI_STATUS rc = AE_OK;
1141 int i;
1142 char *objname;
1143 ACPI_OBJECT *obj;
1144 ACPI_BUFFER buf;
1145 char *method = ACPIDEV_METHOD_NAME_EDL;
1146
1147 ASSERT(hdl != NULL);
1148 ASSERT(cb != NULL);
1149 if (hdl == NULL || cb == NULL) {
1150 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
1151 "acpidev_dr_device_walk_edl().");
1152 return (AE_BAD_PARAMETER);
1153 }
1154
1155 objname = acpidev_get_object_name(hdl);
1156 buf.Length = ACPI_ALLOCATE_BUFFER;
1157 rc = AcpiEvaluateObjectTyped(hdl, method, NULL, &buf,
1158 ACPI_TYPE_PACKAGE);
1159 if (rc == AE_NOT_FOUND) {
1160 acpidev_free_object_name(objname);
1161 return (AE_OK);
1162 } else if (ACPI_FAILURE(rc)) {
1163 cmn_err(CE_WARN,
1164 "!acpidev: failed to evaluate method %s under %s.",
1165 method, objname);
1166 acpidev_free_object_name(objname);
1167 return (AE_ERROR);
1168 }
1169
1170 /* Validate the package structure. */
1171 obj = buf.Pointer;
1172 for (i = 0; i < obj->Package.Count; i++) {
1173 if (obj->Package.Elements[i].Type !=
1174 ACPI_TYPE_LOCAL_REFERENCE) {
1175 cmn_err(CE_WARN, "!acpidev: element %d in package "
1176 "returned by %s of %s is not local reference.",
1177 i, method, objname);
1178 AcpiOsFree(buf.Pointer);
1179 acpidev_free_object_name(objname);
1180 return (AE_ERROR);
1181 } else if (obj->Package.Elements[i].Reference.ActualType !=
1182 ACPI_TYPE_DEVICE) {
1183 cmn_err(CE_WARN, "!acpidev: element %d in package "
1184 "returned by %s of %s doesn't refer to device.",
1185 i, method, objname);
1186 AcpiOsFree(buf.Pointer);
1187 acpidev_free_object_name(objname);
1188 return (AE_ERROR);
1189 }
1190 }
1191
1192 for (i = 0; i < obj->Package.Count; i++) {
1193 if (obj->Package.Elements[i].Reference.Handle == NULL) {
1194 cmn_err(CE_WARN, "!acpidev: handle of element %d in "
1195 "package returned by %s of %s is NULL.",
1196 i, method, objname);
1197 continue;
1198 }
1199 rc = (*cb)(obj->Package.Elements[i].Reference.Handle,
1200 UINT32_MAX, arg, retval);
1201 if (rc == AE_CTRL_DEPTH || rc == AE_CTRL_TERMINATE) {
1202 rc = AE_OK;
1203 }
1204 if (ACPI_FAILURE(rc)) {
1205 break;
1206 }
1207 }
1208
1209 AcpiOsFree(buf.Pointer);
1210 acpidev_free_object_name(objname);
1211
1212 return (rc);
1213 }
1214
1215 ACPI_STATUS
1216 acpidev_dr_device_walk_ejd(ACPI_HANDLE hdl,
1217 ACPI_WALK_CALLBACK cb, void *arg, void **retval)
1218 {
1219 ACPI_STATUS rc = AE_OK;
1220 char *objname;
1221 ACPI_OBJECT *obj;
1222 ACPI_BUFFER buf;
1223 ACPI_HANDLE chdl;
1224 char *method = ACPIDEV_METHOD_NAME_EJD;
1225
1226 ASSERT(hdl != NULL);
1227 ASSERT(cb != NULL);
1228 if (hdl == NULL || cb == NULL) {
1229 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
1230 "acpidev_dr_device_walk_ejd().");
1231 return (AE_BAD_PARAMETER);
1232 }
1233
1234 objname = acpidev_get_object_name(hdl);
1235 buf.Length = ACPI_ALLOCATE_BUFFER;
1236 rc = AcpiEvaluateObjectTyped(hdl, method, NULL, &buf,
1237 ACPI_TYPE_STRING);
1238 if (rc == AE_NOT_FOUND) {
1239 acpidev_free_object_name(objname);
1240 return (AE_OK);
1241 } else if (ACPI_FAILURE(rc)) {
1242 cmn_err(CE_WARN,
1243 "!acpidev: failed to evaluate method %s under %s.",
1244 method, objname);
1245 acpidev_free_object_name(objname);
1246 return (AE_ERROR);
1247 }
1248
1249 obj = buf.Pointer;
1250 ASSERT(obj->String.Pointer);
1251 if (ACPI_FAILURE(AcpiGetHandle(NULL, obj->String.Pointer, &chdl))) {
1252 cmn_err(CE_WARN, "!acpidev: failed to get handle for %s.",
1253 obj->String.Pointer);
1254 rc = AE_ERROR;
1255 } else {
1256 rc = (*cb)(chdl, UINT32_MAX, arg, retval);
1257 if (rc == AE_CTRL_DEPTH || rc == AE_CTRL_TERMINATE) {
1258 rc = AE_OK;
1259 }
1260 }
1261
1262 AcpiOsFree(buf.Pointer);
1263 acpidev_free_object_name(objname);
1264
1265 return (rc);
1266 }
1267
1268 /*
1269 * Walk all child devices and special devices in the eject device list.
1270 */
1271 static ACPI_STATUS
1272 acpidev_dr_device_walk_child(ACPI_HANDLE hdl, boolean_t init, uint_t max_lvl,
1273 ACPI_WALK_CALLBACK cb, void *arg, void **retval)
1274 {
1275 ACPI_STATUS rc = AE_OK;
1276
1277 ASSERT(hdl != NULL);
1278 ASSERT(cb != NULL);
1279 if (hdl == NULL || cb == NULL) {
1280 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
1281 "acpidev_dr_device_walk_child().");
1282 return (AE_BAD_PARAMETER);
1283 }
1284
1285 /*
1286 * Walk the eject device list first when destroying.
1287 * According to ACPI spec, devices in _EDL list must be handled first
1288 * when the ejecting device.
1289 */
1290 if (init == B_FALSE) {
1291 rc = acpidev_dr_device_walk_edl(hdl, cb, arg, retval);
1292 if (ACPI_FAILURE(rc)) {
1293 ACPIDEV_DEBUG(CE_NOTE,
1294 "!acpidev: failed to walk eject device list in "
1295 "acpidev_dr_device_walk_child().");
1296 }
1297 }
1298
1299 /* Walk all child ACPI DEVICE objects. */
1300 if (ACPI_SUCCESS(rc)) {
1301 rc = AcpiWalkNamespace(ACPI_TYPE_DEVICE, hdl,
1302 max_lvl, cb, NULL, arg, retval);
1303 if (ACPI_FAILURE(rc)) {
1304 ACPIDEV_DEBUG(CE_NOTE,
1305 "!acpidev: failed to walk DEVICE objects in "
1306 "acpidev_dr_device_walk_child().");
1307 }
1308 }
1309
1310 /* Walk all child ACPI PROCESSOR objects. */
1311 if (ACPI_SUCCESS(rc)) {
1312 rc = AcpiWalkNamespace(ACPI_TYPE_PROCESSOR, hdl,
1313 max_lvl, cb, NULL, arg, retval);
1314 if (ACPI_FAILURE(rc)) {
1315 ACPIDEV_DEBUG(CE_NOTE,
1316 "!acpidev: failed to walk PROCESSOR objects in "
1317 "acpidev_dr_device_walk_child().");
1318 }
1319 }
1320
1321 /*
1322 * Walk the eject device list last when initializing.
1323 */
1324 if (init == B_TRUE && ACPI_SUCCESS(rc)) {
1325 rc = acpidev_dr_device_walk_edl(hdl, cb, arg, retval);
1326 if (ACPI_FAILURE(rc)) {
1327 ACPIDEV_DEBUG(CE_NOTE,
1328 "!acpidev: failed to walk eject device list in "
1329 "acpidev_dr_device_walk_child().");
1330 }
1331 }
1332
1333 return (rc);
1334 }
1335
1336 ACPI_STATUS
1337 acpidev_dr_device_walk_device(ACPI_HANDLE hdl, uint_t max_lvl,
1338 ACPI_WALK_CALLBACK cb, void *arg, void **retval)
1339 {
1340 ACPI_STATUS rc = AE_OK;
1341 char *objname;
1342
1343 ASSERT(hdl != NULL);
1344 ASSERT(cb != NULL);
1345 if (hdl == NULL || cb == NULL) {
1346 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter to "
1347 "acpidev_dr_walk_device().");
1348 return (AE_BAD_PARAMETER);
1349 }
1350
1351 /* Walk the top object itself first. */
1352 rc = (*cb)(hdl, 0, arg, retval);
1353 if (rc == AE_CTRL_DEPTH || rc == AE_CTRL_TERMINATE) {
1354 rc = AE_OK;
1355 } else if (ACPI_FAILURE(rc)) {
1356 objname = acpidev_get_object_name(hdl);
1357 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to handle top node %s "
1358 "in acpidev_dr_walk_device().", objname);
1359 acpidev_free_object_name(objname);
1360 } else {
1361 rc = acpidev_dr_device_walk_child(hdl, B_TRUE, max_lvl,
1362 cb, arg, retval);
1363 if (ACPI_FAILURE(rc)) {
1364 objname = acpidev_get_object_name(hdl);
1365 ACPIDEV_DEBUG(CE_WARN,
1366 "!acpidev: failed to handle descendant nodes of %s "
1367 "in acpidev_dr_walk_device().", objname);
1368 acpidev_free_object_name(objname);
1369 }
1370 }
1371
1372 return (rc);
1373 }
1374
1375 static ACPI_STATUS
1376 acpidev_dr_no_support(ACPI_HANDLE hdl, UINT32 lvl, void *arg, void **retval)
1377 {
1378 _NOTE(ARGUNUSED(arg, retval));
1379
1380 char *objname;
1381
1382 ASSERT(hdl != NULL);
1383
1384 objname = acpidev_get_object_name(hdl);
1385 ACPIDEV_DEBUG(CE_NOTE,
1386 "!acpidev: device %s at level 0x%x is unsupported.",
1387 objname, lvl);
1388 acpidev_free_object_name(objname);
1389
1390 return (AE_SUPPORT);
1391 }
1392
1393 static ACPI_STATUS
1394 acpidev_dr_set_prop(ACPI_HANDLE hdl, char *objname,
1395 struct acpidev_dr_set_prop_arg *ap, uint32_t lvl,
1396 acpidev_class_id_t clsid, uint_t *devid)
1397 {
1398 acpidev_data_handle_t dhdl;
1399
1400 /* Create data handle first if it doesn't exist yet. */
1401 dhdl = acpidev_data_get_handle(hdl);
1402 if (dhdl == NULL) {
1403 uint32_t rlvl;
1404 ACPI_HANDLE phdl;
1405
1406 /*
1407 * Compute level by walking ACPI namespace if it's a device
1408 * from the eject device list.
1409 */
1410 if (lvl == UINT32_MAX) {
1411 /*
1412 * AcpiGetParent() fails when it tries to get
1413 * the parent of the ACPI namespace root node.
1414 */
1415 for (rlvl = 0, phdl = hdl;
1416 ACPI_SUCCESS(AcpiGetParent(phdl, &phdl));
1417 rlvl++) {
1418 if (phdl == ACPI_ROOT_OBJECT) {
1419 break;
1420 }
1421 }
1422 if (rlvl == 0) {
1423 ACPIDEV_DEBUG(CE_WARN,
1424 "!acpidev: failed to get level of %s.",
1425 objname);
1426 return (AE_BAD_PARAMETER);
1427 }
1428 } else {
1429 rlvl = ap->level;
1430 }
1431 if (rlvl >= ACPIDEV_MAX_ENUM_LEVELS) {
1432 ACPIDEV_DEBUG(CE_WARN,
1433 "!acpidev: recursive level of %s is too deep.",
1434 objname);
1435 return (AE_SUPPORT);
1436 }
1437
1438 dhdl = acpidev_data_create_handle(hdl);
1439 if (dhdl != NULL) {
1440 dhdl->aod_hdl = hdl;
1441 dhdl->aod_level = rlvl;
1442 }
1443 }
1444
1445 if (dhdl == NULL) {
1446 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to create data handle "
1447 "for device %s.", objname);
1448 return (AE_NO_MEMORY);
1449 }
1450
1451 if (ACPIDEV_DR_IS_READY(dhdl)) {
1452 /*
1453 * The same device may be enumerated twice at most. Once as
1454 * child devices, another time from the eject device list.
1455 */
1456 if (dhdl->aod_bdnum == ap->bdnum) {
1457 return (AE_OK);
1458 } else {
1459 /*
1460 * A device has been enumerated more than once from
1461 * different paths. It's dangerous to support such
1462 * a topology. Disable support of DR operations.
1463 */
1464 ACPIDEV_DEBUG(CE_WARN, "!acpidev: device %s has been "
1465 "enumerated more than once for DR.", objname);
1466 acpidev_dr_failed = 1;
1467 return (AE_SUPPORT);
1468 }
1469 }
1470
1471 /* Set properties for DR operations. */
1472 dhdl->aod_class_id = clsid;
1473 dhdl->aod_bdnum = ap->bdnum;
1474 dhdl->aod_portid = atomic_inc_32_nv(devid) - 1;
1475 if (clsid == ACPIDEV_CLASS_ID_MEMORY) {
1476 dhdl->aod_memidx = acpidev_dr_memory_device_cnt;
1477 ASSERT(dhdl->aod_memidx < ACPI_MEMNODE_DEVID_BOOT);
1478 }
1479 ACPIDEV_DR_SET_READY(dhdl);
1480
1481 return (AE_OK);
1482 }
1483
1484 /*
1485 * Verify whether the hardware topology is supported by the DR driver.
1486 * The ACPI specification is so flexible that for safety reasons, only
1487 * a few well defined topologies are supported.
1488 * Possible values of parameter lvl:
1489 * 0: the device is the board itself.
1490 * UINT32_MAX: the device is from the _EDL list of the board.
1491 * other: the device is a descendant of the board.
1492 * Return values:
1493 * AE_OK: the topology is supported
1494 * AE_SUPPORT: the topology is unsupported
1495 * AE_ERROR: other errors
1496 */
1497 static ACPI_STATUS
1498 acpidev_dr_scan_topo(ACPI_HANDLE hdl, UINT32 lvl, void *arg, void **retval)
1499 {
1500 _NOTE(ARGUNUSED(retval));
1501
1502 ACPI_STATUS rc = AE_OK;
1503 char *objname;
1504 acpidev_class_id_t cid;
1505 struct acpidev_dr_set_prop_arg *ap = arg;
1506
1507 ASSERT(hdl != NULL);
1508 ASSERT(lvl == 0 || lvl == 1 || lvl == UINT32_MAX);
1509 objname = acpidev_get_object_name(hdl);
1510
1511 /*
1512 * Validate descendants of the hotplug capable board.
1513 * lvl is zero if it's the hotplug capable board itself, otherwise
1514 * non-zero for descendants.
1515 */
1516 if (lvl != 0) {
1517 /*
1518 * Skip subtree if the device is hotplug capable.
1519 * It will be treated as another hotplug capable board.
1520 */
1521 if (acpidev_dr_device_hotplug_capable(hdl)) {
1522 acpidev_free_object_name(objname);
1523 return (AE_CTRL_DEPTH);
1524 }
1525
1526 /*
1527 * Don't support the _EDL list of a non-hotplug-capable device.
1528 */
1529 if (acpidev_dr_device_has_edl(hdl)) {
1530 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: non-hotplug-capable "
1531 "object %s has _EDL method.", objname);
1532 acpidev_free_object_name(objname);
1533 return (AE_SUPPORT);
1534 }
1535 }
1536
1537 cid = acpidev_dr_device_get_class(hdl);
1538 switch (cid) {
1539 case ACPIDEV_CLASS_ID_CPU:
1540 /* Don't support logical CPUs in the _EDL list. */
1541 if (lvl == UINT32_MAX) {
1542 ACPIDEV_DEBUG(CE_WARN, "!acpidev: logical CPU %s in "
1543 "_EDL is unsupported.", objname);
1544 rc = AE_SUPPORT;
1545 break;
1546 }
1547
1548 /* Don't support logical CPUs with children. */
1549 ap->level++;
1550 rc = acpidev_dr_device_walk_child(hdl, B_TRUE, 1,
1551 acpidev_dr_no_support, arg, NULL);
1552 ap->level--;
1553 if (rc == AE_SUPPORT) {
1554 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: logical CPU %s has "
1555 "child or dependent devices.", objname);
1556 break;
1557 } else if (ACPI_FAILURE(rc)) {
1558 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to scan "
1559 "children of logical CPU %s.", objname);
1560 rc = AE_ERROR;
1561 break;
1562 } else if (ap != NULL) {
1563 rc = acpidev_dr_set_prop(hdl, objname, ap, lvl,
1564 ACPIDEV_CLASS_ID_CPU, &ap->cpu_id);
1565 }
1566 break;
1567
1568 case ACPIDEV_CLASS_ID_MEMORY:
1569 /* Don't support memory devices with children. */
1570 ap->level++;
1571 rc = acpidev_dr_device_walk_child(hdl, B_TRUE, 1,
1572 acpidev_dr_no_support, arg, NULL);
1573 ap->level--;
1574 if (rc == AE_SUPPORT) {
1575 ACPIDEV_DEBUG(CE_NOTE,
1576 "!acpidev: memory device %s has child or "
1577 "dependent devices.", objname);
1578 } else if (ACPI_FAILURE(rc)) {
1579 ACPIDEV_DEBUG(CE_WARN,
1580 "!acpidev: failed to scan children of "
1581 "memory device %s.", objname);
1582 rc = AE_ERROR;
1583 } else if (ap != NULL) {
1584 acpidev_dr_memory_device_cnt++;
1585 rc = acpidev_dr_set_prop(hdl, objname, ap, lvl,
1586 ACPIDEV_CLASS_ID_MEMORY, &ap->mem_id);
1587 }
1588 break;
1589
1590 case ACPIDEV_CLASS_ID_PCI:
1591 case ACPIDEV_CLASS_ID_PCIEX:
1592 /* Don't scan child/descendant devices of PCI/PCIex devices. */
1593 if (ap != NULL) {
1594 rc = acpidev_dr_set_prop(hdl, objname, ap, lvl,
1595 cid, &ap->io_id);
1596 }
1597 break;
1598
1599 case ACPIDEV_CLASS_ID_CONTAINER:
1600 /* Don't support module devices in the _EDL list. */
1601 if (lvl == UINT32_MAX) {
1602 ACPIDEV_DEBUG(CE_WARN, "!acpidev: module device %s in "
1603 "_EDL is unsupported.", objname);
1604 rc = AE_SUPPORT;
1605 break;
1606 }
1607
1608 /* Don't support recurrence of module devices. */
1609 if (lvl > 0) {
1610 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: recursion level of "
1611 "module device %s is too deep.", objname);
1612 rc = AE_SUPPORT;
1613 break;
1614 }
1615
1616 ap->level++;
1617 rc = acpidev_dr_device_walk_child(hdl, B_TRUE, 1,
1618 acpidev_dr_scan_topo, arg, NULL);
1619 ap->level--;
1620 if (ACPI_SUCCESS(rc) && ap != NULL) {
1621 rc = acpidev_dr_set_prop(hdl, objname, ap, lvl,
1622 ACPIDEV_CLASS_ID_CONTAINER, &ap->mod_id);
1623 }
1624 break;
1625
1626 case ACPIDEV_CLASS_ID_INVALID:
1627 /*FALLTHROUGH*/
1628 default:
1629 ACPIDEV_DEBUG(CE_NOTE,
1630 "!acpidev: device %s is unsupported.", objname);
1631 rc = AE_SUPPORT;
1632 break;
1633 }
1634
1635 acpidev_free_object_name(objname);
1636
1637 return (rc);
1638 }
1639
1640 /* Create walk information structures. */
1641 static ACPI_STATUS
1642 acpidev_dr_create_walk_info(ACPI_HANDLE hdl, acpidev_data_handle_t dhdl,
1643 char *objname, acpidev_walk_info_t **infopp, acpidev_walk_info_t **cinfopp)
1644 {
1645 ACPI_HANDLE phdl = NULL;
1646 dev_info_t *pdip = NULL;
1647 acpidev_data_handle_t pdhdl, tdhdl;
1648 acpidev_walk_info_t *infop = NULL, *cinfop = NULL;
1649
1650 ASSERT(hdl != NULL);
1651 ASSERT(dhdl != NULL);
1652 ASSERT(dhdl->aod_class_list != NULL);
1653 ASSERT(objname != NULL);
1654 ASSERT(infopp != NULL);
1655 ASSERT(cinfopp != NULL);
1656
1657 if (ACPI_FAILURE(AcpiGetParent(hdl, &phdl))) {
1658 cmn_err(CE_WARN,
1659 "!acpidev: failed to get parent object of %s.", objname);
1660 return (AE_ERROR);
1661 }
1662
1663 pdhdl = acpidev_data_get_handle(phdl);
1664 if (pdhdl == NULL) {
1665 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get data "
1666 "associated with parent of %s.", objname);
1667 return (AE_ERROR);
1668 }
1669 if (pdhdl->aod_level >= ACPIDEV_MAX_ENUM_LEVELS - 1) {
1670 ACPIDEV_DEBUG(CE_WARN,
1671 "!acpidev: recursion level (%d) of %s is too deep.",
1672 pdhdl->aod_level, objname);
1673 return (AE_ERROR);
1674 }
1675 ASSERT(pdhdl->aod_class_list != NULL);
1676 if (pdhdl->aod_class_list == NULL) {
1677 ACPIDEV_DEBUG(CE_WARN,
1678 "!acpidev: class list for parent of %s is NULL.", objname);
1679 return (AE_ERROR);
1680 }
1681
1682 /* Allocate a walk info structure for its parent. */
1683 infop = acpidev_alloc_walk_info(ACPIDEV_OP_HOTPLUG_PROBE,
1684 pdhdl->aod_level, phdl, dhdl->aod_class_list, NULL);
1685 if (infop == NULL) {
1686 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to allocate walk info "
1687 "structure for parent of %s.", objname);
1688 return (AE_ERROR);
1689 }
1690
1691 /* Get the parent dip if it's not ready yet. */
1692 while (infop->awi_dip == NULL) {
1693 if (ACPI_FAILURE(AcpiGetParent(phdl, &phdl))) {
1694 ACPIDEV_DEBUG(CE_WARN,
1695 "!acpidev: failed to get parent of object %p.",
1696 phdl);
1697 break;
1698 }
1699 tdhdl = acpidev_data_get_handle(phdl);
1700 if (tdhdl == NULL) {
1701 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get data "
1702 "associated with object %p.", phdl);
1703 break;
1704 }
1705 pdip = acpidev_data_get_devinfo(tdhdl);
1706 if (pdip != NULL) {
1707 infop->awi_dip = pdip;
1708 break;
1709 }
1710 /* Give up if reaches the ACPI namespace root node. */
1711 if (phdl == ACPI_ROOT_OBJECT) {
1712 break;
1713 }
1714 }
1715 if (infop->awi_dip == NULL) {
1716 ACPIDEV_DEBUG(CE_WARN,
1717 "!acpidev: failed to get parent dip of %s.", objname);
1718 acpidev_free_walk_info(infop);
1719 return (AE_ERROR);
1720 }
1721
1722 /* Allocate a walk info for the child. */
1723 cinfop = acpidev_alloc_walk_info(ACPIDEV_OP_HOTPLUG_PROBE,
1724 infop->awi_level + 1, hdl, NULL, infop);
1725 if (cinfop == NULL) {
1726 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to allocate walk info "
1727 "structure for %s.", objname);
1728 acpidev_free_walk_info(infop);
1729 return (AE_ERROR);
1730 }
1731
1732 *infopp = infop;
1733 *cinfopp = cinfop;
1734
1735 return (AE_OK);
1736 }
1737
1738 static ACPI_STATUS
1739 acpidev_dr_probe_object(ACPI_HANDLE hdl, acpidev_data_handle_t dhdl)
1740 {
1741 ACPI_STATUS rc = AE_OK;
1742 int circ;
1743 char *objname;
1744 dev_info_t *pdip;
1745 ACPI_STATUS res;
1746 ACPI_OBJECT_TYPE type;
1747 acpidev_class_list_t *it;
1748 acpidev_walk_info_t *infop, *cinfop;
1749
1750 ASSERT(hdl != NULL);
1751 ASSERT(dhdl != NULL);
1752 if (hdl == NULL || dhdl == NULL) {
1753 ACPIDEV_DEBUG(CE_WARN, "!acpidev: hdl or dhdl is NULL in "
1754 "acpidev_dr_probe_object().");
1755 return (AE_BAD_PARAMETER);
1756 }
1757 objname = acpidev_get_object_name(hdl);
1758
1759 /* Check whether the device is of interest. */
1760 if (ACPI_FAILURE(AcpiGetType(hdl, &type)) ||
1761 type > ACPI_TYPE_NS_NODE_MAX ||
1762 BT_TEST(acpidev_object_type_mask, type) == 0) {
1763 ACPIDEV_DEBUG(CE_WARN,
1764 "!acpidev: ACPI object %s is unsupported.", objname);
1765 acpidev_free_object_name(objname);
1766 return (AE_SUPPORT);
1767 }
1768
1769 if (dhdl->aod_class_list == NULL) {
1770 ACPIDEV_DEBUG(CE_WARN,
1771 "!acpidev: class list is NULL in data associated with %s.",
1772 objname);
1773 acpidev_free_object_name(objname);
1774 return (AE_ERROR);
1775 }
1776
1777 pdip = NULL;
1778 infop = NULL;
1779 cinfop = NULL;
1780 rc = acpidev_dr_create_walk_info(hdl, dhdl, objname, &infop, &cinfop);
1781 if (ACPI_FAILURE(rc)) {
1782 ACPIDEV_DEBUG(CE_WARN,
1783 "!acpidev: failed to create walk info structures for %s.",
1784 objname);
1785 acpidev_free_object_name(objname);
1786 return (rc);
1787 }
1788 ASSERT(infop != NULL);
1789 ASSERT(infop->awi_dip != NULL);
1790 ASSERT(infop->awi_class_list != NULL);
1791 ASSERT(cinfop != NULL);
1792 ASSERT(cinfop->awi_data == dhdl);
1793
1794 /* Lock the parent dip before touching children. */
1795 pdip = infop->awi_dip;
1796 ndi_devi_enter(pdip, &circ);
1797 rw_enter(&acpidev_class_lock, RW_READER);
1798
1799 /* Call pre-probe callback functions to prepare for probing. */
1800 for (it = *(infop->awi_class_list); it != NULL; it = it->acl_next) {
1801 if (it->acl_class->adc_pre_probe == NULL) {
1802 continue;
1803 }
1804 infop->awi_class_curr = it->acl_class;
1805 if (ACPI_FAILURE(it->acl_class->adc_pre_probe(infop))) {
1806 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: failed to pre-probe "
1807 "device of type %s under %s.",
1808 it->acl_class->adc_class_name, infop->awi_name);
1809 }
1810 }
1811
1812 /* Call registered probe callback functions to probe devices. */
1813 for (it = *(infop->awi_class_list); it != NULL; it = it->acl_next) {
1814 if (it->acl_class->adc_probe == NULL) {
1815 continue;
1816 }
1817 cinfop->awi_class_curr = it->acl_class;
1818 res = it->acl_class->adc_probe(cinfop);
1819 if (ACPI_FAILURE(res)) {
1820 rc = res;
1821 ACPIDEV_DEBUG(CE_NOTE,
1822 "!acpidev: failed to process object %s under %s.",
1823 objname, infop->awi_name);
1824 }
1825 }
1826
1827 /* Call post-probe callback functions to clean up. */
1828 for (it = *(infop->awi_class_list); it != NULL; it = it->acl_next) {
1829 if (it->acl_class->adc_post_probe == NULL) {
1830 continue;
1831 }
1832 infop->awi_class_curr = it->acl_class;
1833 if (ACPI_FAILURE(it->acl_class->adc_post_probe(infop))) {
1834 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: failed to post-probe "
1835 "device of type %s under %s.",
1836 it->acl_class->adc_class_name, infop->awi_name);
1837 }
1838 }
1839
1840 rw_exit(&acpidev_class_lock);
1841 ndi_devi_exit(pdip, circ);
1842
1843 acpidev_free_walk_info(cinfop);
1844 acpidev_free_walk_info(infop);
1845 acpidev_free_object_name(objname);
1846
1847 return (rc);
1848 }
1849
1850 /*
1851 * Some PCI/PCIex buses embedded in physical processors may be presented in
1852 * the eject device list instead of being presented as child devices.
1853 * This function figures out such devices and create device nodes for them.
1854 */
1855 static ACPI_STATUS
1856 acpidev_dr_probe_dependent(ACPI_HANDLE hdl, UINT32 lvl, void *ctx,
1857 void **retval)
1858 {
1859 _NOTE(ARGUNUSED(retval));
1860
1861 ACPI_STATUS rc = AE_OK;
1862 int status;
1863 char *objname;
1864 ACPI_HANDLE phdl, thdl;
1865 acpidev_data_handle_t dhdl;
1866
1867 ASSERT(lvl == UINT32_MAX);
1868 ASSERT(hdl != NULL);
1869 ASSERT(ctx != NULL);
1870 phdl = ctx;
1871 objname = acpidev_get_object_name(hdl);
1872
1873 dhdl = acpidev_data_get_handle(hdl);
1874 if (dhdl == NULL) {
1875 ACPIDEV_DEBUG(CE_WARN,
1876 "!acpidev: failed to get data associated with %s.",
1877 objname);
1878 acpidev_free_object_name(objname);
1879 return (AE_ERROR);
1880 }
1881
1882 /*
1883 * It should be treated as another board if device is hotplug capable.
1884 */
1885 if (ACPIDEV_DR_IS_BOARD(dhdl)) {
1886 acpidev_free_object_name(objname);
1887 return (AE_OK);
1888 } else if (!ACPIDEV_DR_IS_WORKING(dhdl)) {
1889 ACPIDEV_DEBUG(CE_WARN,
1890 "!acpidev: %s is unusable for DR operations.", objname);
1891 acpidev_free_object_name(objname);
1892 return (AE_SUPPORT);
1893 }
1894
1895 /*
1896 * Skip hdl if it's a descendant of phdl because it should have
1897 * already been handled when handling phdl itself.
1898 */
1899 for (thdl = hdl; ACPI_SUCCESS(AcpiGetParent(thdl, &thdl)); ) {
1900 /* Return when reaches the phdl. */
1901 if (thdl == phdl) {
1902 acpidev_free_object_name(objname);
1903 return (AE_OK);
1904 }
1905 /* Break out when reaches the ACPI namespace root node. */
1906 if (thdl == ACPI_ROOT_OBJECT) {
1907 break;
1908 }
1909 }
1910
1911 /*
1912 * No support of enumerating PCI/PCIex Host Bridge devices yet.
1913 * It will be enabled when PCI/PCIex Host Bridge hotplug is ready.
1914 */
1915 if (dhdl->aod_class_id == ACPIDEV_CLASS_ID_PCI ||
1916 dhdl->aod_class_id == ACPIDEV_CLASS_ID_PCIEX) {
1917 ACPIDEV_DEBUG(CE_WARN, "!acpidev: PCI/PCIEX host bridge %s is "
1918 "unsupported, skip it.", objname);
1919 acpidev_free_object_name(objname);
1920 return (AE_OK);
1921 }
1922
1923 /* Check whether the device exists and has been enabled. */
1924 status = acpidev_query_device_status(hdl);
1925 if (!acpidev_check_device_enabled(status)) {
1926 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: object %s is disabled/absent "
1927 "when trying to connect it.", objname);
1928 acpidev_free_object_name(objname);
1929 return (AE_OK);
1930 }
1931
1932 /* Probe the device and its children. */
1933 rc = acpidev_dr_probe_object(hdl, dhdl);
1934 if (ACPI_FAILURE(rc)) {
1935 ACPIDEV_DEBUG(CE_WARN,
1936 "!acpidev: failed to probe object %s in eject device list.",
1937 objname);
1938 return (rc);
1939 }
1940
1941 return (AE_OK);
1942 }
1943
1944 ACPI_STATUS
1945 acpidev_dr_device_insert(ACPI_HANDLE hdl)
1946 {
1947 ACPI_STATUS rc = AE_OK;
1948 int status, circ;
1949 char *objname;
1950 dev_info_t *dip;
1951 acpidev_data_handle_t dhdl;
1952
1953 ASSERT(acpidev_root_node() != NULL);
1954 ASSERT(hdl != NULL);
1955 if (hdl == NULL) {
1956 ACPIDEV_DEBUG(CE_WARN, "!acpidev: parameter hdl to "
1957 "acpidev_dr_insert_insert() is NULL.");
1958 return (AE_BAD_PARAMETER);
1959 }
1960
1961 objname = acpidev_get_object_name(hdl);
1962 dhdl = acpidev_data_get_handle(hdl);
1963 if (dhdl == NULL) {
1964 ACPIDEV_DEBUG(CE_WARN,
1965 "!acpidev: failed to get data handle associated with %s.",
1966 objname);
1967 acpidev_free_object_name(objname);
1968 return (AE_ERROR);
1969 }
1970
1971 /* Validate that the object is hotplug capable. */
1972 if (!ACPIDEV_DR_BOARD_READY(dhdl)) {
1973 ACPIDEV_DEBUG(CE_WARN,
1974 "!acpidev: object %s is not hotplug capable.", objname);
1975 acpidev_free_object_name(objname);
1976 return (AE_SUPPORT);
1977 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
1978 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %s is in the FAILED "
1979 "state, unusable for DR.", objname);
1980 acpidev_free_object_name(objname);
1981 return (AE_ERROR);
1982 }
1983
1984 /* Check whether the device exists and has been enabled. */
1985 status = acpidev_query_device_status(hdl);
1986 if (!acpidev_check_device_enabled(status)) {
1987 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %s is disabled/absent "
1988 "when trying to connect it.", objname);
1989 acpidev_free_object_name(objname);
1990 return (AE_NOT_EXIST);
1991 }
1992
1993 /* Check that there's no device node created for object yet. */
1994 dip = acpidev_data_get_devinfo(dhdl);
1995 if (dip != NULL) {
1996 ACPIDEV_DEBUG(CE_WARN, "!acpidev: device node for object %s "
1997 "already exists when trying to connect it.", objname);
1998 acpidev_free_object_name(objname);
1999 return (AE_ALREADY_EXISTS);
2000 }
2001
2002 /*
2003 * Solaris has a limitation that all device nodes for PCI/PCIex host
2004 * bridges must exist directly under /devices.
2005 * Special care is needed here to deal with hot-adding PCI/PCIex host
2006 * bridges to avoid dead lock caused by ndi_devi_enter().
2007 * Here the lock on ddi_root_node() is held first, which will break
2008 * the dead lock loop.
2009 */
2010 ndi_devi_enter(ddi_root_node(), &circ);
2011
2012 rc = acpidev_dr_probe_object(hdl, dhdl);
2013 if (ACPI_SUCCESS(rc)) {
2014 rc = acpidev_dr_device_walk_edl(hdl,
2015 &acpidev_dr_probe_dependent, hdl, NULL);
2016 }
2017 if (ACPI_FAILURE(rc)) {
2018 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to create device "
2019 "nodes for children of %s.", objname);
2020 cmn_err(CE_WARN, "!acpidev: disable DR support for object %s "
2021 "due to failure when creating device nodes for it.",
2022 objname);
2023 ACPIDEV_DR_SET_FAILED(dhdl);
2024 }
2025
2026 ndi_devi_exit(ddi_root_node(), circ);
2027 acpidev_free_object_name(objname);
2028
2029 return (rc);
2030 }
2031
2032 static ACPI_STATUS
2033 acpidev_dr_device_remove_cb(ACPI_HANDLE hdl, UINT32 lvl, void *ctx,
2034 void **retval)
2035 {
2036 _NOTE(ARGUNUSED(lvl));
2037
2038 ACPI_STATUS rc = AE_OK;
2039 int status;
2040 char *objname;
2041 dev_info_t *dip;
2042 acpidev_data_handle_t dhdl;
2043 struct acpidev_dr_device_remove_arg *argp;
2044
2045 ASSERT(hdl != NULL && ctx != NULL);
2046 if (hdl == NULL || ctx == NULL) {
2047 ACPIDEV_DEBUG(CE_WARN, "!acpidev: parameter to "
2048 "acpidev_dr_device_remove_cb() is NULL.");
2049 return (AE_BAD_PARAMETER);
2050 }
2051
2052 argp = (struct acpidev_dr_device_remove_arg *)ctx;
2053 objname = acpidev_get_object_name(hdl);
2054 dhdl = acpidev_data_get_handle(hdl);
2055 if (dhdl == NULL) {
2056 ACPIDEV_DEBUG(CE_WARN,
2057 "!acpidev: failed to get data handle associated with %s.",
2058 objname);
2059 acpidev_free_object_name(objname);
2060 return (AE_ERROR);
2061 }
2062
2063 /* Validate that the object is hotplug capable. */
2064 /* It's the hotplug capable board itself if level is zero. */
2065 if (argp->level == 0) {
2066 if (!ACPIDEV_DR_BOARD_READY(dhdl)) {
2067 ACPIDEV_DEBUG(CE_WARN,
2068 "!acpidev: object %s is not hotplug capable.",
2069 objname);
2070 acpidev_free_object_name(objname);
2071 return (AE_SUPPORT);
2072 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2073 ACPIDEV_DEBUG(CE_WARN,
2074 "!acpidev: object %s is unusable for DR.", objname);
2075 acpidev_free_object_name(objname);
2076 return (AE_SUPPORT);
2077 }
2078 } else {
2079 /* It's a device under the hotplug capable board. */
2080 /*
2081 * Skip it if device itself is hotplug capable.
2082 * It will be treated as another hotplug capable board.
2083 */
2084 if (ACPIDEV_DR_IS_BOARD(dhdl)) {
2085 acpidev_free_object_name(objname);
2086 return (AE_OK);
2087 }
2088
2089 if (!ACPIDEV_DR_IS_READY(dhdl)) {
2090 ACPIDEV_DEBUG(CE_WARN,
2091 "!acpidev: object %s is not hotplug capable.",
2092 objname);
2093 acpidev_free_object_name(objname);
2094 return (AE_SUPPORT);
2095 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2096 ACPIDEV_DEBUG(CE_WARN,
2097 "!acpidev: object %s is unusable for DR.", objname);
2098 acpidev_free_object_name(objname);
2099 return (AE_SUPPORT);
2100 }
2101 }
2102
2103 /* Skip the device if it hasn't been enabled at all. */
2104 status = acpidev_data_get_status(dhdl);
2105 if (!acpidev_check_device_enabled(status)) {
2106 acpidev_free_object_name(objname);
2107 return (AE_OK);
2108 }
2109
2110 dip = acpidev_data_get_devinfo(dhdl);
2111 if (dip == NULL) {
2112 ACPIDEV_DEBUG(CE_WARN,
2113 "!acpidev: failed to get dev_info associated with %s.",
2114 objname);
2115 acpidev_free_object_name(objname);
2116 return (AE_SUPPORT);
2117 }
2118
2119 /* For safety, only handle supported device types when unconfiguring. */
2120 switch (dhdl->aod_class_id) {
2121 case ACPIDEV_CLASS_ID_CONTAINER:
2122 /*FALLTHROUGH*/
2123 case ACPIDEV_CLASS_ID_CPU:
2124 /*FALLTHROUGH*/
2125 case ACPIDEV_CLASS_ID_MEMORY:
2126 break;
2127
2128 default:
2129 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %s (type %d) doesn't "
2130 "support unconfiguration.", objname, dhdl->aod_class_id);
2131 acpidev_free_object_name(objname);
2132 return (AE_SUPPORT);
2133 }
2134
2135 /* Destroy descendants first. */
2136 argp->level++;
2137 rc = acpidev_dr_device_walk_child(hdl, B_FALSE, 1,
2138 acpidev_dr_device_remove_cb, ctx, retval);
2139 argp->level--;
2140 if (ACPI_FAILURE(rc)) {
2141 ACPIDEV_DEBUG(CE_WARN,
2142 "!acpidev: failed to destroy descendants of %s.", objname);
2143 acpidev_free_object_name(objname);
2144 return (rc);
2145 }
2146
2147 /* Untag dip and ACPI object before destroying the dip. */
2148 if ((dhdl->aod_iflag & ACPIDEV_ODF_DEVINFO_TAGGED) &&
2149 ACPI_FAILURE(acpica_untag_devinfo(dip, hdl))) {
2150 ACPIDEV_DEBUG(CE_WARN,
2151 "!acpidev: failed to untag object %s.", objname);
2152 /* Mark the node as unusable. */
2153 ACPIDEV_DR_SET_FAILED(dhdl);
2154 acpidev_free_object_name(objname);
2155 return (AE_ERROR);
2156 }
2157
2158 /* Destroy the node itself. */
2159 if (e_ddi_branch_destroy(dip, NULL, 0) != 0) {
2160 char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2161
2162 if ((dhdl->aod_iflag & ACPIDEV_ODF_DEVINFO_TAGGED) &&
2163 ACPI_FAILURE(acpica_tag_devinfo(dip, hdl))) {
2164 ACPIDEV_DEBUG(CE_WARN,
2165 "!acpidev: failed to retag object %s.", objname);
2166 }
2167
2168 /* Mark the node as unusable. */
2169 ACPIDEV_DR_SET_FAILED(dhdl);
2170
2171 (void) ddi_pathname(dip, path);
2172 cmn_err(CE_WARN,
2173 "acpidev: failed to remove node %s (%s).", path, objname);
2174 kmem_free(path, MAXPATHLEN);
2175 acpidev_free_object_name(objname);
2176
2177 return (AE_ERROR);
2178 }
2179
2180 /* Update status and information associated with the device. */
2181 dhdl->aod_dip = NULL;
2182 dhdl->aod_iflag &= ~ACPIDEV_ODF_DEVINFO_CREATED;
2183 dhdl->aod_iflag &= ~ACPIDEV_ODF_DEVINFO_TAGGED;
2184 if (dhdl->aod_class != NULL) {
2185 if (dhdl->aod_class->adc_fini != NULL) {
2186 (*(dhdl->aod_class->adc_fini))(hdl, dhdl,
2187 dhdl->aod_class);
2188 }
2189 atomic_dec_32(&(dhdl->aod_class->adc_refcnt));
2190 dhdl->aod_class = NULL;
2191 }
2192 dhdl->aod_iflag &= ~ACPIDEV_ODF_STATUS_VALID;
2193 dhdl->aod_status = 0;
2194
2195 acpidev_free_object_name(objname);
2196
2197 return (AE_OK);
2198 }
2199
2200 ACPI_STATUS
2201 acpidev_dr_device_remove(ACPI_HANDLE hdl)
2202 {
2203 ACPI_STATUS rc = AE_OK;
2204 int circ;
2205 char *objname;
2206 acpidev_data_handle_t dhdl;
2207 struct acpidev_dr_device_remove_arg arg;
2208
2209 ASSERT(acpidev_root_node() != NULL);
2210 ASSERT(hdl != NULL);
2211 if (hdl == NULL) {
2212 ACPIDEV_DEBUG(CE_WARN, "!acpidev: parameter hdl to "
2213 "acpidev_dr_device_remove() is NULL.");
2214 return (AE_BAD_PARAMETER);
2215 }
2216
2217 objname = acpidev_get_object_name(hdl);
2218 dhdl = acpidev_data_get_handle(hdl);
2219 if (dhdl == NULL) {
2220 ACPIDEV_DEBUG(CE_WARN,
2221 "!acpidev: failed to get data handle associated with %s.",
2222 objname);
2223 acpidev_free_object_name(objname);
2224 return (AE_ERROR);
2225 }
2226
2227 /* Validate that the device is hotplug capable. */
2228 if (!ACPIDEV_DR_BOARD_READY(dhdl)) {
2229 ACPIDEV_DEBUG(CE_WARN,
2230 "!acpidev: object %s is not hotplug capable.", objname);
2231 acpidev_free_object_name(objname);
2232 return (AE_SUPPORT);
2233 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2234 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %s is in the FAILED "
2235 "state, unusable for DR.", objname);
2236 acpidev_free_object_name(objname);
2237 return (AE_ERROR);
2238 }
2239
2240 /*
2241 * Recursively destroy descendants under the top node.
2242 * No need to undo what has been done if error happens, it will be
2243 * handled by DR driver.
2244 */
2245 /*
2246 * Lock ddi_root_node() to avoid deadlock.
2247 */
2248 ndi_devi_enter(ddi_root_node(), &circ);
2249
2250 arg.level = 0;
2251 rc = acpidev_dr_device_remove_cb(hdl, 0, &arg, NULL);
2252 ASSERT(arg.level == 0);
2253 if (ACPI_FAILURE(rc)) {
2254 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to destroy device "
2255 "nodes for children of %s.", objname);
2256 cmn_err(CE_WARN, "!acpidev: disable DR support for object %s "
2257 "due to failure when destroying device nodes for it.",
2258 objname);
2259 ACPIDEV_DR_SET_FAILED(dhdl);
2260 }
2261
2262 ndi_devi_exit(ddi_root_node(), circ);
2263 acpidev_free_object_name(objname);
2264
2265 return (rc);
2266 }
2267
2268 ACPI_STATUS
2269 acpidev_dr_device_poweron(ACPI_HANDLE hdl)
2270 {
2271 acpidev_data_handle_t dhdl;
2272
2273 dhdl = acpidev_data_get_handle(hdl);
2274 if (dhdl == NULL) {
2275 ACPIDEV_DEBUG(CE_WARN,
2276 "!acpidev: failed to get data handle associated with %p.",
2277 hdl);
2278 return (AE_ERROR);
2279 }
2280
2281 /* Check whether the device is hotplug capable. */
2282 if (!ACPIDEV_DR_BOARD_READY(dhdl)) {
2283 ACPIDEV_DEBUG(CE_WARN,
2284 "!acpidev: object %p is not hotplug capable.", hdl);
2285 return (AE_SUPPORT);
2286 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2287 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %p is in the FAILED "
2288 "state, unusable for DR.", hdl);
2289 return (AE_ERROR);
2290 }
2291
2292 return (AE_OK);
2293 }
2294
2295 ACPI_STATUS
2296 acpidev_dr_device_poweroff(ACPI_HANDLE hdl)
2297 {
2298 ACPI_STATUS rc;
2299 acpidev_data_handle_t dhdl;
2300
2301 dhdl = acpidev_data_get_handle(hdl);
2302 if (dhdl == NULL) {
2303 ACPIDEV_DEBUG(CE_WARN,
2304 "!acpidev: failed to get data handle associated with %p.",
2305 hdl);
2306 return (AE_ERROR);
2307 }
2308
2309 /* Check whether the device is hotplug capable. */
2310 if (!ACPIDEV_DR_BOARD_READY(dhdl)) {
2311 ACPIDEV_DEBUG(CE_WARN,
2312 "!acpidev: object %p is not hotplug capable.", hdl);
2313 return (AE_SUPPORT);
2314 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2315 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %p is in the FAILED "
2316 "state, unusable for DR.", hdl);
2317 return (AE_ERROR);
2318 }
2319
2320 rc = acpidev_eval_ej0(hdl);
2321 if (ACPI_FAILURE(rc)) {
2322 ACPIDEV_DEBUG(CE_WARN,
2323 "!acpidev: failed to evaluate _EJ0 for object %p.", hdl);
2324 }
2325
2326 return (rc);
2327 }
2328
2329 ACPI_STATUS
2330 acpidev_dr_device_check_status(ACPI_HANDLE hdl)
2331 {
2332 acpidev_data_handle_t dhdl;
2333
2334 dhdl = acpidev_data_get_handle(hdl);
2335 if (dhdl == NULL) {
2336 ACPIDEV_DEBUG(CE_WARN,
2337 "!acpidev: failed to get data handle associated with %p.",
2338 hdl);
2339 return (AE_ERROR);
2340 }
2341
2342 /* Check whether the device is hotplug capable. */
2343 if (!ACPIDEV_DR_BOARD_READY(dhdl)) {
2344 ACPIDEV_DEBUG(CE_WARN,
2345 "!acpidev: object %p is not hotplug capable.", hdl);
2346 return (AE_SUPPORT);
2347 } else if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2348 ACPIDEV_DEBUG(CE_WARN, "!acpidev: object %p is in the FAILED "
2349 "state, unusable for DR.", hdl);
2350 return (AE_ERROR);
2351 }
2352
2353 return (AE_OK);
2354 }
2355
2356 void
2357 acpidev_dr_lock_all(void)
2358 {
2359 mutex_enter(&acpidev_dr_lock);
2360 }
2361
2362 void
2363 acpidev_dr_unlock_all(void)
2364 {
2365 mutex_exit(&acpidev_dr_lock);
2366 }
2367
2368 ACPI_STATUS
2369 acpidev_dr_allocate_cpuid(ACPI_HANDLE hdl, processorid_t *idp)
2370 {
2371 int rv;
2372 processorid_t cpuid;
2373 uint32_t procid, apicid;
2374 mach_cpu_add_arg_t arg;
2375 acpidev_data_handle_t dhdl;
2376 dev_info_t *dip = NULL;
2377
2378 ASSERT(MUTEX_HELD(&cpu_lock));
2379 ASSERT(hdl != NULL);
2380 if (hdl == NULL) {
2381 ACPIDEV_DEBUG(CE_WARN, "!acpidev: parameter hdl to "
2382 "acpidev_dr_allocate_cpuid() is NULL.");
2383 return (AE_BAD_PARAMETER);
2384 }
2385
2386 /* Validate that the device is ready for hotplug. */
2387 if (ACPI_FAILURE(acpica_get_devinfo(hdl, &dip))) {
2388 ACPIDEV_DEBUG(CE_WARN,
2389 "!acpidev: failed to get devinfo for object %p.", hdl);
2390 return (AE_ERROR);
2391 }
2392 ASSERT(dip != NULL);
2393 dhdl = acpidev_data_get_handle(hdl);
2394 if (dhdl == NULL) {
2395 ACPIDEV_DEBUG(CE_WARN,
2396 "!acpidev: failed to get data associated with object %p",
2397 hdl);
2398 return (AE_SUPPORT);
2399 }
2400 if (!ACPIDEV_DR_IS_READY(dhdl)) {
2401 ACPIDEV_DEBUG(CE_WARN,
2402 "!acpidev: dip %p is not hotplug ready.", (void *)dip);
2403 return (AE_SUPPORT);
2404 }
2405 if (ACPIDEV_DR_IS_FAILED(dhdl)) {
2406 ACPIDEV_DEBUG(CE_NOTE,
2407 "!acpidev: dip %p is in the FAILED state.", (void *)dip);
2408 return (AE_SUPPORT);
2409 }
2410
2411 /* Query CPU relative information */
2412 apicid = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2413 DDI_PROP_DONTPASS, ACPIDEV_PROP_NAME_LOCALAPIC_ID, UINT32_MAX);
2414 procid = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, dip,
2415 DDI_PROP_DONTPASS, ACPIDEV_PROP_NAME_PROCESSOR_ID, UINT32_MAX);
2416 if (procid == UINT32_MAX || apicid == UINT32_MAX || apicid == 255) {
2417 ACPIDEV_DEBUG(CE_WARN, "!acpidev: dip %p is malformed, "
2418 "procid(0x%x) or apicid(0x%x) is invalid.",
2419 (void *)dip, procid, apicid);
2420 return (AE_ERROR);
2421 }
2422
2423 /* Check whether the CPU device is in offline state. */
2424 mutex_enter(&(DEVI(dip)->devi_lock));
2425 if (!DEVI_IS_DEVICE_OFFLINE(dip)) {
2426 mutex_exit(&DEVI(dip)->devi_lock);
2427 ACPIDEV_DEBUG(CE_WARN,
2428 "!acpidev: dip %p isn't in offline state.", (void *)dip);
2429 return (AE_ERROR);
2430 }
2431 mutex_exit(&DEVI(dip)->devi_lock);
2432
2433 /* Check whether the CPU already exists. */
2434 if (ACPI_SUCCESS(acpica_get_cpu_id_by_object(hdl, &cpuid))) {
2435 ACPIDEV_DEBUG(CE_WARN,
2436 "!acpidev: dip %p already has CPU id(%d) assigned.",
2437 (void *)dip, cpuid);
2438 return (AE_ALREADY_EXISTS);
2439 }
2440
2441 /* Allocate cpuid for the CPU */
2442 arg.arg.apic.apic_id = apicid;
2443 arg.arg.apic.proc_id = procid;
2444 if (apicid >= 255) {
2445 arg.type = MACH_CPU_ARG_LOCAL_X2APIC;
2446 } else {
2447 arg.type = MACH_CPU_ARG_LOCAL_APIC;
2448 }
2449 rv = mach_cpu_add(&arg, &cpuid);
2450 if (rv != PSM_SUCCESS) {
2451 ACPIDEV_DEBUG(CE_WARN,
2452 "!acpidev: failed to allocate cpu id for dip %p.",
2453 (void *)dip);
2454 return (AE_NOT_EXIST);
2455 }
2456
2457 ASSERT(cpuid >= 0 && cpuid < NCPU && cpuid < max_ncpus);
2458 if (idp != NULL) {
2459 *idp = cpuid;
2460 }
2461
2462 return (AE_OK);
2463 }
2464
2465 ACPI_STATUS
2466 acpidev_dr_free_cpuid(ACPI_HANDLE hdl)
2467 {
2468 ACPI_STATUS rv = AE_OK;
2469 processorid_t cpuid;
2470
2471 ASSERT(MUTEX_HELD(&cpu_lock));
2472 ASSERT(hdl != NULL);
2473 if (hdl == NULL) {
2474 ACPIDEV_DEBUG(CE_WARN, "!acpidev: parameter hdl to "
2475 "acpidev_dr_free_cpuid() is NULL.");
2476 return (AE_BAD_PARAMETER);
2477 }
2478
2479 if (ACPI_FAILURE(acpica_get_cpu_id_by_object(hdl, &cpuid))) {
2480 ACPIDEV_DEBUG(CE_WARN,
2481 "!acpidev: failed to get cpuid for object %p.", hdl);
2482 rv = AE_NOT_EXIST;
2483 } else if (cpuid < 0 || cpuid > max_ncpus) {
2484 ACPIDEV_DEBUG(CE_WARN,
2485 "!acpidev: cpuid(%d) of object %p is invalid.",
2486 cpuid, hdl);
2487 rv = AE_ERROR;
2488 } else if (mach_cpu_remove(cpuid) != PSM_SUCCESS) {
2489 ACPIDEV_DEBUG(CE_WARN,
2490 "!acpidev: failed to free cpuid(%d) for object %p.",
2491 cpuid, hdl);
2492 rv = AE_ERROR;
2493 }
2494
2495 return (rv);
2496 }
2497
2498 static ACPI_STATUS
2499 acpidev_dr_get_latency(ACPI_HANDLE hdl, void **hdlpp,
2500 uint32_t pxmid, uint32_t *slicntp, uchar_t **slipp)
2501 {
2502 ACPI_STATUS rc;
2503 ACPI_BUFFER buf;
2504 uint32_t i, pxmcnt;
2505 uchar_t *valp, *sp, *ep;
2506
2507 /* Evaluate the ACPI _SLI method under the object. */
2508 buf.Length = ACPI_ALLOCATE_BUFFER;
2509 rc = AcpiEvaluateObjectTyped(hdl, ACPIDEV_METHOD_NAME_SLI, NULL, &buf,
2510 ACPI_TYPE_BUFFER);
2511 if (ACPI_SUCCESS(rc)) {
2512 valp = (uchar_t *)buf.Pointer;
2513 if (acpidev_slit_tbl_ptr->LocalityCount > pxmid) {
2514 pxmcnt = acpidev_slit_tbl_ptr->LocalityCount;
2515 } else {
2516 pxmcnt = pxmid + 1;
2517 }
2518
2519 /*
2520 * Validate data returned by the ACPI _SLI method.
2521 * Please refer to 6.2.14 "_SLI (System Locality Information)"
2522 * in ACPI4.0 for data format returned by _SLI method.
2523 */
2524 if (buf.Length != pxmcnt * 2 * sizeof (uchar_t)) {
2525 ACPIDEV_DEBUG(CE_WARN,
2526 "!acpidev: buffer length returned by _SLI method "
2527 "under %p is invalid.", hdl);
2528 AcpiOsFree(buf.Pointer);
2529 } else if (valp[pxmid] != ACPI_SLIT_SELF_LATENCY ||
2530 valp[pxmid + pxmcnt] != ACPI_SLIT_SELF_LATENCY) {
2531 ACPIDEV_DEBUG(CE_WARN,
2532 "!acpidev: local latency returned by _SLI method "
2533 "under %p is not %u.", hdl, ACPI_SLIT_SELF_LATENCY);
2534 AcpiOsFree(buf.Pointer);
2535 } else {
2536 *slicntp = pxmcnt;
2537 *slipp = (uchar_t *)buf.Pointer;
2538 *hdlpp = buf.Pointer;
2539 return (AE_OK);
2540 }
2541 } else if (rc != AE_NOT_FOUND) {
2542 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to evaluate "
2543 "_SLI method under object %p.", hdl);
2544 }
2545
2546 /* Return data from the ACPI SLIT table. */
2547 ASSERT(acpidev_slit_tbl_ptr != NULL);
2548 pxmcnt = acpidev_slit_tbl_ptr->LocalityCount;
2549 if (pxmid >= pxmcnt) {
2550 ACPIDEV_DEBUG(CE_WARN, "!acpidev: proximity domain id "
2551 "(%u) is too big, max %u.", pxmid, pxmcnt - 1);
2552 *slicntp = 0;
2553 *slipp = NULL;
2554 return (AE_ERROR);
2555 } else {
2556 sp = AcpiOsAllocate(pxmcnt * 2 * sizeof (uchar_t));
2557 ep = acpidev_slit_tbl_ptr->Entry;
2558 for (i = 0; i < pxmcnt; i++) {
2559 sp[i] = ep[pxmcnt * pxmid + i];
2560 sp[i + pxmcnt] = ep[pxmcnt * i + pxmid];
2561 }
2562 *slicntp = pxmcnt;
2563 *slipp = sp;
2564 *hdlpp = sp;
2565 return (AE_OK);
2566 }
2567 }
2568
2569 /*
2570 * Query NUMA information for the CPU device.
2571 * It returns APIC id, Proximity id and latency information of the CPU device.
2572 */
2573 int
2574 acpidev_dr_get_cpu_numa_info(cpu_t *cp, void **hdlpp, uint32_t *apicidp,
2575 uint32_t *pxmidp, uint32_t *slicntp, uchar_t **slipp)
2576 {
2577 dev_info_t *dip = NULL;
2578 ACPI_HANDLE hdl = NULL;
2579
2580 ASSERT(cp != NULL);
2581 ASSERT(hdlpp != NULL);
2582 ASSERT(apicidp != NULL);
2583 ASSERT(pxmidp != NULL);
2584 if (cp == NULL || hdlpp == NULL || apicidp == NULL || pxmidp == NULL) {
2585 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameters to "
2586 "acpidev_dr_get_cpu_numa_info().");
2587 return (-1);
2588 }
2589
2590 *hdlpp = NULL;
2591 *apicidp = UINT32_MAX;
2592 *pxmidp = UINT32_MAX;
2593 if (lgrp_plat_node_cnt == 1) {
2594 return (-1);
2595 }
2596 ASSERT(acpidev_slit_tbl_ptr != NULL);
2597
2598 /* Query APIC id and Proximity id from device properties. */
2599 if (ACPI_FAILURE(acpica_get_cpu_object_by_cpuid(cp->cpu_id, &hdl))) {
2600 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get ACPI object "
2601 "for CPU(%d).", cp->cpu_id);
2602 return (-1);
2603 }
2604 if (ACPI_FAILURE(acpica_get_devinfo(hdl, &dip))) {
2605 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get device node "
2606 "for CPU(%d).", cp->cpu_id);
2607 return (-1);
2608 }
2609 *apicidp = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
2610 ACPIDEV_PROP_NAME_LOCALAPIC_ID, UINT32_MAX);
2611 *pxmidp = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
2612 ACPIDEV_PROP_NAME_PROXIMITY_ID, UINT32_MAX);
2613 if (*apicidp == UINT32_MAX || *pxmidp == UINT32_MAX) {
2614 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to get local APIC id "
2615 "or proximity id for CPU(%d).", cp->cpu_id);
2616 return (-1);
2617 }
2618
2619 ASSERT((slicntp && slipp) || (!slicntp && !slipp));
2620 if (slicntp != NULL && slipp != NULL) {
2621 if (ACPI_FAILURE(acpidev_dr_get_latency(hdl, hdlpp, *pxmidp,
2622 slicntp, slipp))) {
2623 return (-1);
2624 }
2625 }
2626
2627 return (0);
2628 }
2629
2630 void
2631 acpidev_dr_free_cpu_numa_info(void *hdlp)
2632 {
2633 if (hdlp != NULL) {
2634 AcpiOsFree(hdlp);
2635 }
2636 }
2637
2638 static ACPI_STATUS
2639 acpidev_dr_mem_search_srat(struct memlist *ml, uint32_t *pxmidp)
2640 {
2641 int len, off;
2642 uint64_t start, end;
2643 boolean_t found = B_FALSE;
2644 ACPI_SUBTABLE_HEADER *sp;
2645 ACPI_SRAT_MEM_AFFINITY *mp;
2646
2647 ASSERT(ml != NULL);
2648 ASSERT(pxmidp != NULL);
2649 ASSERT(acpidev_srat_tbl_ptr != NULL);
2650
2651 /* Search the static ACPI SRAT table for proximity domain. */
2652 sp = (ACPI_SUBTABLE_HEADER *)(acpidev_srat_tbl_ptr + 1);
2653 len = acpidev_srat_tbl_ptr->Header.Length;
2654 off = sizeof (*acpidev_srat_tbl_ptr);
2655 while (off < len) {
2656 if (sp->Type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
2657 mp = (ACPI_SRAT_MEM_AFFINITY *)sp;
2658 if ((mp->Flags & ACPI_SRAT_MEM_ENABLED) &&
2659 (mp->Flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) &&
2660 ml->ml_address >= mp->BaseAddress &&
2661 ml->ml_address <= mp->BaseAddress + mp->Length) {
2662 found = B_TRUE;
2663 break;
2664 }
2665 }
2666 off += sp->Length;
2667 sp = (ACPI_SUBTABLE_HEADER *)(((char *)sp) + sp->Length);
2668 }
2669 if (!found)
2670 return (AE_NOT_FOUND);
2671
2672 /*
2673 * Verify that all memory regions in the list belong to the same domain.
2674 */
2675 start = mp->BaseAddress;
2676 end = mp->BaseAddress + mp->Length;
2677 while (ml) {
2678 if (ml->ml_address < start ||
2679 ml->ml_address + ml->ml_size > end) {
2680 ACPIDEV_DEBUG(CE_WARN,
2681 "!acpidev: memory for hot-adding doesn't belong "
2682 "to the same proximity domain.");
2683 return (AE_ERROR);
2684 }
2685 ml = ml->ml_next;
2686 }
2687
2688 return (AE_OK);
2689 }
2690
2691 /*
2692 * Query lgrp information for a memory device.
2693 * It returns proximity domain id and latency information of the memory device.
2694 */
2695 ACPI_STATUS
2696 acpidev_dr_get_mem_numa_info(ACPI_HANDLE hdl, struct memlist *ml,
2697 void **hdlpp, uint32_t *pxmidp, uint32_t *slicntp, uchar_t **slipp)
2698 {
2699 ASSERT(ml != NULL);
2700 ASSERT(hdlpp != NULL);
2701 ASSERT(pxmidp != NULL);
2702 if (ml == NULL || hdlpp == NULL || pxmidp == NULL) {
2703 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameters to "
2704 "acpidev_dr_get_mem_numa_info().");
2705 return (AE_BAD_PARAMETER);
2706 }
2707
2708 *pxmidp = UINT32_MAX;
2709 if (lgrp_plat_node_cnt == 1) {
2710 return (AE_SUPPORT);
2711 }
2712
2713 if (ACPI_FAILURE(acpidev_eval_pxm(hdl, pxmidp))) {
2714 /*
2715 * Try to get proximity domain id from SRAT table if failed to
2716 * evaluate ACPI _PXM method for memory device.
2717 */
2718 if (ACPI_FAILURE(acpidev_dr_mem_search_srat(ml, pxmidp))) {
2719 ACPIDEV_DEBUG(CE_WARN,
2720 "!acpidev: failed to get proximity domain id for "
2721 "memory device %p.", hdl);
2722 return (AE_ERROR);
2723 }
2724 }
2725
2726 ASSERT((slicntp && slipp) || (!slicntp && !slipp));
2727 if (slicntp != NULL && slipp != NULL) {
2728 if (ACPI_FAILURE(acpidev_dr_get_latency(hdl, hdlpp, *pxmidp,
2729 slicntp, slipp))) {
2730 return (AE_ERROR);
2731 }
2732 }
2733
2734 return (AE_OK);
2735 }
2736
2737 void
2738 acpidev_dr_free_mem_numa_info(void *hdlp)
2739 {
2740 if (hdlp != NULL) {
2741 AcpiOsFree(hdlp);
2742 }
2743 }