Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 046d9ce6 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

ACPI: Move device resources interpretation code from PNP to ACPI core 



Move some code used for parsing ACPI device resources from the PNP
subsystem to the ACPI core, so that other bus types (platform, SPI,
I2C) can use the same routines for parsing resources in a consistent
way, without duplicating code.

Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: default avatarMika Westerberg <mika.westerberg@linux.intel.com>
Tested-by: default avatarMika Westerberg <mika.westerberg@linux.intel.com>
parent b4b6cae2

drivers/acpi/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ acpi-$(CONFIG_ACPI_SLEEP) += proc.o 
#

acpi-y				+= bus.o glue.o

acpi-y				+= scan.o

acpi-y				+= resource.o

acpi-y				+= processor_core.o

acpi-y				+= ec.o

acpi-$(CONFIG_ACPI_DOCK)	+= dock.o

drivers/acpi/resource.c

0 → 100644
+393 −0
Original line number Diff line number Diff line 
/*

 * drivers/acpi/resource.c - ACPI device resources interpretation.

 *

 * Copyright (C) 2012, Intel Corp.

 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

 *

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License version 2 as published

 *  by the Free Software Foundation.

 *

 *  This program is distributed in the hope that it will be useful, but

 *  WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 *  General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License along

 *  with this program; if not, write to the Free Software Foundation, Inc.,

 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

 *

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 */



#include <linux/acpi.h>

#include <linux/device.h>

#include <linux/export.h>

#include <linux/ioport.h>



#ifdef CONFIG_X86

#define valid_IRQ(i) (((i) != 0) && ((i) != 2))

#else

#define valid_IRQ(i) (true)

#endif



static unsigned long acpi_dev_memresource_flags(u64 len, u8 write_protect,

						bool window)

{

	unsigned long flags = IORESOURCE_MEM;



	if (len == 0)

		flags |= IORESOURCE_DISABLED;



	if (write_protect == ACPI_READ_WRITE_MEMORY)

		flags |= IORESOURCE_MEM_WRITEABLE;



	if (window)

		flags |= IORESOURCE_WINDOW;



	return flags;

}



static void acpi_dev_get_memresource(struct resource *res, u64 start, u64 len,

				     u8 write_protect)

{

	res->start = start;

	res->end = start + len - 1;

	res->flags = acpi_dev_memresource_flags(len, write_protect, false);

}



/**

 * acpi_dev_resource_memory - Extract ACPI memory resource information.

 * @ares: Input ACPI resource object.

 * @res: Output generic resource object.

 *

 * Check if the given ACPI resource object represents a memory resource and

 * if that's the case, use the information in it to populate the generic

 * resource object pointed to by @res.

 */

bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res)

{

	struct acpi_resource_memory24 *memory24;

	struct acpi_resource_memory32 *memory32;

	struct acpi_resource_fixed_memory32 *fixed_memory32;



	switch (ares->type) {

	case ACPI_RESOURCE_TYPE_MEMORY24:

		memory24 = &ares->data.memory24;

		acpi_dev_get_memresource(res, memory24->minimum,

					 memory24->address_length,

					 memory24->write_protect);

		break;

	case ACPI_RESOURCE_TYPE_MEMORY32:

		memory32 = &ares->data.memory32;

		acpi_dev_get_memresource(res, memory32->minimum,

					 memory32->address_length,

					 memory32->write_protect);

		break;

	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:

		fixed_memory32 = &ares->data.fixed_memory32;

		acpi_dev_get_memresource(res, fixed_memory32->address,

					 fixed_memory32->address_length,

					 fixed_memory32->write_protect);

		break;

	default:

		return false;

	}

	return true;

}

EXPORT_SYMBOL_GPL(acpi_dev_resource_memory);



static unsigned int acpi_dev_ioresource_flags(u64 start, u64 end, u8 io_decode,

					      bool window)

{

	int flags = IORESOURCE_IO;



	if (io_decode == ACPI_DECODE_16)

		flags |= IORESOURCE_IO_16BIT_ADDR;



	if (start > end || end >= 0x10003)

		flags |= IORESOURCE_DISABLED;



	if (window)

		flags |= IORESOURCE_WINDOW;



	return flags;

}



static void acpi_dev_get_ioresource(struct resource *res, u64 start, u64 len,

				    u8 io_decode)

