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
,
184 u64 end
= start
+ len
- 1;
186 if (io_decode
== ACPI_DECODE_16
)
187 flags
|= IORESOURCE_IO_16BIT_ADDR
;
188 if (len
== 0 || end
>= 0x10003)
189 flags
|= IORESOURCE_DISABLED
;
191 flags
|= IORESOURCE_WINDOW
;
193 pnp_add_io_resource(dev
, start
, end
, flags
);
197 * Device CSRs that do not appear in PCI config space should be described
198 * via ACPI. This would normally be done with Address Space Descriptors
199 * marked as "consumer-only," but old versions of Windows and Linux ignore
200 * the producer/consumer flag, so HP invented a vendor-defined resource to
201 * describe the location and size of CSR space.
203 static struct acpi_vendor_uuid hp_ccsr_uuid
= {
205 .data
= { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
206 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
209 static int vendor_resource_matches(struct pnp_dev
*dev
,
210 struct acpi_resource_vendor_typed
*vendor
,
211 struct acpi_vendor_uuid
*match
,
214 int uuid_len
= sizeof(vendor
->uuid
);
215 u8 uuid_subtype
= vendor
->uuid_subtype
;
216 u8
*uuid
= vendor
->uuid
;
219 /* byte_length includes uuid_subtype and uuid */
220 actual_len
= vendor
->byte_length
- uuid_len
- 1;
222 if (uuid_subtype
== match
->subtype
&&
223 uuid_len
== sizeof(match
->data
) &&
224 memcmp(uuid
, match
->data
, uuid_len
) == 0) {
225 if (expected_len
&& expected_len
!= actual_len
) {
226 dev_err(&dev
->dev
, "wrong vendor descriptor size; "
227 "expected %d, found %d bytes\n",
228 expected_len
, actual_len
);
238 static void pnpacpi_parse_allocated_vendor(struct pnp_dev
*dev
,
239 struct acpi_resource_vendor_typed
*vendor
)
241 if (vendor_resource_matches(dev
, vendor
, &hp_ccsr_uuid
, 16)) {
244 memcpy(&start
, vendor
->byte_data
, sizeof(start
));
245 memcpy(&length
, vendor
->byte_data
+ 8, sizeof(length
));
247 pnp_add_mem_resource(dev
, start
, start
+ length
- 1, 0);
251 static void pnpacpi_parse_allocated_memresource(struct pnp_dev
*dev
,
253 int write_protect
, int window
)
256 u64 end
= start
+ len
- 1;
259 flags
|= IORESOURCE_DISABLED
;
260 if (write_protect
== ACPI_READ_WRITE_MEMORY
)
261 flags
|= IORESOURCE_MEM_WRITEABLE
;
263 flags
|= IORESOURCE_WINDOW
;
265 pnp_add_mem_resource(dev
, start
, end
, flags
);
268 static void pnpacpi_parse_allocated_busresource(struct pnp_dev
*dev
,
271 u64 end
= start
+ len
- 1;
273 pnp_add_bus_resource(dev
, start
, end
);
276 static u64
addr_space_length(struct pnp_dev
*dev
, u64 min
, u64 max
, u64 len
)
280 max_len
= max
- min
+ 1;
285 * Per 6.4.3.5, _LEN cannot exceed _MAX - _MIN + 1, but some BIOSes
286 * don't do this correctly, e.g.,
287 * https://bugzilla.kernel.org/show_bug.cgi?id=15480
290 "resource length %#llx doesn't fit in %#llx-%#llx, trimming\n",
291 (unsigned long long) len
, (unsigned long long) min
,
292 (unsigned long long) max
);
296 static void pnpacpi_parse_allocated_address_space(struct pnp_dev
*dev
,
297 struct acpi_resource
*res
)
299 struct acpi_resource_address64 addr
, *p
= &addr
;
304 status
= acpi_resource_to_address64(res
, p
);
305 if (!ACPI_SUCCESS(status
)) {
306 dev_warn(&dev
->dev
, "failed to convert resource type %d\n",
311 len
= addr_space_length(dev
, p
->minimum
, p
->maximum
, p
->address_length
);
312 window
= (p
->producer_consumer
== ACPI_PRODUCER
) ? 1 : 0;
314 if (p
->resource_type
== ACPI_MEMORY_RANGE
)
315 pnpacpi_parse_allocated_memresource(dev
, p
->minimum
, len
,
316 p
->info
.mem
.write_protect
, window
);
317 else if (p
->resource_type
== ACPI_IO_RANGE
)
318 pnpacpi_parse_allocated_ioresource(dev
, p
->minimum
, len
,
319 p
->granularity
== 0xfff ? ACPI_DECODE_10
:
320 ACPI_DECODE_16
, window
);
321 else if (p
->resource_type
== ACPI_BUS_NUMBER_RANGE
)
322 pnpacpi_parse_allocated_busresource(dev
, p
->minimum
, len
);
325 static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev
*dev
,
326 struct acpi_resource
*res
)
328 struct acpi_resource_extended_address64
*p
= &res
->data
.ext_address64
;
332 len
= addr_space_length(dev
, p
->minimum
, p
->maximum
, p
->address_length
);
333 window
= (p
->producer_consumer
== ACPI_PRODUCER
) ? 1 : 0;
335 if (p
->resource_type
== ACPI_MEMORY_RANGE
)
336 pnpacpi_parse_allocated_memresource(dev
, p
->minimum
, len
,
337 p
->info
.mem
.write_protect
, window
);
338 else if (p
->resource_type
== ACPI_IO_RANGE
)
339 pnpacpi_parse_allocated_ioresource(dev
, p
->minimum
, len
,
340 p
->granularity
== 0xfff ? ACPI_DECODE_10
:
341 ACPI_DECODE_16
, window
);
342 else if (p
->resource_type
== ACPI_BUS_NUMBER_RANGE
)
343 pnpacpi_parse_allocated_busresource(dev
, p
->minimum
, len
);
346 static acpi_status
pnpacpi_allocated_resource(struct acpi_resource
*res
,
349 struct pnp_dev
*dev
= data
;
350 struct acpi_resource_irq
*irq
;
351 struct acpi_resource_dma
*dma
;
352 struct acpi_resource_io
*io
;
353 struct acpi_resource_fixed_io
*fixed_io
;
354 struct acpi_resource_vendor_typed
*vendor_typed
;
355 struct acpi_resource_memory24
*memory24
;
356 struct acpi_resource_memory32
*memory32
;
357 struct acpi_resource_fixed_memory32
*fixed_memory32
;
358 struct acpi_resource_extended_irq
*extended_irq
;
362 case ACPI_RESOURCE_TYPE_IRQ
:
364 * Per spec, only one interrupt per descriptor is allowed in
365 * _CRS, but some firmware violates this, so parse them all.
367 irq
= &res
->data
.irq
;
368 if (irq
->interrupt_count
== 0)
369 pnp_add_irq_resource(dev
, 0, IORESOURCE_DISABLED
);
371 for (i
= 0; i
< irq
->interrupt_count
; i
++) {
372 pnpacpi_parse_allocated_irqresource(dev
,
380 * The IRQ encoder puts a single interrupt in each
381 * descriptor, so if a _CRS descriptor has more than
382 * one interrupt, we won't be able to re-encode it.
384 if (pnp_can_write(dev
) && irq
->interrupt_count
> 1) {
385 dev_warn(&dev
->dev
, "multiple interrupts in "
386 "_CRS descriptor; configuration can't "
388 dev
->capabilities
&= ~PNP_WRITE
;
393 case ACPI_RESOURCE_TYPE_DMA
:
394 dma
= &res
->data
.dma
;
395 if (dma
->channel_count
> 0 && dma
->channels
[0] != (u8
) -1)
396 flags
= dma_flags(dev
, dma
->type
, dma
->bus_master
,
399 flags
= IORESOURCE_DISABLED
;
400 pnp_add_dma_resource(dev
, dma
->channels
[0], flags
);
403 case ACPI_RESOURCE_TYPE_IO
:
405 pnpacpi_parse_allocated_ioresource(dev
,
411 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
412 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
415 case ACPI_RESOURCE_TYPE_FIXED_IO
:
416 fixed_io
= &res
->data
.fixed_io
;
417 pnpacpi_parse_allocated_ioresource(dev
,
419 fixed_io
->address_length
,
423 case ACPI_RESOURCE_TYPE_VENDOR
:
424 vendor_typed
= &res
->data
.vendor_typed
;
425 pnpacpi_parse_allocated_vendor(dev
, vendor_typed
);
428 case ACPI_RESOURCE_TYPE_END_TAG
:
431 case ACPI_RESOURCE_TYPE_MEMORY24
:
432 memory24
= &res
->data
.memory24
;
433 pnpacpi_parse_allocated_memresource(dev
,
435 memory24
->address_length
,
436 memory24
->write_protect
, 0);
438 case ACPI_RESOURCE_TYPE_MEMORY32
:
439 memory32
= &res
->data
.memory32
;
440 pnpacpi_parse_allocated_memresource(dev
,
442 memory32
->address_length
,
443 memory32
->write_protect
, 0);
445 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
446 fixed_memory32
= &res
->data
.fixed_memory32
;
447 pnpacpi_parse_allocated_memresource(dev
,
448 fixed_memory32
->address
,
449 fixed_memory32
->address_length
,
450 fixed_memory32
->write_protect
, 0);
452 case ACPI_RESOURCE_TYPE_ADDRESS16
:
453 case ACPI_RESOURCE_TYPE_ADDRESS32
:
454 case ACPI_RESOURCE_TYPE_ADDRESS64
:
455 pnpacpi_parse_allocated_address_space(dev
, res
);
458 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
459 pnpacpi_parse_allocated_ext_address_space(dev
, res
);
462 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
463 extended_irq
= &res
->data
.extended_irq
;
465 if (extended_irq
->interrupt_count
== 0)
466 pnp_add_irq_resource(dev
, 0, IORESOURCE_DISABLED
);
468 for (i
= 0; i
< extended_irq
->interrupt_count
; i
++) {
469 pnpacpi_parse_allocated_irqresource(dev
,
470 extended_irq
->interrupts
[i
],
471 extended_irq
->triggering
,
472 extended_irq
->polarity
,
473 extended_irq
->sharable
);
477 * The IRQ encoder puts a single interrupt in each
478 * descriptor, so if a _CRS descriptor has more than
479 * one interrupt, we won't be able to re-encode it.
481 if (pnp_can_write(dev
) &&
482 extended_irq
->interrupt_count
> 1) {
483 dev_warn(&dev
->dev
, "multiple interrupts in "
484 "_CRS descriptor; configuration can't "
486 dev
->capabilities
&= ~PNP_WRITE
;
491 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
495 dev_warn(&dev
->dev
, "unknown resource type %d in _CRS\n",
503 int pnpacpi_parse_allocated_resource(struct pnp_dev
*dev
)
505 struct acpi_device
*acpi_dev
= dev
->data
;
506 acpi_handle handle
= acpi_dev
->handle
;
509 pnp_dbg(&dev
->dev
, "parse allocated resources\n");
511 pnp_init_resources(dev
);
513 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
514 pnpacpi_allocated_resource
, dev
);
516 if (ACPI_FAILURE(status
)) {
517 if (status
!= AE_NOT_FOUND
)
518 dev_err(&dev
->dev
, "can't evaluate _CRS: %d", status
);
524 static __init
void pnpacpi_parse_dma_option(struct pnp_dev
*dev
,
525 unsigned int option_flags
,
526 struct acpi_resource_dma
*p
)
529 unsigned char map
= 0, flags
;
531 if (p
->channel_count
== 0)
534 for (i
= 0; i
< p
->channel_count
; i
++)
535 map
|= 1 << p
->channels
[i
];
537 flags
= dma_flags(dev
, p
->type
, p
->bus_master
, p
->transfer
);
538 pnp_register_dma_resource(dev
, option_flags
, map
, flags
);
541 static __init
void pnpacpi_parse_irq_option(struct pnp_dev
*dev
,
542 unsigned int option_flags
,
543 struct acpi_resource_irq
*p
)
549 if (p
->interrupt_count
== 0)
552 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
553 for (i
= 0; i
< p
->interrupt_count
; i
++)
554 if (p
->interrupts
[i
])
555 __set_bit(p
->interrupts
[i
], map
.bits
);
557 flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
558 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
561 static __init
void pnpacpi_parse_ext_irq_option(struct pnp_dev
*dev
,
562 unsigned int option_flags
,
563 struct acpi_resource_extended_irq
*p
)
569 if (p
->interrupt_count
== 0)
572 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
573 for (i
= 0; i
< p
->interrupt_count
; i
++) {
574 if (p
->interrupts
[i
]) {
575 if (p
->interrupts
[i
] < PNP_IRQ_NR
)
576 __set_bit(p
->interrupts
[i
], map
.bits
);
578 dev_err(&dev
->dev
, "ignoring IRQ %d option "
579 "(too large for %d entry bitmap)\n",
580 p
->interrupts
[i
], PNP_IRQ_NR
);
584 flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
585 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
588 static __init
void pnpacpi_parse_port_option(struct pnp_dev
*dev
,
589 unsigned int option_flags
,
590 struct acpi_resource_io
*io
)
592 unsigned char flags
= 0;
594 if (io
->address_length
== 0)
597 if (io
->io_decode
== ACPI_DECODE_16
)
598 flags
= IORESOURCE_IO_16BIT_ADDR
;
599 pnp_register_port_resource(dev
, option_flags
, io
->minimum
, io
->maximum
,
600 io
->alignment
, io
->address_length
, flags
);
603 static __init
void pnpacpi_parse_fixed_port_option(struct pnp_dev
*dev
,
604 unsigned int option_flags
,
605 struct acpi_resource_fixed_io
*io
)
607 if (io
->address_length
== 0)
610 pnp_register_port_resource(dev
, option_flags
, io
->address
, io
->address
,
611 0, io
->address_length
, IORESOURCE_IO_FIXED
);
614 static __init
void pnpacpi_parse_mem24_option(struct pnp_dev
*dev
,
615 unsigned int option_flags
,
616 struct acpi_resource_memory24
*p
)
618 unsigned char flags
= 0;
620 if (p
->address_length
== 0)
623 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
624 flags
= IORESOURCE_MEM_WRITEABLE
;
625 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
, p
->maximum
,
626 p
->alignment
, p
->address_length
, flags
);
629 static __init
void pnpacpi_parse_mem32_option(struct pnp_dev
*dev
,
630 unsigned int option_flags
,
631 struct acpi_resource_memory32
*p
)
633 unsigned char flags
= 0;
635 if (p
->address_length
== 0)
638 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
639 flags
= IORESOURCE_MEM_WRITEABLE
;
640 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
, p
->maximum
,
641 p
->alignment
, p
->address_length
, flags
);
644 static __init
void pnpacpi_parse_fixed_mem32_option(struct pnp_dev
*dev
,
645 unsigned int option_flags
,
646 struct acpi_resource_fixed_memory32
*p
)
648 unsigned char flags
= 0;
650 if (p
->address_length
== 0)
653 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
654 flags
= IORESOURCE_MEM_WRITEABLE
;
655 pnp_register_mem_resource(dev
, option_flags
, p
->address
, p
->address
,
656 0, p
->address_length
, flags
);
659 static __init
void pnpacpi_parse_address_option(struct pnp_dev
*dev
,
660 unsigned int option_flags
,
661 struct acpi_resource
*r
)
663 struct acpi_resource_address64 addr
, *p
= &addr
;
665 unsigned char flags
= 0;
667 status
= acpi_resource_to_address64(r
, p
);
668 if (ACPI_FAILURE(status
)) {
669 dev_warn(&dev
->dev
, "can't convert resource type %d\n",
674 if (p
->address_length
== 0)
677 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
678 if (p
->info
.mem
.write_protect
== ACPI_READ_WRITE_MEMORY
)
679 flags
= IORESOURCE_MEM_WRITEABLE
;
680 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
,
681 p
->minimum
, 0, p
->address_length
,
683 } else if (p
->resource_type
== ACPI_IO_RANGE
)
684 pnp_register_port_resource(dev
, option_flags
, p
->minimum
,
685 p
->minimum
, 0, p
->address_length
,
686 IORESOURCE_IO_FIXED
);
689 static __init
void pnpacpi_parse_ext_address_option(struct pnp_dev
*dev
,
690 unsigned int option_flags
,
691 struct acpi_resource
*r
)
693 struct acpi_resource_extended_address64
*p
= &r
->data
.ext_address64
;
694 unsigned char flags
= 0;
696 if (p
->address_length
== 0)
699 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
700 if (p
->info
.mem
.write_protect
== ACPI_READ_WRITE_MEMORY
)
701 flags
= IORESOURCE_MEM_WRITEABLE
;
702 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
,
703 p
->minimum
, 0, p
->address_length
,
705 } else if (p
->resource_type
== ACPI_IO_RANGE
)
706 pnp_register_port_resource(dev
, option_flags
, p
->minimum
,
707 p
->minimum
, 0, p
->address_length
,
708 IORESOURCE_IO_FIXED
);
711 struct acpipnp_parse_option_s
{
713 unsigned int option_flags
;
716 static __init acpi_status
pnpacpi_option_resource(struct acpi_resource
*res
,
720 struct acpipnp_parse_option_s
*parse_data
= data
;
721 struct pnp_dev
*dev
= parse_data
->dev
;
722 unsigned int option_flags
= parse_data
->option_flags
;
725 case ACPI_RESOURCE_TYPE_IRQ
:
726 pnpacpi_parse_irq_option(dev
, option_flags
, &res
->data
.irq
);
729 case ACPI_RESOURCE_TYPE_DMA
:
730 pnpacpi_parse_dma_option(dev
, option_flags
, &res
->data
.dma
);
733 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
734 switch (res
->data
.start_dpf
.compatibility_priority
) {
735 case ACPI_GOOD_CONFIGURATION
:
736 priority
= PNP_RES_PRIORITY_PREFERRED
;
739 case ACPI_ACCEPTABLE_CONFIGURATION
:
740 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
743 case ACPI_SUB_OPTIMAL_CONFIGURATION
:
744 priority
= PNP_RES_PRIORITY_FUNCTIONAL
;
747 priority
= PNP_RES_PRIORITY_INVALID
;
750 parse_data
->option_flags
= pnp_new_dependent_set(dev
, priority
);
753 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
754 parse_data
->option_flags
= 0;
757 case ACPI_RESOURCE_TYPE_IO
:
758 pnpacpi_parse_port_option(dev
, option_flags
, &res
->data
.io
);
761 case ACPI_RESOURCE_TYPE_FIXED_IO
:
762 pnpacpi_parse_fixed_port_option(dev
, option_flags
,
763 &res
->data
.fixed_io
);
766 case ACPI_RESOURCE_TYPE_VENDOR
:
767 case ACPI_RESOURCE_TYPE_END_TAG
:
770 case ACPI_RESOURCE_TYPE_MEMORY24
:
771 pnpacpi_parse_mem24_option(dev
, option_flags
,
772 &res
->data
.memory24
);
775 case ACPI_RESOURCE_TYPE_MEMORY32
:
776 pnpacpi_parse_mem32_option(dev
, option_flags
,
777 &res
->data
.memory32
);
780 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
781 pnpacpi_parse_fixed_mem32_option(dev
, option_flags
,
782 &res
->data
.fixed_memory32
);
785 case ACPI_RESOURCE_TYPE_ADDRESS16
:
786 case ACPI_RESOURCE_TYPE_ADDRESS32
:
787 case ACPI_RESOURCE_TYPE_ADDRESS64
:
788 pnpacpi_parse_address_option(dev
, option_flags
, res
);
791 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
792 pnpacpi_parse_ext_address_option(dev
, option_flags
, res
);
795 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
796 pnpacpi_parse_ext_irq_option(dev
, option_flags
,
797 &res
->data
.extended_irq
);
800 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
804 dev_warn(&dev
->dev
, "unknown resource type %d in _PRS\n",
812 int __init
pnpacpi_parse_resource_option_data(struct pnp_dev
*dev
)
814 struct acpi_device
*acpi_dev
= dev
->data
;
815 acpi_handle handle
= acpi_dev
->handle
;
817 struct acpipnp_parse_option_s parse_data
;
819 pnp_dbg(&dev
->dev
, "parse resource options\n");
821 parse_data
.dev
= dev
;
822 parse_data
.option_flags
= 0;
824 status
= acpi_walk_resources(handle
, METHOD_NAME__PRS
,
825 pnpacpi_option_resource
, &parse_data
);
827 if (ACPI_FAILURE(status
)) {
828 if (status
!= AE_NOT_FOUND
)
829 dev_err(&dev
->dev
, "can't evaluate _PRS: %d", status
);
835 static int pnpacpi_supported_resource(struct acpi_resource
*res
)
838 case ACPI_RESOURCE_TYPE_IRQ
:
839 case ACPI_RESOURCE_TYPE_DMA
:
840 case ACPI_RESOURCE_TYPE_IO
:
841 case ACPI_RESOURCE_TYPE_FIXED_IO
:
842 case ACPI_RESOURCE_TYPE_MEMORY24
:
843 case ACPI_RESOURCE_TYPE_MEMORY32
:
844 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
845 case ACPI_RESOURCE_TYPE_ADDRESS16
:
846 case ACPI_RESOURCE_TYPE_ADDRESS32
:
847 case ACPI_RESOURCE_TYPE_ADDRESS64
:
848 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
849 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
858 static acpi_status
pnpacpi_count_resources(struct acpi_resource
*res
,
863 if (pnpacpi_supported_resource(res
))
868 static acpi_status
pnpacpi_type_resources(struct acpi_resource
*res
, void *data
)
870 struct acpi_resource
**resource
= data
;
872 if (pnpacpi_supported_resource(res
)) {
873 (*resource
)->type
= res
->type
;
874 (*resource
)->length
= sizeof(struct acpi_resource
);
875 if (res
->type
== ACPI_RESOURCE_TYPE_IRQ
)
876 (*resource
)->data
.irq
.descriptor_length
=
877 res
->data
.irq
.descriptor_length
;
884 int pnpacpi_build_resource_template(struct pnp_dev
*dev
,
885 struct acpi_buffer
*buffer
)
887 struct acpi_device
*acpi_dev
= dev
->data
;
888 acpi_handle handle
= acpi_dev
->handle
;
889 struct acpi_resource
*resource
;
893 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
894 pnpacpi_count_resources
, &res_cnt
);
895 if (ACPI_FAILURE(status
)) {
896 dev_err(&dev
->dev
, "can't evaluate _CRS: %d\n", status
);
901 buffer
->length
= sizeof(struct acpi_resource
) * (res_cnt
+ 1) + 1;
902 buffer
->pointer
= kzalloc(buffer
->length
- 1, GFP_KERNEL
);
903 if (!buffer
->pointer
)
906 resource
= (struct acpi_resource
*)buffer
->pointer
;
907 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
908 pnpacpi_type_resources
, &resource
);
909 if (ACPI_FAILURE(status
)) {
910 kfree(buffer
->pointer
);
911 dev_err(&dev
->dev
, "can't evaluate _CRS: %d\n", status
);
914 /* resource will pointer the end resource now */
915 resource
->type
= ACPI_RESOURCE_TYPE_END_TAG
;
920 static void pnpacpi_encode_irq(struct pnp_dev
*dev
,
921 struct acpi_resource
*resource
,
924 struct acpi_resource_irq
*irq
= &resource
->data
.irq
;
925 int triggering
, polarity
, shareable
;
927 if (!pnp_resource_enabled(p
)) {
928 irq
->interrupt_count
= 0;
929 pnp_dbg(&dev
->dev
, " encode irq (%s)\n",
930 p
? "disabled" : "missing");
934 decode_irq_flags(dev
, p
->flags
, &triggering
, &polarity
, &shareable
);
935 irq
->triggering
= triggering
;
936 irq
->polarity
= polarity
;
937 irq
->sharable
= shareable
;
938 irq
->interrupt_count
= 1;
939 irq
->interrupts
[0] = p
->start
;
941 pnp_dbg(&dev
->dev
, " encode irq %d %s %s %s (%d-byte descriptor)\n",
943 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
944 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
945 irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive",
946 irq
->descriptor_length
);
949 static void pnpacpi_encode_ext_irq(struct pnp_dev
*dev
,
950 struct acpi_resource
*resource
,
953 struct acpi_resource_extended_irq
*extended_irq
= &resource
->data
.extended_irq
;
954 int triggering
, polarity
, shareable
;
956 if (!pnp_resource_enabled(p
)) {
957 extended_irq
->interrupt_count
= 0;
958 pnp_dbg(&dev
->dev
, " encode extended irq (%s)\n",
959 p
? "disabled" : "missing");
963 decode_irq_flags(dev
, p
->flags
, &triggering
, &polarity
, &shareable
);
964 extended_irq
->producer_consumer
= ACPI_CONSUMER
;
965 extended_irq
->triggering
= triggering
;
966 extended_irq
->polarity
= polarity
;
967 extended_irq
->sharable
= shareable
;
968 extended_irq
->interrupt_count
= 1;
969 extended_irq
->interrupts
[0] = p
->start
;
971 pnp_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
972 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
973 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
974 extended_irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
977 static void pnpacpi_encode_dma(struct pnp_dev
*dev
,
978 struct acpi_resource
*resource
,
981 struct acpi_resource_dma
*dma
= &resource
->data
.dma
;
983 if (!pnp_resource_enabled(p
)) {
984 dma
->channel_count
= 0;
985 pnp_dbg(&dev
->dev
, " encode dma (%s)\n",
986 p
? "disabled" : "missing");
990 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
991 switch (p
->flags
& IORESOURCE_DMA_SPEED_MASK
) {
992 case IORESOURCE_DMA_TYPEA
:
993 dma
->type
= ACPI_TYPE_A
;
995 case IORESOURCE_DMA_TYPEB
:
996 dma
->type
= ACPI_TYPE_B
;
998 case IORESOURCE_DMA_TYPEF
:
999 dma
->type
= ACPI_TYPE_F
;
1002 dma
->type
= ACPI_COMPATIBILITY
;
1005 switch (p
->flags
& IORESOURCE_DMA_TYPE_MASK
) {
1006 case IORESOURCE_DMA_8BIT
:
1007 dma
->transfer
= ACPI_TRANSFER_8
;
1009 case IORESOURCE_DMA_8AND16BIT
:
1010 dma
->transfer
= ACPI_TRANSFER_8_16
;
1013 dma
->transfer
= ACPI_TRANSFER_16
;
1016 dma
->bus_master
= !!(p
->flags
& IORESOURCE_DMA_MASTER
);
1017 dma
->channel_count
= 1;
1018 dma
->channels
[0] = p
->start
;
1020 pnp_dbg(&dev
->dev
, " encode dma %d "
1021 "type %#x transfer %#x master %d\n",
1022 (int) p
->start
, dma
->type
, dma
->transfer
, dma
->bus_master
);
1025 static void pnpacpi_encode_io(struct pnp_dev
*dev
,
1026 struct acpi_resource
*resource
,
1029 struct acpi_resource_io
*io
= &resource
->data
.io
;
1031 if (pnp_resource_enabled(p
)) {
1032 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
1033 io
->io_decode
= (p
->flags
& IORESOURCE_IO_16BIT_ADDR
) ?
1034 ACPI_DECODE_16
: ACPI_DECODE_10
;
1035 io
->minimum
= p
->start
;
1036 io
->maximum
= p
->end
;
1037 io
->alignment
= 0; /* Correct? */
1038 io
->address_length
= p
->end
- p
->start
+ 1;
1041 io
->address_length
= 0;
1044 pnp_dbg(&dev
->dev
, " encode io %#x-%#x decode %#x\n", io
->minimum
,
1045 io
->minimum
+ io
->address_length
- 1, io
->io_decode
);
1048 static void pnpacpi_encode_fixed_io(struct pnp_dev
*dev
,
1049 struct acpi_resource
*resource
,
1052 struct acpi_resource_fixed_io
*fixed_io
= &resource
->data
.fixed_io
;
1054 if (pnp_resource_enabled(p
)) {
1055 fixed_io
->address
= p
->start
;
1056 fixed_io
->address_length
= p
->end
- p
->start
+ 1;
1058 fixed_io
->address
= 0;
1059 fixed_io
->address_length
= 0;
1062 pnp_dbg(&dev
->dev
, " encode fixed_io %#x-%#x\n", fixed_io
->address
,
1063 fixed_io
->address
+ fixed_io
->address_length
- 1);
1066 static void pnpacpi_encode_mem24(struct pnp_dev
*dev
,
1067 struct acpi_resource
*resource
,
1070 struct acpi_resource_memory24
*memory24
= &resource
->data
.memory24
;
1072 if (pnp_resource_enabled(p
)) {
1073 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
1074 memory24
->write_protect
= p
->flags
& IORESOURCE_MEM_WRITEABLE
?
1075 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1076 memory24
->minimum
= p
->start
;
1077 memory24
->maximum
= p
->end
;
1078 memory24
->alignment
= 0;
1079 memory24
->address_length
= p
->end
- p
->start
+ 1;
1081 memory24
->minimum
= 0;
1082 memory24
->address_length
= 0;
1085 pnp_dbg(&dev
->dev
, " encode mem24 %#x-%#x write_protect %#x\n",
1087 memory24
->minimum
+ memory24
->address_length
- 1,
1088 memory24
->write_protect
);
1091 static void pnpacpi_encode_mem32(struct pnp_dev
*dev
,
1092 struct acpi_resource
*resource
,
1095 struct acpi_resource_memory32
*memory32
= &resource
->data
.memory32
;
1097 if (pnp_resource_enabled(p
)) {
1098 memory32
->write_protect
= p
->flags
& IORESOURCE_MEM_WRITEABLE
?
1099 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1100 memory32
->minimum
= p
->start
;
1101 memory32
->maximum
= p
->end
;
1102 memory32
->alignment
= 0;
1103 memory32
->address_length
= p
->end
- p
->start
+ 1;
1105 memory32
->minimum
= 0;
1106 memory32
->alignment
= 0;
1109 pnp_dbg(&dev
->dev
, " encode mem32 %#x-%#x write_protect %#x\n",
1111 memory32
->minimum
+ memory32
->address_length
- 1,
1112 memory32
->write_protect
);
1115 static void pnpacpi_encode_fixed_mem32(struct pnp_dev
*dev
,
1116 struct acpi_resource
*resource
,
1119 struct acpi_resource_fixed_memory32
*fixed_memory32
= &resource
->data
.fixed_memory32
;
1121 if (pnp_resource_enabled(p
)) {
1122 fixed_memory32
->write_protect
=
1123 p
->flags
& IORESOURCE_MEM_WRITEABLE
?
1124 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1125 fixed_memory32
->address
= p
->start
;
1126 fixed_memory32
->address_length
= p
->end
- p
->start
+ 1;
1128 fixed_memory32
->address
= 0;
1129 fixed_memory32
->address_length
= 0;
1132 pnp_dbg(&dev
->dev
, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
1133 fixed_memory32
->address
,
1134 fixed_memory32
->address
+ fixed_memory32
->address_length
- 1,
1135 fixed_memory32
->write_protect
);
1138 int pnpacpi_encode_resources(struct pnp_dev
*dev
, struct acpi_buffer
*buffer
)
1141 /* pnpacpi_build_resource_template allocates extra mem */
1142 int res_cnt
= (buffer
->length
- 1) / sizeof(struct acpi_resource
) - 1;
1143 struct acpi_resource
*resource
= buffer
->pointer
;
1144 int port
= 0, irq
= 0, dma
= 0, mem
= 0;
1146 pnp_dbg(&dev
->dev
, "encode %d resources\n", res_cnt
);
1147 while (i
< res_cnt
) {
1148 switch (resource
->type
) {
1149 case ACPI_RESOURCE_TYPE_IRQ
:
1150 pnpacpi_encode_irq(dev
, resource
,
1151 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1155 case ACPI_RESOURCE_TYPE_DMA
:
1156 pnpacpi_encode_dma(dev
, resource
,
1157 pnp_get_resource(dev
, IORESOURCE_DMA
, dma
));
1160 case ACPI_RESOURCE_TYPE_IO
:
1161 pnpacpi_encode_io(dev
, resource
,
1162 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1165 case ACPI_RESOURCE_TYPE_FIXED_IO
:
1166 pnpacpi_encode_fixed_io(dev
, resource
,
1167 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1170 case ACPI_RESOURCE_TYPE_MEMORY24
:
1171 pnpacpi_encode_mem24(dev
, resource
,
1172 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1175 case ACPI_RESOURCE_TYPE_MEMORY32
:
1176 pnpacpi_encode_mem32(dev
, resource
,
1177 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1180 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
1181 pnpacpi_encode_fixed_mem32(dev
, resource
,
1182 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1185 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
1186 pnpacpi_encode_ext_irq(dev
, resource
,
1187 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1190 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
1191 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
1192 case ACPI_RESOURCE_TYPE_VENDOR
:
1193 case ACPI_RESOURCE_TYPE_END_TAG
:
1194 case ACPI_RESOURCE_TYPE_ADDRESS16
:
1195 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1196 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1197 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
1198 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
1199 default: /* other type */
1200 dev_warn(&dev
->dev
, "can't encode unknown resource "
1201 "type %d\n", resource
->type
);