acpi_resource.c revision 1.2 1 /* $NetBSD: acpi_resource.c,v 1.2 2001/11/13 13:01:57 lukem Exp $ */
2
3 /*
4 * Copyright 2001 Wasabi Systems, Inc.
5 * All rights reserved.
6 *
7 * Written by Jason R. Thorpe for Wasabi Systems, Inc.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed for the NetBSD Project by
20 * Wasabi Systems, Inc.
21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22 * or promote products derived from this software without specific prior
23 * written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 /*-
39 * Copyright (c) 2000 Michael Smith
40 * Copyright (c) 2000 BSDi
41 * All rights reserved.
42 *
43 * Redistribution and use in source and binary forms, with or without
44 * modification, are permitted provided that the following conditions
45 * are met:
46 * 1. Redistributions of source code must retain the above copyright
47 * notice, this list of conditions and the following disclaimer.
48 * 2. Redistributions in binary form must reproduce the above copyright
49 * notice, this list of conditions and the following disclaimer in the
50 * documentation and/or other materials provided with the distribution.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62 * SUCH DAMAGE.
63 */
64
65 /*
66 * ACPI resource parsing.
67 */
68
69 #include <sys/cdefs.h>
70 __KERNEL_RCSID(0, "$NetBSD: acpi_resource.c,v 1.2 2001/11/13 13:01:57 lukem Exp $");
71
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/device.h>
75 #include <sys/malloc.h>
76
77 #include <dev/acpi/acpica.h>
78 #include <dev/acpi/acpireg.h>
79 #include <dev/acpi/acpivar.h>
80
81 #define _COMPONENT ACPI_BUS
82 MODULE_NAME("RESOURCE")
83
84 /*
85 * acpi_resource_parse:
86 *
87 * Parse a device node's resources and fill them in for the
88 * client.
89 *
90 * Note that it might be nice to also locate ACPI-specific resource
91 * items, such as GPE bits.
92 */
93 ACPI_STATUS
94 acpi_resource_parse(struct device *dev, struct acpi_devnode *ad,
95 void *arg, const struct acpi_resource_parse_ops *ops)
96 {
97 ACPI_BUFFER buf;
98 ACPI_RESOURCE *res;
99 char *cur, *last;
100 ACPI_STATUS status;
101 void *context;
102 int i;
103
104 FUNCTION_TRACE(__FUNCTION__);
105
106 /*
107 * XXX Note, this means we only get devices that are currently
108 * decoding their address space. This might not be what we
109 * want, in the long term.
110 */
111
112 status = acpi_get(ad->ad_handle, &buf, AcpiGetCurrentResources);
113 if (status != AE_OK) {
114 printf("%s: ACPI: unable to get Current Resources: %d\n",
115 dev->dv_xname, status);
116 return_ACPI_STATUS(status);
117 }
118
119 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "got %d bytes of _CRS\n",
120 buf.Length));
121
122 (*ops->init)(dev, arg, &context);
123
124 cur = buf.Pointer;
125 last = cur + buf.Length;
126 while (cur < last) {
127 res = (ACPI_RESOURCE *) cur;
128 cur += res->Length;
129
130 switch (res->Id) {
131 case ACPI_RSTYPE_END_TAG:
132 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "EndTag\n"));
133 cur = last;
134 break;
135
136 case ACPI_RSTYPE_FIXED_IO:
137 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
138 "FixedIo 0x%x/%d\n",
139 res->Data.FixedIo.BaseAddress,
140 res->Data.FixedIo.RangeLength));
141 (*ops->ioport)(dev, context,
142 res->Data.FixedIo.BaseAddress,
143 res->Data.FixedIo.RangeLength);
144 break;
145
146 case ACPI_RSTYPE_IO:
147 if (res->Data.Io.MinBaseAddress ==
148 res->Data.Io.MaxBaseAddress) {
149 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
150 "Io 0x%x/%d\n",
151 res->Data.Io.MinBaseAddress,
152 res->Data.Io.RangeLength));
153 (*ops->ioport)(dev, context,
154 res->Data.Io.MinBaseAddress,
155 res->Data.Io.RangeLength);
156 } else {
157 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
158 "Io 0x%x-0x%x/%d\n",
159 res->Data.Io.MinBaseAddress,
160 res->Data.Io.MaxBaseAddress,
161 res->Data.Io.RangeLength));
162 (*ops->iorange)(dev, context,
163 res->Data.Io.MinBaseAddress,
164 res->Data.Io.MaxBaseAddress,
165 res->Data.Io.RangeLength,
166 res->Data.Io.Alignment);
167 }
168 break;
169
170 case ACPI_RSTYPE_FIXED_MEM32:
171 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
172 "FixedMemory32 0x%x/%d\n",
173 res->Data.FixedMemory32.RangeBaseAddress,
174 res->Data.FixedMemory32.RangeLength));
175 (*ops->memory)(dev, context,
176 res->Data.FixedMemory32.RangeBaseAddress,
177 res->Data.FixedMemory32.RangeLength);
178 break;
179
180 case ACPI_RSTYPE_MEM32:
181 if (res->Data.Memory32.MinBaseAddress ==
182 res->Data.Memory32.MaxBaseAddress) {
183 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
184 "Memory32 0x%x/%d\n",
185 res->Data.Memory32.MinBaseAddress,
186 res->Data.Memory32.RangeLength));
187 (*ops->memory)(dev, context,
188 res->Data.Memory32.MinBaseAddress,
189 res->Data.Memory32.RangeLength);
190 } else {
191 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
192 "Memory32 0x%x-0x%x/%d\n",
193 res->Data.Memory32.MinBaseAddress,
194 res->Data.Memory32.MaxBaseAddress,
195 res->Data.Memory32.RangeLength));
196 (*ops->memrange)(dev, context,
197 res->Data.Memory32.MinBaseAddress,
198 res->Data.Memory32.MaxBaseAddress,
199 res->Data.Memory32.RangeLength,
200 res->Data.Memory32.Alignment);
201 }
202 break;
203
204 case ACPI_RSTYPE_MEM24:
205 if (res->Data.Memory24.MinBaseAddress ==
206 res->Data.Memory24.MaxBaseAddress) {
207 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
208 "Memory24 0x%x/%d\n",
209 res->Data.Memory24.MinBaseAddress,
210 res->Data.Memory24.RangeLength));
211 (*ops->memory)(dev, context,
212 res->Data.Memory24.MinBaseAddress,
213 res->Data.Memory24.RangeLength);
214 } else {
215 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
216 "Memory24 0x%x-0x%x/%d\n",
217 res->Data.Memory24.MinBaseAddress,
218 res->Data.Memory24.MaxBaseAddress,
219 res->Data.Memory24.RangeLength));
220 (*ops->memrange)(dev, context,
221 res->Data.Memory24.MinBaseAddress,
222 res->Data.Memory24.MaxBaseAddress,
223 res->Data.Memory24.RangeLength,
224 res->Data.Memory24.Alignment);
225 }
226 break;
227
228 case ACPI_RSTYPE_IRQ:
229 for (i = 0; i < res->Data.Irq.NumberOfInterrupts; i++) {
230 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
231 "IRQ %d\n", res->Data.Irq.Interrupts[i]));
232 (*ops->irq)(dev, context,
233 res->Data.Irq.Interrupts[i]);
234 }
235 break;
236
237 case ACPI_RSTYPE_DMA:
238 for (i = 0; i < res->Data.Dma.NumberOfChannels; i++) {
239 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
240 "DRQ %d\n", res->Data.Dma.Channels[i]));
241 (*ops->drq)(dev, context,
242 res->Data.Dma.Channels[i]);
243 }
244 break;
245
246 case ACPI_RSTYPE_START_DPF:
247 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
248 "Start dependant functions: %d\n",
249 res->Data.StartDpf.CompatibilityPriority));
250 (*ops->start_dep)(dev, context,
251 res->Data.StartDpf.CompatibilityPriority);
252 break;
253
254 case ACPI_RSTYPE_END_DPF:
255 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
256 "End dependant functions\n"));
257 (*ops->end_dep)(dev, context);
258
259 case ACPI_RSTYPE_ADDRESS32:
260 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
261 "Address32 unimplemented\n"));
262 break;
263
264 case ACPI_RSTYPE_ADDRESS16:
265 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
266 "Address16 unimplemented\n"));
267 break;
268
269 case ACPI_RSTYPE_EXT_IRQ:
270 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
271 "ExtendedIrq unimplemented\n"));
272 break;
273
274 case ACPI_RSTYPE_VENDOR:
275 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
276 "VendorSpecific unimplemented\n"));
277 break;
278
279 default:
280 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
281 "Unknown resource type: %d\n", res->Id));
282 break;
283 }
284 }
285
286 AcpiOsFree(buf.Pointer);
287 (*ops->fini)(dev, context);
288
289 return_ACPI_STATUS(AE_OK);
290 }
291
292 /*
293 * acpi_resource_print:
294 *
295 * Print the resources assigned to a device.
296 */
297 void
298 acpi_resource_print(struct device *dev, struct acpi_resources *res)
299 {
300 const char *sep;
301
302 if (SIMPLEQ_EMPTY(&res->ar_io) &&
303 SIMPLEQ_EMPTY(&res->ar_iorange) &&
304 SIMPLEQ_EMPTY(&res->ar_mem) &&
305 SIMPLEQ_EMPTY(&res->ar_memrange) &&
306 SIMPLEQ_EMPTY(&res->ar_irq) &&
307 SIMPLEQ_EMPTY(&res->ar_drq))
308 return;
309
310 printf("%s:", dev->dv_xname);
311
312 if (SIMPLEQ_EMPTY(&res->ar_io) == 0) {
313 struct acpi_io *ar;
314
315 sep = "";
316 printf(" io ");
317 for (ar = SIMPLEQ_FIRST(&res->ar_io); ar != NULL;
318 ar = SIMPLEQ_NEXT(ar, ar_list)) {
319 printf("%s0x%x", sep, ar->ar_base);
320 if (ar->ar_length > 1)
321 printf("-0x%x", ar->ar_base +
322 ar->ar_length - 1);
323 sep = ",";
324 }
325 }
326
327 /* XXX iorange */
328
329 if (SIMPLEQ_EMPTY(&res->ar_mem) == 0) {
330 struct acpi_mem *ar;
331
332 sep = "";
333 printf(" mem ");
334 for (ar = SIMPLEQ_FIRST(&res->ar_mem); ar != NULL;
335 ar = SIMPLEQ_NEXT(ar, ar_list)) {
336 printf("%s0x%x", sep, ar->ar_base);
337 if (ar->ar_length > 1)
338 printf("-0x%x", ar->ar_base +
339 ar->ar_length - 1);
340 sep = ",";
341 }
342 }
343
344 /* XXX memrange */
345
346 if (SIMPLEQ_EMPTY(&res->ar_irq) == 0) {
347 struct acpi_irq *ar;
348
349 sep = "";
350 printf(" irq ");
351 for (ar = SIMPLEQ_FIRST(&res->ar_irq); ar != NULL;
352 ar = SIMPLEQ_NEXT(ar, ar_list)) {
353 printf("%s%d", sep, ar->ar_irq);
354 sep = ",";
355 }
356 }
357
358 if (SIMPLEQ_EMPTY(&res->ar_drq) == 0) {
359 struct acpi_drq *ar;
360
361 sep = "";
362 printf(" drq ");
363 for (ar = SIMPLEQ_FIRST(&res->ar_drq); ar != NULL;
364 ar = SIMPLEQ_NEXT(ar, ar_list)) {
365 printf("%s%d", sep, ar->ar_drq);
366 sep = ",";
367 }
368 }
369
370 printf("\n");
371 }
372
373 struct acpi_io *
374 acpi_res_io(struct acpi_resources *res, int idx)
375 {
376 struct acpi_io *ar;
377
378 SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
379 if (ar->ar_index == idx)
380 return (ar);
381 }
382 return (NULL);
383 }
384
385 struct acpi_iorange *
386 acpi_res_iorange(struct acpi_resources *res, int idx)
387 {
388 struct acpi_iorange *ar;
389
390 SIMPLEQ_FOREACH(ar, &res->ar_iorange, ar_list) {
391 if (ar->ar_index == idx)
392 return (ar);
393 }
394 return (NULL);
395 }
396
397 struct acpi_mem *
398 acpi_res_mem(struct acpi_resources *res, int idx)
399 {
400 struct acpi_mem *ar;
401
402 SIMPLEQ_FOREACH(ar, &res->ar_mem, ar_list) {
403 if (ar->ar_index == idx)
404 return (ar);
405 }
406 return (NULL);
407 }
408
409 struct acpi_memrange *
410 acpi_res_memrange(struct acpi_resources *res, int idx)
411 {
412 struct acpi_memrange *ar;
413
414 SIMPLEQ_FOREACH(ar, &res->ar_memrange, ar_list) {
415 if (ar->ar_index == idx)
416 return (ar);
417 }
418 return (NULL);
419 }
420
421 struct acpi_irq *
422 acpi_res_irq(struct acpi_resources *res, int idx)
423 {
424 struct acpi_irq *ar;
425
426 SIMPLEQ_FOREACH(ar, &res->ar_irq, ar_list) {
427 if (ar->ar_index == idx)
428 return (ar);
429 }
430 return (NULL);
431 }
432
433 struct acpi_drq *
434 acpi_res_drq(struct acpi_resources *res, int idx)
435 {
436 struct acpi_drq *ar;
437
438 SIMPLEQ_FOREACH(ar, &res->ar_drq, ar_list) {
439 if (ar->ar_index == idx)
440 return (ar);
441 }
442 return (NULL);
443 }
444
445 /*****************************************************************************
446 * Default ACPI resource parse operations.
447 *****************************************************************************/
448
449 static void acpi_res_parse_init(struct device *, void *, void **);
450 static void acpi_res_parse_fini(struct device *, void *);
451
452 static void acpi_res_parse_ioport(struct device *, void *, uint32_t,
453 uint32_t);
454 static void acpi_res_parse_iorange(struct device *, void *, uint32_t,
455 uint32_t, uint32_t, uint32_t);
456
457 static void acpi_res_parse_memory(struct device *, void *, uint32_t,
458 uint32_t);
459 static void acpi_res_parse_memrange(struct device *, void *, uint32_t,
460 uint32_t, uint32_t, uint32_t);
461
462 static void acpi_res_parse_irq(struct device *, void *, uint32_t);
463 static void acpi_res_parse_drq(struct device *, void *, uint32_t);
464
465 static void acpi_res_parse_start_dep(struct device *, void *, int);
466 static void acpi_res_parse_end_dep(struct device *, void *);
467
468 const struct acpi_resource_parse_ops acpi_resource_parse_ops_default = {
469 acpi_res_parse_init,
470 acpi_res_parse_fini,
471
472 acpi_res_parse_ioport,
473 acpi_res_parse_iorange,
474
475 acpi_res_parse_memory,
476 acpi_res_parse_memrange,
477
478 acpi_res_parse_irq,
479 acpi_res_parse_drq,
480
481 acpi_res_parse_start_dep,
482 acpi_res_parse_end_dep,
483 };
484
485 static void
486 acpi_res_parse_init(struct device *dev, void *arg, void **contextp)
487 {
488 struct acpi_resources *res = arg;
489
490 SIMPLEQ_INIT(&res->ar_io);
491 res->ar_nio = 0;
492
493 SIMPLEQ_INIT(&res->ar_iorange);
494 res->ar_niorange = 0;
495
496 SIMPLEQ_INIT(&res->ar_mem);
497 res->ar_nmem = 0;
498
499 SIMPLEQ_INIT(&res->ar_memrange);
500 res->ar_nmemrange = 0;
501
502 SIMPLEQ_INIT(&res->ar_irq);
503 res->ar_nirq = 0;
504
505 SIMPLEQ_INIT(&res->ar_drq);
506 res->ar_ndrq = 0;
507
508 *contextp = res;
509 }
510
511 static void
512 acpi_res_parse_fini(struct device *dev, void *context)
513 {
514 struct acpi_resources *res = context;
515
516 /* Print the resources we're using. */
517 acpi_resource_print(dev, res);
518 }
519
520 static void
521 acpi_res_parse_ioport(struct device *dev, void *context, uint32_t base,
522 uint32_t length)
523 {
524 struct acpi_resources *res = context;
525 struct acpi_io *ar;
526
527 ar = AcpiOsAllocate(sizeof(*ar));
528 if (ar == NULL) {
529 printf("%s: ACPI: unable to allocate I/O resource %d\n",
530 dev->dv_xname, res->ar_nio);
531 res->ar_nio++;
532 return;
533 }
534
535 ar->ar_index = res->ar_nio++;
536 ar->ar_base = base;
537 ar->ar_length = length;
538
539 SIMPLEQ_INSERT_TAIL(&res->ar_io, ar, ar_list);
540 }
541
542 static void
543 acpi_res_parse_iorange(struct device *dev, void *context, uint32_t low,
544 uint32_t high, uint32_t length, uint32_t align)
545 {
546 struct acpi_resources *res = context;
547 struct acpi_iorange *ar;
548
549 ar = AcpiOsAllocate(sizeof(*ar));
550 if (ar == NULL) {
551 printf("%s: ACPI: unable to allocate I/O range resource %d\n",
552 dev->dv_xname, res->ar_niorange);
553 res->ar_niorange++;
554 return;
555 }
556
557 ar->ar_index = res->ar_niorange++;
558 ar->ar_low = low;
559 ar->ar_high = high;
560 ar->ar_length = length;
561 ar->ar_align = align;
562
563 SIMPLEQ_INSERT_TAIL(&res->ar_iorange, ar, ar_list);
564 }
565
566 static void
567 acpi_res_parse_memory(struct device *dev, void *context, uint32_t base,
568 uint32_t length)
569 {
570 struct acpi_resources *res = context;
571 struct acpi_mem *ar;
572
573 ar = AcpiOsAllocate(sizeof(*ar));
574 if (ar == NULL) {
575 printf("%s: ACPI: unable to allocate Memory resource %d\n",
576 dev->dv_xname, res->ar_nmem);
577 res->ar_nmem++;
578 return;
579 }
580
581 ar->ar_index = res->ar_nmem++;
582 ar->ar_base = base;
583 ar->ar_length = length;
584
585 SIMPLEQ_INSERT_TAIL(&res->ar_mem, ar, ar_list);
586 }
587
588 static void
589 acpi_res_parse_memrange(struct device *dev, void *context, uint32_t low,
590 uint32_t high, uint32_t length, uint32_t align)
591 {
592 struct acpi_resources *res = context;
593 struct acpi_memrange *ar;
594
595 ar = AcpiOsAllocate(sizeof(*ar));
596 if (ar == NULL) {
597 printf("%s: ACPI: unable to allocate Memory range resource "
598 "%d\n", dev->dv_xname, res->ar_nmemrange);
599 res->ar_nmemrange++;
600 return;
601 }
602
603 ar->ar_index = res->ar_nmemrange++;
604 ar->ar_low = low;
605 ar->ar_high = high;
606 ar->ar_length = length;
607 ar->ar_align = align;
608
609 SIMPLEQ_INSERT_TAIL(&res->ar_memrange, ar, ar_list);
610 }
611
612 static void
613 acpi_res_parse_irq(struct device *dev, void *context, uint32_t irq)
614 {
615 struct acpi_resources *res = context;
616 struct acpi_irq *ar;
617
618 ar = AcpiOsAllocate(sizeof(*ar));
619 if (ar == NULL) {
620 printf("%s: ACPI: unable to allocate IRQ resource %d\n",
621 dev->dv_xname, res->ar_nirq);
622 res->ar_nirq++;
623 return;
624 }
625
626 ar->ar_index = res->ar_nirq++;
627 ar->ar_irq = irq;
628
629 SIMPLEQ_INSERT_TAIL(&res->ar_irq, ar, ar_list);
630 }
631
632 static void
633 acpi_res_parse_drq(struct device *dev, void *context, uint32_t drq)
634 {
635 struct acpi_resources *res = context;
636 struct acpi_drq *ar;
637
638 ar = AcpiOsAllocate(sizeof(*ar));
639 if (ar == NULL) {
640 printf("%s: ACPI: unable to allocate DRQ resource %d\n",
641 dev->dv_xname, res->ar_ndrq);
642 res->ar_ndrq++;
643 return;
644 }
645
646 ar->ar_index = res->ar_ndrq++;
647 ar->ar_drq = drq;
648
649 SIMPLEQ_INSERT_TAIL(&res->ar_drq, ar, ar_list);
650 }
651
652 static void
653 acpi_res_parse_start_dep(struct device *dev, void *context, int preference)
654 {
655
656 printf("%s: ACPI: dependant functions not supported\n",
657 dev->dv_xname);
658 }
659
660 static void
661 acpi_res_parse_end_dep(struct device *dev, void *context)
662 {
663
664 /* Nothing to do. */
665 }
666