{

	u64 end = start + len - 1;



	res->start = start;

	res->end = end;

	res->flags = acpi_dev_ioresource_flags(start, end, io_decode, false);

}



/**

 * acpi_dev_resource_io - Extract ACPI I/O resource information.

 * @ares: Input ACPI resource object.

 * @res: Output generic resource object.

 *

 * Check if the given ACPI resource object represents an I/O resource and

 * if that's the case, use the information in it to populate the generic

 * resource object pointed to by @res.

 */

bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res)

{

	struct acpi_resource_io *io;

	struct acpi_resource_fixed_io *fixed_io;



	switch (ares->type) {

	case ACPI_RESOURCE_TYPE_IO:

		io = &ares->data.io;

		acpi_dev_get_ioresource(res, io->minimum,

					io->address_length,

					io->io_decode);

		break;

	case ACPI_RESOURCE_TYPE_FIXED_IO:

		fixed_io = &ares->data.fixed_io;

		acpi_dev_get_ioresource(res, fixed_io->address,

					fixed_io->address_length,

					ACPI_DECODE_10);

		break;

	default:

		return false;

	}

	return true;

}

EXPORT_SYMBOL_GPL(acpi_dev_resource_io);



/**

 * acpi_dev_resource_address_space - Extract ACPI address space information.

 * @ares: Input ACPI resource object.

 * @res: Output generic resource object.

 *

 * Check if the given ACPI resource object represents an address space resource

 * and if that's the case, use the information in it to populate the generic

 * resource object pointed to by @res.

 */

bool acpi_dev_resource_address_space(struct acpi_resource *ares,

				     struct resource *res)

{

	acpi_status status;

	struct acpi_resource_address64 addr;

	bool window;

	u64 len;

	u8 io_decode;



	switch (ares->type) {

	case ACPI_RESOURCE_TYPE_ADDRESS16:

	case ACPI_RESOURCE_TYPE_ADDRESS32:

	case ACPI_RESOURCE_TYPE_ADDRESS64:

		break;

	default:

		return false;

	}



	status = acpi_resource_to_address64(ares, &addr);

	if (ACPI_FAILURE(status))

		return true;



	res->start = addr.minimum;

	res->end = addr.maximum;

	window = addr.producer_consumer == ACPI_PRODUCER;



	switch(addr.resource_type) {

	case ACPI_MEMORY_RANGE:

		len = addr.maximum - addr.minimum + 1;

		res->flags = acpi_dev_memresource_flags(len,

						addr.info.mem.write_protect,

						window);

		break;

	case ACPI_IO_RANGE:

		io_decode = addr.granularity == 0xfff ?

				ACPI_DECODE_10 : ACPI_DECODE_16;

		res->flags = acpi_dev_ioresource_flags(addr.minimum,

						       addr.maximum,

						       io_decode, window);

		break;

	case ACPI_BUS_NUMBER_RANGE:

		res->flags = IORESOURCE_BUS;

		break;

	default:

		res->flags = 0;

	}



	return true;

}

EXPORT_SYMBOL_GPL(acpi_dev_resource_address_space);



/**

 * acpi_dev_resource_ext_address_space - Extract ACPI address space information.

 * @ares: Input ACPI resource object.

 * @res: Output generic resource object.

 *

 * Check if the given ACPI resource object represents an extended address space

 * resource and if that's the case, use the information in it to populate the

 * generic resource object pointed to by @res.

 */

bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,

					 struct resource *res)

{

	struct acpi_resource_extended_address64 *ext_addr;

	bool window;

	u64 len;

	u8 io_decode;



	if (ares->type != ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64)

		return false;



	ext_addr = &ares->data.ext_address64;



	res->start = ext_addr->minimum;

	res->end = ext_addr->maximum;

	window = ext_addr->producer_consumer == ACPI_PRODUCER;



