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>
27 #define valid_IRQ(i) (1)
29 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
35 static int irq_flags(int triggering
, int polarity
, int shareable
)
39 if (triggering
== ACPI_LEVEL_SENSITIVE
) {
40 if (polarity
== ACPI_ACTIVE_LOW
)
41 flags
= IORESOURCE_IRQ_LOWLEVEL
;
43 flags
= IORESOURCE_IRQ_HIGHLEVEL
;
45 if (polarity
== ACPI_ACTIVE_LOW
)
46 flags
= IORESOURCE_IRQ_LOWEDGE
;
48 flags
= IORESOURCE_IRQ_HIGHEDGE
;
52 flags
|= IORESOURCE_IRQ_SHAREABLE
;
57 static void decode_irq_flags(int flag
, int *triggering
, int *polarity
)
60 case IORESOURCE_IRQ_LOWLEVEL
:
61 *triggering
= ACPI_LEVEL_SENSITIVE
;
62 *polarity
= ACPI_ACTIVE_LOW
;
64 case IORESOURCE_IRQ_HIGHLEVEL
:
65 *triggering
= ACPI_LEVEL_SENSITIVE
;
66 *polarity
= ACPI_ACTIVE_HIGH
;
68 case IORESOURCE_IRQ_LOWEDGE
:
69 *triggering
= ACPI_EDGE_SENSITIVE
;
70 *polarity
= ACPI_ACTIVE_LOW
;
72 case IORESOURCE_IRQ_HIGHEDGE
:
73 *triggering
= ACPI_EDGE_SENSITIVE
;
74 *polarity
= ACPI_ACTIVE_HIGH
;
79 static void pnpacpi_parse_allocated_irqresource(struct pnp_dev
*dev
,
80 u32 gsi
, int triggering
,
81 int polarity
, int shareable
)
83 struct pnp_resource_table
*res
= &dev
->res
;
87 static unsigned char warned
;
92 while (!(res
->irq_resource
[i
].flags
& IORESOURCE_UNSET
) &&
95 if (i
>= PNP_MAX_IRQ
) {
97 printk(KERN_WARNING
"pnpacpi: exceeded the max number"
98 " of IRQ resources: %d\n", PNP_MAX_IRQ
);
104 * in IO-APIC mode, use overrided attribute. Two reasons:
105 * 1. BIOS bug in DSDT
106 * 2. BIOS uses IO-APIC mode Interrupt Source Override
108 if (!acpi_get_override_irq(gsi
, &t
, &p
)) {
109 t
= t
? ACPI_LEVEL_SENSITIVE
: ACPI_EDGE_SENSITIVE
;
110 p
= p
? ACPI_ACTIVE_LOW
: ACPI_ACTIVE_HIGH
;
112 if (triggering
!= t
|| polarity
!= p
) {
113 dev_warn(&dev
->dev
, "IRQ %d override to %s, %s\n",
114 gsi
, t
? "edge":"level", p
? "low":"high");
120 res
->irq_resource
[i
].flags
= IORESOURCE_IRQ
; // Also clears _UNSET flag
121 res
->irq_resource
[i
].flags
|= irq_flags(triggering
, polarity
, shareable
);
122 irq
= acpi_register_gsi(gsi
, triggering
, polarity
);
124 res
->irq_resource
[i
].flags
|= IORESOURCE_DISABLED
;
128 res
->irq_resource
[i
].start
= irq
;
129 res
->irq_resource
[i
].end
= irq
;
130 pcibios_penalize_isa_irq(irq
, 1);
133 static int dma_flags(int type
, int bus_master
, int transfer
)
138 flags
|= IORESOURCE_DMA_MASTER
;
140 case ACPI_COMPATIBILITY
:
141 flags
|= IORESOURCE_DMA_COMPATIBLE
;
144 flags
|= IORESOURCE_DMA_TYPEA
;
147 flags
|= IORESOURCE_DMA_TYPEB
;
150 flags
|= IORESOURCE_DMA_TYPEF
;
153 /* Set a default value ? */
154 flags
|= IORESOURCE_DMA_COMPATIBLE
;
155 pnp_err("Invalid DMA type");
158 case ACPI_TRANSFER_8
:
159 flags
|= IORESOURCE_DMA_8BIT
;
161 case ACPI_TRANSFER_8_16
:
162 flags
|= IORESOURCE_DMA_8AND16BIT
;
164 case ACPI_TRANSFER_16
:
165 flags
|= IORESOURCE_DMA_16BIT
;
168 /* Set a default value ? */
169 flags
|= IORESOURCE_DMA_8AND16BIT
;
170 pnp_err("Invalid DMA transfer type");
176 static void pnpacpi_parse_allocated_dmaresource(struct pnp_dev
*dev
,
179 struct pnp_resource_table
*res
= &dev
->res
;
181 static unsigned char warned
;
183 while (i
< PNP_MAX_DMA
&&
184 !(res
->dma_resource
[i
].flags
& IORESOURCE_UNSET
))
186 if (i
< PNP_MAX_DMA
) {
187 res
->dma_resource
[i
].flags
= IORESOURCE_DMA
; // Also clears _UNSET flag
188 res
->dma_resource
[i
].flags
|= flags
;
190 res
->dma_resource
[i
].flags
|= IORESOURCE_DISABLED
;
193 res
->dma_resource
[i
].start
= dma
;
194 res
->dma_resource
[i
].end
= dma
;
195 } else if (!warned
) {
196 printk(KERN_WARNING
"pnpacpi: exceeded the max number of DMA "
197 "resources: %d \n", PNP_MAX_DMA
);
202 static void pnpacpi_parse_allocated_ioresource(struct pnp_dev
*dev
,
203 u64 io
, u64 len
, int io_decode
)
205 struct pnp_resource_table
*res
= &dev
->res
;
207 static unsigned char warned
;
209 while (!(res
->port_resource
[i
].flags
& IORESOURCE_UNSET
) &&
212 if (i
< PNP_MAX_PORT
) {
213 res
->port_resource
[i
].flags
= IORESOURCE_IO
; // Also clears _UNSET flag
214 if (io_decode
== ACPI_DECODE_16
)
215 res
->port_resource
[i
].flags
|= PNP_PORT_FLAG_16BITADDR
;
216 if (len
<= 0 || (io
+ len
- 1) >= 0x10003) {
217 res
->port_resource
[i
].flags
|= IORESOURCE_DISABLED
;
220 res
->port_resource
[i
].start
= io
;
221 res
->port_resource
[i
].end
= io
+ len
- 1;
222 } else if (!warned
) {
223 printk(KERN_WARNING
"pnpacpi: exceeded the max number of IO "
224 "resources: %d \n", PNP_MAX_PORT
);
229 static void pnpacpi_parse_allocated_memresource(struct pnp_dev
*dev
,
233 struct pnp_resource_table
*res
= &dev
->res
;
235 static unsigned char warned
;
237 while (!(res
->mem_resource
[i
].flags
& IORESOURCE_UNSET
) &&
240 if (i
< PNP_MAX_MEM
) {
241 res
->mem_resource
[i
].flags
= IORESOURCE_MEM
; // Also clears _UNSET flag
243 res
->mem_resource
[i
].flags
|= IORESOURCE_DISABLED
;
246 if (write_protect
== ACPI_READ_WRITE_MEMORY
)
247 res
->mem_resource
[i
].flags
|= IORESOURCE_MEM_WRITEABLE
;
249 res
->mem_resource
[i
].start
= mem
;
250 res
->mem_resource
[i
].end
= mem
+ len
- 1;
251 } else if (!warned
) {
252 printk(KERN_WARNING
"pnpacpi: exceeded the max number of mem "
253 "resources: %d\n", PNP_MAX_MEM
);
258 static void pnpacpi_parse_allocated_address_space(struct pnp_dev
*dev
,
259 struct acpi_resource
*res
)
261 struct acpi_resource_address64 addr
, *p
= &addr
;
264 status
= acpi_resource_to_address64(res
, p
);
265 if (!ACPI_SUCCESS(status
)) {
266 dev_warn(&dev
->dev
, "failed to convert resource type %d\n",
271 if (p
->producer_consumer
== ACPI_PRODUCER
)
274 if (p
->resource_type
== ACPI_MEMORY_RANGE
)
275 pnpacpi_parse_allocated_memresource(dev
,
276 p
->minimum
, p
->address_length
,
277 p
->info
.mem
.write_protect
);
278 else if (p
->resource_type
== ACPI_IO_RANGE
)
279 pnpacpi_parse_allocated_ioresource(dev
,
280 p
->minimum
, p
->address_length
,
281 p
->granularity
== 0xfff ? ACPI_DECODE_10
:
285 static acpi_status
pnpacpi_allocated_resource(struct acpi_resource
*res
,
288 struct pnp_dev
*dev
= data
;
289 struct acpi_resource_irq
*irq
;
290 struct acpi_resource_dma
*dma
;
291 struct acpi_resource_io
*io
;
292 struct acpi_resource_fixed_io
*fixed_io
;
293 struct acpi_resource_memory24
*memory24
;
294 struct acpi_resource_memory32
*memory32
;
295 struct acpi_resource_fixed_memory32
*fixed_memory32
;
296 struct acpi_resource_extended_irq
*extended_irq
;
300 case ACPI_RESOURCE_TYPE_IRQ
:
302 * Per spec, only one interrupt per descriptor is allowed in
303 * _CRS, but some firmware violates this, so parse them all.
305 irq
= &res
->data
.irq
;
306 for (i
= 0; i
< irq
->interrupt_count
; i
++) {
307 pnpacpi_parse_allocated_irqresource(dev
,
315 case ACPI_RESOURCE_TYPE_DMA
:
316 dma
= &res
->data
.dma
;
317 if (dma
->channel_count
> 0)
318 pnpacpi_parse_allocated_dmaresource(dev
,
320 dma_flags(dma
->type
, dma
->bus_master
,
324 case ACPI_RESOURCE_TYPE_IO
:
326 pnpacpi_parse_allocated_ioresource(dev
,
332 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
333 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
336 case ACPI_RESOURCE_TYPE_FIXED_IO
:
337 fixed_io
= &res
->data
.fixed_io
;
338 pnpacpi_parse_allocated_ioresource(dev
,
340 fixed_io
->address_length
,
344 case ACPI_RESOURCE_TYPE_VENDOR
:
347 case ACPI_RESOURCE_TYPE_END_TAG
:
350 case ACPI_RESOURCE_TYPE_MEMORY24
:
351 memory24
= &res
->data
.memory24
;
352 pnpacpi_parse_allocated_memresource(dev
,
354 memory24
->address_length
,
355 memory24
->write_protect
);
357 case ACPI_RESOURCE_TYPE_MEMORY32
:
358 memory32
= &res
->data
.memory32
;
359 pnpacpi_parse_allocated_memresource(dev
,
361 memory32
->address_length
,
362 memory32
->write_protect
);
364 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
365 fixed_memory32
= &res
->data
.fixed_memory32
;
366 pnpacpi_parse_allocated_memresource(dev
,
367 fixed_memory32
->address
,
368 fixed_memory32
->address_length
,
369 fixed_memory32
->write_protect
);
371 case ACPI_RESOURCE_TYPE_ADDRESS16
:
372 case ACPI_RESOURCE_TYPE_ADDRESS32
:
373 case ACPI_RESOURCE_TYPE_ADDRESS64
:
374 pnpacpi_parse_allocated_address_space(dev
, res
);
377 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
378 if (res
->data
.ext_address64
.producer_consumer
== ACPI_PRODUCER
)
382 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
383 extended_irq
= &res
->data
.extended_irq
;
384 if (extended_irq
->producer_consumer
== ACPI_PRODUCER
)
387 for (i
= 0; i
< extended_irq
->interrupt_count
; i
++) {
388 pnpacpi_parse_allocated_irqresource(dev
,
389 extended_irq
->interrupts
[i
],
390 extended_irq
->triggering
,
391 extended_irq
->polarity
,
392 extended_irq
->sharable
);
396 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
400 dev_warn(&dev
->dev
, "unknown resource type %d in _CRS\n",
408 acpi_status
pnpacpi_parse_allocated_resource(struct pnp_dev
*dev
)
410 acpi_handle handle
= dev
->data
;
412 dev_dbg(&dev
->dev
, "parse allocated resources\n");
414 pnp_init_resources(dev
);
416 return acpi_walk_resources(handle
, METHOD_NAME__CRS
,
417 pnpacpi_allocated_resource
, dev
);
420 static __init
void pnpacpi_parse_dma_option(struct pnp_dev
*dev
,
421 struct pnp_option
*option
,
422 struct acpi_resource_dma
*p
)
427 if (p
->channel_count
== 0)
429 dma
= kzalloc(sizeof(struct pnp_dma
), GFP_KERNEL
);
433 for (i
= 0; i
< p
->channel_count
; i
++)
434 dma
->map
|= 1 << p
->channels
[i
];
436 dma
->flags
= dma_flags(p
->type
, p
->bus_master
, p
->transfer
);
438 pnp_register_dma_resource(dev
, option
, dma
);
441 static __init
void pnpacpi_parse_irq_option(struct pnp_dev
*dev
,
442 struct pnp_option
*option
,
443 struct acpi_resource_irq
*p
)
448 if (p
->interrupt_count
== 0)
450 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
454 for (i
= 0; i
< p
->interrupt_count
; i
++)
455 if (p
->interrupts
[i
])
456 __set_bit(p
->interrupts
[i
], irq
->map
);
457 irq
->flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
459 pnp_register_irq_resource(dev
, option
, irq
);
462 static __init
void pnpacpi_parse_ext_irq_option(struct pnp_dev
*dev
,
463 struct pnp_option
*option
,
464 struct acpi_resource_extended_irq
*p
)
469 if (p
->interrupt_count
== 0)
471 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
475 for (i
= 0; i
< p
->interrupt_count
; i
++)
476 if (p
->interrupts
[i
])
477 __set_bit(p
->interrupts
[i
], irq
->map
);
478 irq
->flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
480 pnp_register_irq_resource(dev
, option
, irq
);
483 static __init
void pnpacpi_parse_port_option(struct pnp_dev
*dev
,
484 struct pnp_option
*option
,
485 struct acpi_resource_io
*io
)
487 struct pnp_port
*port
;
489 if (io
->address_length
== 0)
491 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
494 port
->min
= io
->minimum
;
495 port
->max
= io
->maximum
;
496 port
->align
= io
->alignment
;
497 port
->size
= io
->address_length
;
498 port
->flags
= ACPI_DECODE_16
== io
->io_decode
?
499 PNP_PORT_FLAG_16BITADDR
: 0;
500 pnp_register_port_resource(dev
, option
, port
);
503 static __init
void pnpacpi_parse_fixed_port_option(struct pnp_dev
*dev
,
504 struct pnp_option
*option
,
505 struct acpi_resource_fixed_io
*io
)
507 struct pnp_port
*port
;
509 if (io
->address_length
== 0)
511 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
514 port
->min
= port
->max
= io
->address
;
515 port
->size
= io
->address_length
;
517 port
->flags
= PNP_PORT_FLAG_FIXED
;
518 pnp_register_port_resource(dev
, option
, port
);
521 static __init
void pnpacpi_parse_mem24_option(struct pnp_dev
*dev
,
522 struct pnp_option
*option
,
523 struct acpi_resource_memory24
*p
)
527 if (p
->address_length
== 0)
529 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
532 mem
->min
= p
->minimum
;
533 mem
->max
= p
->maximum
;
534 mem
->align
= p
->alignment
;
535 mem
->size
= p
->address_length
;
537 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
538 IORESOURCE_MEM_WRITEABLE
: 0;
540 pnp_register_mem_resource(dev
, option
, mem
);
543 static __init
void pnpacpi_parse_mem32_option(struct pnp_dev
*dev
,
544 struct pnp_option
*option
,
545 struct acpi_resource_memory32
*p
)
549 if (p
->address_length
== 0)
551 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
554 mem
->min
= p
->minimum
;
555 mem
->max
= p
->maximum
;
556 mem
->align
= p
->alignment
;
557 mem
->size
= p
->address_length
;
559 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
560 IORESOURCE_MEM_WRITEABLE
: 0;
562 pnp_register_mem_resource(dev
, option
, mem
);
565 static __init
void pnpacpi_parse_fixed_mem32_option(struct pnp_dev
*dev
,
566 struct pnp_option
*option
,
567 struct acpi_resource_fixed_memory32
*p
)
571 if (p
->address_length
== 0)
573 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
576 mem
->min
= mem
->max
= p
->address
;
577 mem
->size
= p
->address_length
;
580 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
581 IORESOURCE_MEM_WRITEABLE
: 0;
583 pnp_register_mem_resource(dev
, option
, mem
);
586 static __init
void pnpacpi_parse_address_option(struct pnp_dev
*dev
,
587 struct pnp_option
*option
,
588 struct acpi_resource
*r
)
590 struct acpi_resource_address64 addr
, *p
= &addr
;
593 struct pnp_port
*port
;
595 status
= acpi_resource_to_address64(r
, p
);
596 if (!ACPI_SUCCESS(status
)) {
597 pnp_warn("PnPACPI: failed to convert resource type %d",
602 if (p
->address_length
== 0)
605 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
606 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
609 mem
->min
= mem
->max
= p
->minimum
;
610 mem
->size
= p
->address_length
;
612 mem
->flags
= (p
->info
.mem
.write_protect
==
613 ACPI_READ_WRITE_MEMORY
) ? IORESOURCE_MEM_WRITEABLE
615 pnp_register_mem_resource(dev
, option
, mem
);
616 } else if (p
->resource_type
== ACPI_IO_RANGE
) {
617 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
620 port
->min
= port
->max
= p
->minimum
;
621 port
->size
= p
->address_length
;
623 port
->flags
= PNP_PORT_FLAG_FIXED
;
624 pnp_register_port_resource(dev
, option
, port
);
628 struct acpipnp_parse_option_s
{
629 struct pnp_option
*option
;
630 struct pnp_option
*option_independent
;
634 static __init acpi_status
pnpacpi_option_resource(struct acpi_resource
*res
,
638 struct acpipnp_parse_option_s
*parse_data
= data
;
639 struct pnp_dev
*dev
= parse_data
->dev
;
640 struct pnp_option
*option
= parse_data
->option
;
643 case ACPI_RESOURCE_TYPE_IRQ
:
644 pnpacpi_parse_irq_option(dev
, option
, &res
->data
.irq
);
647 case ACPI_RESOURCE_TYPE_DMA
:
648 pnpacpi_parse_dma_option(dev
, option
, &res
->data
.dma
);
651 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
652 switch (res
->data
.start_dpf
.compatibility_priority
) {
653 case ACPI_GOOD_CONFIGURATION
:
654 priority
= PNP_RES_PRIORITY_PREFERRED
;
657 case ACPI_ACCEPTABLE_CONFIGURATION
:
658 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
661 case ACPI_SUB_OPTIMAL_CONFIGURATION
:
662 priority
= PNP_RES_PRIORITY_FUNCTIONAL
;
665 priority
= PNP_RES_PRIORITY_INVALID
;
668 /* TBD: Consider performance/robustness bits */
669 option
= pnp_register_dependent_option(dev
, priority
);
672 parse_data
->option
= option
;
675 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
676 /*only one EndDependentFn is allowed */
677 if (!parse_data
->option_independent
) {
678 dev_warn(&dev
->dev
, "more than one EndDependentFn "
682 parse_data
->option
= parse_data
->option_independent
;
683 parse_data
->option_independent
= NULL
;
684 dev_dbg(&dev
->dev
, "end dependent options\n");
687 case ACPI_RESOURCE_TYPE_IO
:
688 pnpacpi_parse_port_option(dev
, option
, &res
->data
.io
);
691 case ACPI_RESOURCE_TYPE_FIXED_IO
:
692 pnpacpi_parse_fixed_port_option(dev
, option
,
693 &res
->data
.fixed_io
);
696 case ACPI_RESOURCE_TYPE_VENDOR
:
697 case ACPI_RESOURCE_TYPE_END_TAG
:
700 case ACPI_RESOURCE_TYPE_MEMORY24
:
701 pnpacpi_parse_mem24_option(dev
, option
, &res
->data
.memory24
);
704 case ACPI_RESOURCE_TYPE_MEMORY32
:
705 pnpacpi_parse_mem32_option(dev
, option
, &res
->data
.memory32
);
708 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
709 pnpacpi_parse_fixed_mem32_option(dev
, option
,
710 &res
->data
.fixed_memory32
);
713 case ACPI_RESOURCE_TYPE_ADDRESS16
:
714 case ACPI_RESOURCE_TYPE_ADDRESS32
:
715 case ACPI_RESOURCE_TYPE_ADDRESS64
:
716 pnpacpi_parse_address_option(dev
, option
, res
);
719 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
722 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
723 pnpacpi_parse_ext_irq_option(dev
, option
,
724 &res
->data
.extended_irq
);
727 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
731 dev_warn(&dev
->dev
, "unknown resource type %d in _PRS\n",
739 acpi_status __init
pnpacpi_parse_resource_option_data(struct pnp_dev
*dev
)
741 acpi_handle handle
= dev
->data
;
743 struct acpipnp_parse_option_s parse_data
;
745 dev_dbg(&dev
->dev
, "parse resource options\n");
747 parse_data
.option
= pnp_register_independent_option(dev
);
748 if (!parse_data
.option
)
750 parse_data
.option_independent
= parse_data
.option
;
751 parse_data
.dev
= dev
;
752 status
= acpi_walk_resources(handle
, METHOD_NAME__PRS
,
753 pnpacpi_option_resource
, &parse_data
);
758 static int pnpacpi_supported_resource(struct acpi_resource
*res
)
761 case ACPI_RESOURCE_TYPE_IRQ
:
762 case ACPI_RESOURCE_TYPE_DMA
:
763 case ACPI_RESOURCE_TYPE_IO
:
764 case ACPI_RESOURCE_TYPE_FIXED_IO
:
765 case ACPI_RESOURCE_TYPE_MEMORY24
:
766 case ACPI_RESOURCE_TYPE_MEMORY32
:
767 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
768 case ACPI_RESOURCE_TYPE_ADDRESS16
:
769 case ACPI_RESOURCE_TYPE_ADDRESS32
:
770 case ACPI_RESOURCE_TYPE_ADDRESS64
:
771 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
780 static acpi_status
pnpacpi_count_resources(struct acpi_resource
*res
,
785 if (pnpacpi_supported_resource(res
))
790 static acpi_status
pnpacpi_type_resources(struct acpi_resource
*res
, void *data
)
792 struct acpi_resource
**resource
= data
;
794 if (pnpacpi_supported_resource(res
)) {
795 (*resource
)->type
= res
->type
;
796 (*resource
)->length
= sizeof(struct acpi_resource
);
803 int pnpacpi_build_resource_template(struct pnp_dev
*dev
,
804 struct acpi_buffer
*buffer
)
806 acpi_handle handle
= dev
->data
;
807 struct acpi_resource
*resource
;
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\n");
819 buffer
->length
= sizeof(struct acpi_resource
) * (res_cnt
+ 1) + 1;
820 buffer
->pointer
= kzalloc(buffer
->length
- 1, GFP_KERNEL
);
821 if (!buffer
->pointer
)
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\n");
832 /* resource will pointer the end resource now */
833 resource
->type
= ACPI_RESOURCE_TYPE_END_TAG
;
838 static void pnpacpi_encode_irq(struct pnp_dev
*dev
,
839 struct acpi_resource
*resource
,
842 struct acpi_resource_irq
*irq
= &resource
->data
.irq
;
843 int triggering
, polarity
;
845 decode_irq_flags(p
->flags
& IORESOURCE_BITS
, &triggering
, &polarity
);
846 irq
->triggering
= triggering
;
847 irq
->polarity
= polarity
;
848 if (triggering
== ACPI_EDGE_SENSITIVE
)
849 irq
->sharable
= ACPI_EXCLUSIVE
;
851 irq
->sharable
= ACPI_SHARED
;
852 irq
->interrupt_count
= 1;
853 irq
->interrupts
[0] = p
->start
;
855 dev_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
856 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
857 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
858 irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
861 static void pnpacpi_encode_ext_irq(struct pnp_dev
*dev
,
862 struct acpi_resource
*resource
,
865 struct acpi_resource_extended_irq
*extended_irq
= &resource
->data
.extended_irq
;
866 int triggering
, polarity
;
868 decode_irq_flags(p
->flags
& IORESOURCE_BITS
, &triggering
, &polarity
);
869 extended_irq
->producer_consumer
= ACPI_CONSUMER
;
870 extended_irq
->triggering
= triggering
;
871 extended_irq
->polarity
= polarity
;
872 if (triggering
== ACPI_EDGE_SENSITIVE
)
873 extended_irq
->sharable
= ACPI_EXCLUSIVE
;
875 extended_irq
->sharable
= ACPI_SHARED
;
876 extended_irq
->interrupt_count
= 1;
877 extended_irq
->interrupts
[0] = p
->start
;
879 dev_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
880 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
881 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
882 extended_irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
885 static void pnpacpi_encode_dma(struct pnp_dev
*dev
,
886 struct acpi_resource
*resource
,
889 struct acpi_resource_dma
*dma
= &resource
->data
.dma
;
891 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
892 switch (p
->flags
& IORESOURCE_DMA_SPEED_MASK
) {
893 case IORESOURCE_DMA_TYPEA
:
894 dma
->type
= ACPI_TYPE_A
;
896 case IORESOURCE_DMA_TYPEB
:
897 dma
->type
= ACPI_TYPE_B
;
899 case IORESOURCE_DMA_TYPEF
:
900 dma
->type
= ACPI_TYPE_F
;
903 dma
->type
= ACPI_COMPATIBILITY
;
906 switch (p
->flags
& IORESOURCE_DMA_TYPE_MASK
) {
907 case IORESOURCE_DMA_8BIT
:
908 dma
->transfer
= ACPI_TRANSFER_8
;
910 case IORESOURCE_DMA_8AND16BIT
:
911 dma
->transfer
= ACPI_TRANSFER_8_16
;
914 dma
->transfer
= ACPI_TRANSFER_16
;
917 dma
->bus_master
= !!(p
->flags
& IORESOURCE_DMA_MASTER
);
918 dma
->channel_count
= 1;
919 dma
->channels
[0] = p
->start
;
921 dev_dbg(&dev
->dev
, " encode dma %d "
922 "type %#x transfer %#x master %d\n",
923 (int) p
->start
, dma
->type
, dma
->transfer
, dma
->bus_master
);
926 static void pnpacpi_encode_io(struct pnp_dev
*dev
,
927 struct acpi_resource
*resource
,
930 struct acpi_resource_io
*io
= &resource
->data
.io
;
932 /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
933 io
->io_decode
= (p
->flags
& PNP_PORT_FLAG_16BITADDR
) ?
934 ACPI_DECODE_16
: ACPI_DECODE_10
;
935 io
->minimum
= p
->start
;
936 io
->maximum
= p
->end
;
937 io
->alignment
= 0; /* Correct? */
938 io
->address_length
= p
->end
- p
->start
+ 1;
940 dev_dbg(&dev
->dev
, " encode io %#llx-%#llx decode %#x\n",
941 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
945 static void pnpacpi_encode_fixed_io(struct pnp_dev
*dev
,
946 struct acpi_resource
*resource
,
949 struct acpi_resource_fixed_io
*fixed_io
= &resource
->data
.fixed_io
;
951 fixed_io
->address
= p
->start
;
952 fixed_io
->address_length
= p
->end
- p
->start
+ 1;
954 dev_dbg(&dev
->dev
, " encode fixed_io %#llx-%#llx\n",
955 (unsigned long long) p
->start
, (unsigned long long) p
->end
);
958 static void pnpacpi_encode_mem24(struct pnp_dev
*dev
,
959 struct acpi_resource
*resource
,
962 struct acpi_resource_memory24
*memory24
= &resource
->data
.memory24
;
964 /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
965 memory24
->write_protect
=
966 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
967 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
968 memory24
->minimum
= p
->start
;
969 memory24
->maximum
= p
->end
;
970 memory24
->alignment
= 0;
971 memory24
->address_length
= p
->end
- p
->start
+ 1;
973 dev_dbg(&dev
->dev
, " encode mem24 %#llx-%#llx write_protect %#x\n",
974 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
975 memory24
->write_protect
);
978 static void pnpacpi_encode_mem32(struct pnp_dev
*dev
,
979 struct acpi_resource
*resource
,
982 struct acpi_resource_memory32
*memory32
= &resource
->data
.memory32
;
984 memory32
->write_protect
=
985 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
986 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
987 memory32
->minimum
= p
->start
;
988 memory32
->maximum
= p
->end
;
989 memory32
->alignment
= 0;
990 memory32
->address_length
= p
->end
- p
->start
+ 1;
992 dev_dbg(&dev
->dev
, " encode mem32 %#llx-%#llx write_protect %#x\n",
993 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
994 memory32
->write_protect
);
997 static void pnpacpi_encode_fixed_mem32(struct pnp_dev
*dev
,
998 struct acpi_resource
*resource
,
1001 struct acpi_resource_fixed_memory32
*fixed_memory32
= &resource
->data
.fixed_memory32
;
1003 fixed_memory32
->write_protect
=
1004 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
1005 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
1006 fixed_memory32
->address
= p
->start
;
1007 fixed_memory32
->address_length
= p
->end
- p
->start
+ 1;
1009 dev_dbg(&dev
->dev
, " encode fixed_mem32 %#llx-%#llx "
1010 "write_protect %#x\n",
1011 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
1012 fixed_memory32
->write_protect
);
1015 int pnpacpi_encode_resources(struct pnp_dev
*dev
, struct acpi_buffer
*buffer
)
1018 /* pnpacpi_build_resource_template allocates extra mem */
1019 int res_cnt
= (buffer
->length
- 1) / sizeof(struct acpi_resource
) - 1;
1020 struct acpi_resource
*resource
= buffer
->pointer
;
1021 int port
= 0, irq
= 0, dma
= 0, mem
= 0;
1023 dev_dbg(&dev
->dev
, "encode %d resources\n", res_cnt
);
1024 while (i
< res_cnt
) {
1025 switch (resource
->type
) {
1026 case ACPI_RESOURCE_TYPE_IRQ
:
1027 pnpacpi_encode_irq(dev
, resource
,
1028 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1032 case ACPI_RESOURCE_TYPE_DMA
:
1033 pnpacpi_encode_dma(dev
, resource
,
1034 pnp_get_resource(dev
, IORESOURCE_DMA
, dma
));
1037 case ACPI_RESOURCE_TYPE_IO
:
1038 pnpacpi_encode_io(dev
, resource
,
1039 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1042 case ACPI_RESOURCE_TYPE_FIXED_IO
:
1043 pnpacpi_encode_fixed_io(dev
, resource
,
1044 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1047 case ACPI_RESOURCE_TYPE_MEMORY24
:
1048 pnpacpi_encode_mem24(dev
, resource
,
1049 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1052 case ACPI_RESOURCE_TYPE_MEMORY32
:
1053 pnpacpi_encode_mem32(dev
, resource
,
1054 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1057 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
1058 pnpacpi_encode_fixed_mem32(dev
, resource
,
1059 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1062 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
1063 pnpacpi_encode_ext_irq(dev
, resource
,
1064 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1067 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
1068 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
1069 case ACPI_RESOURCE_TYPE_VENDOR
:
1070 case ACPI_RESOURCE_TYPE_END_TAG
:
1071 case ACPI_RESOURCE_TYPE_ADDRESS16
:
1072 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1073 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1074 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
1075 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
1076 default: /* other type */
1077 dev_warn(&dev
->dev
, "can't encode unknown resource "
1078 "type %d\n", resource
->type
);