2 * pnpacpi -- PnP ACPI driver
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>
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
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.
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
23 #include <linux/kernel.h>
24 #include <linux/acpi.h>
25 #include <linux/pci.h>
26 #include <linux/pnp.h>
31 #define valid_IRQ(i) (1)
33 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
39 static int irq_flags(int triggering
, int polarity
, int shareable
)
43 if (triggering
== ACPI_LEVEL_SENSITIVE
) {
44 if (polarity
== ACPI_ACTIVE_LOW
)
45 flags
= IORESOURCE_IRQ_LOWLEVEL
;
47 flags
= IORESOURCE_IRQ_HIGHLEVEL
;
49 if (polarity
== ACPI_ACTIVE_LOW
)
50 flags
= IORESOURCE_IRQ_LOWEDGE
;
52 flags
= IORESOURCE_IRQ_HIGHEDGE
;
55 if (shareable
== ACPI_SHARED
)
56 flags
|= IORESOURCE_IRQ_SHAREABLE
;
61 static void decode_irq_flags(struct pnp_dev
*dev
, int flags
, int *triggering
,
62 int *polarity
, int *shareable
)
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
;
70 case IORESOURCE_IRQ_HIGHLEVEL
:
71 *triggering
= ACPI_LEVEL_SENSITIVE
;
72 *polarity
= ACPI_ACTIVE_HIGH
;
74 case IORESOURCE_IRQ_LOWEDGE
:
75 *triggering
= ACPI_EDGE_SENSITIVE
;
76 *polarity
= ACPI_ACTIVE_LOW
;
78 case IORESOURCE_IRQ_HIGHEDGE
:
79 *triggering
= ACPI_EDGE_SENSITIVE
;
80 *polarity
= ACPI_ACTIVE_HIGH
;
83 dev_err(&dev
->dev
, "can't encode invalid IRQ mode %#x\n",
85 *triggering
= ACPI_EDGE_SENSITIVE
;
86 *polarity
= ACPI_ACTIVE_HIGH
;
90 if (flags
& IORESOURCE_IRQ_SHAREABLE
)
91 *shareable
= ACPI_SHARED
;
93 *shareable
= ACPI_EXCLUSIVE
;
96 static void pnpacpi_parse_allocated_irqresource(struct pnp_dev
*dev
,
97 u32 gsi
, int triggering
,
98 int polarity
, int shareable
)
103 if (!valid_IRQ(gsi
)) {
104 pnp_add_irq_resource(dev
, gsi
, IORESOURCE_DISABLED
);
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
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
;
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");
125 flags
= irq_flags(triggering
, polarity
, shareable
);
126 irq
= acpi_register_gsi(&dev
->dev
, gsi
, triggering
, polarity
);
128 pcibios_penalize_isa_irq(irq
, 1);
130 flags
|= IORESOURCE_DISABLED
;
132 pnp_add_irq_resource(dev
, irq
, flags
);
135 static int dma_flags(struct pnp_dev
*dev
, int type
, int bus_master
,
141 flags
|= IORESOURCE_DMA_MASTER
;
143 case ACPI_COMPATIBILITY
:
144 flags
|= IORESOURCE_DMA_COMPATIBLE
;
147 flags
|= IORESOURCE_DMA_TYPEA
;
150 flags
|= IORESOURCE_DMA_TYPEB
;
153 flags
|= IORESOURCE_DMA_TYPEF
;
156 /* Set a default value ? */
157 flags
|= IORESOURCE_DMA_COMPATIBLE
;
158 dev_err(&dev
->dev
, "invalid DMA type %d\n", type
);
161 case ACPI_TRANSFER_8
:
162 flags
|= IORESOURCE_DMA_8BIT
;
164 case ACPI_TRANSFER_8_16
:
165 flags
|= IORESOURCE_DMA_8AND16BIT
;
167 case ACPI_TRANSFER_16
:
168 flags
|= IORESOURCE_DMA_16BIT
;
171 /* Set a default value ? */
172 flags
|= IORESOURCE_DMA_8AND16BIT
;
173 dev_err(&dev
->dev
, "invalid DMA transfer type %d\n", transfer
);
179 static void pnpacpi_parse_allocated_ioresource(struct pnp_dev
*dev
, u64 start
,
180 u64 len
, int io_decode
)
183 u64 end
= start
+ len
- 1;
185 if (io_decode
== ACPI_DECODE_16
)
186 flags
|= IORESOURCE_IO_16BIT_ADDR
;
187 if (len
== 0 || end
>= 0x10003)
188 flags
|= IORESOURCE_DISABLED
;
190 pnp_add_io_resource(dev
, start
, end
, flags
);
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.
200 static struct acpi_vendor_uuid hp_ccsr_uuid
= {
202 .data
= { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
203 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
206 static int vendor_resource_matches(struct pnp_dev
*dev
,
207 struct acpi_resource_vendor_typed
*vendor
,
208 struct acpi_vendor_uuid
*match
,
211 int uuid_len
= sizeof(vendor
->uuid
);
212 u8 uuid_subtype
= vendor
->uuid_subtype
;
213 u8
*uuid
= vendor
->uuid
;
216 /* byte_length includes uuid_subtype and uuid */
217 actual_len
= vendor
->byte_length
- uuid_len
- 1;
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
);
235 static void pnpacpi_parse_allocated_vendor(struct pnp_dev
*dev
,
236 struct acpi_resource_vendor_typed
*vendor
)
238 if (vendor_resource_matches(dev
, vendor
, &hp_ccsr_uuid
, 16)) {
241 memcpy(&start
, vendor
->byte_data
, sizeof(start
));
242 memcpy(&length
, vendor
->byte_data
+ 8, sizeof(length
));
244 pnp_add_mem_resource(dev
, start
, start
+ length
- 1, 0);
248 static void pnpacpi_parse_allocated_memresource(struct pnp_dev
*dev
,
253 u64 end
= start
+ len
- 1;
256 flags
|= IORESOURCE_DISABLED
;
257 if (write_protect
== ACPI_READ_WRITE_MEMORY
)
258 flags
|= IORESOURCE_MEM_WRITEABLE
;
260 pnp_add_mem_resource(dev
, start
, end
, flags
);
263 static void pnpacpi_parse_allocated_address_space(struct pnp_dev
*dev
,
264 struct acpi_resource
*res
)
266 struct acpi_resource_address64 addr
, *p
= &addr
;
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",
276 if (p
->producer_consumer
== ACPI_PRODUCER
)
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
:
290 static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev
*dev
,
291 struct acpi_resource
*res
)
293 struct acpi_resource_extended_address64
*p
= &res
->data
.ext_address64
;
295 if (p
->producer_consumer
== ACPI_PRODUCER
)
298 if (p
->resource_type
== ACPI_MEMORY_RANGE
)
299 pnpacpi_parse_allocated_memresource(dev
,
300 p
->minimum
, p
->address_length
,
301 p
->info
.mem
.write_protect
);
302 else if (p
->resource_type
== ACPI_IO_RANGE
)
303 pnpacpi_parse_allocated_ioresource(dev
,
304 p
->minimum
, p
->address_length
,
305 p
->granularity
== 0xfff ? ACPI_DECODE_10
:
309 static acpi_status
pnpacpi_allocated_resource(struct acpi_resource
*res
,
312 struct pnp_dev
*dev
= data
;
313 struct acpi_resource_irq
*irq
;
314 struct acpi_resource_dma
*dma
;
315 struct acpi_resource_io
*io
;
316 struct acpi_resource_fixed_io
*fixed_io
;
317 struct acpi_resource_vendor_typed
*vendor_typed
;
318 struct acpi_resource_memory24
*memory24
;
319 struct acpi_resource_memory32
*memory32
;
320 struct acpi_resource_fixed_memory32
*fixed_memory32
;
321 struct acpi_resource_extended_irq
*extended_irq
;
325 case ACPI_RESOURCE_TYPE_IRQ
:
327 * Per spec, only one interrupt per descriptor is allowed in
328 * _CRS, but some firmware violates this, so parse them all.
330 irq
= &res
->data
.irq
;
331 if (irq
->interrupt_count
== 0)
332 pnp_add_irq_resource(dev
, 0, IORESOURCE_DISABLED
);
334 for (i
= 0; i
< irq
->interrupt_count
; i
++) {
335 pnpacpi_parse_allocated_irqresource(dev
,
343 * The IRQ encoder puts a single interrupt in each
344 * descriptor, so if a _CRS descriptor has more than
345 * one interrupt, we won't be able to re-encode it.
347 if (pnp_can_write(dev
) && irq
->interrupt_count
> 1) {
348 dev_warn(&dev
->dev
, "multiple interrupts in "
349 "_CRS descriptor; configuration can't "
351 dev
->capabilities
&= ~PNP_WRITE
;
356 case ACPI_RESOURCE_TYPE_DMA
:
357 dma
= &res
->data
.dma
;
358 if (dma
->channel_count
> 0 && dma
->channels
[0] != (u8
) -1)
359 flags
= dma_flags(dev
, dma
->type
, dma
->bus_master
,
362 flags
= IORESOURCE_DISABLED
;
363 pnp_add_dma_resource(dev
, dma
->channels
[0], flags
);
366 case ACPI_RESOURCE_TYPE_IO
:
368 pnpacpi_parse_allocated_ioresource(dev
,
374 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
375 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
378 case ACPI_RESOURCE_TYPE_FIXED_IO
:
379 fixed_io
= &res
->data
.fixed_io
;
380 pnpacpi_parse_allocated_ioresource(dev
,
382 fixed_io
->address_length
,
386 case ACPI_RESOURCE_TYPE_VENDOR
:
387 vendor_typed
= &res
->data
.vendor_typed
;
388 pnpacpi_parse_allocated_vendor(dev
, vendor_typed
);
391 case ACPI_RESOURCE_TYPE_END_TAG
:
394 case ACPI_RESOURCE_TYPE_MEMORY24
:
395 memory24
= &res
->data
.memory24
;
396 pnpacpi_parse_allocated_memresource(dev
,
398 memory24
->address_length
,
399 memory24
->write_protect
);
401 case ACPI_RESOURCE_TYPE_MEMORY32
:
402 memory32
= &res
->data
.memory32
;
403 pnpacpi_parse_allocated_memresource(dev
,
405 memory32
->address_length
,
406 memory32
->write_protect
);
408 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
409 fixed_memory32
= &res
->data
.fixed_memory32
;
410 pnpacpi_parse_allocated_memresource(dev
,
411 fixed_memory32
->address
,
412 fixed_memory32
->address_length
,
413 fixed_memory32
->write_protect
);
415 case ACPI_RESOURCE_TYPE_ADDRESS16
:
416 case ACPI_RESOURCE_TYPE_ADDRESS32
:
417 case ACPI_RESOURCE_TYPE_ADDRESS64
:
418 pnpacpi_parse_allocated_address_space(dev
, res
);
421 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
422 pnpacpi_parse_allocated_ext_address_space(dev
, res
);
425 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
426 extended_irq
= &res
->data
.extended_irq
;
428 if (extended_irq
->interrupt_count
== 0)
429 pnp_add_irq_resource(dev
, 0, IORESOURCE_DISABLED
);
431 for (i
= 0; i
< extended_irq
->interrupt_count
; i
++) {
432 pnpacpi_parse_allocated_irqresource(dev
,
433 extended_irq
->interrupts
[i
],
434 extended_irq
->triggering
,
435 extended_irq
->polarity
,
436 extended_irq
->sharable
);
440 * The IRQ encoder puts a single interrupt in each
441 * descriptor, so if a _CRS descriptor has more than
442 * one interrupt, we won't be able to re-encode it.
444 if (pnp_can_write(dev
) &&
445 extended_irq
->interrupt_count
> 1) {
446 dev_warn(&dev
->dev
, "multiple interrupts in "
447 "_CRS descriptor; configuration can't "
449 dev
->capabilities
&= ~PNP_WRITE
;
454 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
458 dev_warn(&dev
->dev
, "unknown resource type %d in _CRS\n",
466 int pnpacpi_parse_allocated_resource(struct pnp_dev
*dev
)
468 struct acpi_device
*acpi_dev
= dev
->data
;
469 acpi_handle handle
= acpi_dev
->handle
;
472 pnp_dbg(&dev
->dev
, "parse allocated resources\n");
474 pnp_init_resources(dev
);
476 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
477 pnpacpi_allocated_resource
, dev
);
479 if (ACPI_FAILURE(status
)) {
480 if (status
!= AE_NOT_FOUND
)
481 dev_err(&dev
->dev
, "can't evaluate _CRS: %d", status
);
487 static __init
void pnpacpi_parse_dma_option(struct pnp_dev
*dev
,
488 unsigned int option_flags
,
489 struct acpi_resource_dma
*p
)
492 unsigned char map
= 0, flags
;
494 if (p
->channel_count
== 0)
497 for (i
= 0; i
< p
->channel_count
; i
++)
498 map
|= 1 << p
->channels
[i
];
500 flags
= dma_flags(dev
, p
->type
, p
->bus_master
, p
->transfer
);
501 pnp_register_dma_resource(dev
, option_flags
, map
, flags
);
504 static __init
void pnpacpi_parse_irq_option(struct pnp_dev
*dev
,
505 unsigned int option_flags
,
506 struct acpi_resource_irq
*p
)
512 if (p
->interrupt_count
== 0)
515 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
516 for (i
= 0; i
< p
->interrupt_count
; i
++)
517 if (p
->interrupts
[i
])
518 __set_bit(p
->interrupts
[i
], map
.bits
);
520 flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
521 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
524 static __init
void pnpacpi_parse_ext_irq_option(struct pnp_dev
*dev
,
525 unsigned int option_flags
,
526 struct acpi_resource_extended_irq
*p
)
532 if (p
->interrupt_count
== 0)
535 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
536 for (i
= 0; i
< p
->interrupt_count
; i
++) {
537 if (p
->interrupts
[i
]) {
538 if (p
->interrupts
[i
] < PNP_IRQ_NR
)
539 __set_bit(p
->interrupts
[i
], map
.bits
);
541 dev_err(&dev
->dev
, "ignoring IRQ %d option "
542 "(too large for %d entry bitmap)\n",
543 p
->interrupts
[i
], PNP_IRQ_NR
);
547 flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
548 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
551 static __init
void pnpacpi_parse_port_option(struct pnp_dev
*dev
,
552 unsigned int option_flags
,
553 struct acpi_resource_io
*io
)
555 unsigned char flags
= 0;
557 if (io
->address_length
== 0)
560 if (io
->io_decode
== ACPI_DECODE_16
)
561 flags
= IORESOURCE_IO_16BIT_ADDR
;
562 pnp_register_port_resource(dev
, option_flags
, io
->minimum
, io
->maximum
,
563 io
->alignment
, io
->address_length
, flags
);
566 static __init
void pnpacpi_parse_fixed_port_option(struct pnp_dev
*dev
,
567 unsigned int option_flags
,
568 struct acpi_resource_fixed_io
*io
)
570 if (io
->address_length
== 0)
573 pnp_register_port_resource(dev
, option_flags
, io
->address
, io
->address
,
574 0, io
->address_length
, IORESOURCE_IO_FIXED
);
577 static __init
void pnpacpi_parse_mem24_option(struct pnp_dev
*dev
,
578 unsigned int option_flags
,
579 struct acpi_resource_memory24
*p
)
581 unsigned char flags
= 0;
583 if (p
->address_length
== 0)
586 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
587 flags
= IORESOURCE_MEM_WRITEABLE
;
588 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
, p
->maximum
,
589 p
->alignment
, p
->address_length
, flags
);
592 static __init
void pnpacpi_parse_mem32_option(struct pnp_dev
*dev
,
593 unsigned int option_flags
,
594 struct acpi_resource_memory32
*p
)
596 unsigned char flags
= 0;
598 if (p
->address_length
== 0)
601 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
602 flags
= IORESOURCE_MEM_WRITEABLE
;
603 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
, p
->maximum
,
604 p
->alignment
, p
->address_length
, flags
);
607 static __init
void pnpacpi_parse_fixed_mem32_option(struct pnp_dev
*dev
,
608 unsigned int option_flags
,
609 struct acpi_resource_fixed_memory32
*p
)
611 unsigned char flags
= 0;
613 if (p
->address_length
== 0)
616 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
617 flags
= IORESOURCE_MEM_WRITEABLE
;
618 pnp_register_mem_resource(dev
, option_flags
, p
->address
, p
->address
,
619 0, p
->address_length
, flags
);
622 static __init
void pnpacpi_parse_address_option(struct pnp_dev
*dev
,
623 unsigned int option_flags
,
624 struct acpi_resource
*r
)
626 struct acpi_resource_address64 addr
, *p
= &addr
;
628 unsigned char flags
= 0;
630 status
= acpi_resource_to_address64(r
, p
);
631 if (ACPI_FAILURE(status
)) {
632 dev_warn(&dev
->dev
, "can't convert resource type %d\n",
637 if (p
->address_length
== 0)
640 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
641 if (p
->info
.mem
.write_protect
== ACPI_READ_WRITE_MEMORY
)
642 flags
= IORESOURCE_MEM_WRITEABLE
;
643 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
,
644 p
->minimum
, 0, p
->address_length
,
646 } else if (p
->resource_type
== ACPI_IO_RANGE
)
647 pnp_register_port_resource(dev
, option_flags
, p
->minimum
,
648 p
->minimum
, 0, p
->address_length
,
649 IORESOURCE_IO_FIXED
);
652 static __init
void pnpacpi_parse_ext_address_option(struct pnp_dev
*dev
,
653 unsigned int option_flags
,
654 struct acpi_resource
*r
)
656 struct acpi_resource_extended_address64
*p
= &r
->data
.ext_address64
;
657 unsigned char flags
= 0;
659 if (p
->address_length
== 0)
662 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
663 if (p
->info
.mem
.write_protect
== ACPI_READ_WRITE_MEMORY
)
664 flags
= IORESOURCE_MEM_WRITEABLE
;
665 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
,
666 p
->minimum
, 0, p
->address_length
,
668 } else if (p
->resource_type
== ACPI_IO_RANGE
)
669 pnp_register_port_resource(dev
, option_flags
, p
->minimum
,
670 p
->minimum
, 0, p
->address_length
,
671 IORESOURCE_IO_FIXED
);
674 struct acpipnp_parse_option_s
{
676 unsigned int option_flags
;
679 static __init acpi_status
pnpacpi_option_resource(struct acpi_resource
*res
,
683 struct acpipnp_parse_option_s
*parse_data
= data
;
684 struct pnp_dev
*dev
= parse_data
->dev
;
685 unsigned int option_flags
= parse_data
->option_flags
;
688 case ACPI_RESOURCE_TYPE_IRQ
:
689 pnpacpi_parse_irq_option(dev
, option_flags
, &res
->data
.irq
);
692 case ACPI_RESOURCE_TYPE_DMA
:
693 pnpacpi_parse_dma_option(dev
, option_flags
, &res
->data
.dma
);
696 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
697 switch (res
->data
.start_dpf
.compatibility_priority
) {
698 case ACPI_GOOD_CONFIGURATION
:
699 priority
= PNP_RES_PRIORITY_PREFERRED
;
702 case ACPI_ACCEPTABLE_CONFIGURATION
:
703 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
706 case ACPI_SUB_OPTIMAL_CONFIGURATION
:
707 priority
= PNP_RES_PRIORITY_FUNCTIONAL
;
710 priority
= PNP_RES_PRIORITY_INVALID
;
713 parse_data
->option_flags
= pnp_new_dependent_set(dev
, priority
);
716 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
717 parse_data
->option_flags
= 0;
720 case ACPI_RESOURCE_TYPE_IO
:
721 pnpacpi_parse_port_option(dev
, option_flags
, &res
->data
.io
);
724 case ACPI_RESOURCE_TYPE_FIXED_IO
:
725 pnpacpi_parse_fixed_port_option(dev
, option_flags
,
726 &res
->data
.fixed_io
);
729 case ACPI_RESOURCE_TYPE_VENDOR
:
730 case ACPI_RESOURCE_TYPE_END_TAG
:
733 case ACPI_RESOURCE_TYPE_MEMORY24
:
734 pnpacpi_parse_mem24_option(dev
, option_flags
,
735 &res
->data
.memory24
);
738 case ACPI_RESOURCE_TYPE_MEMORY32
:
739 pnpacpi_parse_mem32_option(dev
, option_flags
,
740 &res
->data
.memory32
);
743 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
744 pnpacpi_parse_fixed_mem32_option(dev
, option_flags
,
745 &res
->data
.fixed_memory32
);
748 case ACPI_RESOURCE_TYPE_ADDRESS16
:
749 case ACPI_RESOURCE_TYPE_ADDRESS32
:
750 case ACPI_RESOURCE_TYPE_ADDRESS64
:
751 pnpacpi_parse_address_option(dev
, option_flags
, res
);
754 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
755 pnpacpi_parse_ext_address_option(dev
, option_flags
, res
);
758 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
759 pnpacpi_parse_ext_irq_option(dev
, option_flags
,
760 &res
->data
.extended_irq
);
763 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
767 dev_warn(&dev
->dev
, "unknown resource type %d in _PRS\n",
775 int __init
pnpacpi_parse_resource_option_data(struct pnp_dev
*dev
)
777 struct acpi_device
*acpi_dev
= dev
->data
;
778 acpi_handle handle
= acpi_dev
->handle
;
780 struct acpipnp_parse_option_s parse_data
;
782 pnp_dbg(&dev
->dev
, "parse resource options\n");
784 parse_data
.dev
= dev
;
785 parse_data
.option_flags
= 0;
787 status
= acpi_walk_resources(handle
, METHOD_NAME__PRS
,
788 pnpacpi_option_resource
, &parse_data
);
790 if (ACPI_FAILURE(status
)) {
791 if (status
!= AE_NOT_FOUND
)
792 dev_err(&dev
->dev
, "can't evaluate _PRS: %d", status
);
798 static int pnpacpi_supported_resource(struct acpi_resource
*res
)
801 case ACPI_RESOURCE_TYPE_IRQ
:
802 case ACPI_RESOURCE_TYPE_DMA
:
803 case ACPI_RESOURCE_TYPE_IO
:
804 case ACPI_RESOURCE_TYPE_FIXED_IO
:
805 case ACPI_RESOURCE_TYPE_MEMORY24
:
806 case ACPI_RESOURCE_TYPE_MEMORY32
:
807 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
808 case ACPI_RESOURCE_TYPE_ADDRESS16
:
809 case ACPI_RESOURCE_TYPE_ADDRESS32
:
810 case ACPI_RESOURCE_TYPE_ADDRESS64
:
811 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
812 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
821 static acpi_status
pnpacpi_count_resources(struct acpi_resource
*res
,
826 if (pnpacpi_supported_resource(res
))
831 static acpi_status
pnpacpi_type_resources(struct acpi_resource
*res
, void *data
)
833 struct acpi_resource
**resource
= data
;
835 if (pnpacpi_supported_resource(res
)) {
836 (*resource
)->type
= res
->type
;
837 (*resource
)->length
= sizeof(struct acpi_resource
);
838 if (res
->type
== ACPI_RESOURCE_TYPE_IRQ
)
839 (*resource
)->data
.irq
.descriptor_length
=
840 res
->data
.irq
.descriptor_length
;
847 int pnpacpi_build_resource_template(struct pnp_dev
*dev
,
848 struct acpi_buffer
*buffer
)
850 struct acpi_device
*acpi_dev
= dev
->data
;
851 acpi_handle handle
= acpi_dev
->handle
;
852 struct acpi_resource
*resource
;
856 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
857 pnpacpi_count_resources
, &res_cnt
);
858 if (ACPI_FAILURE(status
)) {
859 dev_err(&dev
->dev
, "can't evaluate _CRS: %d\n", status
);
864 buffer
->length
= sizeof(struct acpi_resource
) * (res_cnt
+ 1) + 1;
865 buffer
->pointer
= kzalloc(buffer
->length
- 1, GFP_KERNEL
);
866 if (!buffer
->pointer
)
869 resource
= (struct acpi_resource
*)buffer
->pointer
;
870 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
871 pnpacpi_type_resources
, &resource
);
872 if (ACPI_FAILURE(status
)) {
873 kfree(buffer
->pointer
);
874 dev_err(&dev
->dev
, "can't evaluate _CRS: %d\n", status
);
877 /* resource will pointer the end resource now */
878 resource
->type
= ACPI_RESOURCE_TYPE_END_TAG
;
883 static void pnpacpi_encode_irq(struct pnp_dev
*dev
,
884 struct acpi_resource
*resource
,
887 struct acpi_resource_irq
*irq
= &resource
->data
.irq
;
888 int triggering
, polarity
, shareable
;
890 if (!pnp_resource_enabled(p
)) {
891 irq
->interrupt_count
= 0;
892 pnp_dbg(&dev
->dev
, " encode irq (%s)\n",
893 p
? "disabled" : "missing");
897 decode_irq_flags(dev
, p
->flags
, &triggering
, &polarity
, &shareable
);
898 irq
->triggering
= triggering
;
899 irq
->polarity
= polarity
;
900 irq
->sharable
= shareable
;
901 irq
->interrupt_count
= 1;
902 irq
->interrupts
[0] = p
->start
;
904 pnp_dbg(&dev
->dev
, " encode irq %d %s %s %s (%d-byte descriptor)\n",
906 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
907 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
908 irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive",
909 irq
->descriptor_length
);
912 static void pnpacpi_encode_ext_irq(struct pnp_dev
*dev
,
913 struct acpi_resource
*resource
,
916 struct acpi_resource_extended_irq
*extended_irq
= &resource
->data
.extended_irq
;
917 int triggering
, polarity
, shareable
;
919 if (!pnp_resource_enabled(p
)) {
920 extended_irq
->interrupt_count
= 0;
921 pnp_dbg(&dev
->dev
, " encode extended irq (%s)\n",
922 p
? "disabled" : "missing");
926 decode_irq_flags(dev
, p
->flags
, &triggering
, &polarity
, &shareable
);
927 extended_irq
->producer_consumer
= ACPI_CONSUMER
;
928 extended_irq
->triggering
= triggering
;
929 extended_irq
->polarity
= polarity
;
930 extended_irq
->sharable
= shareable
;
931 extended_irq
->interrupt_count
= 1;
932 extended_irq
->interrupts
[0] = p
->start
;
934 pnp_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
935 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
936 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
937 extended_irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
940 static void pnpacpi_encode_dma(struct pnp_dev
*dev
,
941 struct acpi_resource
*resource
,
944 struct acpi_resource_dma
*dma
= &resource
->data
.dma
;
946 if (!pnp_resource_enabled(p
)) {
947 dma
->channel_count
= 0;
948 pnp_dbg(&dev
->dev
, " encode dma (%s)\n",
949 p
? "disabled" : "missing");
953 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
954 switch (p
->flags
& IORESOURCE_DMA_SPEED_MASK
) {
955 case IORESOURCE_DMA_TYPEA
:
956 dma
->type
= ACPI_TYPE_A
;
958 case IORESOURCE_DMA_TYPEB
:
959 dma
->type
= ACPI_TYPE_B
;
961 case IORESOURCE_DMA_TYPEF
:
962 dma
->type
= ACPI_TYPE_F
;
965 dma
->type
= ACPI_COMPATIBILITY
;
968 switch (p
->flags
& IORESOURCE_DMA_TYPE_MASK
) {
969 case IORESOURCE_DMA_8BIT
:
970 dma
->transfer
= ACPI_TRANSFER_8
;
972 case IORESOURCE_DMA_8AND16BIT
:
973 dma
->transfer
= ACPI_TRANSFER_8_16
;
976 dma
->transfer
= ACPI_TRANSFER_16
;
979 dma
->bus_master
= !!(p
->flags
& IORESOURCE_DMA_MASTER
);
980 dma
->channel_count
= 1;
981 dma
->channels
[0] = p
->start
;
983 pnp_dbg(&dev
->dev
, " encode dma %d "
984 "type %#x transfer %#x master %d\n",
985 (int) p
->start
, dma
->type
, dma
->transfer
, dma
->bus_master
);
988 static void pnpacpi_encode_io(struct pnp_dev
*dev
,
989 struct acpi_resource
*resource
,
992 struct acpi_resource_io
*io
= &resource
->data
.io
;
994 if (pnp_resource_enabled(p
)) {
995 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
996 io
->io_decode
= (p
->flags
& IORESOURCE_IO_16BIT_ADDR
) ?
997 ACPI_DECODE_16
: ACPI_DECODE_10
;
998 io
->minimum
= p
->start
;
999 io
->maximum
= p
->end
;
1000 io
->alignment
= 0; /* Correct? */
1001 io
->address_length
= p
->end
- p
->start
+ 1;
1004 io
->address_length
= 0;
1007 pnp_dbg(&dev
->dev
, " encode io %#x-%#x decode %#x\n", io
->minimum
,
1008 io
->minimum
+ io
->address_length
- 1, io
->io_decode
);
1011 static void pnpacpi_encode_fixed_io(struct pnp_dev
*dev
,
1012 struct acpi_resource
*resource
,
1015 struct acpi_resource_fixed_io
*fixed_io
= &resource
->data
.fixed_io
;
1017 if (pnp_resource_enabled(p
)) {
1018 fixed_io
->address
= p
->start
;
1019 fixed_io
->address_length
= p
->end
- p
->start
+ 1;
1021 fixed_io
->address
= 0;
1022 fixed_io
->address_length
= 0;
1025 pnp_dbg(&dev
->dev
, " encode fixed_io %#x-%#x\n", fixed_io
->address
,
1026 fixed_io
->address
+ fixed_io
->address_length
- 1);
1029 static void pnpacpi_encode_mem24(struct pnp_dev
*dev
,
1030 struct acpi_resource
*resource
,
1033 struct acpi_resource_memory24
*memory24
= &resource
->data
.memory24
;
1035 if (pnp_resource_enabled(p
)) {
1036 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
1037 memory24
->write_protect
= p
->flags
& IORESOURCE_MEM_WRITEABLE
?
1038 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1039 memory24
->minimum
= p
->start
;
1040 memory24
->maximum
= p
->end
;
1041 memory24
->alignment
= 0;
1042 memory24
->address_length
= p
->end
- p
->start
+ 1;
1044 memory24
->minimum
= 0;
1045 memory24
->address_length
= 0;
1048 pnp_dbg(&dev
->dev
, " encode mem24 %#x-%#x write_protect %#x\n",
1050 memory24
->minimum
+ memory24
->address_length
- 1,
1051 memory24
->write_protect
);
1054 static void pnpacpi_encode_mem32(struct pnp_dev
*dev
,
1055 struct acpi_resource
*resource
,
1058 struct acpi_resource_memory32
*memory32
= &resource
->data
.memory32
;
1060 if (pnp_resource_enabled(p
)) {
1061 memory32
->write_protect
= p
->flags
& IORESOURCE_MEM_WRITEABLE
?
1062 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1063 memory32
->minimum
= p
->start
;
1064 memory32
->maximum
= p
->end
;
1065 memory32
->alignment
= 0;
1066 memory32
->address_length
= p
->end
- p
->start
+ 1;
1068 memory32
->minimum
= 0;
1069 memory32
->alignment
= 0;
1072 pnp_dbg(&dev
->dev
, " encode mem32 %#x-%#x write_protect %#x\n",
1074 memory32
->minimum
+ memory32
->address_length
- 1,
1075 memory32
->write_protect
);
1078 static void pnpacpi_encode_fixed_mem32(struct pnp_dev
*dev
,
1079 struct acpi_resource
*resource
,
1082 struct acpi_resource_fixed_memory32
*fixed_memory32
= &resource
->data
.fixed_memory32
;
1084 if (pnp_resource_enabled(p
)) {
1085 fixed_memory32
->write_protect
=
1086 p
->flags
& IORESOURCE_MEM_WRITEABLE
?
1087 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1088 fixed_memory32
->address
= p
->start
;
1089 fixed_memory32
->address_length
= p
->end
- p
->start
+ 1;
1091 fixed_memory32
->address
= 0;
1092 fixed_memory32
->address_length
= 0;
1095 pnp_dbg(&dev
->dev
, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
1096 fixed_memory32
->address
,
1097 fixed_memory32
->address
+ fixed_memory32
->address_length
- 1,
1098 fixed_memory32
->write_protect
);
1101 int pnpacpi_encode_resources(struct pnp_dev
*dev
, struct acpi_buffer
*buffer
)
1104 /* pnpacpi_build_resource_template allocates extra mem */
1105 int res_cnt
= (buffer
->length
- 1) / sizeof(struct acpi_resource
) - 1;
1106 struct acpi_resource
*resource
= buffer
->pointer
;
1107 int port
= 0, irq
= 0, dma
= 0, mem
= 0;
1109 pnp_dbg(&dev
->dev
, "encode %d resources\n", res_cnt
);
1110 while (i
< res_cnt
) {
1111 switch (resource
->type
) {
1112 case ACPI_RESOURCE_TYPE_IRQ
:
1113 pnpacpi_encode_irq(dev
, resource
,
1114 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1118 case ACPI_RESOURCE_TYPE_DMA
:
1119 pnpacpi_encode_dma(dev
, resource
,
1120 pnp_get_resource(dev
, IORESOURCE_DMA
, dma
));
1123 case ACPI_RESOURCE_TYPE_IO
:
1124 pnpacpi_encode_io(dev
, resource
,
1125 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1128 case ACPI_RESOURCE_TYPE_FIXED_IO
:
1129 pnpacpi_encode_fixed_io(dev
, resource
,
1130 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1133 case ACPI_RESOURCE_TYPE_MEMORY24
:
1134 pnpacpi_encode_mem24(dev
, resource
,
1135 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1138 case ACPI_RESOURCE_TYPE_MEMORY32
:
1139 pnpacpi_encode_mem32(dev
, resource
,
1140 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1143 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
1144 pnpacpi_encode_fixed_mem32(dev
, resource
,
1145 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1148 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
1149 pnpacpi_encode_ext_irq(dev
, resource
,
1150 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1153 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
1154 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
1155 case ACPI_RESOURCE_TYPE_VENDOR
:
1156 case ACPI_RESOURCE_TYPE_END_TAG
:
1157 case ACPI_RESOURCE_TYPE_ADDRESS16
:
1158 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1159 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1160 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
1161 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
1162 default: /* other type */
1163 dev_warn(&dev
->dev
, "can't encode unknown resource "
1164 "type %d\n", resource
->type
);