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>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/kernel.h>
22 #include <linux/acpi.h>
23 #include <linux/pci.h>
24 #include <linux/pnp.h>
29 #define valid_IRQ(i) (1)
31 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
37 static int irq_flags(int triggering
, int polarity
, int shareable
)
41 if (triggering
== ACPI_LEVEL_SENSITIVE
) {
42 if (polarity
== ACPI_ACTIVE_LOW
)
43 flags
= IORESOURCE_IRQ_LOWLEVEL
;
45 flags
= IORESOURCE_IRQ_HIGHLEVEL
;
47 if (polarity
== ACPI_ACTIVE_LOW
)
48 flags
= IORESOURCE_IRQ_LOWEDGE
;
50 flags
= IORESOURCE_IRQ_HIGHEDGE
;
54 flags
|= IORESOURCE_IRQ_SHAREABLE
;
59 static void decode_irq_flags(int flag
, int *triggering
, int *polarity
)
62 case IORESOURCE_IRQ_LOWLEVEL
:
63 *triggering
= ACPI_LEVEL_SENSITIVE
;
64 *polarity
= ACPI_ACTIVE_LOW
;
66 case IORESOURCE_IRQ_HIGHLEVEL
:
67 *triggering
= ACPI_LEVEL_SENSITIVE
;
68 *polarity
= ACPI_ACTIVE_HIGH
;
70 case IORESOURCE_IRQ_LOWEDGE
:
71 *triggering
= ACPI_EDGE_SENSITIVE
;
72 *polarity
= ACPI_ACTIVE_LOW
;
74 case IORESOURCE_IRQ_HIGHEDGE
:
75 *triggering
= ACPI_EDGE_SENSITIVE
;
76 *polarity
= ACPI_ACTIVE_HIGH
;
81 static void pnpacpi_parse_allocated_irqresource(struct pnp_dev
*dev
,
82 u32 gsi
, int triggering
,
83 int polarity
, int shareable
)
85 struct pnp_resource_table
*res
= dev
->res
;
89 static unsigned char warned
;
94 while (!(res
->irq_resource
[i
].flags
& IORESOURCE_UNSET
) &&
97 if (i
>= PNP_MAX_IRQ
) {
99 printk(KERN_WARNING
"pnpacpi: exceeded the max number"
100 " of IRQ resources: %d\n", PNP_MAX_IRQ
);
106 * in IO-APIC mode, use overrided attribute. Two reasons:
107 * 1. BIOS bug in DSDT
108 * 2. BIOS uses IO-APIC mode Interrupt Source Override
110 if (!acpi_get_override_irq(gsi
, &t
, &p
)) {
111 t
= t
? ACPI_LEVEL_SENSITIVE
: ACPI_EDGE_SENSITIVE
;
112 p
= p
? ACPI_ACTIVE_LOW
: ACPI_ACTIVE_HIGH
;
114 if (triggering
!= t
|| polarity
!= p
) {
115 dev_warn(&dev
->dev
, "IRQ %d override to %s, %s\n",
116 gsi
, t
? "edge":"level", p
? "low":"high");
122 res
->irq_resource
[i
].flags
= IORESOURCE_IRQ
; // Also clears _UNSET flag
123 res
->irq_resource
[i
].flags
|= irq_flags(triggering
, polarity
, shareable
);
124 irq
= acpi_register_gsi(gsi
, triggering
, polarity
);
126 res
->irq_resource
[i
].flags
|= IORESOURCE_DISABLED
;
130 res
->irq_resource
[i
].start
= irq
;
131 res
->irq_resource
[i
].end
= irq
;
132 pcibios_penalize_isa_irq(irq
, 1);
135 static int dma_flags(int type
, int bus_master
, int transfer
)
140 flags
|= IORESOURCE_DMA_MASTER
;
142 case ACPI_COMPATIBILITY
:
143 flags
|= IORESOURCE_DMA_COMPATIBLE
;
146 flags
|= IORESOURCE_DMA_TYPEA
;
149 flags
|= IORESOURCE_DMA_TYPEB
;
152 flags
|= IORESOURCE_DMA_TYPEF
;
155 /* Set a default value ? */
156 flags
|= IORESOURCE_DMA_COMPATIBLE
;
157 pnp_err("Invalid DMA type");
160 case ACPI_TRANSFER_8
:
161 flags
|= IORESOURCE_DMA_8BIT
;
163 case ACPI_TRANSFER_8_16
:
164 flags
|= IORESOURCE_DMA_8AND16BIT
;
166 case ACPI_TRANSFER_16
:
167 flags
|= IORESOURCE_DMA_16BIT
;
170 /* Set a default value ? */
171 flags
|= IORESOURCE_DMA_8AND16BIT
;
172 pnp_err("Invalid DMA transfer type");
178 static void pnpacpi_parse_allocated_dmaresource(struct pnp_dev
*dev
,
181 struct pnp_resource_table
*res
= dev
->res
;
183 static unsigned char warned
;
185 while (i
< PNP_MAX_DMA
&&
186 !(res
->dma_resource
[i
].flags
& IORESOURCE_UNSET
))
188 if (i
< PNP_MAX_DMA
) {
189 res
->dma_resource
[i
].flags
= IORESOURCE_DMA
; // Also clears _UNSET flag
190 res
->dma_resource
[i
].flags
|= flags
;
192 res
->dma_resource
[i
].flags
|= IORESOURCE_DISABLED
;
195 res
->dma_resource
[i
].start
= dma
;
196 res
->dma_resource
[i
].end
= dma
;
197 } else if (!warned
) {
198 printk(KERN_WARNING
"pnpacpi: exceeded the max number of DMA "
199 "resources: %d \n", PNP_MAX_DMA
);
204 static void pnpacpi_parse_allocated_ioresource(struct pnp_dev
*dev
,
205 u64 io
, u64 len
, int io_decode
)
207 struct pnp_resource_table
*res
= dev
->res
;
209 static unsigned char warned
;
211 while (!(res
->port_resource
[i
].flags
& IORESOURCE_UNSET
) &&
214 if (i
< PNP_MAX_PORT
) {
215 res
->port_resource
[i
].flags
= IORESOURCE_IO
; // Also clears _UNSET flag
216 if (io_decode
== ACPI_DECODE_16
)
217 res
->port_resource
[i
].flags
|= PNP_PORT_FLAG_16BITADDR
;
218 if (len
<= 0 || (io
+ len
- 1) >= 0x10003) {
219 res
->port_resource
[i
].flags
|= IORESOURCE_DISABLED
;
222 res
->port_resource
[i
].start
= io
;
223 res
->port_resource
[i
].end
= io
+ len
- 1;
224 } else if (!warned
) {
225 printk(KERN_WARNING
"pnpacpi: exceeded the max number of IO "
226 "resources: %d \n", PNP_MAX_PORT
);
231 static void pnpacpi_parse_allocated_memresource(struct pnp_dev
*dev
,
235 struct pnp_resource_table
*res
= dev
->res
;
237 static unsigned char warned
;
239 while (!(res
->mem_resource
[i
].flags
& IORESOURCE_UNSET
) &&
242 if (i
< PNP_MAX_MEM
) {
243 res
->mem_resource
[i
].flags
= IORESOURCE_MEM
; // Also clears _UNSET flag
245 res
->mem_resource
[i
].flags
|= IORESOURCE_DISABLED
;
248 if (write_protect
== ACPI_READ_WRITE_MEMORY
)
249 res
->mem_resource
[i
].flags
|= IORESOURCE_MEM_WRITEABLE
;
251 res
->mem_resource
[i
].start
= mem
;
252 res
->mem_resource
[i
].end
= mem
+ len
- 1;
253 } else if (!warned
) {
254 printk(KERN_WARNING
"pnpacpi: exceeded the max number of mem "
255 "resources: %d\n", PNP_MAX_MEM
);
260 static void pnpacpi_parse_allocated_address_space(struct pnp_dev
*dev
,
261 struct acpi_resource
*res
)
263 struct acpi_resource_address64 addr
, *p
= &addr
;
266 status
= acpi_resource_to_address64(res
, p
);
267 if (!ACPI_SUCCESS(status
)) {
268 dev_warn(&dev
->dev
, "failed to convert resource type %d\n",
273 if (p
->producer_consumer
== ACPI_PRODUCER
)
276 if (p
->resource_type
== ACPI_MEMORY_RANGE
)
277 pnpacpi_parse_allocated_memresource(dev
,
278 p
->minimum
, p
->address_length
,
279 p
->info
.mem
.write_protect
);
280 else if (p
->resource_type
== ACPI_IO_RANGE
)
281 pnpacpi_parse_allocated_ioresource(dev
,
282 p
->minimum
, p
->address_length
,
283 p
->granularity
== 0xfff ? ACPI_DECODE_10
:
287 static acpi_status
pnpacpi_allocated_resource(struct acpi_resource
*res
,
290 struct pnp_dev
*dev
= data
;
291 struct acpi_resource_irq
*irq
;
292 struct acpi_resource_dma
*dma
;
293 struct acpi_resource_io
*io
;
294 struct acpi_resource_fixed_io
*fixed_io
;
295 struct acpi_resource_memory24
*memory24
;
296 struct acpi_resource_memory32
*memory32
;
297 struct acpi_resource_fixed_memory32
*fixed_memory32
;
298 struct acpi_resource_extended_irq
*extended_irq
;
302 case ACPI_RESOURCE_TYPE_IRQ
:
304 * Per spec, only one interrupt per descriptor is allowed in
305 * _CRS, but some firmware violates this, so parse them all.
307 irq
= &res
->data
.irq
;
308 for (i
= 0; i
< irq
->interrupt_count
; i
++) {
309 pnpacpi_parse_allocated_irqresource(dev
,
317 case ACPI_RESOURCE_TYPE_DMA
:
318 dma
= &res
->data
.dma
;
319 if (dma
->channel_count
> 0)
320 pnpacpi_parse_allocated_dmaresource(dev
,
322 dma_flags(dma
->type
, dma
->bus_master
,
326 case ACPI_RESOURCE_TYPE_IO
:
328 pnpacpi_parse_allocated_ioresource(dev
,
334 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
335 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
338 case ACPI_RESOURCE_TYPE_FIXED_IO
:
339 fixed_io
= &res
->data
.fixed_io
;
340 pnpacpi_parse_allocated_ioresource(dev
,
342 fixed_io
->address_length
,
346 case ACPI_RESOURCE_TYPE_VENDOR
:
349 case ACPI_RESOURCE_TYPE_END_TAG
:
352 case ACPI_RESOURCE_TYPE_MEMORY24
:
353 memory24
= &res
->data
.memory24
;
354 pnpacpi_parse_allocated_memresource(dev
,
356 memory24
->address_length
,
357 memory24
->write_protect
);
359 case ACPI_RESOURCE_TYPE_MEMORY32
:
360 memory32
= &res
->data
.memory32
;
361 pnpacpi_parse_allocated_memresource(dev
,
363 memory32
->address_length
,
364 memory32
->write_protect
);
366 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
367 fixed_memory32
= &res
->data
.fixed_memory32
;
368 pnpacpi_parse_allocated_memresource(dev
,
369 fixed_memory32
->address
,
370 fixed_memory32
->address_length
,
371 fixed_memory32
->write_protect
);
373 case ACPI_RESOURCE_TYPE_ADDRESS16
:
374 case ACPI_RESOURCE_TYPE_ADDRESS32
:
375 case ACPI_RESOURCE_TYPE_ADDRESS64
:
376 pnpacpi_parse_allocated_address_space(dev
, res
);
379 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
380 if (res
->data
.ext_address64
.producer_consumer
== ACPI_PRODUCER
)
384 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
385 extended_irq
= &res
->data
.extended_irq
;
386 if (extended_irq
->producer_consumer
== ACPI_PRODUCER
)
389 for (i
= 0; i
< extended_irq
->interrupt_count
; i
++) {
390 pnpacpi_parse_allocated_irqresource(dev
,
391 extended_irq
->interrupts
[i
],
392 extended_irq
->triggering
,
393 extended_irq
->polarity
,
394 extended_irq
->sharable
);
398 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
402 dev_warn(&dev
->dev
, "unknown resource type %d in _CRS\n",
410 acpi_status
pnpacpi_parse_allocated_resource(struct pnp_dev
*dev
)
412 acpi_handle handle
= dev
->data
;
414 dev_dbg(&dev
->dev
, "parse allocated resources\n");
416 pnp_init_resources(dev
);
418 return acpi_walk_resources(handle
, METHOD_NAME__CRS
,
419 pnpacpi_allocated_resource
, dev
);
422 static __init
void pnpacpi_parse_dma_option(struct pnp_dev
*dev
,
423 struct pnp_option
*option
,
424 struct acpi_resource_dma
*p
)
429 if (p
->channel_count
== 0)
431 dma
= kzalloc(sizeof(struct pnp_dma
), GFP_KERNEL
);
435 for (i
= 0; i
< p
->channel_count
; i
++)
436 dma
->map
|= 1 << p
->channels
[i
];
438 dma
->flags
= dma_flags(p
->type
, p
->bus_master
, p
->transfer
);
440 pnp_register_dma_resource(dev
, option
, dma
);
443 static __init
void pnpacpi_parse_irq_option(struct pnp_dev
*dev
,
444 struct pnp_option
*option
,
445 struct acpi_resource_irq
*p
)
450 if (p
->interrupt_count
== 0)
452 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
456 for (i
= 0; i
< p
->interrupt_count
; i
++)
457 if (p
->interrupts
[i
])
458 __set_bit(p
->interrupts
[i
], irq
->map
);
459 irq
->flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
461 pnp_register_irq_resource(dev
, option
, irq
);
464 static __init
void pnpacpi_parse_ext_irq_option(struct pnp_dev
*dev
,
465 struct pnp_option
*option
,
466 struct acpi_resource_extended_irq
*p
)
471 if (p
->interrupt_count
== 0)
473 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
477 for (i
= 0; i
< p
->interrupt_count
; i
++)
478 if (p
->interrupts
[i
])
479 __set_bit(p
->interrupts
[i
], irq
->map
);
480 irq
->flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
482 pnp_register_irq_resource(dev
, option
, irq
);
485 static __init
void pnpacpi_parse_port_option(struct pnp_dev
*dev
,
486 struct pnp_option
*option
,
487 struct acpi_resource_io
*io
)
489 struct pnp_port
*port
;
491 if (io
->address_length
== 0)
493 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
496 port
->min
= io
->minimum
;
497 port
->max
= io
->maximum
;
498 port
->align
= io
->alignment
;
499 port
->size
= io
->address_length
;
500 port
->flags
= ACPI_DECODE_16
== io
->io_decode
?
501 PNP_PORT_FLAG_16BITADDR
: 0;
502 pnp_register_port_resource(dev
, option
, port
);
505 static __init
void pnpacpi_parse_fixed_port_option(struct pnp_dev
*dev
,
506 struct pnp_option
*option
,
507 struct acpi_resource_fixed_io
*io
)
509 struct pnp_port
*port
;
511 if (io
->address_length
== 0)
513 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
516 port
->min
= port
->max
= io
->address
;
517 port
->size
= io
->address_length
;
519 port
->flags
= PNP_PORT_FLAG_FIXED
;
520 pnp_register_port_resource(dev
, option
, port
);
523 static __init
void pnpacpi_parse_mem24_option(struct pnp_dev
*dev
,
524 struct pnp_option
*option
,
525 struct acpi_resource_memory24
*p
)
529 if (p
->address_length
== 0)
531 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
534 mem
->min
= p
->minimum
;
535 mem
->max
= p
->maximum
;
536 mem
->align
= p
->alignment
;
537 mem
->size
= p
->address_length
;
539 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
540 IORESOURCE_MEM_WRITEABLE
: 0;
542 pnp_register_mem_resource(dev
, option
, mem
);
545 static __init
void pnpacpi_parse_mem32_option(struct pnp_dev
*dev
,
546 struct pnp_option
*option
,
547 struct acpi_resource_memory32
*p
)
551 if (p
->address_length
== 0)
553 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
556 mem
->min
= p
->minimum
;
557 mem
->max
= p
->maximum
;
558 mem
->align
= p
->alignment
;
559 mem
->size
= p
->address_length
;
561 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
562 IORESOURCE_MEM_WRITEABLE
: 0;
564 pnp_register_mem_resource(dev
, option
, mem
);
567 static __init
void pnpacpi_parse_fixed_mem32_option(struct pnp_dev
*dev
,
568 struct pnp_option
*option
,
569 struct acpi_resource_fixed_memory32
*p
)
573 if (p
->address_length
== 0)
575 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
578 mem
->min
= mem
->max
= p
->address
;
579 mem
->size
= p
->address_length
;
582 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
583 IORESOURCE_MEM_WRITEABLE
: 0;
585 pnp_register_mem_resource(dev
, option
, mem
);
588 static __init
void pnpacpi_parse_address_option(struct pnp_dev
*dev
,
589 struct pnp_option
*option
,
590 struct acpi_resource
*r
)
592 struct acpi_resource_address64 addr
, *p
= &addr
;
595 struct pnp_port
*port
;
597 status
= acpi_resource_to_address64(r
, p
);
598 if (!ACPI_SUCCESS(status
)) {
599 pnp_warn("PnPACPI: failed to convert resource type %d",
604 if (p
->address_length
== 0)
607 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
608 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
611 mem
->min
= mem
->max
= p
->minimum
;
612 mem
->size
= p
->address_length
;
614 mem
->flags
= (p
->info
.mem
.write_protect
==
615 ACPI_READ_WRITE_MEMORY
) ? IORESOURCE_MEM_WRITEABLE
617 pnp_register_mem_resource(dev
, option
, mem
);
618 } else if (p
->resource_type
== ACPI_IO_RANGE
) {
619 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
622 port
->min
= port
->max
= p
->minimum
;
623 port
->size
= p
->address_length
;
625 port
->flags
= PNP_PORT_FLAG_FIXED
;
626 pnp_register_port_resource(dev
, option
, port
);
630 struct acpipnp_parse_option_s
{
631 struct pnp_option
*option
;
632 struct pnp_option
*option_independent
;
636 static __init acpi_status
pnpacpi_option_resource(struct acpi_resource
*res
,
640 struct acpipnp_parse_option_s
*parse_data
= data
;
641 struct pnp_dev
*dev
= parse_data
->dev
;
642 struct pnp_option
*option
= parse_data
->option
;
645 case ACPI_RESOURCE_TYPE_IRQ
:
646 pnpacpi_parse_irq_option(dev
, option
, &res
->data
.irq
);
649 case ACPI_RESOURCE_TYPE_DMA
:
650 pnpacpi_parse_dma_option(dev
, option
, &res
->data
.dma
);
653 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
654 switch (res
->data
.start_dpf
.compatibility_priority
) {
655 case ACPI_GOOD_CONFIGURATION
:
656 priority
= PNP_RES_PRIORITY_PREFERRED
;
659 case ACPI_ACCEPTABLE_CONFIGURATION
:
660 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
663 case ACPI_SUB_OPTIMAL_CONFIGURATION
:
664 priority
= PNP_RES_PRIORITY_FUNCTIONAL
;
667 priority
= PNP_RES_PRIORITY_INVALID
;
670 /* TBD: Consider performance/robustness bits */
671 option
= pnp_register_dependent_option(dev
, priority
);
674 parse_data
->option
= option
;
677 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
678 /*only one EndDependentFn is allowed */
679 if (!parse_data
->option_independent
) {
680 dev_warn(&dev
->dev
, "more than one EndDependentFn "
684 parse_data
->option
= parse_data
->option_independent
;
685 parse_data
->option_independent
= NULL
;
686 dev_dbg(&dev
->dev
, "end dependent options\n");
689 case ACPI_RESOURCE_TYPE_IO
:
690 pnpacpi_parse_port_option(dev
, option
, &res
->data
.io
);
693 case ACPI_RESOURCE_TYPE_FIXED_IO
:
694 pnpacpi_parse_fixed_port_option(dev
, option
,
695 &res
->data
.fixed_io
);
698 case ACPI_RESOURCE_TYPE_VENDOR
:
699 case ACPI_RESOURCE_TYPE_END_TAG
:
702 case ACPI_RESOURCE_TYPE_MEMORY24
:
703 pnpacpi_parse_mem24_option(dev
, option
, &res
->data
.memory24
);
706 case ACPI_RESOURCE_TYPE_MEMORY32
:
707 pnpacpi_parse_mem32_option(dev
, option
, &res
->data
.memory32
);
710 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
711 pnpacpi_parse_fixed_mem32_option(dev
, option
,
712 &res
->data
.fixed_memory32
);
715 case ACPI_RESOURCE_TYPE_ADDRESS16
:
716 case ACPI_RESOURCE_TYPE_ADDRESS32
:
717 case ACPI_RESOURCE_TYPE_ADDRESS64
:
718 pnpacpi_parse_address_option(dev
, option
, res
);
721 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
724 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
725 pnpacpi_parse_ext_irq_option(dev
, option
,
726 &res
->data
.extended_irq
);
729 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
733 dev_warn(&dev
->dev
, "unknown resource type %d in _PRS\n",
741 acpi_status __init
pnpacpi_parse_resource_option_data(struct pnp_dev
*dev
)
743 acpi_handle handle
= dev
->data
;
745 struct acpipnp_parse_option_s parse_data
;
747 dev_dbg(&dev
->dev
, "parse resource options\n");
749 parse_data
.option
= pnp_register_independent_option(dev
);
750 if (!parse_data
.option
)
752 parse_data
.option_independent
= parse_data
.option
;
753 parse_data
.dev
= dev
;
754 status
= acpi_walk_resources(handle
, METHOD_NAME__PRS
,
755 pnpacpi_option_resource
, &parse_data
);
760 static int pnpacpi_supported_resource(struct acpi_resource
*res
)
763 case ACPI_RESOURCE_TYPE_IRQ
:
764 case ACPI_RESOURCE_TYPE_DMA
:
765 case ACPI_RESOURCE_TYPE_IO
:
766 case ACPI_RESOURCE_TYPE_FIXED_IO
:
767 case ACPI_RESOURCE_TYPE_MEMORY24
:
768 case ACPI_RESOURCE_TYPE_MEMORY32
:
769 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
770 case ACPI_RESOURCE_TYPE_ADDRESS16
:
771 case ACPI_RESOURCE_TYPE_ADDRESS32
:
772 case ACPI_RESOURCE_TYPE_ADDRESS64
:
773 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
782 static acpi_status
pnpacpi_count_resources(struct acpi_resource
*res
,
787 if (pnpacpi_supported_resource(res
))
792 static acpi_status
pnpacpi_type_resources(struct acpi_resource
*res
, void *data
)
794 struct acpi_resource
**resource
= data
;
796 if (pnpacpi_supported_resource(res
)) {
797 (*resource
)->type
= res
->type
;
798 (*resource
)->length
= sizeof(struct acpi_resource
);
805 int pnpacpi_build_resource_template(struct pnp_dev
*dev
,
806 struct acpi_buffer
*buffer
)
808 acpi_handle handle
= dev
->data
;
809 struct acpi_resource
*resource
;
813 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
814 pnpacpi_count_resources
, &res_cnt
);
815 if (ACPI_FAILURE(status
)) {
816 dev_err(&dev
->dev
, "can't evaluate _CRS\n");
821 buffer
->length
= sizeof(struct acpi_resource
) * (res_cnt
+ 1) + 1;
822 buffer
->pointer
= kzalloc(buffer
->length
- 1, GFP_KERNEL
);
823 if (!buffer
->pointer
)
826 resource
= (struct acpi_resource
*)buffer
->pointer
;
827 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
828 pnpacpi_type_resources
, &resource
);
829 if (ACPI_FAILURE(status
)) {
830 kfree(buffer
->pointer
);
831 dev_err(&dev
->dev
, "can't evaluate _CRS\n");
834 /* resource will pointer the end resource now */
835 resource
->type
= ACPI_RESOURCE_TYPE_END_TAG
;
840 static void pnpacpi_encode_irq(struct pnp_dev
*dev
,
841 struct acpi_resource
*resource
,
844 struct acpi_resource_irq
*irq
= &resource
->data
.irq
;
845 int triggering
, polarity
;
847 decode_irq_flags(p
->flags
& IORESOURCE_BITS
, &triggering
, &polarity
);
848 irq
->triggering
= triggering
;
849 irq
->polarity
= polarity
;
850 if (triggering
== ACPI_EDGE_SENSITIVE
)
851 irq
->sharable
= ACPI_EXCLUSIVE
;
853 irq
->sharable
= ACPI_SHARED
;
854 irq
->interrupt_count
= 1;
855 irq
->interrupts
[0] = p
->start
;
857 dev_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
858 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
859 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
860 irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
863 static void pnpacpi_encode_ext_irq(struct pnp_dev
*dev
,
864 struct acpi_resource
*resource
,
867 struct acpi_resource_extended_irq
*extended_irq
= &resource
->data
.extended_irq
;
868 int triggering
, polarity
;
870 decode_irq_flags(p
->flags
& IORESOURCE_BITS
, &triggering
, &polarity
);
871 extended_irq
->producer_consumer
= ACPI_CONSUMER
;
872 extended_irq
->triggering
= triggering
;
873 extended_irq
->polarity
= polarity
;
874 if (triggering
== ACPI_EDGE_SENSITIVE
)
875 extended_irq
->sharable
= ACPI_EXCLUSIVE
;
877 extended_irq
->sharable
= ACPI_SHARED
;
878 extended_irq
->interrupt_count
= 1;
879 extended_irq
->interrupts
[0] = p
->start
;
881 dev_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
882 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
883 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
884 extended_irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
887 static void pnpacpi_encode_dma(struct pnp_dev
*dev
,
888 struct acpi_resource
*resource
,
891 struct acpi_resource_dma
*dma
= &resource
->data
.dma
;
893 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
894 switch (p
->flags
& IORESOURCE_DMA_SPEED_MASK
) {
895 case IORESOURCE_DMA_TYPEA
:
896 dma
->type
= ACPI_TYPE_A
;
898 case IORESOURCE_DMA_TYPEB
:
899 dma
->type
= ACPI_TYPE_B
;
901 case IORESOURCE_DMA_TYPEF
:
902 dma
->type
= ACPI_TYPE_F
;
905 dma
->type
= ACPI_COMPATIBILITY
;
908 switch (p
->flags
& IORESOURCE_DMA_TYPE_MASK
) {
909 case IORESOURCE_DMA_8BIT
:
910 dma
->transfer
= ACPI_TRANSFER_8
;
912 case IORESOURCE_DMA_8AND16BIT
:
913 dma
->transfer
= ACPI_TRANSFER_8_16
;
916 dma
->transfer
= ACPI_TRANSFER_16
;
919 dma
->bus_master
= !!(p
->flags
& IORESOURCE_DMA_MASTER
);
920 dma
->channel_count
= 1;
921 dma
->channels
[0] = p
->start
;
923 dev_dbg(&dev
->dev
, " encode dma %d "
924 "type %#x transfer %#x master %d\n",
925 (int) p
->start
, dma
->type
, dma
->transfer
, dma
->bus_master
);
928 static void pnpacpi_encode_io(struct pnp_dev
*dev
,
929 struct acpi_resource
*resource
,
932 struct acpi_resource_io
*io
= &resource
->data
.io
;
934 /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
935 io
->io_decode
= (p
->flags
& PNP_PORT_FLAG_16BITADDR
) ?
936 ACPI_DECODE_16
: ACPI_DECODE_10
;
937 io
->minimum
= p
->start
;
938 io
->maximum
= p
->end
;
939 io
->alignment
= 0; /* Correct? */
940 io
->address_length
= p
->end
- p
->start
+ 1;
942 dev_dbg(&dev
->dev
, " encode io %#llx-%#llx decode %#x\n",
943 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
947 static void pnpacpi_encode_fixed_io(struct pnp_dev
*dev
,
948 struct acpi_resource
*resource
,
951 struct acpi_resource_fixed_io
*fixed_io
= &resource
->data
.fixed_io
;
953 fixed_io
->address
= p
->start
;
954 fixed_io
->address_length
= p
->end
- p
->start
+ 1;
956 dev_dbg(&dev
->dev
, " encode fixed_io %#llx-%#llx\n",
957 (unsigned long long) p
->start
, (unsigned long long) p
->end
);
960 static void pnpacpi_encode_mem24(struct pnp_dev
*dev
,
961 struct acpi_resource
*resource
,
964 struct acpi_resource_memory24
*memory24
= &resource
->data
.memory24
;
966 /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
967 memory24
->write_protect
=
968 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
969 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
970 memory24
->minimum
= p
->start
;
971 memory24
->maximum
= p
->end
;
972 memory24
->alignment
= 0;
973 memory24
->address_length
= p
->end
- p
->start
+ 1;
975 dev_dbg(&dev
->dev
, " encode mem24 %#llx-%#llx write_protect %#x\n",
976 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
977 memory24
->write_protect
);
980 static void pnpacpi_encode_mem32(struct pnp_dev
*dev
,
981 struct acpi_resource
*resource
,
984 struct acpi_resource_memory32
*memory32
= &resource
->data
.memory32
;
986 memory32
->write_protect
=
987 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
988 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
989 memory32
->minimum
= p
->start
;
990 memory32
->maximum
= p
->end
;
991 memory32
->alignment
= 0;
992 memory32
->address_length
= p
->end
- p
->start
+ 1;
994 dev_dbg(&dev
->dev
, " encode mem32 %#llx-%#llx write_protect %#x\n",
995 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
996 memory32
->write_protect
);
999 static void pnpacpi_encode_fixed_mem32(struct pnp_dev
*dev
,
1000 struct acpi_resource
*resource
,
1003 struct acpi_resource_fixed_memory32
*fixed_memory32
= &resource
->data
.fixed_memory32
;
1005 fixed_memory32
->write_protect
=
1006 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
1007 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1008 fixed_memory32
->address
= p
->start
;
1009 fixed_memory32
->address_length
= p
->end
- p
->start
+ 1;
1011 dev_dbg(&dev
->dev
, " encode fixed_mem32 %#llx-%#llx "
1012 "write_protect %#x\n",
1013 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
1014 fixed_memory32
->write_protect
);
1017 int pnpacpi_encode_resources(struct pnp_dev
*dev
, struct acpi_buffer
*buffer
)
1020 /* pnpacpi_build_resource_template allocates extra mem */
1021 int res_cnt
= (buffer
->length
- 1) / sizeof(struct acpi_resource
) - 1;
1022 struct acpi_resource
*resource
= buffer
->pointer
;
1023 int port
= 0, irq
= 0, dma
= 0, mem
= 0;
1025 dev_dbg(&dev
->dev
, "encode %d resources\n", res_cnt
);
1026 while (i
< res_cnt
) {
1027 switch (resource
->type
) {
1028 case ACPI_RESOURCE_TYPE_IRQ
:
1029 pnpacpi_encode_irq(dev
, resource
,
1030 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1034 case ACPI_RESOURCE_TYPE_DMA
:
1035 pnpacpi_encode_dma(dev
, resource
,
1036 pnp_get_resource(dev
, IORESOURCE_DMA
, dma
));
1039 case ACPI_RESOURCE_TYPE_IO
:
1040 pnpacpi_encode_io(dev
, resource
,
1041 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1044 case ACPI_RESOURCE_TYPE_FIXED_IO
:
1045 pnpacpi_encode_fixed_io(dev
, resource
,
1046 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1049 case ACPI_RESOURCE_TYPE_MEMORY24
:
1050 pnpacpi_encode_mem24(dev
, resource
,
1051 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1054 case ACPI_RESOURCE_TYPE_MEMORY32
:
1055 pnpacpi_encode_mem32(dev
, resource
,
1056 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1059 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
1060 pnpacpi_encode_fixed_mem32(dev
, resource
,
1061 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1064 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
1065 pnpacpi_encode_ext_irq(dev
, resource
,
1066 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1069 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
1070 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
1071 case ACPI_RESOURCE_TYPE_VENDOR
:
1072 case ACPI_RESOURCE_TYPE_END_TAG
:
1073 case ACPI_RESOURCE_TYPE_ADDRESS16
:
1074 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1075 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1076 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
1077 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
1078 default: /* other type */
1079 dev_warn(&dev
->dev
, "can't encode unknown resource "
1080 "type %d\n", resource
->type
);