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>
27 #include <linux/slab.h>
31 static void decode_irq_flags(struct pnp_dev
*dev
, int flags
, int *triggering
,
32 int *polarity
, int *shareable
)
34 switch (flags
& (IORESOURCE_IRQ_LOWLEVEL
| IORESOURCE_IRQ_HIGHLEVEL
|
35 IORESOURCE_IRQ_LOWEDGE
| IORESOURCE_IRQ_HIGHEDGE
)) {
36 case IORESOURCE_IRQ_LOWLEVEL
:
37 *triggering
= ACPI_LEVEL_SENSITIVE
;
38 *polarity
= ACPI_ACTIVE_LOW
;
40 case IORESOURCE_IRQ_HIGHLEVEL
:
41 *triggering
= ACPI_LEVEL_SENSITIVE
;
42 *polarity
= ACPI_ACTIVE_HIGH
;
44 case IORESOURCE_IRQ_LOWEDGE
:
45 *triggering
= ACPI_EDGE_SENSITIVE
;
46 *polarity
= ACPI_ACTIVE_LOW
;
48 case IORESOURCE_IRQ_HIGHEDGE
:
49 *triggering
= ACPI_EDGE_SENSITIVE
;
50 *polarity
= ACPI_ACTIVE_HIGH
;
53 dev_err(&dev
->dev
, "can't encode invalid IRQ mode %#x\n",
55 *triggering
= ACPI_EDGE_SENSITIVE
;
56 *polarity
= ACPI_ACTIVE_HIGH
;
60 if (flags
& IORESOURCE_IRQ_SHAREABLE
)
61 *shareable
= ACPI_SHARED
;
63 *shareable
= ACPI_EXCLUSIVE
;
66 static int dma_flags(struct pnp_dev
*dev
, int type
, int bus_master
,
72 flags
|= IORESOURCE_DMA_MASTER
;
74 case ACPI_COMPATIBILITY
:
75 flags
|= IORESOURCE_DMA_COMPATIBLE
;
78 flags
|= IORESOURCE_DMA_TYPEA
;
81 flags
|= IORESOURCE_DMA_TYPEB
;
84 flags
|= IORESOURCE_DMA_TYPEF
;
87 /* Set a default value ? */
88 flags
|= IORESOURCE_DMA_COMPATIBLE
;
89 dev_err(&dev
->dev
, "invalid DMA type %d\n", type
);
93 flags
|= IORESOURCE_DMA_8BIT
;
95 case ACPI_TRANSFER_8_16
:
96 flags
|= IORESOURCE_DMA_8AND16BIT
;
98 case ACPI_TRANSFER_16
:
99 flags
|= IORESOURCE_DMA_16BIT
;
102 /* Set a default value ? */
103 flags
|= IORESOURCE_DMA_8AND16BIT
;
104 dev_err(&dev
->dev
, "invalid DMA transfer type %d\n", transfer
);
111 * Allocated Resources
114 static void pnpacpi_add_irqresource(struct pnp_dev
*dev
, struct resource
*r
)
116 if (!(r
->flags
& IORESOURCE_DISABLED
))
117 pcibios_penalize_isa_irq(r
->start
, 1);
119 pnp_add_resource(dev
, r
);
123 * Device CSRs that do not appear in PCI config space should be described
124 * via ACPI. This would normally be done with Address Space Descriptors
125 * marked as "consumer-only," but old versions of Windows and Linux ignore
126 * the producer/consumer flag, so HP invented a vendor-defined resource to
127 * describe the location and size of CSR space.
129 static struct acpi_vendor_uuid hp_ccsr_uuid
= {
131 .data
= { 0xf9, 0xad, 0xe9, 0x69, 0x4f, 0x92, 0x5f, 0xab, 0xf6, 0x4a,
132 0x24, 0xd2, 0x01, 0x37, 0x0e, 0xad },
135 static int vendor_resource_matches(struct pnp_dev
*dev
,
136 struct acpi_resource_vendor_typed
*vendor
,
137 struct acpi_vendor_uuid
*match
,
140 int uuid_len
= sizeof(vendor
->uuid
);
141 u8 uuid_subtype
= vendor
->uuid_subtype
;
142 u8
*uuid
= vendor
->uuid
;
145 /* byte_length includes uuid_subtype and uuid */
146 actual_len
= vendor
->byte_length
- uuid_len
- 1;
148 if (uuid_subtype
== match
->subtype
&&
149 uuid_len
== sizeof(match
->data
) &&
150 memcmp(uuid
, match
->data
, uuid_len
) == 0) {
151 if (expected_len
&& expected_len
!= actual_len
) {
152 dev_err(&dev
->dev
, "wrong vendor descriptor size; "
153 "expected %d, found %d bytes\n",
154 expected_len
, actual_len
);
164 static void pnpacpi_parse_allocated_vendor(struct pnp_dev
*dev
,
165 struct acpi_resource_vendor_typed
*vendor
)
167 if (vendor_resource_matches(dev
, vendor
, &hp_ccsr_uuid
, 16)) {
170 memcpy(&start
, vendor
->byte_data
, sizeof(start
));
171 memcpy(&length
, vendor
->byte_data
+ 8, sizeof(length
));
173 pnp_add_mem_resource(dev
, start
, start
+ length
- 1, 0);
177 static acpi_status
pnpacpi_allocated_resource(struct acpi_resource
*res
,
180 struct pnp_dev
*dev
= data
;
181 struct acpi_resource_dma
*dma
;
182 struct acpi_resource_vendor_typed
*vendor_typed
;
183 struct resource r
= {0};
186 if (acpi_dev_resource_memory(res
, &r
)
187 || acpi_dev_resource_io(res
, &r
)
188 || acpi_dev_resource_address_space(res
, &r
)
189 || acpi_dev_resource_ext_address_space(res
, &r
)) {
190 pnp_add_resource(dev
, &r
);
195 if (acpi_dev_resource_interrupt(res
, 0, &r
)) {
196 pnpacpi_add_irqresource(dev
, &r
);
197 for (i
= 1; acpi_dev_resource_interrupt(res
, i
, &r
); i
++)
198 pnpacpi_add_irqresource(dev
, &r
);
202 * The IRQ encoder puts a single interrupt in each
203 * descriptor, so if a _CRS descriptor has more than
204 * one interrupt, we won't be able to re-encode it.
206 if (pnp_can_write(dev
)) {
207 dev_warn(&dev
->dev
, "multiple interrupts in "
208 "_CRS descriptor; configuration can't "
210 dev
->capabilities
&= ~PNP_WRITE
;
214 } else if (r
.flags
& IORESOURCE_DISABLED
) {
215 pnp_add_irq_resource(dev
, 0, IORESOURCE_DISABLED
);
220 case ACPI_RESOURCE_TYPE_DMA
:
221 dma
= &res
->data
.dma
;
222 if (dma
->channel_count
> 0 && dma
->channels
[0] != (u8
) -1)
223 flags
= dma_flags(dev
, dma
->type
, dma
->bus_master
,
226 flags
= IORESOURCE_DISABLED
;
227 pnp_add_dma_resource(dev
, dma
->channels
[0], flags
);
230 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
231 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
234 case ACPI_RESOURCE_TYPE_VENDOR
:
235 vendor_typed
= &res
->data
.vendor_typed
;
236 pnpacpi_parse_allocated_vendor(dev
, vendor_typed
);
239 case ACPI_RESOURCE_TYPE_END_TAG
:
242 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
246 dev_warn(&dev
->dev
, "unknown resource type %d in _CRS\n",
254 int pnpacpi_parse_allocated_resource(struct pnp_dev
*dev
)
256 struct acpi_device
*acpi_dev
= dev
->data
;
257 acpi_handle handle
= acpi_dev
->handle
;
260 pnp_dbg(&dev
->dev
, "parse allocated resources\n");
262 pnp_init_resources(dev
);
264 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
265 pnpacpi_allocated_resource
, dev
);
267 if (ACPI_FAILURE(status
)) {
268 if (status
!= AE_NOT_FOUND
)
269 dev_err(&dev
->dev
, "can't evaluate _CRS: %d", status
);
275 static __init
void pnpacpi_parse_dma_option(struct pnp_dev
*dev
,
276 unsigned int option_flags
,
277 struct acpi_resource_dma
*p
)
280 unsigned char map
= 0, flags
;
282 for (i
= 0; i
< p
->channel_count
; i
++)
283 map
|= 1 << p
->channels
[i
];
285 flags
= dma_flags(dev
, p
->type
, p
->bus_master
, p
->transfer
);
286 pnp_register_dma_resource(dev
, option_flags
, map
, flags
);
289 static __init
void pnpacpi_parse_irq_option(struct pnp_dev
*dev
,
290 unsigned int option_flags
,
291 struct acpi_resource_irq
*p
)
297 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
298 for (i
= 0; i
< p
->interrupt_count
; i
++)
299 if (p
->interrupts
[i
])
300 __set_bit(p
->interrupts
[i
], map
.bits
);
302 flags
= acpi_dev_irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
303 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
306 static __init
void pnpacpi_parse_ext_irq_option(struct pnp_dev
*dev
,
307 unsigned int option_flags
,
308 struct acpi_resource_extended_irq
*p
)
314 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
315 for (i
= 0; i
< p
->interrupt_count
; i
++) {
316 if (p
->interrupts
[i
]) {
317 if (p
->interrupts
[i
] < PNP_IRQ_NR
)
318 __set_bit(p
->interrupts
[i
], map
.bits
);
320 dev_err(&dev
->dev
, "ignoring IRQ %d option "
321 "(too large for %d entry bitmap)\n",
322 p
->interrupts
[i
], PNP_IRQ_NR
);
326 flags
= acpi_dev_irq_flags(p
->triggering
, p
->polarity
, p
->sharable
);
327 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
330 static __init
void pnpacpi_parse_port_option(struct pnp_dev
*dev
,
331 unsigned int option_flags
,
332 struct acpi_resource_io
*io
)
334 unsigned char flags
= 0;
336 if (io
->io_decode
== ACPI_DECODE_16
)
337 flags
= IORESOURCE_IO_16BIT_ADDR
;
338 pnp_register_port_resource(dev
, option_flags
, io
->minimum
, io
->maximum
,
339 io
->alignment
, io
->address_length
, flags
);
342 static __init
void pnpacpi_parse_fixed_port_option(struct pnp_dev
*dev
,
343 unsigned int option_flags
,
344 struct acpi_resource_fixed_io
*io
)
346 pnp_register_port_resource(dev
, option_flags
, io
->address
, io
->address
,
347 0, io
->address_length
, IORESOURCE_IO_FIXED
);
350 static __init
void pnpacpi_parse_mem24_option(struct pnp_dev
*dev
,
351 unsigned int option_flags
,
352 struct acpi_resource_memory24
*p
)
354 unsigned char flags
= 0;
356 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
357 flags
= IORESOURCE_MEM_WRITEABLE
;
358 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
, p
->maximum
,
359 p
->alignment
, p
->address_length
, flags
);
362 static __init
void pnpacpi_parse_mem32_option(struct pnp_dev
*dev
,
363 unsigned int option_flags
,
364 struct acpi_resource_memory32
*p
)
366 unsigned char flags
= 0;
368 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
369 flags
= IORESOURCE_MEM_WRITEABLE
;
370 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
, p
->maximum
,
371 p
->alignment
, p
->address_length
, flags
);
374 static __init
void pnpacpi_parse_fixed_mem32_option(struct pnp_dev
*dev
,
375 unsigned int option_flags
,
376 struct acpi_resource_fixed_memory32
*p
)
378 unsigned char flags
= 0;
380 if (p
->write_protect
== ACPI_READ_WRITE_MEMORY
)
381 flags
= IORESOURCE_MEM_WRITEABLE
;
382 pnp_register_mem_resource(dev
, option_flags
, p
->address
, p
->address
,
383 0, p
->address_length
, flags
);
386 static __init
void pnpacpi_parse_address_option(struct pnp_dev
*dev
,
387 unsigned int option_flags
,
388 struct acpi_resource
*r
)
390 struct acpi_resource_address64 addr
, *p
= &addr
;
392 unsigned char flags
= 0;
394 status
= acpi_resource_to_address64(r
, p
);
395 if (ACPI_FAILURE(status
)) {
396 dev_warn(&dev
->dev
, "can't convert resource type %d\n",
401 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
402 if (p
->info
.mem
.write_protect
== ACPI_READ_WRITE_MEMORY
)
403 flags
= IORESOURCE_MEM_WRITEABLE
;
404 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
,
405 p
->minimum
, 0, p
->address_length
,
407 } else if (p
->resource_type
== ACPI_IO_RANGE
)
408 pnp_register_port_resource(dev
, option_flags
, p
->minimum
,
409 p
->minimum
, 0, p
->address_length
,
410 IORESOURCE_IO_FIXED
);
413 static __init
void pnpacpi_parse_ext_address_option(struct pnp_dev
*dev
,
414 unsigned int option_flags
,
415 struct acpi_resource
*r
)
417 struct acpi_resource_extended_address64
*p
= &r
->data
.ext_address64
;
418 unsigned char flags
= 0;
420 if (p
->resource_type
== ACPI_MEMORY_RANGE
) {
421 if (p
->info
.mem
.write_protect
== ACPI_READ_WRITE_MEMORY
)
422 flags
= IORESOURCE_MEM_WRITEABLE
;
423 pnp_register_mem_resource(dev
, option_flags
, p
->minimum
,
424 p
->minimum
, 0, p
->address_length
,
426 } else if (p
->resource_type
== ACPI_IO_RANGE
)
427 pnp_register_port_resource(dev
, option_flags
, p
->minimum
,
428 p
->minimum
, 0, p
->address_length
,
429 IORESOURCE_IO_FIXED
);
432 struct acpipnp_parse_option_s
{
434 unsigned int option_flags
;
437 static __init acpi_status
pnpacpi_option_resource(struct acpi_resource
*res
,
441 struct acpipnp_parse_option_s
*parse_data
= data
;
442 struct pnp_dev
*dev
= parse_data
->dev
;
443 unsigned int option_flags
= parse_data
->option_flags
;
446 case ACPI_RESOURCE_TYPE_IRQ
:
447 pnpacpi_parse_irq_option(dev
, option_flags
, &res
->data
.irq
);
450 case ACPI_RESOURCE_TYPE_DMA
:
451 pnpacpi_parse_dma_option(dev
, option_flags
, &res
->data
.dma
);
454 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
455 switch (res
->data
.start_dpf
.compatibility_priority
) {
456 case ACPI_GOOD_CONFIGURATION
:
457 priority
= PNP_RES_PRIORITY_PREFERRED
;
460 case ACPI_ACCEPTABLE_CONFIGURATION
:
461 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
464 case ACPI_SUB_OPTIMAL_CONFIGURATION
:
465 priority
= PNP_RES_PRIORITY_FUNCTIONAL
;
468 priority
= PNP_RES_PRIORITY_INVALID
;
471 parse_data
->option_flags
= pnp_new_dependent_set(dev
, priority
);
474 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
475 parse_data
->option_flags
= 0;
478 case ACPI_RESOURCE_TYPE_IO
:
479 pnpacpi_parse_port_option(dev
, option_flags
, &res
->data
.io
);
482 case ACPI_RESOURCE_TYPE_FIXED_IO
:
483 pnpacpi_parse_fixed_port_option(dev
, option_flags
,
484 &res
->data
.fixed_io
);
487 case ACPI_RESOURCE_TYPE_VENDOR
:
488 case ACPI_RESOURCE_TYPE_END_TAG
:
491 case ACPI_RESOURCE_TYPE_MEMORY24
:
492 pnpacpi_parse_mem24_option(dev
, option_flags
,
493 &res
->data
.memory24
);
496 case ACPI_RESOURCE_TYPE_MEMORY32
:
497 pnpacpi_parse_mem32_option(dev
, option_flags
,
498 &res
->data
.memory32
);
501 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
502 pnpacpi_parse_fixed_mem32_option(dev
, option_flags
,
503 &res
->data
.fixed_memory32
);
506 case ACPI_RESOURCE_TYPE_ADDRESS16
:
507 case ACPI_RESOURCE_TYPE_ADDRESS32
:
508 case ACPI_RESOURCE_TYPE_ADDRESS64
:
509 pnpacpi_parse_address_option(dev
, option_flags
, res
);
512 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
513 pnpacpi_parse_ext_address_option(dev
, option_flags
, res
);
516 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
517 pnpacpi_parse_ext_irq_option(dev
, option_flags
,
518 &res
->data
.extended_irq
);
521 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
525 dev_warn(&dev
->dev
, "unknown resource type %d in _PRS\n",
533 int __init
pnpacpi_parse_resource_option_data(struct pnp_dev
*dev
)
535 struct acpi_device
*acpi_dev
= dev
->data
;
536 acpi_handle handle
= acpi_dev
->handle
;
538 struct acpipnp_parse_option_s parse_data
;
540 pnp_dbg(&dev
->dev
, "parse resource options\n");
542 parse_data
.dev
= dev
;
543 parse_data
.option_flags
= 0;
545 status
= acpi_walk_resources(handle
, METHOD_NAME__PRS
,
546 pnpacpi_option_resource
, &parse_data
);
548 if (ACPI_FAILURE(status
)) {
549 if (status
!= AE_NOT_FOUND
)
550 dev_err(&dev
->dev
, "can't evaluate _PRS: %d", status
);
556 static int pnpacpi_supported_resource(struct acpi_resource
*res
)
559 case ACPI_RESOURCE_TYPE_IRQ
:
560 case ACPI_RESOURCE_TYPE_DMA
:
561 case ACPI_RESOURCE_TYPE_IO
:
562 case ACPI_RESOURCE_TYPE_FIXED_IO
:
563 case ACPI_RESOURCE_TYPE_MEMORY24
:
564 case ACPI_RESOURCE_TYPE_MEMORY32
:
565 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
566 case ACPI_RESOURCE_TYPE_ADDRESS16
:
567 case ACPI_RESOURCE_TYPE_ADDRESS32
:
568 case ACPI_RESOURCE_TYPE_ADDRESS64
:
569 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
570 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
579 static acpi_status
pnpacpi_count_resources(struct acpi_resource
*res
,
584 if (pnpacpi_supported_resource(res
))
589 static acpi_status
pnpacpi_type_resources(struct acpi_resource
*res
, void *data
)
591 struct acpi_resource
**resource
= data
;
593 if (pnpacpi_supported_resource(res
)) {
594 (*resource
)->type
= res
->type
;
595 (*resource
)->length
= sizeof(struct acpi_resource
);
596 if (res
->type
== ACPI_RESOURCE_TYPE_IRQ
)
597 (*resource
)->data
.irq
.descriptor_length
=
598 res
->data
.irq
.descriptor_length
;
605 int pnpacpi_build_resource_template(struct pnp_dev
*dev
,
606 struct acpi_buffer
*buffer
)
608 struct acpi_device
*acpi_dev
= dev
->data
;
609 acpi_handle handle
= acpi_dev
->handle
;
610 struct acpi_resource
*resource
;
614 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
615 pnpacpi_count_resources
, &res_cnt
);
616 if (ACPI_FAILURE(status
)) {
617 dev_err(&dev
->dev
, "can't evaluate _CRS: %d\n", status
);
622 buffer
->length
= sizeof(struct acpi_resource
) * (res_cnt
+ 1) + 1;
623 buffer
->pointer
= kzalloc(buffer
->length
- 1, GFP_KERNEL
);
624 if (!buffer
->pointer
)
627 resource
= (struct acpi_resource
*)buffer
->pointer
;
628 status
= acpi_walk_resources(handle
, METHOD_NAME__CRS
,
629 pnpacpi_type_resources
, &resource
);
630 if (ACPI_FAILURE(status
)) {
631 kfree(buffer
->pointer
);
632 dev_err(&dev
->dev
, "can't evaluate _CRS: %d\n", status
);
635 /* resource will pointer the end resource now */
636 resource
->type
= ACPI_RESOURCE_TYPE_END_TAG
;
637 resource
->length
= sizeof(struct acpi_resource
);
642 static void pnpacpi_encode_irq(struct pnp_dev
*dev
,
643 struct acpi_resource
*resource
,
646 struct acpi_resource_irq
*irq
= &resource
->data
.irq
;
647 int triggering
, polarity
, shareable
;
649 if (!pnp_resource_enabled(p
)) {
650 irq
->interrupt_count
= 0;
651 pnp_dbg(&dev
->dev
, " encode irq (%s)\n",
652 p
? "disabled" : "missing");
656 decode_irq_flags(dev
, p
->flags
, &triggering
, &polarity
, &shareable
);
657 irq
->triggering
= triggering
;
658 irq
->polarity
= polarity
;
659 irq
->sharable
= shareable
;
660 irq
->interrupt_count
= 1;
661 irq
->interrupts
[0] = p
->start
;
663 pnp_dbg(&dev
->dev
, " encode irq %d %s %s %s (%d-byte descriptor)\n",
665 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
666 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
667 irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive",
668 irq
->descriptor_length
);
671 static void pnpacpi_encode_ext_irq(struct pnp_dev
*dev
,
672 struct acpi_resource
*resource
,
675 struct acpi_resource_extended_irq
*extended_irq
= &resource
->data
.extended_irq
;
676 int triggering
, polarity
, shareable
;
678 if (!pnp_resource_enabled(p
)) {
679 extended_irq
->interrupt_count
= 0;
680 pnp_dbg(&dev
->dev
, " encode extended irq (%s)\n",
681 p
? "disabled" : "missing");
685 decode_irq_flags(dev
, p
->flags
, &triggering
, &polarity
, &shareable
);
686 extended_irq
->producer_consumer
= ACPI_CONSUMER
;
687 extended_irq
->triggering
= triggering
;
688 extended_irq
->polarity
= polarity
;
689 extended_irq
->sharable
= shareable
;
690 extended_irq
->interrupt_count
= 1;
691 extended_irq
->interrupts
[0] = p
->start
;
693 pnp_dbg(&dev
->dev
, " encode irq %d %s %s %s\n", (int) p
->start
,
694 triggering
== ACPI_LEVEL_SENSITIVE
? "level" : "edge",
695 polarity
== ACPI_ACTIVE_LOW
? "low" : "high",
696 extended_irq
->sharable
== ACPI_SHARED
? "shared" : "exclusive");
699 static void pnpacpi_encode_dma(struct pnp_dev
*dev
,
700 struct acpi_resource
*resource
,
703 struct acpi_resource_dma
*dma
= &resource
->data
.dma
;
705 if (!pnp_resource_enabled(p
)) {
706 dma
->channel_count
= 0;
707 pnp_dbg(&dev
->dev
, " encode dma (%s)\n",
708 p
? "disabled" : "missing");
712 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
713 switch (p
->flags
& IORESOURCE_DMA_SPEED_MASK
) {
714 case IORESOURCE_DMA_TYPEA
:
715 dma
->type
= ACPI_TYPE_A
;
717 case IORESOURCE_DMA_TYPEB
:
718 dma
->type
= ACPI_TYPE_B
;
720 case IORESOURCE_DMA_TYPEF
:
721 dma
->type
= ACPI_TYPE_F
;
724 dma
->type
= ACPI_COMPATIBILITY
;
727 switch (p
->flags
& IORESOURCE_DMA_TYPE_MASK
) {
728 case IORESOURCE_DMA_8BIT
:
729 dma
->transfer
= ACPI_TRANSFER_8
;
731 case IORESOURCE_DMA_8AND16BIT
:
732 dma
->transfer
= ACPI_TRANSFER_8_16
;
735 dma
->transfer
= ACPI_TRANSFER_16
;
738 dma
->bus_master
= !!(p
->flags
& IORESOURCE_DMA_MASTER
);
739 dma
->channel_count
= 1;
740 dma
->channels
[0] = p
->start
;
742 pnp_dbg(&dev
->dev
, " encode dma %d "
743 "type %#x transfer %#x master %d\n",
744 (int) p
->start
, dma
->type
, dma
->transfer
, dma
->bus_master
);
747 static void pnpacpi_encode_io(struct pnp_dev
*dev
,
748 struct acpi_resource
*resource
,
751 struct acpi_resource_io
*io
= &resource
->data
.io
;
753 if (pnp_resource_enabled(p
)) {
754 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
755 io
->io_decode
= (p
->flags
& IORESOURCE_IO_16BIT_ADDR
) ?
756 ACPI_DECODE_16
: ACPI_DECODE_10
;
757 io
->minimum
= p
->start
;
758 io
->maximum
= p
->end
;
759 io
->alignment
= 0; /* Correct? */
760 io
->address_length
= resource_size(p
);
763 io
->address_length
= 0;
766 pnp_dbg(&dev
->dev
, " encode io %#x-%#x decode %#x\n", io
->minimum
,
767 io
->minimum
+ io
->address_length
- 1, io
->io_decode
);
770 static void pnpacpi_encode_fixed_io(struct pnp_dev
*dev
,
771 struct acpi_resource
*resource
,
774 struct acpi_resource_fixed_io
*fixed_io
= &resource
->data
.fixed_io
;
776 if (pnp_resource_enabled(p
)) {
777 fixed_io
->address
= p
->start
;
778 fixed_io
->address_length
= resource_size(p
);
780 fixed_io
->address
= 0;
781 fixed_io
->address_length
= 0;
784 pnp_dbg(&dev
->dev
, " encode fixed_io %#x-%#x\n", fixed_io
->address
,
785 fixed_io
->address
+ fixed_io
->address_length
- 1);
788 static void pnpacpi_encode_mem24(struct pnp_dev
*dev
,
789 struct acpi_resource
*resource
,
792 struct acpi_resource_memory24
*memory24
= &resource
->data
.memory24
;
794 if (pnp_resource_enabled(p
)) {
795 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
796 memory24
->write_protect
= p
->flags
& IORESOURCE_MEM_WRITEABLE
?
797 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
798 memory24
->minimum
= p
->start
;
799 memory24
->maximum
= p
->end
;
800 memory24
->alignment
= 0;
801 memory24
->address_length
= resource_size(p
);
803 memory24
->minimum
= 0;
804 memory24
->address_length
= 0;
807 pnp_dbg(&dev
->dev
, " encode mem24 %#x-%#x write_protect %#x\n",
809 memory24
->minimum
+ memory24
->address_length
- 1,
810 memory24
->write_protect
);
813 static void pnpacpi_encode_mem32(struct pnp_dev
*dev
,
814 struct acpi_resource
*resource
,
817 struct acpi_resource_memory32
*memory32
= &resource
->data
.memory32
;
819 if (pnp_resource_enabled(p
)) {
820 memory32
->write_protect
= p
->flags
& IORESOURCE_MEM_WRITEABLE
?
821 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
822 memory32
->minimum
= p
->start
;
823 memory32
->maximum
= p
->end
;
824 memory32
->alignment
= 0;
825 memory32
->address_length
= resource_size(p
);
827 memory32
->minimum
= 0;
828 memory32
->alignment
= 0;
831 pnp_dbg(&dev
->dev
, " encode mem32 %#x-%#x write_protect %#x\n",
833 memory32
->minimum
+ memory32
->address_length
- 1,
834 memory32
->write_protect
);
837 static void pnpacpi_encode_fixed_mem32(struct pnp_dev
*dev
,
838 struct acpi_resource
*resource
,
841 struct acpi_resource_fixed_memory32
*fixed_memory32
= &resource
->data
.fixed_memory32
;
843 if (pnp_resource_enabled(p
)) {
844 fixed_memory32
->write_protect
=
845 p
->flags
& IORESOURCE_MEM_WRITEABLE
?
846 ACPI_READ_WRITE_MEMORY
: ACPI_READ_ONLY_MEMORY
;
847 fixed_memory32
->address
= p
->start
;
848 fixed_memory32
->address_length
= resource_size(p
);
850 fixed_memory32
->address
= 0;
851 fixed_memory32
->address_length
= 0;
854 pnp_dbg(&dev
->dev
, " encode fixed_mem32 %#x-%#x write_protect %#x\n",
855 fixed_memory32
->address
,
856 fixed_memory32
->address
+ fixed_memory32
->address_length
- 1,
857 fixed_memory32
->write_protect
);
860 int pnpacpi_encode_resources(struct pnp_dev
*dev
, struct acpi_buffer
*buffer
)
863 /* pnpacpi_build_resource_template allocates extra mem */
864 int res_cnt
= (buffer
->length
- 1) / sizeof(struct acpi_resource
) - 1;
865 struct acpi_resource
*resource
= buffer
->pointer
;
866 int port
= 0, irq
= 0, dma
= 0, mem
= 0;
868 pnp_dbg(&dev
->dev
, "encode %d resources\n", res_cnt
);
869 while (i
< res_cnt
) {
870 switch (resource
->type
) {
871 case ACPI_RESOURCE_TYPE_IRQ
:
872 pnpacpi_encode_irq(dev
, resource
,
873 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
877 case ACPI_RESOURCE_TYPE_DMA
:
878 pnpacpi_encode_dma(dev
, resource
,
879 pnp_get_resource(dev
, IORESOURCE_DMA
, dma
));
882 case ACPI_RESOURCE_TYPE_IO
:
883 pnpacpi_encode_io(dev
, resource
,
884 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
887 case ACPI_RESOURCE_TYPE_FIXED_IO
:
888 pnpacpi_encode_fixed_io(dev
, resource
,
889 pnp_get_resource(dev
, IORESOURCE_IO
, port
));
892 case ACPI_RESOURCE_TYPE_MEMORY24
:
893 pnpacpi_encode_mem24(dev
, resource
,
894 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
897 case ACPI_RESOURCE_TYPE_MEMORY32
:
898 pnpacpi_encode_mem32(dev
, resource
,
899 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
902 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32
:
903 pnpacpi_encode_fixed_mem32(dev
, resource
,
904 pnp_get_resource(dev
, IORESOURCE_MEM
, mem
));
907 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
908 pnpacpi_encode_ext_irq(dev
, resource
,
909 pnp_get_resource(dev
, IORESOURCE_IRQ
, irq
));
912 case ACPI_RESOURCE_TYPE_START_DEPENDENT
:
913 case ACPI_RESOURCE_TYPE_END_DEPENDENT
:
914 case ACPI_RESOURCE_TYPE_VENDOR
:
915 case ACPI_RESOURCE_TYPE_END_TAG
:
916 case ACPI_RESOURCE_TYPE_ADDRESS16
:
917 case ACPI_RESOURCE_TYPE_ADDRESS32
:
918 case ACPI_RESOURCE_TYPE_ADDRESS64
:
919 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
:
920 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER
:
921 default: /* other type */
922 dev_warn(&dev
->dev
, "can't encode unknown resource "
923 "type %d\n", resource
->type
);