	switch(ext_addr->resource_type) {

	case ACPI_MEMORY_RANGE:

		len = ext_addr->maximum - ext_addr->minimum + 1;

		res->flags = acpi_dev_memresource_flags(len,

					ext_addr->info.mem.write_protect,

					window);

		break;

	case ACPI_IO_RANGE:

		io_decode = ext_addr->granularity == 0xfff ?

				ACPI_DECODE_10 : ACPI_DECODE_16;

		res->flags = acpi_dev_ioresource_flags(ext_addr->minimum,

						       ext_addr->maximum,

						       io_decode, window);

		break;

	case ACPI_BUS_NUMBER_RANGE:

		res->flags = IORESOURCE_BUS;

		break;

	default:

		res->flags = 0;

	}



	return true;

}

EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);



/**

 * acpi_dev_irq_flags - Determine IRQ resource flags.

 * @triggering: Triggering type as provided by ACPI.

 * @polarity: Interrupt polarity as provided by ACPI.

 * @shareable: Whether or not the interrupt is shareable.

 */

unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)

{

	unsigned long flags;



	if (triggering == ACPI_LEVEL_SENSITIVE)

		flags = polarity == ACPI_ACTIVE_LOW ?

			IORESOURCE_IRQ_LOWLEVEL : IORESOURCE_IRQ_HIGHLEVEL;

	else

		flags = polarity == ACPI_ACTIVE_LOW ?

			IORESOURCE_IRQ_LOWEDGE : IORESOURCE_IRQ_HIGHEDGE;



	if (shareable == ACPI_SHARED)

		flags |= IORESOURCE_IRQ_SHAREABLE;



	return flags | IORESOURCE_IRQ;

}

EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);



static void acpi_dev_irqresource_disabled(struct resource *res, u32 gsi)

{

	res->start = gsi;

	res->end = gsi;

	res->flags = IORESOURCE_IRQ | IORESOURCE_DISABLED;

}



static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,

				     u8 triggering, u8 polarity, u8 shareable)

{

	int irq, p, t;



	if (!valid_IRQ(gsi)) {

		acpi_dev_irqresource_disabled(res, gsi);

		return;

	}



	/*

	 * In IO-APIC mode, use overrided attribute. Two reasons:

	 * 1. BIOS bug in DSDT

	 * 2. BIOS uses IO-APIC mode Interrupt Source Override

	 */

	if (!acpi_get_override_irq(gsi, &t, &p)) {

		u8 trig = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;

		u8 pol = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;



		if (triggering != trig || polarity != pol) {

			pr_warning("ACPI: IRQ %d override to %s, %s\n", gsi,

				   t ? "edge" : "level", p ? "low" : "high");

			triggering = trig;

			polarity = pol;

		}

	}



	res->flags = acpi_dev_irq_flags(triggering, polarity, shareable);

	irq = acpi_register_gsi(NULL, gsi, triggering, polarity);

	if (irq >= 0) {

		res->start = irq;

		res->end = irq;

	} else {

		acpi_dev_irqresource_disabled(res, gsi);

	}

}



/**

 * acpi_dev_resource_interrupt - Extract ACPI interrupt resource information.

 * @ares: Input ACPI resource object.

 * @index: Index into the array of GSIs represented by the resource.

 * @res: Output generic resource object.

 *

 * Check if the given ACPI resource object represents an interrupt resource

 * and @index does not exceed the resource's interrupt count (true is returned

 * in that case regardless of the results of the other checks)).  If that's the

 * case, register the GSI corresponding to @index from the array of interrupts

 * represented by the resource and populate the generic resource object pointed

 * to by @res accordingly.  If the registration of the GSI is not successful,

 * IORESOURCE_DISABLED will be set it that object's flags.

 */

bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,

				 struct resource *res)

{

	struct acpi_resource_irq *irq;

	struct acpi_resource_extended_irq *ext_irq;



	switch (ares->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 = &ares->data.irq;

		if (index >= irq->interrupt_count) {

			acpi_dev_irqresource_disabled(res, 0);

			return false;

		}

		acpi_dev_get_irqresource(res, irq->interrupts[index],

					 irq->triggering, irq->polarity,

					 irq->sharable);

		break;

	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:

		ext_irq = &ares->data.extended_irq;

		if (index >= ext_irq->interrupt_count) {

			acpi_dev_irqresource_disabled(res, 0);

			return false;

		}

		acpi_dev_get_irqresource(res, ext_irq->interrupts[index],

					 ext_irq->triggering, ext_irq->polarity,

					 ext_irq->sharable);

		break;

	default:

		return false;

	}



	return true;

}

