static void pnpacpi_encode_ext_irq(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq; int triggering, polarity, shareable; if (!pnp_resource_enabled(p)) { extended_irq->interrupt_count = 0; pnp_dbg(&dev->dev, " encode extended irq (%s)\n", p ? "disabled" : "missing"); return; } decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable); extended_irq->producer_consumer = ACPI_CONSUMER; extended_irq->triggering = triggering; extended_irq->polarity = polarity; extended_irq->sharable = shareable; extended_irq->interrupt_count = 1; extended_irq->interrupts[0] = p->start; pnp_dbg(&dev->dev, " encode irq %d %s %s %s\n", (int) p->start, triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge", polarity == ACPI_ACTIVE_LOW ? "low" : "high", extended_irq->sharable == ACPI_SHARED ? "shared" : "exclusive"); }
static void pnpacpi_encode_irq(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_irq *irq = &resource->data.irq; int triggering, polarity, shareable; if (!pnp_resource_enabled(p)) { irq->interrupt_count = 0; pnp_dbg(&dev->dev, " encode irq (%s)\n", p ? "disabled" : "missing"); return; } decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable); irq->triggering = triggering; irq->polarity = polarity; irq->sharable = shareable; irq->interrupt_count = 1; irq->interrupts[0] = p->start; pnp_dbg(&dev->dev, " encode irq %d %s %s %s (%d-byte descriptor)\n", (int) p->start, triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge", polarity == ACPI_ACTIVE_LOW ? "low" : "high", irq->sharable == ACPI_SHARED ? "shared" : "exclusive", irq->descriptor_length); }
static int serial_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id) { struct uart_8250_port uart; int ret, line, flags = dev_id->driver_data; struct resource *res = NULL; if (flags & UNKNOWN_DEV) { ret = serial_pnp_guess_board(dev); if (ret < 0) return ret; } memset(&uart, 0, sizeof(uart)); if (pnp_irq_valid(dev, 0)) uart.port.irq = pnp_irq(dev, 0); if ((flags & CIR_PORT) && pnp_port_valid(dev, 2)) res = pnp_get_resource(dev, IORESOURCE_IO, 2); else if (pnp_port_valid(dev, 0)) res = pnp_get_resource(dev, IORESOURCE_IO, 0); if (pnp_resource_enabled(res)) { uart.port.iobase = res->start; uart.port.iotype = UPIO_PORT; } else if (pnp_mem_valid(dev, 0)) { uart.port.mapbase = pnp_mem_start(dev, 0); uart.port.iotype = UPIO_MEM; uart.port.flags = UPF_IOREMAP; } else return -ENODEV; #ifdef SERIAL_DEBUG_PNP printk(KERN_DEBUG "Setup PNP port: port %x, mem 0x%lx, irq %d, type %d\n", uart.port.iobase, uart.port.mapbase, uart.port.irq, uart.port.iotype); #endif if (flags & CIR_PORT) { uart.port.flags |= UPF_FIXED_PORT | UPF_FIXED_TYPE; uart.port.type = PORT_8250_CIR; } uart.port.flags |= UPF_SKIP_TEST | UPF_BOOT_AUTOCONF; if (pnp_irq_flags(dev, 0) & IORESOURCE_IRQ_SHAREABLE) uart.port.flags |= UPF_SHARE_IRQ; uart.port.uartclk = 1843200; uart.port.dev = &dev->dev; line = serial8250_register_8250_port(&uart); if (line < 0 || (flags & CIR_PORT)) return -ENODEV; pnp_set_drvdata(dev, (void *)((long)line + 1)); return 0; }
static void pnpacpi_encode_dma(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_dma *dma = &resource->data.dma; if (!pnp_resource_enabled(p)) { dma->channel_count = 0; pnp_dbg(&dev->dev, " encode dma (%s)\n", p ? "disabled" : "missing"); return; } /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */ switch (p->flags & IORESOURCE_DMA_SPEED_MASK) { case IORESOURCE_DMA_TYPEA: dma->type = ACPI_TYPE_A; break; case IORESOURCE_DMA_TYPEB: dma->type = ACPI_TYPE_B; break; case IORESOURCE_DMA_TYPEF: dma->type = ACPI_TYPE_F; break; default: dma->type = ACPI_COMPATIBILITY; } switch (p->flags & IORESOURCE_DMA_TYPE_MASK) { case IORESOURCE_DMA_8BIT: dma->transfer = ACPI_TRANSFER_8; break; case IORESOURCE_DMA_8AND16BIT: dma->transfer = ACPI_TRANSFER_8_16; break; default: dma->transfer = ACPI_TRANSFER_16; } dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER); dma->channel_count = 1; dma->channels[0] = p->start; pnp_dbg(&dev->dev, " encode dma %d " "type %#x transfer %#x master %d\n", (int) p->start, dma->type, dma->transfer, dma->bus_master); }
static void pnpacpi_encode_fixed_io(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io; if (pnp_resource_enabled(p)) { fixed_io->address = p->start; fixed_io->address_length = resource_size(p); } else { fixed_io->address = 0; fixed_io->address_length = 0; } pnp_dbg(&dev->dev, " encode fixed_io %#x-%#x\n", fixed_io->address, fixed_io->address + fixed_io->address_length - 1); }
static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32; if (pnp_resource_enabled(p)) { fixed_memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ? ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; fixed_memory32->address = p->start; fixed_memory32->address_length = resource_size(p); } else { fixed_memory32->address = 0; fixed_memory32->address_length = 0; } pnp_dbg(&dev->dev, " encode fixed_mem32 %#x-%#x write_protect %#x\n", fixed_memory32->address, fixed_memory32->address + fixed_memory32->address_length - 1, fixed_memory32->write_protect); }
static void pnpacpi_encode_io(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_io *io = &resource->data.io; if (pnp_resource_enabled(p)) { /* Note: pnp_assign_port copies pnp_port->flags into p->flags */ io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ? ACPI_DECODE_16 : ACPI_DECODE_10; io->minimum = p->start; io->maximum = p->end; io->alignment = 0; /* Correct? */ io->address_length = resource_size(p); } else { io->minimum = 0; io->address_length = 0; } pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum, io->minimum + io->address_length - 1, io->io_decode); }
static void pnpacpi_encode_io(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_io *io = &resource->data.io; if (pnp_resource_enabled(p)) { io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ? ACPI_DECODE_16 : ACPI_DECODE_10; io->minimum = p->start; io->maximum = p->end; io->alignment = 0; io->address_length = p->end - p->start + 1; } else { io->minimum = 0; io->address_length = 0; } pnp_dbg(&dev->dev, " encode io %#x-%#x decode %#x\n", io->minimum, io->minimum + io->address_length - 1, io->io_decode); }
static void pnpacpi_encode_mem32(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_memory32 *memory32 = &resource->data.memory32; if (pnp_resource_enabled(p)) { memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ? ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; memory32->minimum = p->start; memory32->maximum = p->end; memory32->alignment = 0; memory32->address_length = resource_size(p); } else { memory32->minimum = 0; memory32->alignment = 0; } pnp_dbg(&dev->dev, " encode mem32 %#x-%#x write_protect %#x\n", memory32->minimum, memory32->minimum + memory32->address_length - 1, memory32->write_protect); }
static void pnpacpi_encode_mem24(struct pnp_dev *dev, struct acpi_resource *resource, struct resource *p) { struct acpi_resource_memory24 *memory24 = &resource->data.memory24; if (pnp_resource_enabled(p)) { /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */ memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ? ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; memory24->minimum = p->start; memory24->maximum = p->end; memory24->alignment = 0; memory24->address_length = p->end - p->start + 1; } else { memory24->minimum = 0; memory24->address_length = 0; } pnp_dbg(&dev->dev, " encode mem24 %#x-%#x write_protect %#x\n", memory24->minimum, memory24->minimum + memory24->address_length - 1, memory24->write_protect); }