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;
45 if (polarity == ACPI_ACTIVE_LOW)
46 flag = IORESOURCE_IRQ_LOWEDGE;
48 flag = IORESOURCE_IRQ_HIGHEDGE;
53 static void decode_irq_flags(int flag, int *triggering, int *polarity)
56 case IORESOURCE_IRQ_LOWLEVEL:
57 *triggering = ACPI_LEVEL_SENSITIVE;
58 *polarity = ACPI_ACTIVE_LOW;
60 case IORESOURCE_IRQ_HIGHLEVEL:
61 *triggering = ACPI_LEVEL_SENSITIVE;
62 *polarity = ACPI_ACTIVE_HIGH;
64 case IORESOURCE_IRQ_LOWEDGE:
65 *triggering = ACPI_EDGE_SENSITIVE;
66 *polarity = ACPI_ACTIVE_LOW;
68 case IORESOURCE_IRQ_HIGHEDGE:
69 *triggering = ACPI_EDGE_SENSITIVE;
70 *polarity = ACPI_ACTIVE_HIGH;
76 pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res, u32 gsi,
77 int triggering, int polarity, int shareable)
85 while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) &&
91 res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag
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);
107 pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res, u32 dma)
110 while (i < PNP_MAX_DMA &&
111 !(res->dma_resource[i].flags & IORESOURCE_UNSET))
113 if (i < PNP_MAX_DMA) {
114 res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag
116 res->dma_resource[i].flags |= IORESOURCE_DISABLED;
119 res->dma_resource[i].start = dma;
120 res->dma_resource[i].end = dma;
125 pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res,
129 while (!(res->port_resource[i].flags & IORESOURCE_UNSET) &&
132 if (i < PNP_MAX_PORT) {
133 res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag
134 if (len <= 0 || (io + len -1) >= 0x10003) {
135 res->port_resource[i].flags |= IORESOURCE_DISABLED;
138 res->port_resource[i].start = io;
139 res->port_resource[i].end = io + len - 1;
144 pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res,
148 while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) &&
151 if (i < PNP_MAX_MEM) {
152 res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag
154 res->mem_resource[i].flags |= IORESOURCE_DISABLED;
157 res->mem_resource[i].start = mem;
158 res->mem_resource[i].end = mem + len - 1;
163 pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
164 struct acpi_resource *res)
166 struct acpi_resource_address64 addr, *p = &addr;
169 status = acpi_resource_to_address64(res, p);
170 if (!ACPI_SUCCESS(status)) {
171 pnp_warn("PnPACPI: failed to convert resource type %d",
176 if (p->resource_type == ACPI_MEMORY_RANGE)
177 pnpacpi_parse_allocated_memresource(res_table,
178 p->minimum, p->address_length);
179 else if (p->resource_type == ACPI_IO_RANGE)
180 pnpacpi_parse_allocated_ioresource(res_table,
181 p->minimum, p->address_length);
184 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
187 struct pnp_resource_table *res_table = (struct pnp_resource_table *)data;
191 case ACPI_RESOURCE_TYPE_IRQ:
193 * Per spec, only one interrupt per descriptor is allowed in
194 * _CRS, but some firmware violates this, so parse them all.
196 for (i = 0; i < res->data.irq.interrupt_count; i++) {
197 pnpacpi_parse_allocated_irqresource(res_table,
198 res->data.irq.interrupts[i],
199 res->data.irq.triggering,
200 res->data.irq.polarity,
201 res->data.irq.sharable);
205 case ACPI_RESOURCE_TYPE_DMA:
206 if (res->data.dma.channel_count > 0)
207 pnpacpi_parse_allocated_dmaresource(res_table,
208 res->data.dma.channels[0]);
211 case ACPI_RESOURCE_TYPE_IO:
212 pnpacpi_parse_allocated_ioresource(res_table,
213 res->data.io.minimum,
214 res->data.io.address_length);
217 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
218 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
221 case ACPI_RESOURCE_TYPE_FIXED_IO:
222 pnpacpi_parse_allocated_ioresource(res_table,
223 res->data.fixed_io.address,
224 res->data.fixed_io.address_length);
227 case ACPI_RESOURCE_TYPE_VENDOR:
230 case ACPI_RESOURCE_TYPE_END_TAG:
233 case ACPI_RESOURCE_TYPE_MEMORY24:
234 pnpacpi_parse_allocated_memresource(res_table,
235 res->data.memory24.minimum,
236 res->data.memory24.address_length);
238 case ACPI_RESOURCE_TYPE_MEMORY32:
239 pnpacpi_parse_allocated_memresource(res_table,
240 res->data.memory32.minimum,
241 res->data.memory32.address_length);
243 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
244 pnpacpi_parse_allocated_memresource(res_table,
245 res->data.fixed_memory32.address,
246 res->data.fixed_memory32.address_length);
248 case ACPI_RESOURCE_TYPE_ADDRESS16:
249 case ACPI_RESOURCE_TYPE_ADDRESS32:
250 case ACPI_RESOURCE_TYPE_ADDRESS64:
251 pnpacpi_parse_allocated_address_space(res_table, res);
254 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
257 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
258 for (i = 0; i < res->data.extended_irq.interrupt_count; i++) {
259 pnpacpi_parse_allocated_irqresource(res_table,
260 res->data.extended_irq.interrupts[i],
261 res->data.extended_irq.triggering,
262 res->data.extended_irq.polarity,
263 res->data.extended_irq.sharable);
267 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
271 pnp_warn("PnPACPI: unknown resource type %d", res->type);
278 acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle, struct pnp_resource_table *res)
280 /* Blank the resource table values */
281 pnp_init_resource_table(res);
283 return acpi_walk_resources(handle, METHOD_NAME__CRS, pnpacpi_allocated_resource, res);
286 static void pnpacpi_parse_dma_option(struct pnp_option *option, struct acpi_resource_dma *p)
289 struct pnp_dma * dma;
291 if (p->channel_count == 0)
293 dma = kcalloc(1, sizeof(struct pnp_dma), GFP_KERNEL);
297 for(i = 0; i < p->channel_count; i++)
298 dma->map |= 1 << p->channels[i];
301 dma->flags |= IORESOURCE_DMA_MASTER;
303 case ACPI_COMPATIBILITY:
304 dma->flags |= IORESOURCE_DMA_COMPATIBLE;
307 dma->flags |= IORESOURCE_DMA_TYPEA;
310 dma->flags |= IORESOURCE_DMA_TYPEB;
313 dma->flags |= IORESOURCE_DMA_TYPEF;
316 /* Set a default value ? */
317 dma->flags |= IORESOURCE_DMA_COMPATIBLE;
318 pnp_err("Invalid DMA type");
320 switch (p->transfer) {
321 case ACPI_TRANSFER_8:
322 dma->flags |= IORESOURCE_DMA_8BIT;
324 case ACPI_TRANSFER_8_16:
325 dma->flags |= IORESOURCE_DMA_8AND16BIT;
327 case ACPI_TRANSFER_16:
328 dma->flags |= IORESOURCE_DMA_16BIT;
331 /* Set a default value ? */
332 dma->flags |= IORESOURCE_DMA_8AND16BIT;
333 pnp_err("Invalid DMA transfer type");
336 pnp_register_dma_resource(option, dma);
341 static void pnpacpi_parse_irq_option(struct pnp_option *option,
342 struct acpi_resource_irq *p)
347 if (p->interrupt_count == 0)
349 irq = kcalloc(1, sizeof(struct pnp_irq), GFP_KERNEL);
353 for(i = 0; i < p->interrupt_count; i++)
354 if (p->interrupts[i])
355 __set_bit(p->interrupts[i], irq->map);
356 irq->flags = irq_flags(p->triggering, p->polarity);
358 pnp_register_irq_resource(option, irq);
362 static void pnpacpi_parse_ext_irq_option(struct pnp_option *option,
363 struct acpi_resource_extended_irq *p)
368 if (p->interrupt_count == 0)
370 irq = kcalloc(1, sizeof(struct pnp_irq), GFP_KERNEL);
374 for(i = 0; i < p->interrupt_count; i++)
375 if (p->interrupts[i])
376 __set_bit(p->interrupts[i], irq->map);
377 irq->flags = irq_flags(p->triggering, p->polarity);
379 pnp_register_irq_resource(option, irq);
384 pnpacpi_parse_port_option(struct pnp_option *option,
385 struct acpi_resource_io *io)
387 struct pnp_port *port;
389 if (io->address_length == 0)
391 port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
394 port->min = io->minimum;
395 port->max = io->maximum;
396 port->align = io->alignment;
397 port->size = io->address_length;
398 port->flags = ACPI_DECODE_16 == io->io_decode ?
399 PNP_PORT_FLAG_16BITADDR : 0;
400 pnp_register_port_resource(option, port);
405 pnpacpi_parse_fixed_port_option(struct pnp_option *option,
406 struct acpi_resource_fixed_io *io)
408 struct pnp_port *port;
410 if (io->address_length == 0)
412 port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
415 port->min = port->max = io->address;
416 port->size = io->address_length;
418 port->flags = PNP_PORT_FLAG_FIXED;
419 pnp_register_port_resource(option, port);
424 pnpacpi_parse_mem24_option(struct pnp_option *option,
425 struct acpi_resource_memory24 *p)
429 if (p->address_length == 0)
431 mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
434 mem->min = p->minimum;
435 mem->max = p->maximum;
436 mem->align = p->alignment;
437 mem->size = p->address_length;
439 mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
440 IORESOURCE_MEM_WRITEABLE : 0;
442 pnp_register_mem_resource(option, mem);
447 pnpacpi_parse_mem32_option(struct pnp_option *option,
448 struct acpi_resource_memory32 *p)
452 if (p->address_length == 0)
454 mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
457 mem->min = p->minimum;
458 mem->max = p->maximum;
459 mem->align = p->alignment;
460 mem->size = p->address_length;
462 mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
463 IORESOURCE_MEM_WRITEABLE : 0;
465 pnp_register_mem_resource(option, mem);
470 pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
471 struct acpi_resource_fixed_memory32 *p)
475 if (p->address_length == 0)
477 mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
480 mem->min = mem->max = p->address;
481 mem->size = p->address_length;
484 mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
485 IORESOURCE_MEM_WRITEABLE : 0;
487 pnp_register_mem_resource(option, mem);
492 pnpacpi_parse_address_option(struct pnp_option *option, struct acpi_resource *r)
494 struct acpi_resource_address64 addr, *p = &addr;
497 struct pnp_port *port;
499 status = acpi_resource_to_address64(r, p);
500 if (!ACPI_SUCCESS(status)) {
501 pnp_warn("PnPACPI: failed to convert resource type %d", r->type);
505 if (p->address_length == 0)
508 if (p->resource_type == ACPI_MEMORY_RANGE) {
509 mem = kcalloc(1, sizeof(struct pnp_mem), GFP_KERNEL);
512 mem->min = mem->max = p->minimum;
513 mem->size = p->address_length;
515 mem->flags = (p->info.mem.write_protect ==
516 ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE : 0;
517 pnp_register_mem_resource(option, mem);
518 } else if (p->resource_type == ACPI_IO_RANGE) {
519 port = kcalloc(1, sizeof(struct pnp_port), GFP_KERNEL);
522 port->min = port->max = p->minimum;
523 port->size = p->address_length;
525 port->flags = PNP_PORT_FLAG_FIXED;
526 pnp_register_port_resource(option, port);
530 struct acpipnp_parse_option_s {
531 struct pnp_option *option;
532 struct pnp_option *option_independent;
536 static acpi_status pnpacpi_option_resource(struct acpi_resource *res,
540 struct acpipnp_parse_option_s *parse_data = (struct acpipnp_parse_option_s *)data;
541 struct pnp_dev *dev = parse_data->dev;
542 struct pnp_option *option = parse_data->option;
545 case ACPI_RESOURCE_TYPE_IRQ:
546 pnpacpi_parse_irq_option(option, &res->data.irq);
549 case ACPI_RESOURCE_TYPE_DMA:
550 pnpacpi_parse_dma_option(option, &res->data.dma);
553 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
554 switch (res->data.start_dpf.compatibility_priority) {
555 case ACPI_GOOD_CONFIGURATION:
556 priority = PNP_RES_PRIORITY_PREFERRED;
559 case ACPI_ACCEPTABLE_CONFIGURATION:
560 priority = PNP_RES_PRIORITY_ACCEPTABLE;
563 case ACPI_SUB_OPTIMAL_CONFIGURATION:
564 priority = PNP_RES_PRIORITY_FUNCTIONAL;
567 priority = PNP_RES_PRIORITY_INVALID;
570 /* TBD: Considering performace/robustness bits */
571 option = pnp_register_dependent_option(dev, priority);
574 parse_data->option = option;
577 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
578 /*only one EndDependentFn is allowed*/
579 if (!parse_data->option_independent) {
580 pnp_warn("PnPACPI: more than one EndDependentFn");
583 parse_data->option = parse_data->option_independent;
584 parse_data->option_independent = NULL;
587 case ACPI_RESOURCE_TYPE_IO:
588 pnpacpi_parse_port_option(option, &res->data.io);
591 case ACPI_RESOURCE_TYPE_FIXED_IO:
592 pnpacpi_parse_fixed_port_option(option,
593 &res->data.fixed_io);
596 case ACPI_RESOURCE_TYPE_VENDOR:
597 case ACPI_RESOURCE_TYPE_END_TAG:
600 case ACPI_RESOURCE_TYPE_MEMORY24:
601 pnpacpi_parse_mem24_option(option, &res->data.memory24);
604 case ACPI_RESOURCE_TYPE_MEMORY32:
605 pnpacpi_parse_mem32_option(option, &res->data.memory32);
608 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
609 pnpacpi_parse_fixed_mem32_option(option,
610 &res->data.fixed_memory32);
613 case ACPI_RESOURCE_TYPE_ADDRESS16:
614 case ACPI_RESOURCE_TYPE_ADDRESS32:
615 case ACPI_RESOURCE_TYPE_ADDRESS64:
616 pnpacpi_parse_address_option(option, res);
619 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
622 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
623 pnpacpi_parse_ext_irq_option(option,
624 &res->data.extended_irq);
627 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
631 pnp_warn("PnPACPI: unknown resource type %d", res->type);
638 acpi_status pnpacpi_parse_resource_option_data(acpi_handle handle,
642 struct acpipnp_parse_option_s parse_data;
644 parse_data.option = pnp_register_independent_option(dev);
645 if (!parse_data.option)
647 parse_data.option_independent = parse_data.option;
648 parse_data.dev = dev;
649 status = acpi_walk_resources(handle, METHOD_NAME__PRS,
650 pnpacpi_option_resource, &parse_data);
655 static int pnpacpi_supported_resource(struct acpi_resource *res)
658 case ACPI_RESOURCE_TYPE_IRQ:
659 case ACPI_RESOURCE_TYPE_DMA:
660 case ACPI_RESOURCE_TYPE_IO:
661 case ACPI_RESOURCE_TYPE_FIXED_IO:
662 case ACPI_RESOURCE_TYPE_MEMORY24:
663 case ACPI_RESOURCE_TYPE_MEMORY32:
664 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
665 case ACPI_RESOURCE_TYPE_ADDRESS16:
666 case ACPI_RESOURCE_TYPE_ADDRESS32:
667 case ACPI_RESOURCE_TYPE_ADDRESS64:
668 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
677 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
680 int *res_cnt = (int *)data;
682 if (pnpacpi_supported_resource(res))
687 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
689 struct acpi_resource **resource = (struct acpi_resource **)data;
691 if (pnpacpi_supported_resource(res)) {
692 (*resource)->type = res->type;
693 (*resource)->length = sizeof(struct acpi_resource);
700 int pnpacpi_build_resource_template(acpi_handle handle,
701 struct acpi_buffer *buffer)
703 struct acpi_resource *resource;
707 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
708 pnpacpi_count_resources, &res_cnt);
709 if (ACPI_FAILURE(status)) {
710 pnp_err("Evaluate _CRS failed");
715 buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
716 buffer->pointer = kcalloc(1, buffer->length - 1, GFP_KERNEL);
717 if (!buffer->pointer)
719 pnp_dbg("Res cnt %d", res_cnt);
720 resource = (struct acpi_resource *)buffer->pointer;
721 status = acpi_walk_resources(handle, METHOD_NAME__CRS,
722 pnpacpi_type_resources, &resource);
723 if (ACPI_FAILURE(status)) {
724 kfree(buffer->pointer);
725 pnp_err("Evaluate _CRS failed");
728 /* resource will pointer the end resource now */
729 resource->type = ACPI_RESOURCE_TYPE_END_TAG;
734 static void pnpacpi_encode_irq(struct acpi_resource *resource,
737 int triggering, polarity;
739 decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
740 resource->data.irq.triggering = triggering;
741 resource->data.irq.polarity = polarity;
742 if (triggering == ACPI_EDGE_SENSITIVE)
743 resource->data.irq.sharable = ACPI_EXCLUSIVE;
745 resource->data.irq.sharable = ACPI_SHARED;
746 resource->data.irq.interrupt_count = 1;
747 resource->data.irq.interrupts[0] = p->start;
750 static void pnpacpi_encode_ext_irq(struct acpi_resource *resource,
753 int triggering, polarity;
755 decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
756 resource->data.extended_irq.producer_consumer = ACPI_CONSUMER;
757 resource->data.extended_irq.triggering = triggering;
758 resource->data.extended_irq.polarity = polarity;
759 if (triggering == ACPI_EDGE_SENSITIVE)
760 resource->data.irq.sharable = ACPI_EXCLUSIVE;
762 resource->data.irq.sharable = ACPI_SHARED;
763 resource->data.extended_irq.interrupt_count = 1;
764 resource->data.extended_irq.interrupts[0] = p->start;
767 static void pnpacpi_encode_dma(struct acpi_resource *resource,
770 /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
771 if (p->flags & IORESOURCE_DMA_COMPATIBLE)
772 resource->data.dma.type = ACPI_COMPATIBILITY;
773 else if (p->flags & IORESOURCE_DMA_TYPEA)
774 resource->data.dma.type = ACPI_TYPE_A;
775 else if (p->flags & IORESOURCE_DMA_TYPEB)
776 resource->data.dma.type = ACPI_TYPE_B;
777 else if (p->flags & IORESOURCE_DMA_TYPEF)
778 resource->data.dma.type = ACPI_TYPE_F;
779 if (p->flags & IORESOURCE_DMA_8BIT)
780 resource->data.dma.transfer = ACPI_TRANSFER_8;
781 else if (p->flags & IORESOURCE_DMA_8AND16BIT)
782 resource->data.dma.transfer = ACPI_TRANSFER_8_16;
783 else if (p->flags & IORESOURCE_DMA_16BIT)
784 resource->data.dma.transfer = ACPI_TRANSFER_16;
785 resource->data.dma.bus_master = p->flags & IORESOURCE_DMA_MASTER;
786 resource->data.dma.channel_count = 1;
787 resource->data.dma.channels[0] = p->start;
790 static void pnpacpi_encode_io(struct acpi_resource *resource,
793 /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
794 resource->data.io.io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR)?
795 ACPI_DECODE_16 : ACPI_DECODE_10;
796 resource->data.io.minimum = p->start;
797 resource->data.io.maximum = p->end;
798 resource->data.io.alignment = 0; /* Correct? */
799 resource->data.io.address_length = p->end - p->start + 1;
802 static void pnpacpi_encode_fixed_io(struct acpi_resource *resource,
805 resource->data.fixed_io.address = p->start;
806 resource->data.fixed_io.address_length = p->end - p->start + 1;
809 static void pnpacpi_encode_mem24(struct acpi_resource *resource,
812 /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
813 resource->data.memory24.write_protect =
814 (p->flags & IORESOURCE_MEM_WRITEABLE) ?
815 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
816 resource->data.memory24.minimum = p->start;
817 resource->data.memory24.maximum = p->end;
818 resource->data.memory24.alignment = 0;
819 resource->data.memory24.address_length = p->end - p->start + 1;
822 static void pnpacpi_encode_mem32(struct acpi_resource *resource,
825 resource->data.memory32.write_protect =
826 (p->flags & IORESOURCE_MEM_WRITEABLE) ?
827 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
828 resource->data.memory32.minimum = p->start;
829 resource->data.memory32.maximum = p->end;
830 resource->data.memory32.alignment = 0;
831 resource->data.memory32.address_length = p->end - p->start + 1;
834 static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
837 resource->data.fixed_memory32.write_protect =
838 (p->flags & IORESOURCE_MEM_WRITEABLE) ?
839 ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
840 resource->data.fixed_memory32.address = p->start;
841 resource->data.fixed_memory32.address_length = p->end - p->start + 1;
844 int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
845 struct acpi_buffer *buffer)
848 /* pnpacpi_build_resource_template allocates extra mem */
849 int res_cnt = (buffer->length - 1)/sizeof(struct acpi_resource) - 1;
850 struct acpi_resource *resource = (struct acpi_resource*)buffer->pointer;
851 int port = 0, irq = 0, dma = 0, mem = 0;
853 pnp_dbg("res cnt %d", res_cnt);
854 while (i < res_cnt) {
855 switch(resource->type) {
856 case ACPI_RESOURCE_TYPE_IRQ:
857 pnp_dbg("Encode irq");
858 pnpacpi_encode_irq(resource,
859 &res_table->irq_resource[irq]);
863 case ACPI_RESOURCE_TYPE_DMA:
864 pnp_dbg("Encode dma");
865 pnpacpi_encode_dma(resource,
866 &res_table->dma_resource[dma]);
869 case ACPI_RESOURCE_TYPE_IO:
870 pnp_dbg("Encode io");
871 pnpacpi_encode_io(resource,
872 &res_table->port_resource[port]);
875 case ACPI_RESOURCE_TYPE_FIXED_IO:
876 pnp_dbg("Encode fixed io");
877 pnpacpi_encode_fixed_io(resource,
878 &res_table->port_resource[port]);
881 case ACPI_RESOURCE_TYPE_MEMORY24:
882 pnp_dbg("Encode mem24");
883 pnpacpi_encode_mem24(resource,
884 &res_table->mem_resource[mem]);
887 case ACPI_RESOURCE_TYPE_MEMORY32:
888 pnp_dbg("Encode mem32");
889 pnpacpi_encode_mem32(resource,
890 &res_table->mem_resource[mem]);
893 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
894 pnp_dbg("Encode fixed mem32");
895 pnpacpi_encode_fixed_mem32(resource,
896 &res_table->mem_resource[mem]);
899 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
900 pnp_dbg("Encode ext irq");
901 pnpacpi_encode_ext_irq(resource,
902 &res_table->irq_resource[irq]);
905 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
906 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
907 case ACPI_RESOURCE_TYPE_VENDOR:
908 case ACPI_RESOURCE_TYPE_END_TAG:
909 case ACPI_RESOURCE_TYPE_ADDRESS16:
910 case ACPI_RESOURCE_TYPE_ADDRESS32:
911 case ACPI_RESOURCE_TYPE_ADDRESS64:
912 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
913 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
914 default: /* other type */
915 pnp_warn("unknown resource type %d", resource->type);