EXPORT_SYMBOL_GPL(acpi_dev_resource_interrupt);

drivers/pnp/base.h

+2 −0
Original line number Diff line number Diff line
@@ -159,6 +159,8 @@ struct pnp_resource { 


void pnp_free_resource(struct pnp_resource *pnp_res);



struct pnp_resource *pnp_add_resource(struct pnp_dev *dev,

				      struct resource *res);

struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq,

					  int flags);

struct pnp_resource *pnp_add_dma_resource(struct pnp_dev *dev, int dma,

drivers/pnp/pnpacpi/rsparser.c

+32 −264
Original line number Diff line number Diff line
@@ -28,37 +28,6 @@ 
#include "../base.h"

#include "pnpacpi.h"



#ifdef CONFIG_IA64

#define valid_IRQ(i) (1)

#else

#define valid_IRQ(i) (((i) != 0) && ((i) != 2))

#endif



/*

 * Allocated Resources

 */

static int irq_flags(int triggering, int polarity, int shareable)

{

	int flags;



	if (triggering == ACPI_LEVEL_SENSITIVE) {

		if (polarity == ACPI_ACTIVE_LOW)

			flags = IORESOURCE_IRQ_LOWLEVEL;

		else

			flags = IORESOURCE_IRQ_HIGHLEVEL;

	} else {

		if (polarity == ACPI_ACTIVE_LOW)

			flags = IORESOURCE_IRQ_LOWEDGE;

		else

			flags = IORESOURCE_IRQ_HIGHEDGE;

	}



	if (shareable == ACPI_SHARED)

		flags |= IORESOURCE_IRQ_SHAREABLE;



	return flags;

}



static void decode_irq_flags(struct pnp_dev *dev, int flags, int *triggering,

			     int *polarity, int *shareable)

{
@@ -94,45 +63,6 @@ static void decode_irq_flags(struct pnp_dev *dev, int flags, int *triggering, 
		*shareable = ACPI_EXCLUSIVE;

}



static void pnpacpi_parse_allocated_irqresource(struct pnp_dev *dev,

						u32 gsi, int triggering,

						int polarity, int shareable)

{

	int irq, flags;

	int p, t;



	if (!valid_IRQ(gsi)) {

		pnp_add_irq_resource(dev, gsi, IORESOURCE_DISABLED);

		return;

	}



	/*

	 * in IO-APIC mode, use overrided attribute. Two reasons:

	 * 1. BIOS bug in DSDT

	 * 2. BIOS uses IO-APIC mode Interrupt Source Override

	 */

	if (!acpi_get_override_irq(gsi, &t, &p)) {

		t = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;

		p = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;



		if (triggering != t || polarity != p) {

			dev_warn(&dev->dev, "IRQ %d override to %s, %s\n",

				gsi, t ? "edge":"level", p ? "low":"high");

			triggering = t;

			polarity = p;

		}

	}



	flags = irq_flags(triggering, polarity, shareable);

	irq = acpi_register_gsi(&dev->dev, gsi, triggering, polarity);

	if (irq >= 0)

		pcibios_penalize_isa_irq(irq, 1);

	else

		flags |= IORESOURCE_DISABLED;



	pnp_add_irq_resource(dev, irq, flags);

}



static int dma_flags(struct pnp_dev *dev, int type, int bus_master,

		     int transfer)

{
@@ -177,21 +107,16 @@ static int dma_flags(struct pnp_dev *dev, int type, int bus_master, 
	return flags;

}



static void pnpacpi_parse_allocated_ioresource(struct pnp_dev *dev, u64 start,

					       u64 len, int io_decode,

					       int window)

{

	int flags = 0;

	u64 end = start + len - 1;

/*

 * Allocated Resources

 */



	if (io_decode == ACPI_DECODE_16)

		flags |= IORESOURCE_IO_16BIT_ADDR;

	if (len == 0 || end >= 0x10003)

		flags |= IORESOURCE_DISABLED;

	if (window)

		flags |= IORESOURCE_WINDOW;

static void pnpacpi_add_irqresource(struct pnp_dev *dev, struct resource *r)

{

	if (!(r->flags & IORESOURCE_DISABLED))

		pcibios_penalize_isa_irq(r->start, 1);



	pnp_add_io_resource(dev, start, end, flags);

	pnp_add_resource(dev, r);

}



/*
@@ -249,130 +174,49 @@ static void pnpacpi_parse_allocated_vendor(struct pnp_dev *dev, 
	}

}



static void pnpacpi_parse_allocated_memresource(struct pnp_dev *dev,

						u64 start, u64 len,

						int write_protect, int window)

{

	int flags = 0;

	u64 end = start + len - 1;



	if (len == 0)

		flags |= IORESOURCE_DISABLED;

	if (write_protect == ACPI_READ_WRITE_MEMORY)

		flags |= IORESOURCE_MEM_WRITEABLE;

	if (window)

		flags |= IORESOURCE_WINDOW;



	pnp_add_mem_resource(dev, start, end, flags);

}



static void pnpacpi_parse_allocated_busresource(struct pnp_dev *dev,

						u64 start, u64 len)

{

	u64 end = start + len - 1;



	pnp_add_bus_resource(dev, start, end);

}



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;

	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 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;

	struct resource r;

	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);

	if (acpi_dev_resource_memory(res, &r)

	    || acpi_dev_resource_io(res, &r)

	    || acpi_dev_resource_address_space(res, &r)

	    || acpi_dev_resource_ext_address_space(res, &r)) {

		pnp_add_resource(dev, &r);

		return AE_OK;

	}



	r.flags = 0;

	if (acpi_dev_resource_interrupt(res, 0, &r)) {

		pnpacpi_add_irqresource(dev, &r);

		for (i = 1; acpi_dev_resource_interrupt(res, i, &r); i++)

			pnpacpi_add_irqresource(dev, &r);



		if (i > 1) {

			/*

			 * 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) {

			if (pnp_can_write(dev)) {

				dev_warn(&dev->dev, "multiple interrupts in "

					 "_CRS descriptor; configuration can't "

					 "be changed\n");

				dev->capabilities &= ~PNP_WRITE;

			}

		}

		break;

		return AE_OK;

	} else if (r.flags & IORESOURCE_DISABLED) {

		pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);

		return AE_OK;

	}



	switch (res->type) {

	case ACPI_RESOURCE_TYPE_DMA:

		dma = &res->data.dma;

		if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
@@ -383,26 +227,10 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, 
		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, 0);

		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, 0);

		break;



	case ACPI_RESOURCE_TYPE_VENDOR:

		vendor_typed = &res->data.vendor_typed;

		pnpacpi_parse_allocated_vendor(dev, vendor_typed);
@@ -411,66 +239,6 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res, 
	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, 0);

		break;

	case ACPI_RESOURCE_TYPE_MEMORY32:

		memory32 = &res->data.memory32;

		pnpacpi_parse_allocated_memresource(dev,

			memory32->minimum,

			memory32->address_length,

			memory32->write_protect, 0);

		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, 0);

		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:

		pnpacpi_parse_allocated_ext_address_space(dev, res);

		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;
@@ -531,7 +299,7 @@ static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev, 
		if (p->interrupts[i])

			__set_bit(p->interrupts[i], map.bits);



	flags = irq_flags(p->triggering, p->polarity, p->sharable);

	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);

	pnp_register_irq_resource(dev, option_flags, &map, flags);

}
@@ -555,7 +323,7 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev, 
		}

	}



	flags = irq_flags(p->triggering, p->polarity, p->sharable);

	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->sharable);

	pnp_register_irq_resource(dev, option_flags, &map, flags);

}

drivers/pnp/resource.c

+16 −0
Original line number Diff line number Diff line
@@ -503,6 +503,22 @@ static struct pnp_resource *pnp_new_resource(struct pnp_dev *dev) 
	return pnp_res;

}



struct pnp_resource *pnp_add_resource(struct pnp_dev *dev,

				      struct resource *res)

{

	struct pnp_resource *pnp_res;



	pnp_res = pnp_new_resource(dev);

	if (!pnp_res) {

		dev_err(&dev->dev, "can't add resource %pR\n", res);

		return NULL;

	}



	pnp_res->res = *res;

	dev_dbg(&dev->dev, "%pR\n", res);

	return pnp_res;

}



struct pnp_resource *pnp_add_irq_resource(struct pnp_dev *dev, int irq,

					  int flags)

{