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)
38 if (triggering == ACPI_LEVEL_SENSITIVE) {
39 if (polarity == ACPI_ACTIVE_LOW)
40 flag = IORESOURCE_IRQ_LOWLEVEL;
42 flag = IORESOURCE_IRQ_HIGHLEVEL;
44 if (polarity == ACPI_ACTIVE_LOW)
45 flag = IORESOURCE_IRQ_LOWEDGE;
47 flag = IORESOURCE_IRQ_HIGHEDGE;
52 static void decode_irq_flags(int flag, int *triggering, int *polarity)
55 case IORESOURCE_IRQ_LOWLEVEL:
56 *triggering = ACPI_LEVEL_SENSITIVE;
57 *polarity = ACPI_ACTIVE_LOW;
59 case IORESOURCE_IRQ_HIGHLEVEL:
60 *triggering = ACPI_LEVEL_SENSITIVE;
61 *polarity = ACPI_ACTIVE_HIGH;
63 case IORESOURCE_IRQ_LOWEDGE:
64 *triggering = ACPI_EDGE_SENSITIVE;
65 *polarity = ACPI_ACTIVE_LOW;
67 case IORESOURCE_IRQ_HIGHEDGE:
68 *triggering = ACPI_EDGE_SENSITIVE;
69 *polarity = ACPI_ACTIVE_HIGH;
74 static void pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res,
75 u32 gsi, int triggering,
76 int polarity, int shareable)
84 while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) &&
90 res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag
91 res->irq_resource[i].flags |= irq_flags(triggering, polarity);
92 irq = acpi_register_gsi(gsi, triggering, polarity);
94 res->irq_resource[i].flags |= IORESOURCE_DISABLED;
99 res->irq_resource[i].flags |= IORESOURCE_IRQ_SHAREABLE;
101 res->irq_resource[i].start = irq;
102 res->irq_resource[i].end = irq;
103 pcibios_penalize_isa_irq(irq, 1);
106 static int dma_flags(int type, int bus_master, int transfer)
111 flags |= IORESOURCE_DMA_MASTER;
113 case ACPI_COMPATIBILITY:
114 flags |= IORESOURCE_DMA_COMPATIBLE;
117 flags |= IORESOURCE_DMA_TYPEA;
120 flags |= IORESOURCE_DMA_TYPEB;
123 flags |= IORESOURCE_DMA_TYPEF;
126 /* Set a default value ? */
127 flags |= IORESOURCE_DMA_COMPATIBLE;
128 pnp_err("Invalid DMA type");
131 case ACPI_TRANSFER_8:
132 flags |= IORESOURCE_DMA_8BIT;
134 case ACPI_TRANSFER_8_16:
135 flags |= IORESOURCE_DMA_8AND16BIT;
137 case ACPI_TRANSFER_16:
138 flags |= IORESOURCE_DMA_16BIT;
141 /* Set a default value ? */
142 flags |= IORESOURCE_DMA_8AND16BIT;
143 pnp_err("Invalid DMA transfer type");
149 static void pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res,
151 int bus_master, int transfer)
155 while (i < PNP_MAX_DMA &&
156 !(res->dma_resource[i].flags & IORESOURCE_UNSET))
158 if (i < PNP_MAX_DMA) {
159 res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag
160 res->dma_resource[i].flags |=
161 dma_flags(type, bus_master, transfer);
163 res->dma_resource[i].flags |= IORESOURCE_DISABLED;
166 res->dma_resource[i].start = dma;
167 res->dma_resource[i].end = dma;
171 static void pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res,
172 u64 io, u64 len, int io_decode)
176 while (!(res->port_resource[i].flags & IORESOURCE_UNSET) &&
179 if (i < PNP_MAX_PORT) {
180 res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag
181 if (io_decode == ACPI_DECODE_16)
182 res->port_resource[i].flags |= PNP_PORT_FLAG_16BITADDR;
183 if (len <= 0 || (io + len - 1) >= 0x10003) {
184 res->port_resource[i].flags |= IORESOURCE_DISABLED;
187 res->port_resource[i].start = io;
188 res->port_resource[i].end = io + len - 1;
192 static void pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res,
198 while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) &&
201 if (i < PNP_MAX_MEM) {
202 res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag
204 res->mem_resource[i].flags |= IORESOURCE_DISABLED;
207 if (write_protect == ACPI_READ_WRITE_MEMORY)
208 res->mem_resource[i].flags |= IORESOURCE_MEM_WRITEABLE;
210 res->mem_resource[i].start = mem;
211 res->mem_resource[i].end = mem + len - 1;
215 static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
216 struct acpi_resource *res)
218 struct acpi_resource_address64 addr, *p = &addr;
221 status = acpi_resource_to_address64(res, p);
222 if (!ACPI_SUCCESS(status)) {
223 pnp_warn("PnPACPI: failed to convert resource type %d",
228 if (p->producer_consumer == ACPI_PRODUCER)
231 if (p->resource_type == ACPI_MEMORY_RANGE)
232 pnpacpi_parse_allocated_memresource(res_table,
233 p->minimum, p->address_length,
234 p->info.mem.write_protect);
235 else if (p->resource_type == ACPI_IO_RANGE)
236 pnpacpi_parse_allocated_ioresource(res_table,
237 p->minimum, p->address_length,
238 p->granularity == 0xfff ? ACPI_DECODE_10 :
242 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
245 struct pnp_resource_table *res_table =
246 (struct pnp_resource_table *)data;
250 case ACPI_RESOURCE_TYPE_IRQ:
252 * Per spec, only one interrupt per descriptor is allowed in
253 * _CRS, but some firmware violates this, so parse them all.
255 for (i = 0; i < res->data.irq.interrupt_count; i++) {
256 pnpacpi_parse_allocated_irqresource(res_table,
257 res->data.irq.interrupts[i],
258 res->data.irq.triggering,
259 res->data.irq.polarity,
260 res->data.irq.sharable);
264 case ACPI_RESOURCE_TYPE_DMA:
265 if (res->data.dma.channel_count > 0)
266 pnpacpi_parse_allocated_dmaresource(res_table,
267 res->data.dma.channels[0],
269 res->data.dma.bus_master,
270 res->data.dma.transfer);
273 case ACPI_RESOURCE_TYPE_IO:
274 pnpacpi_parse_allocated_ioresource(res_table,
275 res->data.io.minimum,
276 res->data.io.address_length,
277 res->data.io.io_decode);
280 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
281 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
284 case ACPI_RESOURCE_TYPE_FIXED_IO:
285 pnpacpi_parse_allocated_ioresource(res_table,
286 res->data.fixed_io.address,
287 res->data.fixed_io.address_length,
291 case ACPI_RESOURCE_TYPE_VENDOR:
294 case ACPI_RESOURCE_TYPE_END_TAG:
297 case ACPI_RESOURCE_TYPE_MEMORY24:
298 pnpacpi_parse_allocated_memresource(res_table,
299 res->data.memory24.minimum,
300 res->data.memory24.address_length,
301 res->data.memory24.write_protect);
303 case ACPI_RESOURCE_TYPE_MEMORY32:
304 pnpacpi_parse_allocated_memresource(res_table,
305 res->data.memory32.minimum,
306 res->data.memory32.address_length,
307 res->data.memory32.write_protect);
309 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
310 pnpacpi_parse_allocated_memresource(res_table,
311 res->data.fixed_memory32.address,
312 res->data.fixed_memory32.address_length,
313 res->data.fixed_memory32.write_protect);
315 case ACPI_RESOURCE_TYPE_ADDRESS16:
316 case ACPI_RESOURCE_TYPE_ADDRESS32:
317 case ACPI_RESOURCE_TYPE_ADDRESS64:
318 pnpacpi_parse_allocated_address_space(res_table, res);
321 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
322 if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
326 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
327 if (res->data.extended_irq.producer_consumer == ACPI_PRODUCER)
330 for (i = 0; i < res->data.extended_irq.interrupt_count; i++) {
331 pnpacpi_parse_allocated_irqresource(res_table,
332 res->data.extended_irq.interrupts[i],
333 res->data.extended_irq.triggering,
334 res->data.extended_irq.polarity,
335 res->data.extended_irq.sharable);
339 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
343 pnp_warn("PnPACPI: unknown resource type %d", res->type);
350 acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle,
351 struct pnp_resource_table * res)
353 /* Blank the resource table values */
354 pnp_init_resource_table(res);
356 return acpi_walk_resources(handle, METHOD_NAME__CRS,
357 pnpacpi_allocated_resource, res);
360 static void pnpacpi_parse_dma_option(struct pnp_option *option,
361 struct acpi_resource_dma *p)
366 if (p->channel_count == 0)
368 dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
372 for (i = 0; i < p->channel_count; i++)
373 dma->map |= 1 << p->channels[i];
375 dma->flags = dma_flags(p->type, p->bus_master, p->transfer);
377 pnp_register_dma_resource(option, dma);
380 static void pnpacpi_parse_irq_option(struct pnp_option *option,
381 struct acpi_resource_irq *p)
386 if (p->interrupt_count == 0)
388 irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
392 for (i = 0; i < p->interrupt_count; i++)
393 if (p->interrupts[i])
394 __set_bit(p->interrupts[i], irq->map);
395 irq->flags = irq_flags(p->triggering, p->polarity);
397 pnp_register_irq_resource(option, irq);
400 static void pnpacpi_parse_ext_irq_option(struct pnp_option *option,
401 struct acpi_resource_extended_irq *p)
406 if (p->interrupt_count == 0)
408 irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
412 for (i = 0; i < p->interrupt_count; i++)
413 if (p->interrupts[i])
414 __set_bit(p->interrupts[i], irq->map);
415 irq->flags = irq_flags(p->triggering, p->polarity);
417 pnp_register_irq_resource(option, irq);
420 static void pnpacpi_parse_port_option(struct pnp_option *option,
421 struct acpi_resource_io *io)
423 struct pnp_port *port;
425 if (io->address_length == 0)
427 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
430 port->min = io->minimum;
431 port->max = io->maximum;
432 port->align = io->alignment;
433 port->size = io->address_length;
434 port->flags = ACPI_DECODE_16 == io->io_decode ?
435 PNP_PORT_FLAG_16BITADDR : 0;
436 pnp_register_port_resource(option, port);
439 static void pnpacpi_parse_fixed_port_option(struct pnp_option *option,
440 struct acpi_resource_fixed_io *io)
442 struct pnp_port *port;
444 if (io->address_length == 0)
446 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
449 port->min = port->max = io->address;
450 port->size = io->address_length;
452 port->flags = PNP_PORT_FLAG_FIXED;
453 pnp_register_port_resource(option, port);
456 static void pnpacpi_parse_mem24_option(struct pnp_option *option,
457 struct acpi_resource_memory24 *p)
461 if (p->address_length == 0)
463 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
466 mem->min = p->minimum;
467 mem->max = p->maximum;
468 mem->align = p->alignment;
469 mem->size = p->address_length;
471 mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
472 IORESOURCE_MEM_WRITEABLE : 0;
474 pnp_register_mem_resource(option, mem);
477 static void pnpacpi_parse_mem32_option(struct pnp_option *option,
478 struct acpi_resource_memory32 *p)
482 if (p->address_length == 0)
484 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
487 mem->min = p->minimum;
488 mem->max = p->maximum;
489 mem->align = p->alignment;
490 mem->size = p->address_length;
492 mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
493 IORESOURCE_MEM_WRITEABLE : 0;
495 pnp_register_mem_resource(option, mem);
498 static void pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
499 struct acpi_resource_fixed_memory32 *p)
503 if (p->address_length == 0)
505 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
508 mem->min = mem->max = p->address;
509 mem->size = p->address_length;
512 mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
513 IORESOURCE_MEM_WRITEABLE : 0;
515 pnp_register_mem_resource(option, mem);
518 static void pnpacpi_parse_address_option(struct pnp_option *option,
519 struct acpi_resource *r)
521 struct acpi_resource_address64 addr, *p = &addr;
524 struct pnp_port *port;
526 status = acpi_resource_to_address64(r, p);
527 if (!ACPI_SUCCESS(status)) {
528 pnp_warn("PnPACPI: failed to convert resource type %d",
533 if (p->address_length == 0)
536 if (p->resource_type == ACPI_MEMORY_RANGE) {
537 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
540 mem->min = mem->max = p->minimum;
541 mem->size = p->address_length;
543 mem->flags = (p->info.mem.write_protect ==
544 ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE
546 pnp_register_mem_resource(option, mem);
547 } else if (p->resource_type == ACPI_IO_RANGE) {
548 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
551 port->min = port->max = p->minimum;
552 port->size = p->address_length;
554 port->flags = PNP_PORT_FLAG_FIXED;
555 pnp_register_port_resource(option, port);
559 struct acpipnp_parse_option_s {
560 struct pnp_option *option;
561 struct pnp_option *option_independent;
565 static acpi_status pnpacpi_option_resource(struct acpi_resource *res,
569 struct acpipnp_parse_option_s *parse_data =
570 (struct acpipnp_parse_option_s *)data;
571 struct pnp_dev *dev = parse_data->dev;
572 struct pnp_option *option = parse_data->option;
575 case ACPI_RESOURCE_TYPE_IRQ:
576 pnpacpi_parse_irq_option(option, &res->data.irq);
579 case ACPI_RESOURCE_TYPE_DMA:
580 pnpacpi_parse_dma_option(option, &res->data.dma);
583 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
584 switch (res->data.start_dpf.compatibility_priority) {
585 case ACPI_GOOD_CONFIGURATION:
586 priority = PNP_RES_PRIORITY_PREFERRED;
589 case ACPI_ACCEPTABLE_CONFIGURATION:
590 priority = PNP_RES_PRIORITY_ACCEPTABLE;
593 case ACPI_SUB_OPTIMAL_CONFIGURATION:
594 priority = PNP_RES_PRIORITY_FUNCTIONAL;
597 priority = PNP_RES_PRIORITY_INVALID;
600 /* TBD: Consider performance/robustness bits */
601 option = pnp_register_dependent_option(dev, priority);
604 parse_data->option = option;
607 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
608 /*only one EndDependentFn is allowed */
609 if (!parse_data->option_independent) {
610 pnp_warn("PnPACPI: more than one EndDependentFn");
613 parse_data->option = parse_data->option_independent;
614 parse_data->option_independent = NULL;
617 case ACPI_RESOURCE_TYPE_IO:
618 pnpacpi_parse_port_option(option, &res->data.io);
621 case ACPI_RESOURCE_TYPE_FIXED_IO:
622 pnpacpi_parse_fixed_port_option(option, &res->data.fixed_io);
625 case ACPI_RESOURCE_TYPE_VENDOR:
626 case ACPI_RESOURCE_TYPE_END_TAG:
629 case ACPI_RESOURCE_TYPE_MEMORY24:
630 pnpacpi_parse_mem24_option(option, &res->data.memory24);
633 case ACPI_RESOURCE_TYPE_MEMORY32:
634 pnpacpi_parse_mem32_option(option, &res->data.memory32);
637 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
638 pnpacpi_parse_fixed_mem32_option(option,
639 &res->data.fixed_memory32);
642 case ACPI_RESOURCE_TYPE_ADDRESS16:
643 case ACPI_RESOURCE_TYPE_ADDRESS32:
644 case ACPI_RESOURCE_TYPE_ADDRESS64:
645 pnpacpi_parse_address_option(option, res);
648 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
651 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
652 pnpacpi_parse_ext_irq_option(option, &res->data.extended_irq);
655 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
659 pnp_warn("PnPACPI: unknown resource type %d", res->type);
666 acpi_status pnpacpi_parse_resource_option_data(acpi_handle handle,
667 struct pnp_dev * dev)
670 struct acpipnp_parse_option_s parse_data;
672 parse_data.option = pnp_register_independent_option(dev);
673 if (!parse_data.option)
675 parse_data.option_independent = parse_data.option;
676 parse_data.dev = dev;
677 status = acpi_walk_resources(handle, METHOD_NAME__PRS,
678 pnpacpi_option_resource, &parse_data);
683 static int pnpacpi_supported_resource(struct acpi_resource *res)
686 case ACPI_RESOURCE_TYPE_IRQ:
687 case ACPI_RESOURCE_TYPE_DMA:
688 case ACPI_RESOURCE_TYPE_IO:
689 case ACPI_RESOURCE_TYPE_FIXED_IO:
690 case ACPI_RESOURCE_TYPE_MEMORY24:
691 case ACPI_RESOURCE_TYPE_MEMORY32:
692 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
693 case ACPI_RESOURCE_TYPE_ADDRESS16:
694 case ACPI_RESOURCE_TYPE_ADDRESS32:
695 case ACPI_RESOURCE_TYPE_ADDRESS64:
696 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
705 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
708 int *res_cnt = (int *)data;
710 if (pnpacpi_supported_resource(res))
715 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
717 struct acpi_resource **resource = (struct acpi_resource **)data;
719 if (pnpacpi_supported_resource(res)) {
720 (*resource)->type = res->type;
721 (*resource)->length = sizeof(struct acpi_resource);
728 int pnpacpi_build_resource_template(acpi_handle handle,
729 struct acpi_buffer *buffer)
731 struct acpi_resource *resource;
735 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
736 pnpacpi_count_resources, &res_cnt);
737 if (ACPI_FAILURE(status)) {
738 pnp_err("Evaluate _CRS failed");
743 buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
744 buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
745 if (!buffer->pointer)
747 pnp_dbg("Res cnt %d", res_cnt);
748 resource = (struct acpi_resource *)buffer->pointer;
749 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
750 pnpacpi_type_resources, &resource);
751 if (ACPI_FAILURE(status)) {
752 kfree(buffer->pointer);
753 pnp_err("Evaluate _CRS failed");
756 /* resource will pointer the end resource now */
757 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
762 static void pnpacpi_encode_irq(struct acpi_resource *resource,
765 int triggering, polarity;
767 decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
768 resource->data.irq.triggering = triggering;
769 resource->data.irq.polarity = polarity;
770 if (triggering == ACPI_EDGE_SENSITIVE)
771 resource->data.irq.sharable = ACPI_EXCLUSIVE;
773 resource->data.irq.sharable = ACPI_SHARED;
774 resource->data.irq.interrupt_count = 1;
775 resource->data.irq.interrupts[0] = p->start;
778 static void pnpacpi_encode_ext_irq(struct acpi_resource *resource,
781 int triggering, polarity;
783 decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
784 resource->data.extended_irq.producer_consumer = ACPI_CONSUMER;
785 resource->data.extended_irq.triggering = triggering;
786 resource->data.extended_irq.polarity = polarity;
787 if (triggering == ACPI_EDGE_SENSITIVE)
788 resource->data.irq.sharable = ACPI_EXCLUSIVE;
790 resource->data.irq.sharable = ACPI_SHARED;
791 resource->data.extended_irq.interrupt_count = 1;
792 resource->data.extended_irq.interrupts[0] = p->start;
795 static void pnpacpi_encode_dma(struct acpi_resource *resource,
798 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
799 switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
800 case IORESOURCE_DMA_TYPEA:
801 resource->data.dma.type = ACPI_TYPE_A;
803 case IORESOURCE_DMA_TYPEB:
804 resource->data.dma.type = ACPI_TYPE_B;
806 case IORESOURCE_DMA_TYPEF:
807 resource->data.dma.type = ACPI_TYPE_F;
810 resource->data.dma.type = ACPI_COMPATIBILITY;
813 switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
814 case IORESOURCE_DMA_8BIT:
815 resource->data.dma.transfer = ACPI_TRANSFER_8;
817 case IORESOURCE_DMA_8AND16BIT:
818 resource->data.dma.transfer = ACPI_TRANSFER_8_16;
821 resource->data.dma.transfer = ACPI_TRANSFER_16;
824 resource->data.dma.bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
825 resource->data.dma.channel_count = 1;
826 resource->data.dma.channels[0] = p->start;
829 static void pnpacpi_encode_io(struct acpi_resource *resource,
832 /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
833 resource->data.io.io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR) ?
834 ACPI_DECODE_16 : ACPI_DECODE_10;
835 resource->data.io.minimum = p->start;
836 resource->data.io.maximum = p->end;
837 resource->data.io.alignment = 0; /* Correct? */
838 resource->data.io.address_length = p->end - p->start + 1;
841 static void pnpacpi_encode_fixed_io(struct acpi_resource *resource,
844 resource->data.fixed_io.address = p->start;
845 resource->data.fixed_io.address_length = p->end - p->start + 1;
848 static void pnpacpi_encode_mem24(struct acpi_resource *resource,
851 /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
852 resource->data.memory24.write_protect =
853 (p->flags & IORESOURCE_MEM_WRITEABLE) ?
854 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
855 resource->data.memory24.minimum = p->start;
856 resource->data.memory24.maximum = p->end;
857 resource->data.memory24.alignment = 0;
858 resource->data.memory24.address_length = p->end - p->start + 1;
861 static void pnpacpi_encode_mem32(struct acpi_resource *resource,
864 resource->data.memory32.write_protect =
865 (p->flags & IORESOURCE_MEM_WRITEABLE) ?
866 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
867 resource->data.memory32.minimum = p->start;
868 resource->data.memory32.maximum = p->end;
869 resource->data.memory32.alignment = 0;
870 resource->data.memory32.address_length = p->end - p->start + 1;
873 static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
876 resource->data.fixed_memory32.write_protect =
877 (p->flags & IORESOURCE_MEM_WRITEABLE) ?
878 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
879 resource->data.fixed_memory32.address = p->start;
880 resource->data.fixed_memory32.address_length = p->end - p->start + 1;
883 int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
884 struct acpi_buffer *buffer)
887 /* pnpacpi_build_resource_template allocates extra mem */
888 int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
889 struct acpi_resource *resource =
890 (struct acpi_resource *)buffer->pointer;
891 int port = 0, irq = 0, dma = 0, mem = 0;
893 pnp_dbg("res cnt %d", res_cnt);
894 while (i < res_cnt) {
895 switch (resource->type) {
896 case ACPI_RESOURCE_TYPE_IRQ:
897 pnp_dbg("Encode irq");
898 pnpacpi_encode_irq(resource,
899 &res_table->irq_resource[irq]);
903 case ACPI_RESOURCE_TYPE_DMA:
904 pnp_dbg("Encode dma");
905 pnpacpi_encode_dma(resource,
906 &res_table->dma_resource[dma]);
909 case ACPI_RESOURCE_TYPE_IO:
910 pnp_dbg("Encode io");
911 pnpacpi_encode_io(resource,
912 &res_table->port_resource[port]);
915 case ACPI_RESOURCE_TYPE_FIXED_IO:
916 pnp_dbg("Encode fixed io");
917 pnpacpi_encode_fixed_io(resource,
919 port_resource[port]);
922 case ACPI_RESOURCE_TYPE_MEMORY24:
923 pnp_dbg("Encode mem24");
924 pnpacpi_encode_mem24(resource,
925 &res_table->mem_resource[mem]);
928 case ACPI_RESOURCE_TYPE_MEMORY32:
929 pnp_dbg("Encode mem32");
930 pnpacpi_encode_mem32(resource,
931 &res_table->mem_resource[mem]);
934 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
935 pnp_dbg("Encode fixed mem32");
936 pnpacpi_encode_fixed_mem32(resource,
941 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
942 pnp_dbg("Encode ext irq");
943 pnpacpi_encode_ext_irq(resource,
944 &res_table->irq_resource[irq]);
947 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
948 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
949 case ACPI_RESOURCE_TYPE_VENDOR:
950 case ACPI_RESOURCE_TYPE_END_TAG:
951 case ACPI_RESOURCE_TYPE_ADDRESS16:
952 case ACPI_RESOURCE_TYPE_ADDRESS32:
953 case ACPI_RESOURCE_TYPE_ADDRESS64:
954 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
955 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
956 default: /* other type */
957 pnp_warn("unknown resource type %d", resource->type);