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
)
92 * in IO-APIC mode, use overrided attribute. Two reasons:
94 * 2. BIOS uses IO-APIC mode Interrupt Source Override
96 if (!acpi_get_override_irq(gsi
, &t
, &p
)) {
97 t
= t
? ACPI_LEVEL_SENSITIVE
: ACPI_EDGE_SENSITIVE
;
98 p
= p
? ACPI_ACTIVE_LOW
: ACPI_ACTIVE_HIGH
;
100 if (triggering
!= t
|| polarity
!= p
) {
101 dev_warn(&dev
->dev
, "IRQ %d override to %s, %s\n",
102 gsi
, t
? "edge":"level", p
? "low":"high");
108 flags
= irq_flags(triggering
, polarity
, shareable
);
109 irq
= acpi_register_gsi(gsi
, triggering
, polarity
);
111 pcibios_penalize_isa_irq(irq
, 1);
113 flags
|= IORESOURCE_DISABLED
;
115 pnp_add_irq_resource(dev
, irq
, flags
);
118 static int dma_flags(int type
, int bus_master
, int transfer
)
123 flags
|= IORESOURCE_DMA_MASTER
;
125 case ACPI_COMPATIBILITY
:
126 flags
|= IORESOURCE_DMA_COMPATIBLE
;
129 flags
|= IORESOURCE_DMA_TYPEA
;
132 flags
|= IORESOURCE_DMA_TYPEB
;
135 flags
|= IORESOURCE_DMA_TYPEF
;
138 /* Set a default value ? */
139 flags
|= IORESOURCE_DMA_COMPATIBLE
;
140 pnp_err("Invalid DMA type");
143 case ACPI_TRANSFER_8
:
144 flags
|= IORESOURCE_DMA_8BIT
;
146 case ACPI_TRANSFER_8_16
:
147 flags
|= IORESOURCE_DMA_8AND16BIT
;
149 case ACPI_TRANSFER_16
:
150 flags
|= IORESOURCE_DMA_16BIT
;
153 /* Set a default value ? */
154 flags
|= IORESOURCE_DMA_8AND16BIT
;
155 pnp_err("Invalid DMA transfer type");
161 static void pnpacpi_parse_allocated_ioresource(struct pnp_dev
*dev
,
162 u64 io
, u64 len
, int io_decode
)
164 struct resource
*res
;
166 static unsigned char warned
;
168 for (i
= 0; i
< PNP_MAX_PORT
; i
++) {
169 res
= pnp_get_resource(dev
, IORESOURCE_IO
, i
);
170 if (!pnp_resource_valid(res
))
173 if (i
< PNP_MAX_PORT
) {
174 res
->flags
= IORESOURCE_IO
; // Also clears _UNSET flag
175 if (io_decode
== ACPI_DECODE_16
)
176 res
->flags
|= PNP_PORT_FLAG_16BITADDR
;
177 if (len
<= 0 || (io
+ len
- 1) >= 0x10003) {
178 res
->flags
|= IORESOURCE_DISABLED
;
182 res
->end
= io
+ len
- 1;
183 } else if (!warned
) {
184 printk(KERN_WARNING
"pnpacpi: exceeded the max number of IO "
185 "resources: %d \n", PNP_MAX_PORT
);
190 static void pnpacpi_parse_allocated_memresource(struct pnp_dev
*dev
,
194 struct resource
*res
;
196 static unsigned char warned
;
198 for (i
= 0; i
< PNP_MAX_MEM
; i
++) {
199 res
= pnp_get_resource(dev
, IORESOURCE_MEM
, i
);
200 if (!pnp_resource_valid(res
))
203 if (i
< PNP_MAX_MEM
) {
204 res
->flags
= IORESOURCE_MEM
; // Also clears _UNSET flag
206 res
->flags
|= IORESOURCE_DISABLED
;
209 if (write_protect
== ACPI_READ_WRITE_MEMORY
)
210 res
->flags
|= IORESOURCE_MEM_WRITEABLE
;
213 res
->end
= mem
+ len
- 1;
214 } else if (!warned
) {
215 printk(KERN_WARNING
"pnpacpi: exceeded the max number of mem "
216 "resources: %d\n", PNP_MAX_MEM
);
221 static void pnpacpi_parse_allocated_address_space(struct pnp_dev
*dev
,
222 struct acpi_resource
*res
)
224 struct acpi_resource_address64 addr
, *p
= &addr
;
227 status
= acpi_resource_to_address64(res
, p
);
228 if (!ACPI_SUCCESS(status
)) {
229 dev_warn(&dev
->dev
, "failed to convert resource type %d\n",
234 if (p
->producer_consumer
== ACPI_PRODUCER
)
237 if (p
->resource_type
== ACPI_MEMORY_RANGE
)
238 pnpacpi_parse_allocated_memresource(dev
,
239 p
->minimum
, p
->address_length
,
240 p
->info
.mem
.write_protect
);
241 else if (p
->resource_type
== ACPI_IO_RANGE
)
242 pnpacpi_parse_allocated_ioresource(dev
,
243 p
->minimum
, p
->address_length
,
244 p
->granularity
== 0xfff ? ACPI_DECODE_10
:
248 static acpi_status
pnpacpi_allocated_resource(struct acpi_resource
*res
,
251 struct pnp_dev
*dev
= data
;
252 struct acpi_resource_irq
*irq
;
253 struct acpi_resource_dma
*dma
;
254 struct acpi_resource_io
*io
;
255 struct acpi_resource_fixed_io
*fixed_io
;
256 struct acpi_resource_memory24
*memory24
;
257 struct acpi_resource_memory32
*memory32
;
258 struct acpi_resource_fixed_memory32
*fixed_memory32
;
259 struct acpi_resource_extended_irq
*extended_irq
;
263 case ACPI_RESOURCE_TYPE_IRQ
:
265 * Per spec, only one interrupt per descriptor is allowed in
266 * _CRS, but some firmware violates this, so parse them all.
268 irq
= &res
->data
.irq
;
269 for (i
= 0; i
< irq
->interrupt_count
; i
++) {
270 pnpacpi_parse_allocated_irqresource(dev
,
278 case ACPI_RESOURCE_TYPE_DMA
:
279 dma
= &res
->data
.dma
;
280 if (dma
->channel_count
> 0) {
281 flags
= dma_flags(dma
->type
, dma
->bus_master
,
283 if (dma
->channels
[0] == (u8
) -1)
284 flags
|= IORESOURCE_DISABLED
;
285 pnp_add_dma_resource(dev
, dma
->channels
[0], flags
);
289 case ACPI_RESOURCE_TYPE_IO
:
291 pnpacpi_parse_allocated_ioresource(dev
,
297 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
298 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
301 case ACPI_RESOURCE_TYPE_FIXED_IO
:
302 fixed_io
= &res
->data
.fixed_io
;
303 pnpacpi_parse_allocated_ioresource(dev
,
305 fixed_io
->address_length
,
309 case ACPI_RESOURCE_TYPE_VENDOR
:
312 case ACPI_RESOURCE_TYPE_END_TAG
:
315 case ACPI_RESOURCE_TYPE_MEMORY24
:
316 memory24
= &res
->data
.memory24
;
317 pnpacpi_parse_allocated_memresource(dev
,
319 memory24
->address_length
,
320 memory24
->write_protect
);
322 case ACPI_RESOURCE_TYPE_MEMORY32
:
323 memory32
= &res
->data
.memory32
;
324 pnpacpi_parse_allocated_memresource(dev
,
326 memory32
->address_length
,
327 memory32
->write_protect
);
329 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
330 fixed_memory32
= &res
->data
.fixed_memory32
;
331 pnpacpi_parse_allocated_memresource(dev
,
332 fixed_memory32
->address
,
333 fixed_memory32
->address_length
,
334 fixed_memory32
->write_protect
);
336 case ACPI_RESOURCE_TYPE_ADDRESS16
:
337 case ACPI_RESOURCE_TYPE_ADDRESS32
:
338 case ACPI_RESOURCE_TYPE_ADDRESS64
:
339 pnpacpi_parse_allocated_address_space(dev
, res
);
342 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
343 if (res
->data
.ext_address64
.producer_consumer
== ACPI_PRODUCER
)
347 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
348 extended_irq
= &res
->data
.extended_irq
;
349 if (extended_irq
->producer_consumer
== ACPI_PRODUCER
)
352 for (i
= 0; i
< extended_irq
->interrupt_count
; i
++) {
353 pnpacpi_parse_allocated_irqresource(dev
,
354 extended_irq
->interrupts
[i
],
355 extended_irq
->triggering
,
356 extended_irq
->polarity
,
357 extended_irq
->sharable
);
361 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
365 dev_warn(&dev
->dev
, "unknown resource type %d in _CRS\n",
373 acpi_status
pnpacpi_parse_allocated_resource(struct pnp_dev
*dev
)
375 acpi_handle handle
= dev
->data
;
377 dev_dbg(&dev
->dev
, "parse allocated resources\n");
379 pnp_init_resources(dev
);
381 return acpi_walk_resources(handle
, METHOD_NAME__CRS
,
382 pnpacpi_allocated_resource
, dev
);
385 static __init
void pnpacpi_parse_dma_option(struct pnp_dev
*dev
,
386 struct pnp_option
*option
,
387 struct acpi_resource_dma
*p
)
392 if (p
->channel_count
== 0)
394 dma
= kzalloc(sizeof(struct pnp_dma
), GFP_KERNEL
);
398 for (i
= 0; i
< p
->channel_count
; i
++)
399 dma
->map
|= 1 << p
->channels
[i
];
401 dma
->flags
= dma_flags(p
->type
, p
->bus_master
, p
->transfer
);
403 pnp_register_dma_resource(dev
, option
, dma
);
406 static __init
void pnpacpi_parse_irq_option(struct pnp_dev
*dev
,
407 struct pnp_option
*option
,
408 struct acpi_resource_irq
*p
)
413 if (p
->interrupt_count
== 0)
415 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
419 for (i
= 0; i
< p
->interrupt_count
; i
++)
420 if (p
->interrupts
[i
])
421 __set_bit(p
->interrupts
[i
], irq
->map
);
422 irq
->flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
424 pnp_register_irq_resource(dev
, option
, irq
);
427 static __init
void pnpacpi_parse_ext_irq_option(struct pnp_dev
*dev
,
428 struct pnp_option
*option
,
429 struct acpi_resource_extended_irq
*p
)
434 if (p
->interrupt_count
== 0)
436 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
440 for (i
= 0; i
< p
->interrupt_count
; i
++)
441 if (p
->interrupts
[i
])
442 __set_bit(p
->interrupts
[i
], irq
->map
);
443 irq
->flags
= irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
445 pnp_register_irq_resource(dev
, option
, irq
);
448 static __init
void pnpacpi_parse_port_option(struct pnp_dev
*dev
,
449 struct pnp_option
*option
,
450 struct acpi_resource_io
*io
)
452 struct pnp_port
*port
;
454 if (io
->address_length
== 0)
456 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
459 port
->min
= io
->minimum
;
460 port
->max
= io
->maximum
;
461 port
->align
= io
->alignment
;
462 port
->size
= io
->address_length
;
463 port
->flags
= ACPI_DECODE_16
== io
->io_decode
?
464 PNP_PORT_FLAG_16BITADDR
: 0;
465 pnp_register_port_resource(dev
, option
, port
);
468 static __init
void pnpacpi_parse_fixed_port_option(struct pnp_dev
*dev
,
469 struct pnp_option
*option
,
470 struct acpi_resource_fixed_io
*io
)
472 struct pnp_port
*port
;
474 if (io
->address_length
== 0)
476 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
479 port
->min
= port
->max
= io
->address
;
480 port
->size
= io
->address_length
;
482 port
->flags
= PNP_PORT_FLAG_FIXED
;
483 pnp_register_port_resource(dev
, option
, port
);
486 static __init
void pnpacpi_parse_mem24_option(struct pnp_dev
*dev
,
487 struct pnp_option
*option
,
488 struct acpi_resource_memory24
*p
)
492 if (p
->address_length
== 0)
494 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
497 mem
->min
= p
->minimum
;
498 mem
->max
= p
->maximum
;
499 mem
->align
= p
->alignment
;
500 mem
->size
= p
->address_length
;
502 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
503 IORESOURCE_MEM_WRITEABLE
: 0;
505 pnp_register_mem_resource(dev
, option
, mem
);
508 static __init
void pnpacpi_parse_mem32_option(struct pnp_dev
*dev
,
509 struct pnp_option
*option
,
510 struct acpi_resource_memory32
*p
)
514 if (p
->address_length
== 0)
516 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
519 mem
->min
= p
->minimum
;
520 mem
->max
= p
->maximum
;
521 mem
->align
= p
->alignment
;
522 mem
->size
= p
->address_length
;
524 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
525 IORESOURCE_MEM_WRITEABLE
: 0;
527 pnp_register_mem_resource(dev
, option
, mem
);
530 static __init
void pnpacpi_parse_fixed_mem32_option(struct pnp_dev
*dev
,
531 struct pnp_option
*option
,
532 struct acpi_resource_fixed_memory32
*p
)
536 if (p
->address_length
== 0)
538 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
541 mem
->min
= mem
->max
= p
->address
;
542 mem
->size
= p
->address_length
;
545 mem
->flags
= (ACPI_READ_WRITE_MEMORY
== p
->write_protect
) ?
546 IORESOURCE_MEM_WRITEABLE
: 0;
548 pnp_register_mem_resource(dev
, option
, mem
);
551 static __init
void pnpacpi_parse_address_option(struct pnp_dev
*dev
,
552 struct pnp_option
*option
,
553 struct acpi_resource
*r
)
555 struct acpi_resource_address64 addr
, *p
= &addr
;
558 struct pnp_port
*port
;
560 status
= acpi_resource_to_address64(r
, p
);
561 if (!ACPI_SUCCESS(status
)) {
562 pnp_warn("PnPACPI: failed to convert resource type %d",
567 if (p
->address_length
== 0)
570 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
571 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
574 mem
->min
= mem
->max
= p
->minimum
;
575 mem
->size
= p
->address_length
;
577 mem
->flags
= (p
->info
.mem
.write_protect
==
578 ACPI_READ_WRITE_MEMORY
) ? IORESOURCE_MEM_WRITEABLE
580 pnp_register_mem_resource(dev
, option
, mem
);
581 } else if (p
->resource_type
== ACPI_IO_RANGE
) {
582 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
585 port
->min
= port
->max
= p
->minimum
;
586 port
->size
= p
->address_length
;
588 port
->flags
= PNP_PORT_FLAG_FIXED
;
589 pnp_register_port_resource(dev
, option
, port
);
593 struct acpipnp_parse_option_s
{
594 struct pnp_option
*option
;
595 struct pnp_option
*option_independent
;
599 static __init acpi_status
pnpacpi_option_resource(struct acpi_resource
*res
,
603 struct acpipnp_parse_option_s
*parse_data
= data
;
604 struct pnp_dev
*dev
= parse_data
->dev
;
605 struct pnp_option
*option
= parse_data
->option
;
608 case ACPI_RESOURCE_TYPE_IRQ
:
609 pnpacpi_parse_irq_option(dev
, option
, &res
->data
.irq
);
612 case ACPI_RESOURCE_TYPE_DMA
:
613 pnpacpi_parse_dma_option(dev
, option
, &res
->data
.dma
);
616 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
617 switch (res
->data
.start_dpf
.compatibility_priority
) {
618 case ACPI_GOOD_CONFIGURATION
:
619 priority
= PNP_RES_PRIORITY_PREFERRED
;
622 case ACPI_ACCEPTABLE_CONFIGURATION
:
623 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
626 case ACPI_SUB_OPTIMAL_CONFIGURATION
:
627 priority
= PNP_RES_PRIORITY_FUNCTIONAL
;
630 priority
= PNP_RES_PRIORITY_INVALID
;
633 /* TBD: Consider performance/robustness bits */
634 option
= pnp_register_dependent_option(dev
, priority
);
637 parse_data
->option
= option
;
640 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
641 /*only one EndDependentFn is allowed */
642 if (!parse_data
->option_independent
) {
643 dev_warn(&dev
->dev
, "more than one EndDependentFn "
647 parse_data
->option
= parse_data
->option_independent
;
648 parse_data
->option_independent
= NULL
;
649 dev_dbg(&dev
->dev
, "end dependent options\n");
652 case ACPI_RESOURCE_TYPE_IO
:
653 pnpacpi_parse_port_option(dev
, option
, &res
->data
.io
);
656 case ACPI_RESOURCE_TYPE_FIXED_IO
:
657 pnpacpi_parse_fixed_port_option(dev
, option
,
658 &res
->data
.fixed_io
);
661 case ACPI_RESOURCE_TYPE_VENDOR
:
662 case ACPI_RESOURCE_TYPE_END_TAG
:
665 case ACPI_RESOURCE_TYPE_MEMORY24
:
666 pnpacpi_parse_mem24_option(dev
, option
, &res
->data
.memory24
);
669 case ACPI_RESOURCE_TYPE_MEMORY32
:
670 pnpacpi_parse_mem32_option(dev
, option
, &res
->data
.memory32
);
673 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
674 pnpacpi_parse_fixed_mem32_option(dev
, option
,
675 &res
->data
.fixed_memory32
);
678 case ACPI_RESOURCE_TYPE_ADDRESS16
:
679 case ACPI_RESOURCE_TYPE_ADDRESS32
:
680 case ACPI_RESOURCE_TYPE_ADDRESS64
:
681 pnpacpi_parse_address_option(dev
, option
, res
);
684 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
687 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
688 pnpacpi_parse_ext_irq_option(dev
, option
,
689 &res
->data
.extended_irq
);
692 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
696 dev_warn(&dev
->dev
, "unknown resource type %d in _PRS\n",
704 acpi_status __init
pnpacpi_parse_resource_option_data(struct pnp_dev
*dev
)
706 acpi_handle handle
= dev
->data
;
708 struct acpipnp_parse_option_s parse_data
;
710 dev_dbg(&dev
->dev
, "parse resource options\n");
712 parse_data
.option
= pnp_register_independent_option(dev
);
713 if (!parse_data
.option
)
715 parse_data
.option_independent
= parse_data
.option
;
716 parse_data
.dev
= dev
;
717 status
= acpi_walk_resources(handle
, METHOD_NAME__PRS
,
718 pnpacpi_option_resource
, &parse_data
);
723 static int pnpacpi_supported_resource(struct acpi_resource
*res
)
726 case ACPI_RESOURCE_TYPE_IRQ
:
727 case ACPI_RESOURCE_TYPE_DMA
:
728 case ACPI_RESOURCE_TYPE_IO
:
729 case ACPI_RESOURCE_TYPE_FIXED_IO
:
730 case ACPI_RESOURCE_TYPE_MEMORY24
:
731 case ACPI_RESOURCE_TYPE_MEMORY32
:
732 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
733 case ACPI_RESOURCE_TYPE_ADDRESS16
:
734 case ACPI_RESOURCE_TYPE_ADDRESS32
:
735 case ACPI_RESOURCE_TYPE_ADDRESS64
:
736 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
745 static acpi_status
pnpacpi_count_resources(struct acpi_resource
*res
,
750 if (pnpacpi_supported_resource(res
))
755 static acpi_status
pnpacpi_type_resources(struct acpi_resource
*res
, void *data
)
757 struct acpi_resource
**resource
= data
;
759 if (pnpacpi_supported_resource(res
)) {
760 (*resource
)->type
= res
->type
;
761 (*resource
)->length
= sizeof(struct acpi_resource
);
768 int pnpacpi_build_resource_template(struct pnp_dev
*dev
,
769 struct acpi_buffer
*buffer
)
771 acpi_handle handle
= dev
->data
;
772 struct acpi_resource
*resource
;
776 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
777 pnpacpi_count_resources
, &res_cnt
);
778 if (ACPI_FAILURE(status
)) {
779 dev_err(&dev
->dev
, "can't evaluate _CRS\n");
784 buffer
->length
= sizeof(struct acpi_resource
) * (res_cnt
+ 1) + 1;
785 buffer
->pointer
= kzalloc(buffer
->length
- 1, GFP_KERNEL
);
786 if (!buffer
->pointer
)
789 resource
= (struct acpi_resource
*)buffer
->pointer
;
790 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
791 pnpacpi_type_resources
, &resource
);
792 if (ACPI_FAILURE(status
)) {
793 kfree(buffer
->pointer
);
794 dev_err(&dev
->dev
, "can't evaluate _CRS\n");
797 /* resource will pointer the end resource now */
798 resource
->type
= ACPI_RESOURCE_TYPE_END_TAG
;
803 static void pnpacpi_encode_irq(struct pnp_dev
*dev
,
804 struct acpi_resource
*resource
,
807 struct acpi_resource_irq
*irq
= &resource
->data
.irq
;
808 int triggering
, polarity
;
810 decode_irq_flags(p
->flags
& IORESOURCE_BITS
, &triggering
, &polarity
);
811 irq
->triggering
= triggering
;
812 irq
->polarity
= polarity
;
813 if (triggering
== ACPI_EDGE_SENSITIVE
)
814 irq
->sharable
= ACPI_EXCLUSIVE
;
816 irq
->sharable
= ACPI_SHARED
;
817 irq
->interrupt_count
= 1;
818 irq
->interrupts
[0] = p
->start
;
820 dev_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
821 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
822 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
823 irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
826 static void pnpacpi_encode_ext_irq(struct pnp_dev
*dev
,
827 struct acpi_resource
*resource
,
830 struct acpi_resource_extended_irq
*extended_irq
= &resource
->data
.extended_irq
;
831 int triggering
, polarity
;
833 decode_irq_flags(p
->flags
& IORESOURCE_BITS
, &triggering
, &polarity
);
834 extended_irq
->producer_consumer
= ACPI_CONSUMER
;
835 extended_irq
->triggering
= triggering
;
836 extended_irq
->polarity
= polarity
;
837 if (triggering
== ACPI_EDGE_SENSITIVE
)
838 extended_irq
->sharable
= ACPI_EXCLUSIVE
;
840 extended_irq
->sharable
= ACPI_SHARED
;
841 extended_irq
->interrupt_count
= 1;
842 extended_irq
->interrupts
[0] = p
->start
;
844 dev_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
845 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
846 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
847 extended_irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
850 static void pnpacpi_encode_dma(struct pnp_dev
*dev
,
851 struct acpi_resource
*resource
,
854 struct acpi_resource_dma
*dma
= &resource
->data
.dma
;
856 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
857 switch (p
->flags
& IORESOURCE_DMA_SPEED_MASK
) {
858 case IORESOURCE_DMA_TYPEA
:
859 dma
->type
= ACPI_TYPE_A
;
861 case IORESOURCE_DMA_TYPEB
:
862 dma
->type
= ACPI_TYPE_B
;
864 case IORESOURCE_DMA_TYPEF
:
865 dma
->type
= ACPI_TYPE_F
;
868 dma
->type
= ACPI_COMPATIBILITY
;
871 switch (p
->flags
& IORESOURCE_DMA_TYPE_MASK
) {
872 case IORESOURCE_DMA_8BIT
:
873 dma
->transfer
= ACPI_TRANSFER_8
;
875 case IORESOURCE_DMA_8AND16BIT
:
876 dma
->transfer
= ACPI_TRANSFER_8_16
;
879 dma
->transfer
= ACPI_TRANSFER_16
;
882 dma
->bus_master
= !!(p
->flags
& IORESOURCE_DMA_MASTER
);
883 dma
->channel_count
= 1;
884 dma
->channels
[0] = p
->start
;
886 dev_dbg(&dev
->dev
, " encode dma %d "
887 "type %#x transfer %#x master %d\n",
888 (int) p
->start
, dma
->type
, dma
->transfer
, dma
->bus_master
);
891 static void pnpacpi_encode_io(struct pnp_dev
*dev
,
892 struct acpi_resource
*resource
,
895 struct acpi_resource_io
*io
= &resource
->data
.io
;
897 /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
898 io
->io_decode
= (p
->flags
& PNP_PORT_FLAG_16BITADDR
) ?
899 ACPI_DECODE_16
: ACPI_DECODE_10
;
900 io
->minimum
= p
->start
;
901 io
->maximum
= p
->end
;
902 io
->alignment
= 0; /* Correct? */
903 io
->address_length
= p
->end
- p
->start
+ 1;
905 dev_dbg(&dev
->dev
, " encode io %#llx-%#llx decode %#x\n",
906 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
910 static void pnpacpi_encode_fixed_io(struct pnp_dev
*dev
,
911 struct acpi_resource
*resource
,
914 struct acpi_resource_fixed_io
*fixed_io
= &resource
->data
.fixed_io
;
916 fixed_io
->address
= p
->start
;
917 fixed_io
->address_length
= p
->end
- p
->start
+ 1;
919 dev_dbg(&dev
->dev
, " encode fixed_io %#llx-%#llx\n",
920 (unsigned long long) p
->start
, (unsigned long long) p
->end
);
923 static void pnpacpi_encode_mem24(struct pnp_dev
*dev
,
924 struct acpi_resource
*resource
,
927 struct acpi_resource_memory24
*memory24
= &resource
->data
.memory24
;
929 /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
930 memory24
->write_protect
=
931 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
932 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
933 memory24
->minimum
= p
->start
;
934 memory24
->maximum
= p
->end
;
935 memory24
->alignment
= 0;
936 memory24
->address_length
= p
->end
- p
->start
+ 1;
938 dev_dbg(&dev
->dev
, " encode mem24 %#llx-%#llx write_protect %#x\n",
939 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
940 memory24
->write_protect
);
943 static void pnpacpi_encode_mem32(struct pnp_dev
*dev
,
944 struct acpi_resource
*resource
,
947 struct acpi_resource_memory32
*memory32
= &resource
->data
.memory32
;
949 memory32
->write_protect
=
950 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
951 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
952 memory32
->minimum
= p
->start
;
953 memory32
->maximum
= p
->end
;
954 memory32
->alignment
= 0;
955 memory32
->address_length
= p
->end
- p
->start
+ 1;
957 dev_dbg(&dev
->dev
, " encode mem32 %#llx-%#llx write_protect %#x\n",
958 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
959 memory32
->write_protect
);
962 static void pnpacpi_encode_fixed_mem32(struct pnp_dev
*dev
,
963 struct acpi_resource
*resource
,
966 struct acpi_resource_fixed_memory32
*fixed_memory32
= &resource
->data
.fixed_memory32
;
968 fixed_memory32
->write_protect
=
969 (p
->flags
& IORESOURCE_MEM_WRITEABLE
) ?
970 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
971 fixed_memory32
->address
= p
->start
;
972 fixed_memory32
->address_length
= p
->end
- p
->start
+ 1;
974 dev_dbg(&dev
->dev
, " encode fixed_mem32 %#llx-%#llx "
975 "write_protect %#x\n",
976 (unsigned long long) p
->start
, (unsigned long long) p
->end
,
977 fixed_memory32
->write_protect
);
980 int pnpacpi_encode_resources(struct pnp_dev
*dev
, struct acpi_buffer
*buffer
)
983 /* pnpacpi_build_resource_template allocates extra mem */
984 int res_cnt
= (buffer
->length
- 1) / sizeof(struct acpi_resource
) - 1;
985 struct acpi_resource
*resource
= buffer
->pointer
;
986 int port
= 0, irq
= 0, dma
= 0, mem
= 0;
988 dev_dbg(&dev
->dev
, "encode %d resources\n", res_cnt
);
989 while (i
< res_cnt
) {
990 switch (resource
->type
) {
991 case ACPI_RESOURCE_TYPE_IRQ
:
992 pnpacpi_encode_irq(dev
, resource
,
993 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
997 case ACPI_RESOURCE_TYPE_DMA
:
998 pnpacpi_encode_dma(dev
, resource
,
999 pnp_get_resource(dev
, IORESOURCE_DMA
, dma
));
1002 case ACPI_RESOURCE_TYPE_IO
:
1003 pnpacpi_encode_io(dev
, resource
,
1004 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1007 case ACPI_RESOURCE_TYPE_FIXED_IO
:
1008 pnpacpi_encode_fixed_io(dev
, resource
,
1009 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
1012 case ACPI_RESOURCE_TYPE_MEMORY24
:
1013 pnpacpi_encode_mem24(dev
, resource
,
1014 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1017 case ACPI_RESOURCE_TYPE_MEMORY32
:
1018 pnpacpi_encode_mem32(dev
, resource
,
1019 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1022 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
1023 pnpacpi_encode_fixed_mem32(dev
, resource
,
1024 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
1027 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
1028 pnpacpi_encode_ext_irq(dev
, resource
,
1029 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
1032 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
1033 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
1034 case ACPI_RESOURCE_TYPE_VENDOR
:
1035 case ACPI_RESOURCE_TYPE_END_TAG
:
1036 case ACPI_RESOURCE_TYPE_ADDRESS16
:
1037 case ACPI_RESOURCE_TYPE_ADDRESS32
:
1038 case ACPI_RESOURCE_TYPE_ADDRESS64
:
1039 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
1040 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
1041 default: /* other type */
1042 dev_warn(&dev
->dev
, "can't encode unknown resource "
1043 "type %d\n", resource
->type
);