?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sh: mach-migor: Add ov772x support.
[linux-2.6/kvm.git] / drivers / pnp / pnpacpi / rsparser.c
blobadf17856bacc187a8216af9ded5ec3cf2ed2662b
1 /*
2 * pnpacpi -- PnP ACPI driver
3 *
4 * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
5 * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
6 * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
7 * Bjorn Helgaas <bjorn.helgaas@hp.com>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2, or (at your option) any
12 * later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 #include <linux/kernel.h>
24 #include <linux/acpi.h>
25 #include <linux/pci.h>
26 #include <linux/pnp.h>
27 #include "../base.h"
28 #include "pnpacpi.h"
29
30 #ifdef CONFIG_IA64
31 #define valid_IRQ(i) (1)
32 #else
33 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
34 #endif
35
36 /*
37 * Allocated Resources
38 */
39 static int irq_flags(int triggering, int polarity, int shareable)
40 {
41 int flags;
42
43 if (triggering == ACPI_LEVEL_SENSITIVE) {
44 if (polarity == ACPI_ACTIVE_LOW)
45 flags = IORESOURCE_IRQ_LOWLEVEL;
46 else
47 flags = IORESOURCE_IRQ_HIGHLEVEL;
48 } else {
49 if (polarity == ACPI_ACTIVE_LOW)
50 flags = IORESOURCE_IRQ_LOWEDGE;
51 else
52 flags = IORESOURCE_IRQ_HIGHEDGE;
53 }
54
55 if (shareable == ACPI_SHARED)
56 flags |= IORESOURCE_IRQ_SHAREABLE;
57
58 return flags;
59 }
60
61 static void decode_irq_flags(struct pnp_dev *dev, int flags, int *triggering,
62 int *polarity, int *shareable)
63 {
64 switch (flags & (IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL |
65 IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE)) {
66 case IORESOURCE_IRQ_LOWLEVEL:
67 *triggering = ACPI_LEVEL_SENSITIVE;
68 *polarity = ACPI_ACTIVE_LOW;
69 break;
70 case IORESOURCE_IRQ_HIGHLEVEL:
71 *triggering = ACPI_LEVEL_SENSITIVE;
72 *polarity = ACPI_ACTIVE_HIGH;
73 break;
74 case IORESOURCE_IRQ_LOWEDGE:
75 *triggering = ACPI_EDGE_SENSITIVE;
76 *polarity = ACPI_ACTIVE_LOW;
77 break;
78 case IORESOURCE_IRQ_HIGHEDGE:
79 *triggering = ACPI_EDGE_SENSITIVE;
80 *polarity = ACPI_ACTIVE_HIGH;
81 break;
82 default:
83 dev_err(&dev->dev, "can't encode invalid IRQ mode %#x\n",
84 flags);
85 *triggering = ACPI_EDGE_SENSITIVE;
86 *polarity = ACPI_ACTIVE_HIGH;
87 break;
88 }
89
90 if (flags & IORESOURCE_IRQ_SHAREABLE)
91 *shareable = ACPI_SHARED;
92 else
93 *shareable = ACPI_EXCLUSIVE;
94 }
95
96 static void pnpacpi_parse_allocated_irqresource(struct pnp_dev *dev,
97 u32 gsi, int triggering,
98 int polarity, int shareable)
99 {
100 int irq, flags;
101 int p, t;
102
103 if (!valid_IRQ(gsi)) {
104 pnp_add_irq_resource(dev, gsi, IORESOURCE_DISABLED);
105 return;
106 }
107
108 /*
109 * in IO-APIC mode, use overrided attribute. Two reasons:
110 * 1. BIOS bug in DSDT
111 * 2. BIOS uses IO-APIC mode Interrupt Source Override
112 */
113 if (!acpi_get_override_irq(gsi, &t, &p)) {
114 t = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
115 p = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
116
117 if (triggering != t || polarity != p) {
118 dev_warn(&dev->dev, "IRQ %d override to %s, %s\n",
119 gsi, t ? "edge":"level", p ? "low":"high");
120 triggering = t;
121 polarity = p;
122 }
123 }
124
125 flags = irq_flags(triggering, polarity, shareable);
126 irq = acpi_register_gsi(gsi, triggering, polarity);
127 if (irq >= 0)
128 pcibios_penalize_isa_irq(irq, 1);
129 else
130 flags |= IORESOURCE_DISABLED;
131
132 pnp_add_irq_resource(dev, irq, flags);
133 }
134
135 static int dma_flags(struct pnp_dev *dev, int type, int bus_master,
136 int transfer)
137 {
138 int flags = 0;
139
140 if (bus_master)
141 flags |= IORESOURCE_DMA_MASTER;
142 switch (type) {
143 case ACPI_COMPATIBILITY:
144 flags |= IORESOURCE_DMA_COMPATIBLE;
145 break;
146 case ACPI_TYPE_A:
147 flags |= IORESOURCE_DMA_TYPEA;
148 break;
149 case ACPI_TYPE_B:
150 flags |= IORESOURCE_DMA_TYPEB;
151 break;
152 case ACPI_TYPE_F:
153 flags |= IORESOURCE_DMA_TYPEF;
154 break;
155 default:
156 /* Set a default value ? */
157 flags |= IORESOURCE_DMA_COMPATIBLE;
158 dev_err(&dev->dev, "invalid DMA type %d\n", type);
159 }
160 switch (transfer) {
161 case ACPI_TRANSFER_8:
162 flags |= IORESOURCE_DMA_8BIT;
163 break;
164 case ACPI_TRANSFER_8_16:
165 flags |= IORESOURCE_DMA_8AND16BIT;
166 break;
167 case ACPI_TRANSFER_16:
168 flags |= IORESOURCE_DMA_16BIT;
169 break;
170 default:
171 /* Set a default value ? */
172 flags |= IORESOURCE_DMA_8AND16BIT;
173 dev_err(&dev->dev, "invalid DMA transfer type %d\n", transfer);
174 }
175
176 return flags;
177 }
178
179 static void pnpacpi_parse_allocated_ioresource(struct pnp_dev *dev, u64 start,
180 u64 len, int io_decode)
181 {
182 int flags = 0;
183 u64 end = start + len - 1;
184
185 if (io_decode == ACPI_DECODE_16)
186 flags |= IORESOURCE_IO_16BIT_ADDR;
187 if (len == 0 || end >= 0x10003)
188 flags |= IORESOURCE_DISABLED;
189
190 pnp_add_io_resource(dev, start, end, flags);
191 }
192
193 /*
194 * Device CSRs that do not appear in PCI config space should be described
195 * via ACPI. This would normally be done with Address Space Descriptors
196 * marked as "consumer-only," but old versions of Windows and Linux ignore
197 * the producer/consumer flag, so HP invented a vendor-defined resource to
198 * describe the location and size of CSR space.
199 */
200 static struct acpi_vendor_uuid hp_ccsr_uuid = {
201 .subtype = 2,
202 .data = { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
203 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
204 };
205
206 static int vendor_resource_matches(struct pnp_dev *dev,
207 struct acpi_resource_vendor_typed *vendor,
208 struct acpi_vendor_uuid *match,
209 int expected_len)
210 {
211 int uuid_len = sizeof(vendor->uuid);
212 u8 uuid_subtype = vendor->uuid_subtype;
213 u8 *uuid = vendor->uuid;
214 int actual_len;
215
216 /* byte_length includes uuid_subtype and uuid */
217 actual_len = vendor->byte_length - uuid_len - 1;
218
219 if (uuid_subtype == match->subtype &&
220 uuid_len == sizeof(match->data) &&
221 memcmp(uuid, match->data, uuid_len) == 0) {
222 if (expected_len && expected_len != actual_len) {
223 dev_err(&dev->dev, "wrong vendor descriptor size; "
224 "expected %d, found %d bytes\n",
225 expected_len, actual_len);
226 return 0;
227 }
228
229 return 1;
230 }
231
232 return 0;
233 }
234
235 static void pnpacpi_parse_allocated_vendor(struct pnp_dev *dev,
236 struct acpi_resource_vendor_typed *vendor)
237 {
238 if (vendor_resource_matches(dev, vendor, &hp_ccsr_uuid, 16)) {
239 u64 start, length;
240
241 memcpy(&start, vendor->byte_data, sizeof(start));
242 memcpy(&length, vendor->byte_data + 8, sizeof(length));
243
244 pnp_add_mem_resource(dev, start, start + length - 1, 0);
245 }
246 }
247
248 static void pnpacpi_parse_allocated_memresource(struct pnp_dev *dev,
249 u64 start, u64 len,
250 int write_protect)
251 {
252 int flags = 0;
253 u64 end = start + len - 1;
254
255 if (len == 0)
256 flags |= IORESOURCE_DISABLED;
257 if (write_protect == ACPI_READ_WRITE_MEMORY)
258 flags |= IORESOURCE_MEM_WRITEABLE;
259
260 pnp_add_mem_resource(dev, start, end, flags);
261 }
262
263 static void pnpacpi_parse_allocated_address_space(struct pnp_dev *dev,
264 struct acpi_resource *res)
265 {
266 struct acpi_resource_address64 addr, *p = &addr;
267 acpi_status status;
268
269 status = acpi_resource_to_address64(res, p);
270 if (!ACPI_SUCCESS(status)) {
271 dev_warn(&dev->dev, "failed to convert resource type %d\n",
272 res->type);
273 return;
274 }
275
276 if (p->producer_consumer == ACPI_PRODUCER)
277 return;
278
279 if (p->resource_type == ACPI_MEMORY_RANGE)
280 pnpacpi_parse_allocated_memresource(dev,
281 p->minimum, p->address_length,
282 p->info.mem.write_protect);
283 else if (p->resource_type == ACPI_IO_RANGE)
284 pnpacpi_parse_allocated_ioresource(dev,
285 p->minimum, p->address_length,
286 p->granularity == 0xfff ? ACPI_DECODE_10 :
287 ACPI_DECODE_16);
288 }
289
290 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
291 void *data)
292 {
293 struct pnp_dev *dev = data;
294 struct acpi_resource_irq *irq;
295 struct acpi_resource_dma *dma;
296 struct acpi_resource_io *io;
297 struct acpi_resource_fixed_io *fixed_io;
298 struct acpi_resource_vendor_typed *vendor_typed;
299 struct acpi_resource_memory24 *memory24;
300 struct acpi_resource_memory32 *memory32;
301 struct acpi_resource_fixed_memory32 *fixed_memory32;
302 struct acpi_resource_extended_irq *extended_irq;
303 int i, flags;
304
305 switch (res->type) {
306 case ACPI_RESOURCE_TYPE_IRQ:
307 /*
308 * Per spec, only one interrupt per descriptor is allowed in
309 * _CRS, but some firmware violates this, so parse them all.
310 */
311 irq = &res->data.irq;
312 if (irq->interrupt_count == 0)
313 pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
314 else {
315 for (i = 0; i < irq->interrupt_count; i++) {
316 pnpacpi_parse_allocated_irqresource(dev,
317 irq->interrupts[i],
318 irq->triggering,
319 irq->polarity,
320 irq->sharable);
321 }
322
323 /*
324 * The IRQ encoder puts a single interrupt in each
325 * descriptor, so if a _CRS descriptor has more than
326 * one interrupt, we won't be able to re-encode it.
327 */
328 if (pnp_can_write(dev) && irq->interrupt_count > 1) {
329 dev_warn(&dev->dev, "multiple interrupts in "
330 "_CRS descriptor; configuration can't "
331 "be changed\n");
332 dev->capabilities &= ~PNP_WRITE;
333 }
334 }
335 break;
336
337 case ACPI_RESOURCE_TYPE_DMA:
338 dma = &res->data.dma;
339 if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
340 flags = dma_flags(dev, dma->type, dma->bus_master,
341 dma->transfer);
342 else
343 flags = IORESOURCE_DISABLED;
344 pnp_add_dma_resource(dev, dma->channels[0], flags);
345 break;
346
347 case ACPI_RESOURCE_TYPE_IO:
348 io = &res->data.io;
349 pnpacpi_parse_allocated_ioresource(dev,
350 io->minimum,
351 io->address_length,
352 io->io_decode);
353 break;
354
355 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
356 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
357 break;
358
359 case ACPI_RESOURCE_TYPE_FIXED_IO:
360 fixed_io = &res->data.fixed_io;
361 pnpacpi_parse_allocated_ioresource(dev,
362 fixed_io->address,
363 fixed_io->address_length,
364 ACPI_DECODE_10);
365 break;
366
367 case ACPI_RESOURCE_TYPE_VENDOR:
368 vendor_typed = &res->data.vendor_typed;
369 pnpacpi_parse_allocated_vendor(dev, vendor_typed);
370 break;
371
372 case ACPI_RESOURCE_TYPE_END_TAG:
373 break;
374
375 case ACPI_RESOURCE_TYPE_MEMORY24:
376 memory24 = &res->data.memory24;
377 pnpacpi_parse_allocated_memresource(dev,
378 memory24->minimum,
379 memory24->address_length,
380 memory24->write_protect);
381 break;
382 case ACPI_RESOURCE_TYPE_MEMORY32:
383 memory32 = &res->data.memory32;
384 pnpacpi_parse_allocated_memresource(dev,
385 memory32->minimum,
386 memory32->address_length,
387 memory32->write_protect);
388 break;
389 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
390 fixed_memory32 = &res->data.fixed_memory32;
391 pnpacpi_parse_allocated_memresource(dev,
392 fixed_memory32->address,
393 fixed_memory32->address_length,
394 fixed_memory32->write_protect);
395 break;
396 case ACPI_RESOURCE_TYPE_ADDRESS16:
397 case ACPI_RESOURCE_TYPE_ADDRESS32:
398 case ACPI_RESOURCE_TYPE_ADDRESS64:
399 pnpacpi_parse_allocated_address_space(dev, res);
400 break;
401
402 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
403 if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
404 return AE_OK;
405 break;
406
407 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
408 extended_irq = &res->data.extended_irq;
409
410 if (extended_irq->interrupt_count == 0)
411 pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
412 else {
413 for (i = 0; i < extended_irq->interrupt_count; i++) {
414 pnpacpi_parse_allocated_irqresource(dev,
415 extended_irq->interrupts[i],
416 extended_irq->triggering,
417 extended_irq->polarity,
418 extended_irq->sharable);
419 }
420
421 /*
422 * The IRQ encoder puts a single interrupt in each
423 * descriptor, so if a _CRS descriptor has more than
424 * one interrupt, we won't be able to re-encode it.
425 */
426 if (pnp_can_write(dev) &&
427 extended_irq->interrupt_count > 1) {
428 dev_warn(&dev->dev, "multiple interrupts in "
429 "_CRS descriptor; configuration can't "
430 "be changed\n");
431 dev->capabilities &= ~PNP_WRITE;
432 }
433 }
434 break;
435
436 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
437 break;
438
439 default:
440 dev_warn(&dev->dev, "unknown resource type %d in _CRS\n",
441 res->type);
442 return AE_ERROR;
443 }
444
445 return AE_OK;
446 }
447
448 int pnpacpi_parse_allocated_resource(struct pnp_dev *dev)
449 {
450 acpi_handle handle = dev->data;
451 acpi_status status;
452
453 pnp_dbg(&dev->dev, "parse allocated resources\n");
454
455 pnp_init_resources(dev);
456
457 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
458 pnpacpi_allocated_resource, dev);
459
460 if (ACPI_FAILURE(status)) {
461 if (status != AE_NOT_FOUND)
462 dev_err(&dev->dev, "can't evaluate _CRS: %d", status);
463 return -EPERM;
464 }
465 return 0;
466 }
467
468 static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
469 unsigned int option_flags,
470 struct acpi_resource_dma *p)
471 {
472 int i;
473 unsigned char map = 0, flags;
474
475 if (p->channel_count == 0)
476 return;
477
478 for (i = 0; i < p->channel_count; i++)
479 map |= 1 << p->channels[i];
480
481 flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
482 pnp_register_dma_resource(dev, option_flags, map, flags);
483 }
484
485 static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
486 unsigned int option_flags,
487 struct acpi_resource_irq *p)
488 {
489 int i;
490 pnp_irq_mask_t map;
491 unsigned char flags;
492
493 if (p->interrupt_count == 0)
494 return;
495
496 bitmap_zero(map.bits, PNP_IRQ_NR);
497 for (i = 0; i < p->interrupt_count; i++)
498 if (p->interrupts[i])
499 __set_bit(p->interrupts[i], map.bits);
500
501 flags = irq_flags(p->triggering, p->polarity, p->sharable);
502 pnp_register_irq_resource(dev, option_flags, &map, flags);
503 }
504
505 static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
506 unsigned int option_flags,
507 struct acpi_resource_extended_irq *p)
508 {
509 int i;
510 pnp_irq_mask_t map;
511 unsigned char flags;
512
513 if (p->interrupt_count == 0)
514 return;
515
516 bitmap_zero(map.bits, PNP_IRQ_NR);
517 for (i = 0; i < p->interrupt_count; i++) {
518 if (p->interrupts[i]) {
519 if (p->interrupts[i] < PNP_IRQ_NR)
520 __set_bit(p->interrupts[i], map.bits);
521 else
522 dev_err(&dev->dev, "ignoring IRQ %d option "
523 "(too large for %d entry bitmap)\n",
524 p->interrupts[i], PNP_IRQ_NR);
525 }
526 }
527
528 flags = irq_flags(p->triggering, p->polarity, p->sharable);
529 pnp_register_irq_resource(dev, option_flags, &map, flags);
530 }
531
532 static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
533 unsigned int option_flags,
534 struct acpi_resource_io *io)
535 {
536 unsigned char flags = 0;
537
538 if (io->address_length == 0)
539 return;
540
541 if (io->io_decode == ACPI_DECODE_16)
542 flags = IORESOURCE_IO_16BIT_ADDR;
543 pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
544 io->alignment, io->address_length, flags);
545 }
546
547 static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
548 unsigned int option_flags,
549 struct acpi_resource_fixed_io *io)
550 {
551 if (io->address_length == 0)
552 return;
553
554 pnp_register_port_resource(dev, option_flags, io->address, io->address,
555 0, io->address_length, IORESOURCE_IO_FIXED);
556 }
557
558 static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
559 unsigned int option_flags,
560 struct acpi_resource_memory24 *p)
561 {
562 unsigned char flags = 0;
563
564 if (p->address_length == 0)
565 return;
566
567 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
568 flags = IORESOURCE_MEM_WRITEABLE;
569 pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
570 p->alignment, p->address_length, flags);
571 }
572
573 static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
574 unsigned int option_flags,
575 struct acpi_resource_memory32 *p)
576 {
577 unsigned char flags = 0;
578
579 if (p->address_length == 0)
580 return;
581
582 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
583 flags = IORESOURCE_MEM_WRITEABLE;
584 pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
585 p->alignment, p->address_length, flags);
586 }
587
588 static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
589 unsigned int option_flags,
590 struct acpi_resource_fixed_memory32 *p)
591 {
592 unsigned char flags = 0;
593
594 if (p->address_length == 0)
595 return;
596
597 if (p->write_protect == ACPI_READ_WRITE_MEMORY)
598 flags = IORESOURCE_MEM_WRITEABLE;
599 pnp_register_mem_resource(dev, option_flags, p->address, p->address,
600 0, p->address_length, flags);
601 }
602
603 static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
604 unsigned int option_flags,
605 struct acpi_resource *r)
606 {
607 struct acpi_resource_address64 addr, *p = &addr;
608 acpi_status status;
609 unsigned char flags = 0;
610
611 status = acpi_resource_to_address64(r, p);
612 if (ACPI_FAILURE(status)) {
613 dev_warn(&dev->dev, "can't convert resource type %d\n",
614 r->type);
615 return;
616 }
617
618 if (p->address_length == 0)
619 return;
620
621 if (p->resource_type == ACPI_MEMORY_RANGE) {
622 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
623 flags = IORESOURCE_MEM_WRITEABLE;
624 pnp_register_mem_resource(dev, option_flags, p->minimum,
625 p->minimum, 0, p->address_length,
626 flags);
627 } else if (p->resource_type == ACPI_IO_RANGE)
628 pnp_register_port_resource(dev, option_flags, p->minimum,
629 p->minimum, 0, p->address_length,
630 IORESOURCE_IO_FIXED);
631 }
632
633 struct acpipnp_parse_option_s {
634 struct pnp_dev *dev;
635 unsigned int option_flags;
636 };
637
638 static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
639 void *data)
640 {
641 int priority;
642 struct acpipnp_parse_option_s *parse_data = data;
643 struct pnp_dev *dev = parse_data->dev;
644 unsigned int option_flags = parse_data->option_flags;
645
646 switch (res->type) {
647 case ACPI_RESOURCE_TYPE_IRQ:
648 pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq);
649 break;
650
651 case ACPI_RESOURCE_TYPE_DMA:
652 pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma);
653 break;
654
655 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
656 switch (res->data.start_dpf.compatibility_priority) {
657 case ACPI_GOOD_CONFIGURATION:
658 priority = PNP_RES_PRIORITY_PREFERRED;
659 break;
660
661 case ACPI_ACCEPTABLE_CONFIGURATION:
662 priority = PNP_RES_PRIORITY_ACCEPTABLE;
663 break;
664
665 case ACPI_SUB_OPTIMAL_CONFIGURATION:
666 priority = PNP_RES_PRIORITY_FUNCTIONAL;
667 break;
668 default:
669 priority = PNP_RES_PRIORITY_INVALID;
670 break;
671 }
672 parse_data->option_flags = pnp_new_dependent_set(dev, priority);
673 break;
674
675 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
676 parse_data->option_flags = 0;
677 break;
678
679 case ACPI_RESOURCE_TYPE_IO:
680 pnpacpi_parse_port_option(dev, option_flags, &res->data.io);
681 break;
682
683 case ACPI_RESOURCE_TYPE_FIXED_IO:
684 pnpacpi_parse_fixed_port_option(dev, option_flags,
685 &res->data.fixed_io);
686 break;
687
688 case ACPI_RESOURCE_TYPE_VENDOR:
689 case ACPI_RESOURCE_TYPE_END_TAG:
690 break;
691
692 case ACPI_RESOURCE_TYPE_MEMORY24:
693 pnpacpi_parse_mem24_option(dev, option_flags,
694 &res->data.memory24);
695 break;
696
697 case ACPI_RESOURCE_TYPE_MEMORY32:
698 pnpacpi_parse_mem32_option(dev, option_flags,
699 &res->data.memory32);
700 break;
701
702 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
703 pnpacpi_parse_fixed_mem32_option(dev, option_flags,
704 &res->data.fixed_memory32);
705 break;
706
707 case ACPI_RESOURCE_TYPE_ADDRESS16:
708 case ACPI_RESOURCE_TYPE_ADDRESS32:
709 case ACPI_RESOURCE_TYPE_ADDRESS64:
710 pnpacpi_parse_address_option(dev, option_flags, res);
711 break;
712
713 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
714 break;
715
716 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
717 pnpacpi_parse_ext_irq_option(dev, option_flags,
718 &res->data.extended_irq);
719 break;
720
721 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
722 break;
723
724 default:
725 dev_warn(&dev->dev, "unknown resource type %d in _PRS\n",
726 res->type);
727 return AE_ERROR;
728 }
729
730 return AE_OK;
731 }
732
733 int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev)
734 {
735 acpi_handle handle = dev->data;
736 acpi_status status;
737 struct acpipnp_parse_option_s parse_data;
738
739 pnp_dbg(&dev->dev, "parse resource options\n");
740
741 parse_data.dev = dev;
742 parse_data.option_flags = 0;
743
744 status = acpi_walk_resources(handle, METHOD_NAME__PRS,
745 pnpacpi_option_resource, &parse_data);
746
747 if (ACPI_FAILURE(status)) {
748 if (status != AE_NOT_FOUND)
749 dev_err(&dev->dev, "can't evaluate _PRS: %d", status);
750 return -EPERM;
751 }
752 return 0;
753 }
754
755 static int pnpacpi_supported_resource(struct acpi_resource *res)
756 {
757 switch (res->type) {
758 case ACPI_RESOURCE_TYPE_IRQ:
759 case ACPI_RESOURCE_TYPE_DMA:
760 case ACPI_RESOURCE_TYPE_IO:
761 case ACPI_RESOURCE_TYPE_FIXED_IO:
762 case ACPI_RESOURCE_TYPE_MEMORY24:
763 case ACPI_RESOURCE_TYPE_MEMORY32:
764 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
765 case ACPI_RESOURCE_TYPE_ADDRESS16:
766 case ACPI_RESOURCE_TYPE_ADDRESS32:
767 case ACPI_RESOURCE_TYPE_ADDRESS64:
768 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
769 return 1;
770 }
771 return 0;
772 }
773
774 /*
775 * Set resource
776 */
777 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
778 void *data)
779 {
780 int *res_cnt = data;
781
782 if (pnpacpi_supported_resource(res))
783 (*res_cnt)++;
784 return AE_OK;
785 }
786
787 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
788 {
789 struct acpi_resource **resource = data;
790
791 if (pnpacpi_supported_resource(res)) {
792 (*resource)->type = res->type;
793 (*resource)->length = sizeof(struct acpi_resource);
794 if (res->type == ACPI_RESOURCE_TYPE_IRQ)
795 (*resource)->data.irq.descriptor_length =
796 res->data.irq.descriptor_length;
797 (*resource)++;
798 }
799
800 return AE_OK;
801 }
802
803 int pnpacpi_build_resource_template(struct pnp_dev *dev,
804 struct acpi_buffer *buffer)
805 {
806 acpi_handle handle = dev->data;
807 struct acpi_resource *resource;
808 int res_cnt = 0;
809 acpi_status status;
810
811 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
812 pnpacpi_count_resources, &res_cnt);
813 if (ACPI_FAILURE(status)) {
814 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
815 return -EINVAL;
816 }
817 if (!res_cnt)
818 return -EINVAL;
819 buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
820 buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
821 if (!buffer->pointer)
822 return -ENOMEM;
823
824 resource = (struct acpi_resource *)buffer->pointer;
825 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
826 pnpacpi_type_resources, &resource);
827 if (ACPI_FAILURE(status)) {
828 kfree(buffer->pointer);
829 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
830 return -EINVAL;
831 }
832 /* resource will pointer the end resource now */
833 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
834
835 return 0;
836 }
837
838 static void pnpacpi_encode_irq(struct pnp_dev *dev,
839 struct acpi_resource *resource,
840 struct resource *p)
841 {
842 struct acpi_resource_irq *irq = &resource->data.irq;
843 int triggering, polarity, shareable;
844
845 if (!pnp_resource_enabled(p)) {
846 irq->interrupt_count = 0;
847 pnp_dbg(&dev->dev, " encode irq (%s)\n",
848 p ? "disabled" : "missing");
849 return;
850 }
851
852 decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
853 irq->triggering = triggering;
854 irq->polarity = polarity;
855 irq->sharable = shareable;
856 irq->interrupt_count = 1;
857 irq->interrupts[0] = p->start;
858
859 pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n",
860 (int) p->start,
861 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
862 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
863 irq->sharable == ACPI_SHARED ? "shared" : "exclusive",
864 irq->descriptor_length);
865 }
866
867 static void pnpacpi_encode_ext_irq(struct pnp_dev *dev,
868 struct acpi_resource *resource,
869 struct resource *p)
870 {
871 struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
872 int triggering, polarity, shareable;
873
874 if (!pnp_resource_enabled(p)) {
875 extended_irq->interrupt_count = 0;
876 pnp_dbg(&dev->dev, " encode extended irq (%s)\n",
877 p ? "disabled" : "missing");
878 return;
879 }
880
881 decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
882 extended_irq->producer_consumer = ACPI_CONSUMER;
883 extended_irq->triggering = triggering;
884 extended_irq->polarity = polarity;
885 extended_irq->sharable = shareable;
886 extended_irq->interrupt_count = 1;
887 extended_irq->interrupts[0] = p->start;
888
889 pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start,
890 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
891 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
892 extended_irq->sharable == ACPI_SHARED ? "shared" : "exclusive");
893 }
894
895 static void pnpacpi_encode_dma(struct pnp_dev *dev,
896 struct acpi_resource *resource,
897 struct resource *p)
898 {
899 struct acpi_resource_dma *dma = &resource->data.dma;
900
901 if (!pnp_resource_enabled(p)) {
902 dma->channel_count = 0;
903 pnp_dbg(&dev->dev, " encode dma (%s)\n",
904 p ? "disabled" : "missing");
905 return;
906 }
907
908 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
909 switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
910 case IORESOURCE_DMA_TYPEA:
911 dma->type = ACPI_TYPE_A;
912 break;
913 case IORESOURCE_DMA_TYPEB:
914 dma->type = ACPI_TYPE_B;
915 break;
916 case IORESOURCE_DMA_TYPEF:
917 dma->type = ACPI_TYPE_F;
918 break;
919 default:
920 dma->type = ACPI_COMPATIBILITY;
921 }
922
923 switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
924 case IORESOURCE_DMA_8BIT:
925 dma->transfer = ACPI_TRANSFER_8;
926 break;
927 case IORESOURCE_DMA_8AND16BIT:
928 dma->transfer = ACPI_TRANSFER_8_16;
929 break;
930 default:
931 dma->transfer = ACPI_TRANSFER_16;
932 }
933
934 dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
935 dma->channel_count = 1;
936 dma->channels[0] = p->start;
937
938 pnp_dbg(&dev->dev, " encode dma %d "
939 "type %#x transfer %#x master %d\n",
940 (int) p->start, dma->type, dma->transfer, dma->bus_master);
941 }
942
943 static void pnpacpi_encode_io(struct pnp_dev *dev,
944 struct acpi_resource *resource,
945 struct resource *p)
946 {
947 struct acpi_resource_io *io = &resource->data.io;
948
949 if (pnp_resource_enabled(p)) {
950 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
951 io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ?
952 ACPI_DECODE_16 : ACPI_DECODE_10;
953 io->minimum = p->start;
954 io->maximum = p->end;
955 io->alignment = 0; /* Correct? */
956 io->address_length = p->end - p->start + 1;
957 } else {
958 io->minimum = 0;
959 io->address_length = 0;
960 }
961
962 pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum,
963 io->minimum + io->address_length - 1, io->io_decode);
964 }
965
966 static void pnpacpi_encode_fixed_io(struct pnp_dev *dev,
967 struct acpi_resource *resource,
968 struct resource *p)
969 {
970 struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
971
972 if (pnp_resource_enabled(p)) {
973 fixed_io->address = p->start;
974 fixed_io->address_length = p->end - p->start + 1;
975 } else {
976 fixed_io->address = 0;
977 fixed_io->address_length = 0;
978 }
979
980 pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address,
981 fixed_io->address + fixed_io->address_length - 1);
982 }
983
984 static void pnpacpi_encode_mem24(struct pnp_dev *dev,
985 struct acpi_resource *resource,
986 struct resource *p)
987 {
988 struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
989
990 if (pnp_resource_enabled(p)) {
991 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
992 memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
993 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
994 memory24->minimum = p->start;
995 memory24->maximum = p->end;
996 memory24->alignment = 0;
997 memory24->address_length = p->end - p->start + 1;
998 } else {
999 memory24->minimum = 0;
1000 memory24->address_length = 0;
1001 }
1002
1003 pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n",
1004 memory24->minimum,
1005 memory24->minimum + memory24->address_length - 1,
1006 memory24->write_protect);
1007 }
1008
1009 static void pnpacpi_encode_mem32(struct pnp_dev *dev,
1010 struct acpi_resource *resource,
1011 struct resource *p)
1012 {
1013 struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
1014
1015 if (pnp_resource_enabled(p)) {
1016 memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
1017 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
1018 memory32->minimum = p->start;
1019 memory32->maximum = p->end;
1020 memory32->alignment = 0;
1021 memory32->address_length = p->end - p->start + 1;
1022 } else {
1023 memory32->minimum = 0;
1024 memory32->alignment = 0;
1025 }
1026
1027 pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n",
1028 memory32->minimum,
1029 memory32->minimum + memory32->address_length - 1,
1030 memory32->write_protect);
1031 }
1032
1033 static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev,
1034 struct acpi_resource *resource,
1035 struct resource *p)
1036 {
1037 struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
1038
1039 if (pnp_resource_enabled(p)) {
1040 fixed_memory32->write_protect =
1041 p->flags & IORESOURCE_MEM_WRITEABLE ?
1042 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
1043 fixed_memory32->address = p->start;
1044 fixed_memory32->address_length = p->end - p->start + 1;
1045 } else {
1046 fixed_memory32->address = 0;
1047 fixed_memory32->address_length = 0;
1048 }
1049
1050 pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
1051 fixed_memory32->address,
1052 fixed_memory32->address + fixed_memory32->address_length - 1,
1053 fixed_memory32->write_protect);
1054 }
1055
1056 int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
1057 {
1058 int i = 0;
1059 /* pnpacpi_build_resource_template allocates extra mem */
1060 int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
1061 struct acpi_resource *resource = buffer->pointer;
1062 int port = 0, irq = 0, dma = 0, mem = 0;
1063
1064 pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt);
1065 while (i < res_cnt) {
1066 switch (resource->type) {
1067 case ACPI_RESOURCE_TYPE_IRQ:
1068 pnpacpi_encode_irq(dev, resource,
1069 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
1070 irq++;
1071 break;
1072
1073 case ACPI_RESOURCE_TYPE_DMA:
1074 pnpacpi_encode_dma(dev, resource,
1075 pnp_get_resource(dev, IORESOURCE_DMA, dma));
1076 dma++;
1077 break;
1078 case ACPI_RESOURCE_TYPE_IO:
1079 pnpacpi_encode_io(dev, resource,
1080 pnp_get_resource(dev, IORESOURCE_IO, port));
1081 port++;
1082 break;
1083 case ACPI_RESOURCE_TYPE_FIXED_IO:
1084 pnpacpi_encode_fixed_io(dev, resource,
1085 pnp_get_resource(dev, IORESOURCE_IO, port));
1086 port++;
1087 break;
1088 case ACPI_RESOURCE_TYPE_MEMORY24:
1089 pnpacpi_encode_mem24(dev, resource,
1090 pnp_get_resource(dev, IORESOURCE_MEM, mem));
1091 mem++;
1092 break;
1093 case ACPI_RESOURCE_TYPE_MEMORY32:
1094 pnpacpi_encode_mem32(dev, resource,
1095 pnp_get_resource(dev, IORESOURCE_MEM, mem));
1096 mem++;
1097 break;
1098 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
1099 pnpacpi_encode_fixed_mem32(dev, resource,
1100 pnp_get_resource(dev, IORESOURCE_MEM, mem));
1101 mem++;
1102 break;
1103 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
1104 pnpacpi_encode_ext_irq(dev, resource,
1105 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
1106 irq++;
1107 break;
1108 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
1109 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
1110 case ACPI_RESOURCE_TYPE_VENDOR:
1111 case ACPI_RESOURCE_TYPE_END_TAG:
1112 case ACPI_RESOURCE_TYPE_ADDRESS16:
1113 case ACPI_RESOURCE_TYPE_ADDRESS32:
1114 case ACPI_RESOURCE_TYPE_ADDRESS64:
1115 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
1116 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
1117 default: /* other type */
1118 dev_warn(&dev->dev, "can't encode unknown resource "
1119 "type %d\n", resource->type);
1120 return -EINVAL;
1121 }
1122 resource++;
1123 i++;
1124 }
1125 return 0;
1126 }
kernel-based virtual machine