static void pnpacpi_parse_allocated_address_space(struct pnp_dev *dev, struct acpi_resource *res) { struct acpi_resource_address64 addr, *p = &addr; acpi_status status; status = acpi_resource_to_address64(res, p); if (!ACPI_SUCCESS(status)) { dev_warn(&dev->dev, "failed to convert resource type %d\n", res->type); return; } if (p->producer_consumer == ACPI_PRODUCER) return; if (p->resource_type == ACPI_MEMORY_RANGE) pnpacpi_parse_allocated_memresource(dev, p->minimum, p->address_length, p->info.mem.write_protect); else if (p->resource_type == ACPI_IO_RANGE) pnpacpi_parse_allocated_ioresource(dev, p->minimum, p->address_length, p->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16); }
static void pnpacpi_parse_allocated_address_space(struct pnp_dev *dev, struct acpi_resource *res) { struct acpi_resource_address64 addr, *p = &addr; acpi_status status; int window; u64 len; status = acpi_resource_to_address64(res, p); if (!ACPI_SUCCESS(status)) { dev_warn(&dev->dev, "failed to convert resource type %d\n", res->type); return; } /* Windows apparently computes length rather than using _LEN */ len = p->maximum - p->minimum + 1; window = (p->producer_consumer == ACPI_PRODUCER) ? 1 : 0; if (p->resource_type == ACPI_MEMORY_RANGE) pnpacpi_parse_allocated_memresource(dev, p->minimum, len, p->info.mem.write_protect, window); else if (p->resource_type == ACPI_IO_RANGE) pnpacpi_parse_allocated_ioresource(dev, p->minimum, len, p->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16, window); else if (p->resource_type == ACPI_BUS_NUMBER_RANGE) pnpacpi_parse_allocated_busresource(dev, p->minimum, len); }
static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev *dev, struct acpi_resource *res) { struct acpi_resource_extended_address64 *p = &res->data.ext_address64; if (p->producer_consumer == ACPI_PRODUCER) return; if (p->resource_type == ACPI_MEMORY_RANGE) pnpacpi_parse_allocated_memresource(dev, p->minimum, p->address_length, p->info.mem.write_protect); else if (p->resource_type == ACPI_IO_RANGE) pnpacpi_parse_allocated_ioresource(dev, p->minimum, p->address_length, p->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16); }
static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev *dev, struct acpi_resource *res) { struct acpi_resource_extended_address64 *p = &res->data.ext_address64; int window; u64 len; /* Windows apparently computes length rather than using _LEN */ len = p->maximum - p->minimum + 1; window = (p->producer_consumer == ACPI_PRODUCER) ? 1 : 0; if (p->resource_type == ACPI_MEMORY_RANGE) pnpacpi_parse_allocated_memresource(dev, p->minimum, len, p->info.mem.write_protect, window); else if (p->resource_type == ACPI_IO_RANGE) pnpacpi_parse_allocated_ioresource(dev, p->minimum, len, p->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16, window); else if (p->resource_type == ACPI_BUS_NUMBER_RANGE) pnpacpi_parse_allocated_busresource(dev, p->minimum, len); }
static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table, struct acpi_resource *res) { struct acpi_resource_address64 addr, *p = &addr; acpi_status status; status = acpi_resource_to_address64(res, p); if (!ACPI_SUCCESS(status)) { pnp_warn("PnPACPI: failed to convert resource type %d", res->type); return; } if (p->producer_consumer == ACPI_PRODUCER) return; if (p->resource_type == ACPI_MEMORY_RANGE) pnpacpi_parse_allocated_memresource(res_table, p->minimum, p->address_length); else if (p->resource_type == ACPI_IO_RANGE) pnpacpi_parse_allocated_ioresource(res_table, p->minimum, p->address_length); }
static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, void *data) { struct pnp_dev *dev = data; struct acpi_resource_irq *irq; struct acpi_resource_dma *dma; struct acpi_resource_io *io; struct acpi_resource_fixed_io *fixed_io; struct acpi_resource_vendor_typed *vendor_typed; struct acpi_resource_memory24 *memory24; struct acpi_resource_memory32 *memory32; struct acpi_resource_fixed_memory32 *fixed_memory32; struct acpi_resource_extended_irq *extended_irq; int i, flags; switch (res->type) { case ACPI_RESOURCE_TYPE_IRQ: /* * Per spec, only one interrupt per descriptor is allowed in * _CRS, but some firmware violates this, so parse them all. */ irq = &res->data.irq; if (irq->interrupt_count == 0) pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED); else { for (i = 0; i < irq->interrupt_count; i++) { pnpacpi_parse_allocated_irqresource(dev, irq->interrupts[i], irq->triggering, irq->polarity, irq->sharable); } /* * The IRQ encoder puts a single interrupt in each * descriptor, so if a _CRS descriptor has more than * one interrupt, we won't be able to re-encode it. */ if (pnp_can_write(dev) && irq->interrupt_count > 1) { dev_warn(&dev->dev, "multiple interrupts in " "_CRS descriptor; configuration can't " "be changed\n"); dev->capabilities &= ~PNP_WRITE; } } break; case ACPI_RESOURCE_TYPE_DMA: dma = &res->data.dma; if (dma->channel_count > 0 && dma->channels[0] != (u8) -1) flags = dma_flags(dev, dma->type, dma->bus_master, dma->transfer); else flags = IORESOURCE_DISABLED; pnp_add_dma_resource(dev, dma->channels[0], flags); break; case ACPI_RESOURCE_TYPE_IO: io = &res->data.io; pnpacpi_parse_allocated_ioresource(dev, io->minimum, io->address_length, io->io_decode); break; case ACPI_RESOURCE_TYPE_START_DEPENDENT: case ACPI_RESOURCE_TYPE_END_DEPENDENT: break; case ACPI_RESOURCE_TYPE_FIXED_IO: fixed_io = &res->data.fixed_io; pnpacpi_parse_allocated_ioresource(dev, fixed_io->address, fixed_io->address_length, ACPI_DECODE_10); break; case ACPI_RESOURCE_TYPE_VENDOR: vendor_typed = &res->data.vendor_typed; pnpacpi_parse_allocated_vendor(dev, vendor_typed); break; case ACPI_RESOURCE_TYPE_END_TAG: break; case ACPI_RESOURCE_TYPE_MEMORY24: memory24 = &res->data.memory24; pnpacpi_parse_allocated_memresource(dev, memory24->minimum, memory24->address_length, memory24->write_protect); break; case ACPI_RESOURCE_TYPE_MEMORY32: memory32 = &res->data.memory32; pnpacpi_parse_allocated_memresource(dev, memory32->minimum, memory32->address_length, memory32->write_protect); break; case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: fixed_memory32 = &res->data.fixed_memory32; pnpacpi_parse_allocated_memresource(dev, fixed_memory32->address, fixed_memory32->address_length, fixed_memory32->write_protect); break; case ACPI_RESOURCE_TYPE_ADDRESS16: case ACPI_RESOURCE_TYPE_ADDRESS32: case ACPI_RESOURCE_TYPE_ADDRESS64: pnpacpi_parse_allocated_address_space(dev, res); break; case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER) return AE_OK; break; case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: extended_irq = &res->data.extended_irq; if (extended_irq->interrupt_count == 0) pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED); else { for (i = 0; i < extended_irq->interrupt_count; i++) { pnpacpi_parse_allocated_irqresource(dev, extended_irq->interrupts[i], extended_irq->triggering, extended_irq->polarity, extended_irq->sharable); } /* * The IRQ encoder puts a single interrupt in each * descriptor, so if a _CRS descriptor has more than * one interrupt, we won't be able to re-encode it. */ if (pnp_can_write(dev) && extended_irq->interrupt_count > 1) { dev_warn(&dev->dev, "multiple interrupts in " "_CRS descriptor; configuration can't " "be changed\n"); dev->capabilities &= ~PNP_WRITE; } } break; case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: break; default: dev_warn(&dev->dev, "unknown resource type %d in _CRS\n", res->type); return AE_ERROR; } return AE_OK; }
static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, void *data) { struct pnp_resource_table * res_table = (struct pnp_resource_table *)data; switch (res->id) { case ACPI_RSTYPE_IRQ: if ((res->data.irq.number_of_interrupts > 0) && valid_IRQ(res->data.irq.interrupts[0])) { pnpacpi_parse_allocated_irqresource(res_table, acpi_register_gsi(res->data.irq.interrupts[0], res->data.irq.edge_level, res->data.irq.active_high_low)); pcibios_penalize_isa_irq(res->data.irq.interrupts[0]); } break; case ACPI_RSTYPE_EXT_IRQ: if ((res->data.extended_irq.number_of_interrupts > 0) && valid_IRQ(res->data.extended_irq.interrupts[0])) { pnpacpi_parse_allocated_irqresource(res_table, acpi_register_gsi(res->data.extended_irq.interrupts[0], res->data.extended_irq.edge_level, res->data.extended_irq.active_high_low)); pcibios_penalize_isa_irq(res->data.extended_irq.interrupts[0]); } break; case ACPI_RSTYPE_DMA: if (res->data.dma.number_of_channels > 0) pnpacpi_parse_allocated_dmaresource(res_table, res->data.dma.channels[0]); break; case ACPI_RSTYPE_IO: pnpacpi_parse_allocated_ioresource(res_table, res->data.io.min_base_address, res->data.io.range_length); break; case ACPI_RSTYPE_FIXED_IO: pnpacpi_parse_allocated_ioresource(res_table, res->data.fixed_io.base_address, res->data.fixed_io.range_length); break; case ACPI_RSTYPE_MEM24: pnpacpi_parse_allocated_memresource(res_table, res->data.memory24.min_base_address, res->data.memory24.range_length); break; case ACPI_RSTYPE_MEM32: pnpacpi_parse_allocated_memresource(res_table, res->data.memory32.min_base_address, res->data.memory32.range_length); break; case ACPI_RSTYPE_FIXED_MEM32: pnpacpi_parse_allocated_memresource(res_table, res->data.fixed_memory32.range_base_address, res->data.fixed_memory32.range_length); break; case ACPI_RSTYPE_ADDRESS16: pnpacpi_parse_allocated_memresource(res_table, res->data.address16.min_address_range, res->data.address16.address_length); break; case ACPI_RSTYPE_ADDRESS32: pnpacpi_parse_allocated_memresource(res_table, res->data.address32.min_address_range, res->data.address32.address_length); break; case ACPI_RSTYPE_ADDRESS64: pnpacpi_parse_allocated_memresource(res_table, res->data.address64.min_address_range, res->data.address64.address_length); break; default: pnp_warn("PnPACPI: Alloc type : %d not handle", res->id); return AE_ERROR; } return AE_OK; }
static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, void *data) { struct pnp_resource_table *res_table = (struct pnp_resource_table *)data; int i; switch (res->type) { case ACPI_RESOURCE_TYPE_IRQ: /* * Per spec, only one interrupt per descriptor is allowed in * _CRS, but some firmware violates this, so parse them all. */ for (i = 0; i < res->data.irq.interrupt_count; i++) { pnpacpi_parse_allocated_irqresource(res_table, res->data.irq.interrupts[i], res->data.irq.triggering, res->data.irq.polarity, res->data.irq.sharable); } break; case ACPI_RESOURCE_TYPE_DMA: if (res->data.dma.channel_count > 0) pnpacpi_parse_allocated_dmaresource(res_table, res->data.dma.channels[0]); break; case ACPI_RESOURCE_TYPE_IO: pnpacpi_parse_allocated_ioresource(res_table, res->data.io.minimum, res->data.io.address_length); break; case ACPI_RESOURCE_TYPE_START_DEPENDENT: case ACPI_RESOURCE_TYPE_END_DEPENDENT: break; case ACPI_RESOURCE_TYPE_FIXED_IO: pnpacpi_parse_allocated_ioresource(res_table, res->data.fixed_io.address, res->data.fixed_io.address_length); break; case ACPI_RESOURCE_TYPE_VENDOR: break; case ACPI_RESOURCE_TYPE_END_TAG: break; case ACPI_RESOURCE_TYPE_MEMORY24: pnpacpi_parse_allocated_memresource(res_table, res->data.memory24.minimum, res->data.memory24.address_length); break; case ACPI_RESOURCE_TYPE_MEMORY32: pnpacpi_parse_allocated_memresource(res_table, res->data.memory32.minimum, res->data.memory32.address_length); break; case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: pnpacpi_parse_allocated_memresource(res_table, res->data.fixed_memory32.address, res->data.fixed_memory32.address_length); break; case ACPI_RESOURCE_TYPE_ADDRESS16: case ACPI_RESOURCE_TYPE_ADDRESS32: case ACPI_RESOURCE_TYPE_ADDRESS64: pnpacpi_parse_allocated_address_space(res_table, res); break; case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER) return AE_OK; break; case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: if (res->data.extended_irq.producer_consumer == ACPI_PRODUCER) return AE_OK; for (i = 0; i < res->data.extended_irq.interrupt_count; i++) { pnpacpi_parse_allocated_irqresource(res_table, res->data.extended_irq.interrupts[i], res->data.extended_irq.triggering, res->data.extended_irq.polarity, res->data.extended_irq.sharable); } break; case ACPI_RESOURCE_TYPE_GENERIC_REGISTER: break; default: pnp_warn("PnPACPI: unknown resource type %d", res->type); return AE_ERROR; } return AE_OK; }
static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, void *data) { struct pnp_resource_table * res_table = (struct pnp_resource_table *)data; int i; switch (res->id) { case ACPI_RSTYPE_IRQ: /* * Per spec, only one interrupt per descriptor is allowed in * _CRS, but some firmware violates this, so parse them all. */ for (i = 0; i < res->data.irq.number_of_interrupts; i++) { pnpacpi_parse_allocated_irqresource(res_table, res->data.irq.interrupts[i], res->data.irq.edge_level, res->data.irq.active_high_low); } break; case ACPI_RSTYPE_EXT_IRQ: for (i = 0; i < res->data.extended_irq.number_of_interrupts; i++) { pnpacpi_parse_allocated_irqresource(res_table, res->data.extended_irq.interrupts[i], res->data.extended_irq.edge_level, res->data.extended_irq.active_high_low); } break; case ACPI_RSTYPE_DMA: if (res->data.dma.number_of_channels > 0) pnpacpi_parse_allocated_dmaresource(res_table, res->data.dma.channels[0]); break; case ACPI_RSTYPE_IO: pnpacpi_parse_allocated_ioresource(res_table, res->data.io.min_base_address, res->data.io.range_length); break; case ACPI_RSTYPE_FIXED_IO: pnpacpi_parse_allocated_ioresource(res_table, res->data.fixed_io.base_address, res->data.fixed_io.range_length); break; case ACPI_RSTYPE_MEM24: pnpacpi_parse_allocated_memresource(res_table, res->data.memory24.min_base_address, res->data.memory24.range_length); break; case ACPI_RSTYPE_MEM32: pnpacpi_parse_allocated_memresource(res_table, res->data.memory32.min_base_address, res->data.memory32.range_length); break; case ACPI_RSTYPE_FIXED_MEM32: pnpacpi_parse_allocated_memresource(res_table, res->data.fixed_memory32.range_base_address, res->data.fixed_memory32.range_length); break; case ACPI_RSTYPE_ADDRESS16: pnpacpi_parse_allocated_memresource(res_table, res->data.address16.min_address_range, res->data.address16.address_length); break; case ACPI_RSTYPE_ADDRESS32: pnpacpi_parse_allocated_memresource(res_table, res->data.address32.min_address_range, res->data.address32.address_length); break; case ACPI_RSTYPE_ADDRESS64: pnpacpi_parse_allocated_memresource(res_table, res->data.address64.min_address_range, res->data.address64.address_length); break; case ACPI_RSTYPE_VENDOR: break; default: pnp_warn("PnPACPI: unknown resource type %d", res->id); return AE_ERROR; } return AE_OK; }