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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright (c) 2009-2010, Intel Corporation.
27 * All rights reserved.
28 */
29
30 #include <sys/types.h>
31 #include <sys/cmn_err.h>
32 #include <sys/sysmacros.h>
33 #include <sys/sunddi.h>
34 #include <sys/sunndi.h>
35 #include <acpica/include/acpi.h>
36 #include <sys/acpica.h>
37 #include <sys/acpidev.h>
38 #include <sys/acpidev_rsc.h>
39 #include <sys/acpidev_impl.h>
40
41 #define ACPIDEV_RES_INIT_ITEMS 8
42 #define ACPIDEV_RES_INCR_ITEMS 8
43
44 /* Data structure to hold parsed resources during walking. */
45 struct acpidev_resource_handle {
46 boolean_t acpidev_consumer;
47 int acpidev_reg_count;
48 int acpidev_reg_max;
49 acpidev_phys_spec_t *acpidev_regp;
50 acpidev_phys_spec_t acpidev_regs[ACPIDEV_RES_INIT_ITEMS];
51 int acpidev_range_count;
52 int acpidev_range_max;
53 acpidev_ranges_t *acpidev_rangep;
54 acpidev_ranges_t acpidev_ranges[ACPIDEV_RES_INIT_ITEMS];
55 int acpidev_bus_count;
56 int acpidev_bus_max;
57 acpidev_bus_range_t *acpidev_busp;
58 acpidev_bus_range_t acpidev_buses[ACPIDEV_RES_INIT_ITEMS];
59 int acpidev_irq_count;
60 int acpidev_irqp[ACPIDEV_RES_IRQ_MAX];
61 int acpidev_dma_count;
62 int acpidev_dmap[ACPIDEV_RES_DMA_MAX];
63 };
64
65 acpidev_resource_handle_t
66 acpidev_resource_handle_alloc(boolean_t consumer)
67 {
68 acpidev_resource_handle_t rhdl;
69
70 rhdl = kmem_zalloc(sizeof (*rhdl), KM_SLEEP);
71 rhdl->acpidev_consumer = consumer;
72 rhdl->acpidev_reg_max = ACPIDEV_RES_INIT_ITEMS;
73 rhdl->acpidev_regp = rhdl->acpidev_regs;
74 rhdl->acpidev_range_max = ACPIDEV_RES_INIT_ITEMS;
75 rhdl->acpidev_rangep = rhdl->acpidev_ranges;
76 rhdl->acpidev_bus_max = ACPIDEV_RES_INIT_ITEMS;
77 rhdl->acpidev_busp = rhdl->acpidev_buses;
78
79 return (rhdl);
80 }
81
82 void
83 acpidev_resource_handle_free(acpidev_resource_handle_t rhdl)
84 {
85 size_t sz;
86
87 ASSERT(rhdl != NULL);
88 if (rhdl != NULL) {
89 if (rhdl->acpidev_regp != rhdl->acpidev_regs) {
90 sz = sizeof (acpidev_phys_spec_t) *
91 rhdl->acpidev_reg_max;
92 kmem_free(rhdl->acpidev_regp, sz);
93 }
94 if (rhdl->acpidev_rangep != rhdl->acpidev_ranges) {
95 sz = sizeof (acpidev_ranges_t) *
96 rhdl->acpidev_range_max;
97 kmem_free(rhdl->acpidev_rangep, sz);
98 }
99 if (rhdl->acpidev_busp != rhdl->acpidev_buses) {
100 sz = sizeof (acpidev_bus_range_t) *
101 rhdl->acpidev_bus_max;
102 kmem_free(rhdl->acpidev_busp, sz);
103 }
104 kmem_free(rhdl, sizeof (struct acpidev_resource_handle));
105 }
106 }
107
108 static void
109 acpidev_resource_handle_grow(acpidev_resource_handle_t rhdl)
110 {
111 size_t sz;
112
113 if (rhdl->acpidev_reg_count == rhdl->acpidev_reg_max) {
114 acpidev_phys_spec_t *regp;
115
116 /* Prefer linear incremental here. */
117 rhdl->acpidev_reg_max += ACPIDEV_RES_INCR_ITEMS;
118 sz = sizeof (*regp) * rhdl->acpidev_reg_max;
119 regp = kmem_zalloc(sz, KM_SLEEP);
120 sz = sizeof (*regp) * rhdl->acpidev_reg_count;
121 bcopy(rhdl->acpidev_regp, regp, sz);
122 if (rhdl->acpidev_regp != rhdl->acpidev_regs) {
123 kmem_free(rhdl->acpidev_regp, sz);
124 }
125 rhdl->acpidev_regp = regp;
126 }
127
128 if (rhdl->acpidev_range_count == rhdl->acpidev_range_max) {
129 acpidev_ranges_t *rngp;
130
131 /* Prefer linear incremental here. */
132 rhdl->acpidev_range_max += ACPIDEV_RES_INCR_ITEMS;
133 sz = sizeof (*rngp) * rhdl->acpidev_range_max;
134 rngp = kmem_zalloc(sz, KM_SLEEP);
135 sz = sizeof (*rngp) * rhdl->acpidev_range_count;
136 bcopy(rhdl->acpidev_rangep, rngp, sz);
137 if (rhdl->acpidev_rangep != rhdl->acpidev_ranges) {
138 kmem_free(rhdl->acpidev_rangep, sz);
139 }
140 rhdl->acpidev_rangep = rngp;
141 }
142
143 if (rhdl->acpidev_bus_count == rhdl->acpidev_bus_max) {
144 acpidev_bus_range_t *busp;
145
146 /* Prefer linear incremental here. */
147 rhdl->acpidev_bus_max += ACPIDEV_RES_INCR_ITEMS;
148 sz = sizeof (*busp) * rhdl->acpidev_bus_max;
149 busp = kmem_zalloc(sz, KM_SLEEP);
150 sz = sizeof (*busp) * rhdl->acpidev_bus_count;
151 bcopy(rhdl->acpidev_busp, busp, sz);
152 if (rhdl->acpidev_busp != rhdl->acpidev_buses) {
153 kmem_free(rhdl->acpidev_busp, sz);
154 }
155 rhdl->acpidev_busp = busp;
156 }
157 }
158
159 ACPI_STATUS
160 acpidev_resource_insert_reg(acpidev_resource_handle_t rhdl,
161 acpidev_regspec_t *regp)
162 {
163 ASSERT(rhdl != NULL);
164 ASSERT(regp != NULL);
165 if (rhdl->acpidev_reg_count >= rhdl->acpidev_reg_max) {
166 acpidev_resource_handle_grow(rhdl);
167 }
168 ASSERT(rhdl->acpidev_reg_count < rhdl->acpidev_reg_max);
169 rhdl->acpidev_regp[rhdl->acpidev_reg_count] = *regp;
170 rhdl->acpidev_reg_count++;
171
172 return (AE_OK);
173 }
174
175 ACPI_STATUS
176 acpidev_resource_get_regs(acpidev_resource_handle_t rhdl,
177 uint_t mask, uint_t value, acpidev_regspec_t *regp, uint_t *cntp)
178 {
179 uint_t i, j;
180
181 ASSERT(rhdl != NULL);
182 ASSERT(cntp != NULL);
183 if (rhdl == NULL || cntp == NULL || (regp == NULL && *cntp != 0)) {
184 return (AE_BAD_PARAMETER);
185 }
186 for (i = 0, j = 0; i < rhdl->acpidev_reg_count; i++) {
187 if ((rhdl->acpidev_regp[i].phys_hi & mask) == value) {
188 if (j < *cntp) {
189 regp[j] = rhdl->acpidev_regp[i];
190 }
191 j++;
192 }
193 }
194 if (j >= *cntp) {
195 *cntp = j;
196 return (AE_LIMIT);
197 } else {
198 *cntp = j;
199 return (AE_OK);
200 }
201 }
202
203 uint_t
204 acpidev_resource_get_reg_count(acpidev_resource_handle_t rhdl,
205 uint_t mask, uint_t value)
206 {
207 uint_t i, j;
208
209 ASSERT(rhdl != NULL);
210 for (i = 0, j = 0; i < rhdl->acpidev_reg_count; i++) {
211 if ((rhdl->acpidev_regp[i].phys_hi & mask) == value) {
212 j++;
213 }
214 }
215
216 return (j);
217 }
218
219 ACPI_STATUS
220 acpidev_resource_insert_range(acpidev_resource_handle_t rhdl,
221 acpidev_ranges_t *rangep)
222 {
223 ASSERT(rhdl != NULL);
224 ASSERT(rangep != NULL);
225 if (rhdl->acpidev_range_count >= rhdl->acpidev_range_max) {
226 acpidev_resource_handle_grow(rhdl);
227 }
228 ASSERT(rhdl->acpidev_range_count < rhdl->acpidev_range_max);
229 rhdl->acpidev_rangep[rhdl->acpidev_range_count] = *rangep;
230 rhdl->acpidev_range_count++;
231
232 return (AE_OK);
233 }
234
235 ACPI_STATUS
236 acpidev_resource_get_ranges(acpidev_resource_handle_t rhdl,
237 uint_t mask, uint_t value, acpidev_ranges_t *rangep, uint_t *cntp)
238 {
239 uint_t i, j;
240
241 ASSERT(rhdl != NULL);
242 ASSERT(cntp != NULL);
243 if (rhdl == NULL || cntp == NULL || (rangep == NULL && *cntp != 0)) {
244 return (AE_BAD_PARAMETER);
245 }
246 for (i = 0, j = 0; i < rhdl->acpidev_range_count; i++) {
247 if ((rhdl->acpidev_rangep[i].child_hi & mask) == value) {
248 if (j < *cntp) {
249 rangep[j] = rhdl->acpidev_rangep[i];
250 }
251 j++;
252 }
253 }
254 if (j >= *cntp) {
255 *cntp = j;
256 return (AE_LIMIT);
257 } else {
258 *cntp = j;
259 return (AE_OK);
260 }
261 }
262
263 uint_t
264 acpidev_resource_get_range_count(acpidev_resource_handle_t rhdl,
265 uint_t mask, uint_t value)
266 {
267 uint_t i, j;
268
269 ASSERT(rhdl != NULL);
270 for (i = 0, j = 0; i < rhdl->acpidev_range_count; i++) {
271 if ((rhdl->acpidev_rangep[i].child_hi & mask) == value) {
272 j++;
273 }
274 }
275
276 return (j);
277 }
278
279 ACPI_STATUS
280 acpidev_resource_insert_bus(acpidev_resource_handle_t rhdl,
281 acpidev_bus_range_t *busp)
282 {
283 ASSERT(rhdl != NULL);
284 ASSERT(busp != NULL);
285 if (rhdl->acpidev_bus_count >= rhdl->acpidev_bus_max) {
286 acpidev_resource_handle_grow(rhdl);
287 }
288 ASSERT(rhdl->acpidev_bus_count < rhdl->acpidev_bus_max);
289 rhdl->acpidev_busp[rhdl->acpidev_bus_count] = *busp;
290 rhdl->acpidev_bus_count++;
291
292 return (AE_OK);
293 }
294
295 ACPI_STATUS
296 acpidev_resource_get_buses(acpidev_resource_handle_t rhdl,
297 acpidev_bus_range_t *busp, uint_t *cntp)
298 {
299 uint_t i, j;
300
301 ASSERT(rhdl != NULL);
302 ASSERT(cntp != NULL);
303 if (rhdl == NULL || cntp == NULL || (busp == NULL && *cntp != 0)) {
304 return (AE_BAD_PARAMETER);
305 }
306 for (i = 0, j = 0; i < rhdl->acpidev_bus_count; i++) {
307 if (j < *cntp) {
308 busp[j] = rhdl->acpidev_busp[i];
309 }
310 j++;
311 }
312 if (j >= *cntp) {
313 *cntp = j;
314 return (AE_LIMIT);
315 } else {
316 *cntp = j;
317 return (AE_OK);
318 }
319 }
320
321 uint_t
322 acpidev_resource_get_bus_count(acpidev_resource_handle_t rhdl)
323 {
324 ASSERT(rhdl != NULL);
325 return (rhdl->acpidev_bus_count);
326 }
327
328 ACPI_STATUS
329 acpidev_resource_insert_dma(acpidev_resource_handle_t rhdl, int dma)
330 {
331 ASSERT(rhdl != NULL);
332 if (rhdl->acpidev_dma_count >= ACPIDEV_RES_DMA_MAX) {
333 ACPIDEV_DEBUG(CE_WARN,
334 "!acpidev: too many DMA resources, max %u.",
335 ACPIDEV_RES_DMA_MAX);
336 return (AE_LIMIT);
337 }
338 rhdl->acpidev_dmap[rhdl->acpidev_dma_count] = dma;
339 rhdl->acpidev_dma_count++;
340
341 return (AE_OK);
342 }
343
344 ACPI_STATUS
345 acpidev_resource_get_dmas(acpidev_resource_handle_t rhdl,
346 uint_t *dmap, uint_t *cntp)
347 {
348 uint_t i, j;
349
350 ASSERT(rhdl != NULL);
351 ASSERT(cntp != NULL);
352 if (rhdl == NULL || cntp == NULL || (dmap == NULL && *cntp != 0)) {
353 return (AE_BAD_PARAMETER);
354 }
355 for (i = 0, j = 0; i < rhdl->acpidev_dma_count; i++) {
356 if (j < *cntp) {
357 dmap[j] = rhdl->acpidev_dmap[i];
358 }
359 j++;
360 }
361 if (j >= *cntp) {
362 *cntp = j;
363 return (AE_LIMIT);
364 } else {
365 *cntp = j;
366 return (AE_OK);
367 }
368 }
369
370 uint_t
371 acpidev_resource_get_dma_count(acpidev_resource_handle_t rhdl)
372 {
373 ASSERT(rhdl != NULL);
374 return (rhdl->acpidev_dma_count);
375 }
376
377 ACPI_STATUS
378 acpidev_resource_insert_irq(acpidev_resource_handle_t rhdl, int irq)
379 {
380 ASSERT(rhdl != NULL);
381 if (rhdl->acpidev_irq_count >= ACPIDEV_RES_IRQ_MAX) {
382 ACPIDEV_DEBUG(CE_WARN,
383 "!acpidev: too many IRQ resources, max %u.",
384 ACPIDEV_RES_IRQ_MAX);
385 return (AE_LIMIT);
386 }
387 rhdl->acpidev_irqp[rhdl->acpidev_irq_count] = irq;
388 rhdl->acpidev_irq_count++;
389
390 return (AE_OK);
391 }
392
393 ACPI_STATUS
394 acpidev_resource_get_irqs(acpidev_resource_handle_t rhdl,
395 uint_t *irqp, uint_t *cntp)
396 {
397 uint_t i, j;
398
399 ASSERT(rhdl != NULL);
400 ASSERT(cntp != NULL);
401 if (rhdl == NULL || cntp == NULL || (irqp == NULL && *cntp != 0)) {
402 return (AE_BAD_PARAMETER);
403 }
404 for (i = 0, j = 0; i < rhdl->acpidev_irq_count; i++) {
405 if (j < *cntp) {
406 irqp[j] = rhdl->acpidev_irqp[i];
407 }
408 j++;
409 }
410 if (j >= *cntp) {
411 *cntp = j;
412 return (AE_LIMIT);
413 } else {
414 *cntp = j;
415 return (AE_OK);
416 }
417 }
418
419 uint_t
420 acpidev_resource_get_irq_count(acpidev_resource_handle_t rhdl)
421 {
422 ASSERT(rhdl != NULL);
423 return (rhdl->acpidev_irq_count);
424 }
425
426 static ACPI_STATUS
427 acpidev_resource_address64(acpidev_resource_handle_t rhdl,
428 ACPI_RESOURCE_ADDRESS64 *addrp)
429 {
430 ACPI_STATUS rc = AE_OK;
431 uint_t high;
432
433 ASSERT(addrp != NULL && rhdl != NULL);
434 if (addrp->AddressLength == 0) {
435 return (AE_OK);
436 }
437
438 switch (addrp->ResourceType) {
439 case ACPI_MEMORY_RANGE:
440 high = ACPIDEV_REG_TYPE_MEMORY;
441 if (addrp->Decode == ACPI_SUB_DECODE) {
442 high |= ACPIDEV_REG_SUB_DEC;
443 }
444 if (addrp->Info.Mem.Translation) {
445 high |= ACPIDEV_REG_TRANSLATED;
446 }
447 if (addrp->Info.Mem.Caching == ACPI_NON_CACHEABLE_MEMORY) {
448 high |= ACPIDEV_REG_MEM_COHERENT_NC;
449 } else if (addrp->Info.Mem.Caching == ACPI_CACHABLE_MEMORY) {
450 high |= ACPIDEV_REG_MEM_COHERENT_CA;
451 } else if (addrp->Info.Mem.Caching ==
452 ACPI_WRITE_COMBINING_MEMORY) {
453 high |= ACPIDEV_REG_MEM_COHERENT_WC;
454 } else if (addrp->Info.Mem.Caching ==
455 ACPI_PREFETCHABLE_MEMORY) {
456 high |= ACPIDEV_REG_MEM_COHERENT_PF;
457 } else {
458 ACPIDEV_DEBUG(CE_WARN,
459 "!acpidev: unknown memory caching type %u.",
460 addrp->Info.Mem.Caching);
461 rc = AE_ERROR;
462 break;
463 }
464 if (addrp->Info.Mem.WriteProtect == ACPI_READ_WRITE_MEMORY) {
465 high |= ACPIDEV_REG_MEM_WRITABLE;
466 }
467
468 /* Generate 'reg' for producer. */
469 if (addrp->ProducerConsumer == ACPI_CONSUMER &&
470 rhdl->acpidev_consumer == B_TRUE) {
471 acpidev_regspec_t reg;
472
473 reg.phys_hi = high;
474 reg.phys_mid = addrp->Minimum >> 32;
475 reg.phys_low = addrp->Minimum & 0xFFFFFFFF;
476 reg.size_hi = addrp->AddressLength >> 32;
477 reg.size_low = addrp->AddressLength & 0xFFFFFFFF;
478 rc = acpidev_resource_insert_reg(rhdl, ®);
479 if (ACPI_FAILURE(rc)) {
480 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
481 "insert regspec into resource handle.");
482 }
483 /* Generate 'ranges' for producer. */
484 } else if (addrp->ProducerConsumer == ACPI_PRODUCER &&
485 rhdl->acpidev_consumer == B_FALSE) {
486 uint64_t paddr;
487 acpidev_ranges_t range;
488
489 range.child_hi = high;
490 range.child_mid = addrp->Minimum >> 32;
491 range.child_low = addrp->Minimum & 0xFFFFFFFF;
492 /* It's IO on parent side if Translation is true. */
493 if (addrp->Info.Mem.Translation) {
494 range.parent_hi = ACPIDEV_REG_TYPE_IO;
495 } else {
496 range.parent_hi = high;
497 }
498 paddr = addrp->Minimum + addrp->TranslationOffset;
499 range.parent_mid = paddr >> 32;
500 range.parent_low = paddr & 0xFFFFFFFF;
501 range.size_hi = addrp->AddressLength >> 32;
502 range.size_low = addrp->AddressLength & 0xFFFFFFFF;
503 rc = acpidev_resource_insert_range(rhdl, &range);
504 if (ACPI_FAILURE(rc)) {
505 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
506 "insert range into resource handle.");
507 }
508 }
509 break;
510
511 case ACPI_IO_RANGE:
512 high = ACPIDEV_REG_TYPE_IO;
513 if (addrp->Decode == ACPI_SUB_DECODE) {
514 high |= ACPIDEV_REG_SUB_DEC;
515 }
516 if (addrp->Info.Io.Translation) {
517 high |= ACPIDEV_REG_TRANSLATED;
518 }
519 if (addrp->Info.Io.RangeType == ACPI_NON_ISA_ONLY_RANGES) {
520 high |= ACPIDEV_REG_IO_RANGE_NONISA;
521 } else if (addrp->Info.Io.RangeType == ACPI_ISA_ONLY_RANGES) {
522 high |= ACPIDEV_REG_IO_RANGE_ISA;
523 } else if (addrp->Info.Io.RangeType == ACPI_ENTIRE_RANGE) {
524 high |= ACPIDEV_REG_IO_RANGE_FULL;
525 } else {
526 ACPIDEV_DEBUG(CE_WARN,
527 "!acpidev: unknown IO range type %u.",
528 addrp->Info.Io.RangeType);
529 rc = AE_ERROR;
530 break;
531 }
532 if (addrp->Info.Io.TranslationType == ACPI_SPARSE_TRANSLATION) {
533 high |= ACPIDEV_REG_IO_SPARSE;
534 }
535
536 /* Generate 'reg' for producer. */
537 if (addrp->ProducerConsumer == ACPI_CONSUMER &&
538 rhdl->acpidev_consumer == B_TRUE) {
539 acpidev_regspec_t reg;
540
541 reg.phys_hi = high;
542 reg.phys_mid = addrp->Minimum >> 32;
543 reg.phys_low = addrp->Minimum & 0xFFFFFFFF;
544 reg.size_hi = addrp->AddressLength >> 32;
545 reg.size_low = addrp->AddressLength & 0xFFFFFFFF;
546 rc = acpidev_resource_insert_reg(rhdl, ®);
547 if (ACPI_FAILURE(rc)) {
548 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
549 "insert regspec into resource handle.");
550 }
551 /* Generate 'ranges' for producer. */
552 } else if (addrp->ProducerConsumer == ACPI_PRODUCER &&
553 rhdl->acpidev_consumer == B_FALSE) {
554 uint64_t paddr;
555 acpidev_ranges_t range;
556
557 range.child_hi = high;
558 range.child_mid = addrp->Minimum >> 32;
559 range.child_low = addrp->Minimum & 0xFFFFFFFF;
560 /* It's Memory on parent side if Translation is true. */
561 if (addrp->Info.Io.Translation) {
562 range.parent_hi = ACPIDEV_REG_TYPE_MEMORY;
563 } else {
564 range.parent_hi = high;
565 }
566 paddr = addrp->Minimum + addrp->TranslationOffset;
567 range.parent_mid = paddr >> 32;
568 range.parent_low = paddr & 0xFFFFFFFF;
569 range.size_hi = addrp->AddressLength >> 32;
570 range.size_low = addrp->AddressLength & 0xFFFFFFFF;
571 rc = acpidev_resource_insert_range(rhdl, &range);
572 if (ACPI_FAILURE(rc)) {
573 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
574 "insert range into resource handle.");
575 }
576 }
577 break;
578
579 case ACPI_BUS_NUMBER_RANGE:
580 /* Only support producer of BUS. */
581 if (addrp->ProducerConsumer == ACPI_PRODUCER &&
582 rhdl->acpidev_consumer == B_FALSE) {
583 uint64_t end;
584 acpidev_bus_range_t bus;
585
586 end = addrp->Minimum + addrp->AddressLength;
587 if (end < addrp->Minimum || end > UINT_MAX) {
588 ACPIDEV_DEBUG(CE_WARN, "!acpidev: bus range "
589 "in ADDRESS64 is invalid.");
590 rc = AE_ERROR;
591 break;
592 }
593 bus.bus_start = addrp->Minimum & 0xFFFFFFFF;
594 bus.bus_end = end & 0xFFFFFFFF;
595 ASSERT(bus.bus_start <= bus.bus_end);
596 rc = acpidev_resource_insert_bus(rhdl, &bus);
597 if (ACPI_FAILURE(rc)) {
598 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
599 "insert bus range into resource handle.");
600 }
601 }
602 break;
603
604 default:
605 ACPIDEV_DEBUG(CE_WARN,
606 "!acpidev: unknown resource type %u in ADDRESS64.",
607 addrp->ResourceType);
608 rc = AE_BAD_PARAMETER;
609 }
610
611 return (rc);
612 }
613
614 static ACPI_STATUS
615 acpidev_resource_walk_producer(ACPI_RESOURCE *rscp, void *ctxp)
616 {
617 ACPI_STATUS rc = AE_OK;
618 acpidev_resource_handle_t rhdl;
619
620 ASSERT(ctxp != NULL);
621 rhdl = (acpidev_resource_handle_t)ctxp;
622 ASSERT(rhdl->acpidev_consumer == B_FALSE);
623
624 switch (rscp->Type) {
625 case ACPI_RESOURCE_TYPE_DMA:
626 case ACPI_RESOURCE_TYPE_IRQ:
627 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
628 case ACPI_RESOURCE_TYPE_FIXED_IO:
629 case ACPI_RESOURCE_TYPE_MEMORY24:
630 case ACPI_RESOURCE_TYPE_MEMORY32:
631 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
632 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
633 case ACPI_RESOURCE_TYPE_VENDOR:
634 ACPIDEV_DEBUG(CE_NOTE,
635 "!acpidev: unsupported producer resource type %u, ignored.",
636 rscp->Type);
637 break;
638
639 case ACPI_RESOURCE_TYPE_IO:
640 {
641 acpidev_ranges_t range;
642
643 range.child_hi = ACPIDEV_REG_TYPE_IO;
644 range.child_hi |= ACPIDEV_REG_IO_RANGE_FULL;
645 if (rscp->Data.Io.IoDecode == ACPI_DECODE_16) {
646 range.child_hi |= ACPIDEV_REG_IO_DECODE16;
647 }
648 range.parent_hi = range.child_hi;
649 range.parent_mid = range.child_mid = 0;
650 range.parent_low = range.child_low = rscp->Data.Io.Minimum;
651 range.size_hi = 0;
652 range.size_low = rscp->Data.Io.AddressLength;
653 if ((uint64_t)range.child_low + range.size_low > UINT16_MAX) {
654 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid IO record, "
655 "IO max is out of range.");
656 rc = AE_ERROR;
657 } else if (range.size_low != 0) {
658 rc = acpidev_resource_insert_range(rhdl, &range);
659 if (ACPI_FAILURE(rc)) {
660 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
661 "insert range into resource handle.");
662 }
663 }
664 break;
665 }
666
667 case ACPI_RESOURCE_TYPE_ADDRESS16:
668 case ACPI_RESOURCE_TYPE_ADDRESS32:
669 case ACPI_RESOURCE_TYPE_ADDRESS64:
670 {
671 ACPI_RESOURCE_ADDRESS64 addr64;
672
673 if (rscp->Data.Address.ProducerConsumer != ACPI_PRODUCER) {
674 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: producer encountered "
675 "a CONSUMER resource, ignored.");
676 } else if (ACPI_FAILURE(AcpiResourceToAddress64(rscp,
677 &addr64))) {
678 ACPIDEV_DEBUG(CE_WARN,
679 "!acpidev: failed to convert resource to ADDR64.");
680 } else if (ACPI_FAILURE(rc = acpidev_resource_address64(rhdl,
681 &addr64))) {
682 ACPIDEV_DEBUG(CE_WARN,
683 "!acpidev: failed to handle ADDRESS resource.");
684 }
685 break;
686 }
687
688 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
689 {
690 ACPI_RESOURCE_ADDRESS64 addr64;
691
692 if (rscp->Data.ExtAddress64.ProducerConsumer != ACPI_PRODUCER) {
693 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: producer encountered "
694 "a CONSUMER resource, ignored.");
695 break;
696 }
697
698 *(ACPI_RESOURCE_ADDRESS *)&addr64 = rscp->Data.Address;
699 addr64.Granularity = rscp->Data.ExtAddress64.Granularity;
700 addr64.Minimum = rscp->Data.ExtAddress64.Minimum;
701 addr64.Maximum = rscp->Data.ExtAddress64.Maximum;
702 addr64.TranslationOffset =
703 rscp->Data.ExtAddress64.TranslationOffset;
704 addr64.AddressLength = rscp->Data.ExtAddress64.AddressLength;
705 if (ACPI_FAILURE(rc = acpidev_resource_address64(rhdl,
706 &addr64))) {
707 ACPIDEV_DEBUG(CE_WARN,
708 "!acpidev: failed to handle EXTADDRESS resource.");
709 }
710 break;
711 }
712
713 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
714 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
715 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: producer encountered "
716 "START_DEPENDENT or END_DEPENDENT tag, ignored.");
717 break;
718
719 case ACPI_RESOURCE_TYPE_END_TAG:
720 /* Finish walking when we encounter END_TAG. */
721 rc = AE_CTRL_TERMINATE;
722 break;
723
724 default:
725 ACPIDEV_DEBUG(CE_NOTE,
726 "!acpidev: unknown ACPI resource type %u, ignored.",
727 rscp->Type);
728 break;
729 }
730
731 return (rc);
732 }
733
734 static ACPI_STATUS
735 acpidev_resource_walk_consumer(ACPI_RESOURCE *rscp, void *ctxp)
736 {
737 ACPI_STATUS rc = AE_OK;
738 acpidev_resource_handle_t rhdl;
739
740 ASSERT(ctxp != NULL);
741 rhdl = (acpidev_resource_handle_t)ctxp;
742 ASSERT(rhdl->acpidev_consumer == B_TRUE);
743
744 switch (rscp->Type) {
745 case ACPI_RESOURCE_TYPE_MEMORY24:
746 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
747 case ACPI_RESOURCE_TYPE_VENDOR:
748 ACPIDEV_DEBUG(CE_NOTE,
749 "!acpidev: unsupported consumer resource type %u, ignored.",
750 rscp->Type);
751 break;
752
753 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
754 {
755 int i;
756
757 if (rscp->Data.ExtendedIrq.ProducerConsumer != ACPI_CONSUMER) {
758 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: consumer encountered "
759 "a PRODUCER resource, ignored.");
760 break;
761 }
762 for (i = 0; i < rscp->Data.ExtendedIrq.InterruptCount; i++) {
763 if (ACPI_SUCCESS(acpidev_resource_insert_irq(rhdl,
764 rscp->Data.ExtendedIrq.Interrupts[i]))) {
765 continue;
766 }
767 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to insert"
768 "Extended IRQ into resource handle.");
769 rc = AE_ERROR;
770 break;
771 }
772 break;
773 }
774
775 case ACPI_RESOURCE_TYPE_IRQ:
776 {
777 int i;
778
779 for (i = 0; i < rscp->Data.Irq.InterruptCount; i++) {
780 if (ACPI_SUCCESS(acpidev_resource_insert_irq(rhdl,
781 rscp->Data.Irq.Interrupts[i]))) {
782 continue;
783 }
784 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to insert"
785 "IRQ into resource handle.");
786 rc = AE_ERROR;
787 break;
788 }
789 break;
790 }
791
792 case ACPI_RESOURCE_TYPE_DMA:
793 {
794 int i;
795
796 for (i = 0; i < rscp->Data.Dma.ChannelCount; i++) {
797 if (ACPI_SUCCESS(acpidev_resource_insert_dma(rhdl,
798 rscp->Data.Dma.Channels[i]))) {
799 continue;
800 }
801 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to insert"
802 "dma into resource handle.");
803 rc = AE_ERROR;
804 break;
805 }
806 break;
807 }
808
809 case ACPI_RESOURCE_TYPE_IO:
810 case ACPI_RESOURCE_TYPE_FIXED_IO:
811 {
812 acpidev_regspec_t reg;
813
814 reg.phys_hi = ACPIDEV_REG_TYPE_IO;
815 reg.phys_hi |= ACPIDEV_REG_IO_RANGE_FULL;
816 if (rscp->Type == ACPI_RESOURCE_TYPE_IO) {
817 if (rscp->Data.Io.IoDecode == ACPI_DECODE_16) {
818 reg.phys_hi |= ACPIDEV_REG_IO_DECODE16;
819 }
820 reg.phys_low = rscp->Data.Io.Minimum;
821 reg.size_low = rscp->Data.Io.AddressLength;
822 } else {
823 reg.phys_hi |= ACPIDEV_REG_IO_DECODE16;
824 reg.phys_low = rscp->Data.FixedIo.Address;
825 reg.size_low = rscp->Data.FixedIo.AddressLength;
826 }
827 reg.phys_mid = 0;
828 reg.size_hi = 0;
829 if ((uint64_t)reg.phys_low + reg.size_low > UINT16_MAX) {
830 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid IO/FIXEDIO "
831 "record, IO max is out of range.");
832 rc = AE_ERROR;
833 } else if (reg.size_low != 0) {
834 rc = acpidev_resource_insert_reg(rhdl, ®);
835 if (ACPI_FAILURE(rc)) {
836 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
837 "insert reg into resource handle.");
838 }
839 }
840 break;
841 }
842
843 case ACPI_RESOURCE_TYPE_MEMORY32:
844 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
845 {
846 acpidev_regspec_t reg;
847
848 reg.phys_hi = ACPIDEV_REG_TYPE_MEMORY;
849 reg.phys_hi |= ACPIDEV_REG_MEM_COHERENT_CA;
850 if (rscp->Type == ACPI_RESOURCE_TYPE_MEMORY32) {
851 if (rscp->Data.Memory32.WriteProtect ==
852 ACPI_READ_WRITE_MEMORY) {
853 reg.phys_hi |= ACPIDEV_REG_MEM_WRITABLE;
854 }
855 reg.phys_low = rscp->Data.Memory32.Minimum;
856 reg.size_low = rscp->Data.Memory32.AddressLength;
857 } else {
858 if (rscp->Data.FixedMemory32.WriteProtect ==
859 ACPI_READ_WRITE_MEMORY) {
860 reg.phys_hi |= ACPIDEV_REG_MEM_WRITABLE;
861 }
862 reg.phys_low = rscp->Data.FixedMemory32.Address;
863 reg.size_low = rscp->Data.FixedMemory32.AddressLength;
864 }
865 reg.phys_mid = 0;
866 reg.size_hi = 0;
867 if ((uint64_t)reg.phys_low + reg.size_low > UINT32_MAX) {
868 ACPIDEV_DEBUG(CE_WARN,
869 "!acpidev: invalid MEMORY32/FIXEDMEMORY32 record, "
870 "memory max is out of range.");
871 rc = AE_ERROR;
872 } else if (reg.size_low != 0) {
873 rc = acpidev_resource_insert_reg(rhdl, ®);
874 if (ACPI_FAILURE(rc)) {
875 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to "
876 "insert reg into resource handle.");
877 }
878 }
879 break;
880 }
881
882 case ACPI_RESOURCE_TYPE_ADDRESS16:
883 case ACPI_RESOURCE_TYPE_ADDRESS32:
884 case ACPI_RESOURCE_TYPE_ADDRESS64:
885 {
886 ACPI_RESOURCE_ADDRESS64 addr64;
887
888 if (rscp->Data.Address.ProducerConsumer != ACPI_CONSUMER) {
889 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: consumer encountered "
890 "a PRODUCER resource, ignored.");
891 } else if (ACPI_FAILURE(AcpiResourceToAddress64(rscp,
892 &addr64))) {
893 ACPIDEV_DEBUG(CE_WARN,
894 "!acpidev: failed to convert resource to ADDR64.");
895 } else if (ACPI_FAILURE(rc = acpidev_resource_address64(rhdl,
896 &addr64))) {
897 ACPIDEV_DEBUG(CE_WARN,
898 "!acpidev: failed to handle ADDRESS resource.");
899 }
900 break;
901 }
902
903 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
904 {
905 ACPI_RESOURCE_ADDRESS64 addr64;
906
907 if (rscp->Data.ExtAddress64.ProducerConsumer != ACPI_CONSUMER) {
908 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: consumer encountered "
909 "a PRODUCER resource, ignored.");
910 break;
911 }
912
913 *(ACPI_RESOURCE_ADDRESS *)&addr64 = rscp->Data.Address;
914 addr64.Granularity = rscp->Data.ExtAddress64.Granularity;
915 addr64.Minimum = rscp->Data.ExtAddress64.Minimum;
916 addr64.Maximum = rscp->Data.ExtAddress64.Maximum;
917 addr64.TranslationOffset =
918 rscp->Data.ExtAddress64.TranslationOffset;
919 addr64.AddressLength = rscp->Data.ExtAddress64.AddressLength;
920 if (ACPI_FAILURE(rc = acpidev_resource_address64(rhdl,
921 &addr64))) {
922 ACPIDEV_DEBUG(CE_WARN,
923 "!acpidev: failed to handle EXTADDRESS resource.");
924 }
925 break;
926 }
927
928 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
929 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
930 ACPIDEV_DEBUG(CE_NOTE, "!acpidev: consumer encountered "
931 "START_DEPENDENT or END_DEPENDENT tag, ignored.");
932 break;
933
934 case ACPI_RESOURCE_TYPE_END_TAG:
935 /* Finish walking when we encounter END_TAG. */
936 rc = AE_CTRL_TERMINATE;
937 break;
938
939 default:
940 ACPIDEV_DEBUG(CE_NOTE,
941 "!acpidev: unknown ACPI resource type %u, ignored.",
942 rscp->Type);
943 break;
944 }
945
946 return (rc);
947 }
948
949 ACPI_STATUS
950 acpidev_resource_walk(ACPI_HANDLE hdl, char *method,
951 boolean_t consumer, acpidev_resource_handle_t *rhdlp)
952 {
953 ACPI_STATUS rc = AE_OK;
954 ACPI_HANDLE mhdl = NULL;
955 acpidev_resource_handle_t rhdl = NULL;
956
957 ASSERT(hdl != NULL);
958 ASSERT(method != NULL);
959 ASSERT(rhdlp != NULL);
960 if (hdl == NULL) {
961 ACPIDEV_DEBUG(CE_WARN,
962 "!acpidev: hdl is NULL in acpidev_resource_walk().");
963 return (AE_BAD_PARAMETER);
964 } else if (method == NULL) {
965 ACPIDEV_DEBUG(CE_WARN,
966 "!acpidev: method is NULL in acpidev_resource_walk().");
967 return (AE_BAD_PARAMETER);
968 } else if (rhdlp == NULL) {
969 ACPIDEV_DEBUG(CE_WARN, "!acpidev: resource handle ptr is NULL "
970 "in acpidev_resource_walk().");
971 return (AE_BAD_PARAMETER);
972 }
973
974 /* Check whether method exists under object. */
975 if (ACPI_FAILURE(AcpiGetHandle(hdl, method, &mhdl))) {
976 char *objname = acpidev_get_object_name(hdl);
977 ACPIDEV_DEBUG(CE_NOTE,
978 "!acpidev: method %s doesn't exist under %s",
979 method, objname);
980 acpidev_free_object_name(objname);
981 return (AE_NOT_FOUND);
982 }
983
984 /* Walk all resources. */
985 rhdl = acpidev_resource_handle_alloc(consumer);
986 if (consumer) {
987 rc = AcpiWalkResources(hdl, method,
988 acpidev_resource_walk_consumer, rhdl);
989 } else {
990 rc = AcpiWalkResources(hdl, method,
991 acpidev_resource_walk_producer, rhdl);
992 }
993 if (ACPI_SUCCESS(rc)) {
994 *rhdlp = rhdl;
995 } else {
996 acpidev_resource_handle_free(rhdl);
997 }
998 if (ACPI_FAILURE(rc)) {
999 char *objname = acpidev_get_object_name(hdl);
1000 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to walk resource from "
1001 "method %s under %s.", method, objname);
1002 acpidev_free_object_name(objname);
1003 }
1004
1005 return (rc);
1006 }
1007
1008 ACPI_STATUS
1009 acpidev_resource_process(acpidev_walk_info_t *infop, boolean_t consumer)
1010 {
1011 ACPI_STATUS rc;
1012 char path[MAXPATHLEN];
1013 acpidev_resource_handle_t rhdl = NULL;
1014
1015 ASSERT(infop != NULL);
1016 if (infop == NULL) {
1017 ACPIDEV_DEBUG(CE_WARN, "!acpidev: invalid parameter "
1018 "in acpidev_resource_process().");
1019 return (AE_BAD_PARAMETER);
1020 }
1021
1022 /* Walk all resources. */
1023 (void) ddi_pathname(infop->awi_dip, path);
1024 rc = acpidev_resource_walk(infop->awi_hdl, METHOD_NAME__CRS,
1025 consumer, &rhdl);
1026 if (ACPI_FAILURE(rc)) {
1027 ACPIDEV_DEBUG(CE_WARN,
1028 "!acpidev: failed to walk ACPI resources of %s(%s).",
1029 path, infop->awi_name);
1030 return (rc);
1031 }
1032
1033 if (consumer) {
1034 /* Create device properties for consumer. */
1035
1036 /* Create 'reg' and 'assigned-addresses' properties. */
1037 if (rhdl->acpidev_reg_count > 0 &&
1038 ndi_prop_update_int_array(DDI_DEV_T_NONE, infop->awi_dip,
1039 "reg", (int *)rhdl->acpidev_regp,
1040 rhdl->acpidev_reg_count * sizeof (acpidev_regspec_t) /
1041 sizeof (int)) != NDI_SUCCESS) {
1042 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to set "
1043 "'reg' property for %s.", path);
1044 rc = AE_ERROR;
1045 goto out;
1046 }
1047 if (rhdl->acpidev_reg_count > 0 &&
1048 ndi_prop_update_int_array(DDI_DEV_T_NONE, infop->awi_dip,
1049 "assigned-addresses", (int *)rhdl->acpidev_regp,
1050 rhdl->acpidev_reg_count * sizeof (acpidev_regspec_t) /
1051 sizeof (int)) != NDI_SUCCESS) {
1052 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to set "
1053 "'assigned-addresses' property for %s.", path);
1054 rc = AE_ERROR;
1055 goto out;
1056 }
1057
1058 /* Create 'interrupts' property. */
1059 if (rhdl->acpidev_irq_count > 0 &&
1060 ndi_prop_update_int_array(DDI_DEV_T_NONE, infop->awi_dip,
1061 "interrupts", (int *)rhdl->acpidev_irqp,
1062 rhdl->acpidev_irq_count) != NDI_SUCCESS) {
1063 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to set "
1064 "'interrupts' property for %s.", path);
1065 rc = AE_ERROR;
1066 goto out;
1067 }
1068
1069 /* Create 'dma-channels' property. */
1070 if (rhdl->acpidev_dma_count > 0 &&
1071 ndi_prop_update_int_array(DDI_DEV_T_NONE, infop->awi_dip,
1072 "dma-channels", (int *)rhdl->acpidev_dmap,
1073 rhdl->acpidev_dma_count) != NDI_SUCCESS) {
1074 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to set "
1075 "'dma-channels' property for %s.", path);
1076 rc = AE_ERROR;
1077 goto out;
1078 }
1079
1080 } else {
1081 /* Create device properties for producer. */
1082
1083 /* Create 'ranges' property. */
1084 if (rhdl->acpidev_range_count > 0 &&
1085 ndi_prop_update_int_array(DDI_DEV_T_NONE, infop->awi_dip,
1086 "ranges", (int *)rhdl->acpidev_rangep,
1087 rhdl->acpidev_range_count * sizeof (acpidev_ranges_t) /
1088 sizeof (int)) != NDI_SUCCESS) {
1089 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to set "
1090 "'ranges' property for %s.", path);
1091 rc = AE_ERROR;
1092 goto out;
1093 }
1094
1095 /* Create 'bus-range' property. */
1096 if (rhdl->acpidev_bus_count > 0 &&
1097 ndi_prop_update_int_array(DDI_DEV_T_NONE, infop->awi_dip,
1098 "bus-range", (int *)rhdl->acpidev_busp,
1099 rhdl->acpidev_bus_count * sizeof (acpidev_bus_range_t) /
1100 sizeof (int)) != NDI_SUCCESS) {
1101 ACPIDEV_DEBUG(CE_WARN, "!acpidev: failed to set "
1102 "'bus-range' property for %s.", path);
1103 rc = AE_ERROR;
1104 goto out;
1105 }
1106 }
1107
1108 out:
1109 /* Free resources allocated by acpidev_resource_walk. */
1110 acpidev_resource_handle_free(rhdl);
1111
1112 return (rc);
1113 }