[linux-2.6-block.git] / drivers / pnp / manager.c

/*
 * manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices
 *
 * based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz>
 * Copyright 2003 Adam Belay <ambx1@neo.rr.com>
 */

#include <linux/errno.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/pnp.h>
#include <linux/slab.h>
#include <linux/bitmap.h>
#include "base.h"

DECLARE_MUTEX(pnp_res_mutex);

static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
{
	resource_size_t *start, *end;
	unsigned long *flags;

	if (idx >= PNP_MAX_PORT) {
		pnp_err
		    ("More than 4 ports is incompatible with pnp specifications.");
		/* pretend we were successful so at least the manager won't try again */
		return 1;
	}

	/* check if this resource has been manually set, if so skip */
	if (!(dev->res.port_resource[idx].flags & IORESOURCE_AUTO))
		return 1;

	start = &dev->res.port_resource[idx].start;
	end = &dev->res.port_resource[idx].end;
	flags = &dev->res.port_resource[idx].flags;

	/* set the initial values */
	*flags |= rule->flags | IORESOURCE_IO;
	*flags &= ~IORESOURCE_UNSET;

	if (!rule->size) {
		*flags |= IORESOURCE_DISABLED;
		return 1;	/* skip disabled resource requests */
	}

	*start = rule->min;
	*end = *start + rule->size - 1;

	/* run through until pnp_check_port is happy */
	while (!pnp_check_port(dev, idx)) {
		*start += rule->align;
		*end = *start + rule->size - 1;
		if (*start > rule->max || !rule->align)
			return 0;
	}
	return 1;
}

static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
{
	resource_size_t *start, *end;
	unsigned long *flags;

	if (idx >= PNP_MAX_MEM) {
		pnp_err
		    ("More than 8 mems is incompatible with pnp specifications.");
		/* pretend we were successful so at least the manager won't try again */
		return 1;
	}

	/* check if this resource has been manually set, if so skip */
	if (!(dev->res.mem_resource[idx].flags & IORESOURCE_AUTO))
		return 1;

	start = &dev->res.mem_resource[idx].start;
	end = &dev->res.mem_resource[idx].end;
	flags = &dev->res.mem_resource[idx].flags;

	/* set the initial values */
	*flags |= rule->flags | IORESOURCE_MEM;
	*flags &= ~IORESOURCE_UNSET;

	/* convert pnp flags to standard Linux flags */
	if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
		*flags |= IORESOURCE_READONLY;
	if (rule->flags & IORESOURCE_MEM_CACHEABLE)
		*flags |= IORESOURCE_CACHEABLE;
	if (rule->flags & IORESOURCE_MEM_RANGELENGTH)
		*flags |= IORESOURCE_RANGELENGTH;
	if (rule->flags & IORESOURCE_MEM_SHADOWABLE)
		*flags |= IORESOURCE_SHADOWABLE;

	if (!rule->size) {
		*flags |= IORESOURCE_DISABLED;
		return 1;	/* skip disabled resource requests */
	}

	*start = rule->min;
	*end = *start + rule->size - 1;

	/* run through until pnp_check_mem is happy */
	while (!pnp_check_mem(dev, idx)) {
		*start += rule->align;
		*end = *start + rule->size - 1;
		if (*start > rule->max || !rule->align)
			return 0;
	}
	return 1;
}

static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
{
	resource_size_t *start, *end;
	unsigned long *flags;
	int i;

	/* IRQ priority: this table is good for i386 */
	static unsigned short xtab[16] = {
		5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
	};

	if (idx >= PNP_MAX_IRQ) {
		pnp_err
		    ("More than 2 irqs is incompatible with pnp specifications.");
		/* pretend we were successful so at least the manager won't try again */
		return 1;
	}

	/* check if this resource has been manually set, if so skip */
	if (!(dev->res.irq_resource[idx].flags & IORESOURCE_AUTO))
		return 1;

	start = &dev->res.irq_resource[idx].start;
	end = &dev->res.irq_resource[idx].end;
	flags = &dev->res.irq_resource[idx].flags;

	/* set the initial values */
	*flags |= rule->flags | IORESOURCE_IRQ;
	*flags &= ~IORESOURCE_UNSET;

	if (bitmap_empty(rule->map, PNP_IRQ_NR)) {
		*flags |= IORESOURCE_DISABLED;
		return 1;	/* skip disabled resource requests */
	}

	/* TBD: need check for >16 IRQ */
	*start = find_next_bit(rule->map, PNP_IRQ_NR, 16);
	if (*start < PNP_IRQ_NR) {
		*end = *start;
		return 1;
	}
	for (i = 0; i < 16; i++) {
		if (test_bit(xtab[i], rule->map)) {
			*start = *end = xtab[i];
			if (pnp_check_irq(dev, idx))
				return 1;
		}
	}
	return 0;
}

static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
{
	resource_size_t *start, *end;
	unsigned long *flags;
	int i;

	/* DMA priority: this table is good for i386 */
	static unsigned short xtab[8] = {
		1, 3, 5, 6, 7, 0, 2, 4
	};

	if (idx >= PNP_MAX_DMA) {
		pnp_err
		    ("More than 2 dmas is incompatible with pnp specifications.");
		/* pretend we were successful so at least the manager won't try again */
		return 1;
	}

	/* check if this resource has been manually set, if so skip */
	if (!(dev->res.dma_resource[idx].flags & IORESOURCE_AUTO))
		return 1;

	start = &dev->res.dma_resource[idx].start;
	end = &dev->res.dma_resource[idx].end;
	flags = &dev->res.dma_resource[idx].flags;

	/* set the initial values */
	*flags |= rule->flags | IORESOURCE_DMA;
	*flags &= ~IORESOURCE_UNSET;

	if (!rule->map) {
		*flags |= IORESOURCE_DISABLED;
		return 1;	/* skip disabled resource requests */
	}

	for (i = 0; i < 8; i++) {
		if (rule->map & (1 << xtab[i])) {
			*start = *end = xtab[i];
			if (pnp_check_dma(dev, idx))
				return 1;
		}
	}
	return 0;
}

/**
 * pnp_init_resources - Resets a resource table to default values.
 * @table: pointer to the desired resource table
 */
void pnp_init_resource_table(struct pnp_resource_table *table)
{
	int idx;

	for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
		table->irq_resource[idx].name = NULL;
		table->irq_resource[idx].start = -1;
		table->irq_resource[idx].end = -1;
		table->irq_resource[idx].flags =
		    IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
	for (idx = 0; idx < PNP_MAX_DMA; idx++) {
		table->dma_resource[idx].name = NULL;
		table->dma_resource[idx].start = -1;
		table->dma_resource[idx].end = -1;
		table->dma_resource[idx].flags =
		    IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
	for (idx = 0; idx < PNP_MAX_PORT; idx++) {
		table->port_resource[idx].name = NULL;
		table->port_resource[idx].start = 0;
		table->port_resource[idx].end = 0;
		table->port_resource[idx].flags =
		    IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
	for (idx = 0; idx < PNP_MAX_MEM; idx++) {
		table->mem_resource[idx].name = NULL;
		table->mem_resource[idx].start = 0;
		table->mem_resource[idx].end = 0;
		table->mem_resource[idx].flags =
		    IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
}

/**
 * pnp_clean_resources - clears resources that were not manually set
 * @res: the resources to clean
 */
static void pnp_clean_resource_table(struct pnp_resource_table *res)
{
	int idx;

	for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
		if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO))
			continue;
		res->irq_resource[idx].start = -1;
		res->irq_resource[idx].end = -1;
		res->irq_resource[idx].flags =
		    IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
	for (idx = 0; idx < PNP_MAX_DMA; idx++) {
		if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
			continue;
		res->dma_resource[idx].start = -1;
		res->dma_resource[idx].end = -1;
		res->dma_resource[idx].flags =
		    IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
	for (idx = 0; idx < PNP_MAX_PORT; idx++) {
		if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
			continue;
		res->port_resource[idx].start = 0;
		res->port_resource[idx].end = 0;
		res->port_resource[idx].flags =
		    IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
	for (idx = 0; idx < PNP_MAX_MEM; idx++) {
		if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
			continue;
		res->mem_resource[idx].start = 0;
		res->mem_resource[idx].end = 0;
		res->mem_resource[idx].flags =
		    IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
	}
}

/**
 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
 * @dev: pointer to the desired device
 * @depnum: the dependent function number
 *
 * Only set depnum to 0 if the device does not have dependent options.
 */
static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
{
	struct pnp_port *port;
	struct pnp_mem *mem;
	struct pnp_irq *irq;
	struct pnp_dma *dma;
	int nport = 0, nmem = 0, nirq = 0, ndma = 0;

	if (!pnp_can_configure(dev))
		return -ENODEV;

	down(&pnp_res_mutex);
	pnp_clean_resource_table(&dev->res);	/* start with a fresh slate */
	if (dev->independent) {
		port = dev->independent->port;
		mem = dev->independent->mem;
		irq = dev->independent->irq;
		dma = dev->independent->dma;
		while (port) {
			if (!pnp_assign_port(dev, port, nport))
				goto fail;
			nport++;
			port = port->next;
		}
		while (mem) {
			if (!pnp_assign_mem(dev, mem, nmem))
				goto fail;
			nmem++;
			mem = mem->next;
		}
		while (irq) {
			if (!pnp_assign_irq(dev, irq, nirq))
				goto fail;
			nirq++;
			irq = irq->next;
		}
		while (dma) {
			if (!pnp_assign_dma(dev, dma, ndma))
				goto fail;
			ndma++;
			dma = dma->next;
		}
	}

	if (depnum) {
		struct pnp_option *dep;
		int i;
		for (i = 1, dep = dev->dependent; i < depnum;
		     i++, dep = dep->next)
			if (!dep)
				goto fail;
		port = dep->port;
		mem = dep->mem;
		irq = dep->irq;
		dma = dep->dma;
		while (port) {
			if (!pnp_assign_port(dev, port, nport))
				goto fail;
			nport++;
			port = port->next;
		}
		while (mem) {
			if (!pnp_assign_mem(dev, mem, nmem))
				goto fail;
			nmem++;
			mem = mem->next;
		}
		while (irq) {
			if (!pnp_assign_irq(dev, irq, nirq))
				goto fail;
			nirq++;
			irq = irq->next;
		}
		while (dma) {
			if (!pnp_assign_dma(dev, dma, ndma))
				goto fail;
			ndma++;
			dma = dma->next;
		}
	} else if (dev->dependent)
		goto fail;

	up(&pnp_res_mutex);
	return 1;

fail:
	pnp_clean_resource_table(&dev->res);
	up(&pnp_res_mutex);
	return 0;
}

/**
 * pnp_manual_config_dev - Disables Auto Config and Manually sets the resource table
 * @dev: pointer to the desired device
 * @res: pointer to the new resource config
 * @mode: 0 or PNP_CONFIG_FORCE
 *
 * This function can be used by drivers that want to manually set thier resources.
 */
int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
			  int mode)
{
	int i;
	struct pnp_resource_table *bak;

	if (!pnp_can_configure(dev))
		return -ENODEV;
	bak = pnp_alloc(sizeof(struct pnp_resource_table));
	if (!bak)
		return -ENOMEM;
	*bak = dev->res;

	down(&pnp_res_mutex);
	dev->res = *res;
	if (!(mode & PNP_CONFIG_FORCE)) {
		for (i = 0; i < PNP_MAX_PORT; i++) {
			if (!pnp_check_port(dev, i))
				goto fail;
		}
		for (i = 0; i < PNP_MAX_MEM; i++) {
			if (!pnp_check_mem(dev, i))
				goto fail;
		}
		for (i = 0; i < PNP_MAX_IRQ; i++) {
			if (!pnp_check_irq(dev, i))
				goto fail;
		}
		for (i = 0; i < PNP_MAX_DMA; i++) {
			if (!pnp_check_dma(dev, i))
				goto fail;
		}
	}
	up(&pnp_res_mutex);

	kfree(bak);
	return 0;

fail:
	dev->res = *bak;
	up(&pnp_res_mutex);
	kfree(bak);
	return -EINVAL;
}

/**
 * pnp_auto_config_dev - automatically assigns resources to a device
 * @dev: pointer to the desired device
 */
int pnp_auto_config_dev(struct pnp_dev *dev)
{
	struct pnp_option *dep;
	int i = 1;

	if (!pnp_can_configure(dev)) {
		pnp_dbg("Device %s does not support resource configuration.",
			dev->dev.bus_id);
		return -ENODEV;
	}

	if (!dev->dependent) {
		if (pnp_assign_resources(dev, 0))
			return 0;
	} else {
		dep = dev->dependent;
		do {
			if (pnp_assign_resources(dev, i))
				return 0;
			dep = dep->next;
			i++;
		} while (dep);
	}

	pnp_err("Unable to assign resources to device %s.", dev->dev.bus_id);
	return -EBUSY;
}

/**
 * pnp_start_dev - low-level start of the PnP device
 * @dev: pointer to the desired device
 *
 * assumes that resources have already been allocated
 */
int pnp_start_dev(struct pnp_dev *dev)
{
	if (!pnp_can_write(dev)) {
		pnp_dbg("Device %s does not support activation.",
			dev->dev.bus_id);
		return -EINVAL;
	}

	if (dev->protocol->set(dev, &dev->res) < 0) {
		pnp_err("Failed to activate device %s.", dev->dev.bus_id);
		return -EIO;
	}

	pnp_info("Device %s activated.", dev->dev.bus_id);
	return 0;
}

/**
 * pnp_stop_dev - low-level disable of the PnP device
 * @dev: pointer to the desired device
 *
 * does not free resources
 */
int pnp_stop_dev(struct pnp_dev *dev)
{
	if (!pnp_can_disable(dev)) {
		pnp_dbg("Device %s does not support disabling.",
			dev->dev.bus_id);
		return -EINVAL;
	}
	if (dev->protocol->disable(dev) < 0) {
		pnp_err("Failed to disable device %s.", dev->dev.bus_id);
		return -EIO;
	}

	pnp_info("Device %s disabled.", dev->dev.bus_id);
	return 0;
}

/**
 * pnp_activate_dev - activates a PnP device for use
 * @dev: pointer to the desired device
 *
 * does not validate or set resources so be careful.
 */
int pnp_activate_dev(struct pnp_dev *dev)
{
	int error;

	if (dev->active)
		return 0;	/* the device is already active */

	/* ensure resources are allocated */
	if (pnp_auto_config_dev(dev))
		return -EBUSY;

	error = pnp_start_dev(dev);
	if (error)
		return error;

	dev->active = 1;
	return 1;
}

/**
 * pnp_disable_dev - disables device
 * @dev: pointer to the desired device
 *
 * inform the correct pnp protocol so that resources can be used by other devices
 */
int pnp_disable_dev(struct pnp_dev *dev)
{
	int error;

	if (!dev->active)
		return 0;	/* the device is already disabled */

	error = pnp_stop_dev(dev);
	if (error)
		return error;

	dev->active = 0;

	/* release the resources so that other devices can use them */
	down(&pnp_res_mutex);
	pnp_clean_resource_table(&dev->res);
	up(&pnp_res_mutex);

	return 1;
}

/**
 * pnp_resource_change - change one resource
 * @resource: pointer to resource to be changed
 * @start: start of region
 * @size: size of region
 */
void pnp_resource_change(struct resource *resource, resource_size_t start,
			 resource_size_t size)
{
	resource->flags &= ~(IORESOURCE_AUTO | IORESOURCE_UNSET);
	resource->start = start;
	resource->end = start + size - 1;
}

EXPORT_SYMBOL(pnp_manual_config_dev);
EXPORT_SYMBOL(pnp_start_dev);
EXPORT_SYMBOL(pnp_stop_dev);
EXPORT_SYMBOL(pnp_activate_dev);
EXPORT_SYMBOL(pnp_disable_dev);
EXPORT_SYMBOL(pnp_resource_change);
EXPORT_SYMBOL(pnp_init_resource_table);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* manager.c - Resource Management, Conflict Resolution, Activation and Disabling of Devices
	3	*
c1017a4c	4	* based on isapnp.c resource management (c) Jaroslav Kysela <perex@perex.cz>
1da177e4	5	* Copyright 2003 Adam Belay <ambx1@neo.rr.com>
1da177e4 LT	6	*/
1da177e4 LT	7
1da177e4 LT	8	#include <linux/errno.h>
	9	#include <linux/module.h>
	10	#include <linux/init.h>
	11	#include <linux/kernel.h>
1da177e4	12	#include <linux/pnp.h>
4e57b681 TS	13	#include <linux/slab.h>
4e57b681 TS	14	#include <linux/bitmap.h>
1da177e4 LT	15	#include "base.h"
	16
	17	DECLARE_MUTEX(pnp_res_mutex);
	18
	19	static int pnp_assign_port(struct pnp_dev dev, struct pnp_port rule, int idx)
	20	{
b60ba834 GKH	21	resource_size_t start, end;
b60ba834 GKH	22	unsigned long *flags;
1da177e4	23
1da177e4	24	if (idx >= PNP_MAX_PORT) {
9dd78466 BH	25	pnp_err
9dd78466 BH	26	("More than 4 ports is incompatible with pnp specifications.");
1da177e4 LT	27	/* pretend we were successful so at least the manager won't try again */
	28	return 1;
	29	}
	30
	31	/* check if this resource has been manually set, if so skip */
	32	if (!(dev->res.port_resource[idx].flags & IORESOURCE_AUTO))
	33	return 1;
	34
	35	start = &dev->res.port_resource[idx].start;
	36	end = &dev->res.port_resource[idx].end;
	37	flags = &dev->res.port_resource[idx].flags;
	38
	39	/* set the initial values */
	40	*flags \|= rule->flags \| IORESOURCE_IO;
9dd78466	41	*flags &= ~IORESOURCE_UNSET;
1da177e4 LT	42
	43	if (!rule->size) {
	44	*flags \|= IORESOURCE_DISABLED;
9dd78466	45	return 1; /* skip disabled resource requests */
1da177e4 LT	46	}
	47
	48	*start = rule->min;
	49	end = start + rule->size - 1;
	50
	51	/* run through until pnp_check_port is happy */
	52	while (!pnp_check_port(dev, idx)) {
	53	*start += rule->align;
	54	end = start + rule->size - 1;
	55	if (*start > rule->max \|\| !rule->align)
	56	return 0;
	57	}
	58	return 1;
	59	}
	60
	61	static int pnp_assign_mem(struct pnp_dev dev, struct pnp_mem rule, int idx)
	62	{
b60ba834 GKH	63	resource_size_t start, end;
b60ba834 GKH	64	unsigned long *flags;
1da177e4	65
1da177e4	66	if (idx >= PNP_MAX_MEM) {
9dd78466 BH	67	pnp_err
9dd78466 BH	68	("More than 8 mems is incompatible with pnp specifications.");
1da177e4 LT	69	/* pretend we were successful so at least the manager won't try again */
	70	return 1;
	71	}
	72
	73	/* check if this resource has been manually set, if so skip */
	74	if (!(dev->res.mem_resource[idx].flags & IORESOURCE_AUTO))
	75	return 1;
	76
	77	start = &dev->res.mem_resource[idx].start;
	78	end = &dev->res.mem_resource[idx].end;
	79	flags = &dev->res.mem_resource[idx].flags;
	80
	81	/* set the initial values */
	82	*flags \|= rule->flags \| IORESOURCE_MEM;
9dd78466	83	*flags &= ~IORESOURCE_UNSET;
1da177e4 LT	84
	85	/* convert pnp flags to standard Linux flags */
	86	if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
	87	*flags \|= IORESOURCE_READONLY;
	88	if (rule->flags & IORESOURCE_MEM_CACHEABLE)
	89	*flags \|= IORESOURCE_CACHEABLE;
	90	if (rule->flags & IORESOURCE_MEM_RANGELENGTH)
	91	*flags \|= IORESOURCE_RANGELENGTH;
	92	if (rule->flags & IORESOURCE_MEM_SHADOWABLE)
	93	*flags \|= IORESOURCE_SHADOWABLE;
	94
	95	if (!rule->size) {
	96	*flags \|= IORESOURCE_DISABLED;
9dd78466	97	return 1; /* skip disabled resource requests */
1da177e4 LT	98	}
	99
	100	*start = rule->min;
9dd78466	101	end = start + rule->size - 1;
1da177e4 LT	102
	103	/* run through until pnp_check_mem is happy */
	104	while (!pnp_check_mem(dev, idx)) {
	105	*start += rule->align;
	106	end = start + rule->size - 1;
	107	if (*start > rule->max \|\| !rule->align)
	108	return 0;
	109	}
	110	return 1;
	111	}
	112
9dd78466	113	static int pnp_assign_irq(struct pnp_dev dev, struct pnp_irq rule, int idx)
1da177e4	114	{
b60ba834 GKH	115	resource_size_t start, end;
b60ba834 GKH	116	unsigned long *flags;
1da177e4 LT	117	int i;
	118
	119	/* IRQ priority: this table is good for i386 */
	120	static unsigned short xtab[16] = {
	121	5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
	122	};
	123
1da177e4	124	if (idx >= PNP_MAX_IRQ) {
9dd78466 BH	125	pnp_err
9dd78466 BH	126	("More than 2 irqs is incompatible with pnp specifications.");
1da177e4 LT	127	/* pretend we were successful so at least the manager won't try again */
	128	return 1;
	129	}
	130
	131	/* check if this resource has been manually set, if so skip */
	132	if (!(dev->res.irq_resource[idx].flags & IORESOURCE_AUTO))
	133	return 1;
	134
	135	start = &dev->res.irq_resource[idx].start;
	136	end = &dev->res.irq_resource[idx].end;
	137	flags = &dev->res.irq_resource[idx].flags;
	138
	139	/* set the initial values */
	140	*flags \|= rule->flags \| IORESOURCE_IRQ;
9dd78466	141	*flags &= ~IORESOURCE_UNSET;
1da177e4 LT	142
	143	if (bitmap_empty(rule->map, PNP_IRQ_NR)) {
	144	*flags \|= IORESOURCE_DISABLED;
9dd78466	145	return 1; /* skip disabled resource requests */
1da177e4 LT	146	}
	147
	148	/* TBD: need check for >16 IRQ */
	149	*start = find_next_bit(rule->map, PNP_IRQ_NR, 16);
	150	if (*start < PNP_IRQ_NR) {
	151	end = start;
	152	return 1;
	153	}
	154	for (i = 0; i < 16; i++) {
9dd78466	155	if (test_bit(xtab[i], rule->map)) {
1da177e4	156	start = end = xtab[i];
9dd78466	157	if (pnp_check_irq(dev, idx))
1da177e4 LT	158	return 1;
	159	}
	160	}
	161	return 0;
	162	}
	163
	164	static int pnp_assign_dma(struct pnp_dev dev, struct pnp_dma rule, int idx)
	165	{
b60ba834 GKH	166	resource_size_t start, end;
b60ba834 GKH	167	unsigned long *flags;
1da177e4 LT	168	int i;
	169
	170	/* DMA priority: this table is good for i386 */
	171	static unsigned short xtab[8] = {
	172	1, 3, 5, 6, 7, 0, 2, 4
	173	};
	174
1da177e4	175	if (idx >= PNP_MAX_DMA) {
9dd78466 BH	176	pnp_err
9dd78466 BH	177	("More than 2 dmas is incompatible with pnp specifications.");
1da177e4 LT	178	/* pretend we were successful so at least the manager won't try again */
	179	return 1;
	180	}
	181
	182	/* check if this resource has been manually set, if so skip */
	183	if (!(dev->res.dma_resource[idx].flags & IORESOURCE_AUTO))
	184	return 1;
	185
	186	start = &dev->res.dma_resource[idx].start;
	187	end = &dev->res.dma_resource[idx].end;
	188	flags = &dev->res.dma_resource[idx].flags;
	189
	190	/* set the initial values */
	191	*flags \|= rule->flags \| IORESOURCE_DMA;
9dd78466	192	*flags &= ~IORESOURCE_UNSET;
1da177e4 LT	193
	194	if (!rule->map) {
	195	*flags \|= IORESOURCE_DISABLED;
9dd78466	196	return 1; /* skip disabled resource requests */
1da177e4 LT	197	}
	198
	199	for (i = 0; i < 8; i++) {
9dd78466	200	if (rule->map & (1 << xtab[i])) {
1da177e4	201	start = end = xtab[i];
9dd78466	202	if (pnp_check_dma(dev, idx))
1da177e4 LT	203	return 1;
	204	}
	205	}
	206	return 0;
	207	}
	208
	209	/**
	210	* pnp_init_resources - Resets a resource table to default values.
	211	* @table: pointer to the desired resource table
1da177e4 LT	212	*/
	213	void pnp_init_resource_table(struct pnp_resource_table *table)
	214	{
	215	int idx;
07d4e9af	216
1da177e4 LT	217	for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
	218	table->irq_resource[idx].name = NULL;
	219	table->irq_resource[idx].start = -1;
	220	table->irq_resource[idx].end = -1;
9dd78466 BH	221	table->irq_resource[idx].flags =
9dd78466 BH	222	IORESOURCE_IRQ \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	223	}
	224	for (idx = 0; idx < PNP_MAX_DMA; idx++) {
	225	table->dma_resource[idx].name = NULL;
	226	table->dma_resource[idx].start = -1;
	227	table->dma_resource[idx].end = -1;
9dd78466 BH	228	table->dma_resource[idx].flags =
9dd78466 BH	229	IORESOURCE_DMA \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	230	}
	231	for (idx = 0; idx < PNP_MAX_PORT; idx++) {
	232	table->port_resource[idx].name = NULL;
	233	table->port_resource[idx].start = 0;
	234	table->port_resource[idx].end = 0;
9dd78466 BH	235	table->port_resource[idx].flags =
9dd78466 BH	236	IORESOURCE_IO \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	237	}
	238	for (idx = 0; idx < PNP_MAX_MEM; idx++) {
	239	table->mem_resource[idx].name = NULL;
	240	table->mem_resource[idx].start = 0;
	241	table->mem_resource[idx].end = 0;
9dd78466 BH	242	table->mem_resource[idx].flags =
9dd78466 BH	243	IORESOURCE_MEM \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	244	}
	245	}
	246
	247	/**
	248	* pnp_clean_resources - clears resources that were not manually set
67be2dd1	249	* @res: the resources to clean
1da177e4	250	*/
9dd78466	251	static void pnp_clean_resource_table(struct pnp_resource_table *res)
1da177e4 LT	252	{
1da177e4 LT	253	int idx;
07d4e9af	254
1da177e4 LT	255	for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
	256	if (!(res->irq_resource[idx].flags & IORESOURCE_AUTO))
	257	continue;
	258	res->irq_resource[idx].start = -1;
	259	res->irq_resource[idx].end = -1;
9dd78466 BH	260	res->irq_resource[idx].flags =
9dd78466 BH	261	IORESOURCE_IRQ \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	262	}
	263	for (idx = 0; idx < PNP_MAX_DMA; idx++) {
	264	if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
	265	continue;
	266	res->dma_resource[idx].start = -1;
	267	res->dma_resource[idx].end = -1;
9dd78466 BH	268	res->dma_resource[idx].flags =
9dd78466 BH	269	IORESOURCE_DMA \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	270	}
	271	for (idx = 0; idx < PNP_MAX_PORT; idx++) {
	272	if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
	273	continue;
	274	res->port_resource[idx].start = 0;
	275	res->port_resource[idx].end = 0;
9dd78466 BH	276	res->port_resource[idx].flags =
9dd78466 BH	277	IORESOURCE_IO \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	278	}
	279	for (idx = 0; idx < PNP_MAX_MEM; idx++) {
	280	if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
	281	continue;
	282	res->mem_resource[idx].start = 0;
	283	res->mem_resource[idx].end = 0;
9dd78466 BH	284	res->mem_resource[idx].flags =
9dd78466 BH	285	IORESOURCE_MEM \| IORESOURCE_AUTO \| IORESOURCE_UNSET;
1da177e4 LT	286	}
	287	}
	288
	289	/**
	290	* pnp_assign_resources - assigns resources to the device based on the specified dependent number
	291	* @dev: pointer to the desired device
	292	* @depnum: the dependent function number
	293	*
	294	* Only set depnum to 0 if the device does not have dependent options.
	295	*/
	296	static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
	297	{
	298	struct pnp_port *port;
	299	struct pnp_mem *mem;
	300	struct pnp_irq *irq;
	301	struct pnp_dma *dma;
	302	int nport = 0, nmem = 0, nirq = 0, ndma = 0;
	303
	304	if (!pnp_can_configure(dev))
	305	return -ENODEV;
	306
	307	down(&pnp_res_mutex);
9dd78466	308	pnp_clean_resource_table(&dev->res); /* start with a fresh slate */
1da177e4 LT	309	if (dev->independent) {
	310	port = dev->independent->port;
	311	mem = dev->independent->mem;
	312	irq = dev->independent->irq;
	313	dma = dev->independent->dma;
	314	while (port) {
	315	if (!pnp_assign_port(dev, port, nport))
	316	goto fail;
	317	nport++;
	318	port = port->next;
	319	}
	320	while (mem) {
	321	if (!pnp_assign_mem(dev, mem, nmem))
	322	goto fail;
	323	nmem++;
	324	mem = mem->next;
	325	}
	326	while (irq) {
	327	if (!pnp_assign_irq(dev, irq, nirq))
	328	goto fail;
	329	nirq++;
	330	irq = irq->next;
	331	}
	332	while (dma) {
	333	if (!pnp_assign_dma(dev, dma, ndma))
	334	goto fail;
	335	ndma++;
	336	dma = dma->next;
	337	}
	338	}
	339
	340	if (depnum) {
	341	struct pnp_option *dep;
	342	int i;
9dd78466 BH	343	for (i = 1, dep = dev->dependent; i < depnum;
	344	i++, dep = dep->next)
	345	if (!dep)
1da177e4	346	goto fail;
9dd78466	347	port = dep->port;
1da177e4 LT	348	mem = dep->mem;
	349	irq = dep->irq;
	350	dma = dep->dma;
	351	while (port) {
	352	if (!pnp_assign_port(dev, port, nport))
	353	goto fail;
	354	nport++;
	355	port = port->next;
	356	}
	357	while (mem) {
	358	if (!pnp_assign_mem(dev, mem, nmem))
	359	goto fail;
	360	nmem++;
	361	mem = mem->next;
	362	}
	363	while (irq) {
	364	if (!pnp_assign_irq(dev, irq, nirq))
	365	goto fail;
	366	nirq++;
	367	irq = irq->next;
	368	}
	369	while (dma) {
	370	if (!pnp_assign_dma(dev, dma, ndma))
	371	goto fail;
	372	ndma++;
	373	dma = dma->next;
	374	}
	375	} else if (dev->dependent)
	376	goto fail;
	377
	378	up(&pnp_res_mutex);
	379	return 1;
	380
1e0aa9ad	381	fail:
1da177e4 LT	382	pnp_clean_resource_table(&dev->res);
	383	up(&pnp_res_mutex);
	384	return 0;
	385	}
	386
	387	/**
	388	* pnp_manual_config_dev - Disables Auto Config and Manually sets the resource table
	389	* @dev: pointer to the desired device
	390	* @res: pointer to the new resource config
3d41088f	391	* @mode: 0 or PNP_CONFIG_FORCE
1da177e4 LT	392	*
	393	* This function can be used by drivers that want to manually set thier resources.
	394	*/
9dd78466 BH	395	int pnp_manual_config_dev(struct pnp_dev dev, struct pnp_resource_table res,
9dd78466 BH	396	int mode)
1da177e4 LT	397	{
1da177e4 LT	398	int i;
9dd78466	399	struct pnp_resource_table *bak;
07d4e9af	400
1da177e4 LT	401	if (!pnp_can_configure(dev))
	402	return -ENODEV;
	403	bak = pnp_alloc(sizeof(struct pnp_resource_table));
	404	if (!bak)
	405	return -ENOMEM;
	406	*bak = dev->res;
	407
	408	down(&pnp_res_mutex);
	409	dev->res = *res;
	410	if (!(mode & PNP_CONFIG_FORCE)) {
	411	for (i = 0; i < PNP_MAX_PORT; i++) {
9dd78466	412	if (!pnp_check_port(dev, i))
1da177e4 LT	413	goto fail;
	414	}
	415	for (i = 0; i < PNP_MAX_MEM; i++) {
9dd78466	416	if (!pnp_check_mem(dev, i))
1da177e4 LT	417	goto fail;
	418	}
	419	for (i = 0; i < PNP_MAX_IRQ; i++) {
9dd78466	420	if (!pnp_check_irq(dev, i))
1da177e4 LT	421	goto fail;
	422	}
	423	for (i = 0; i < PNP_MAX_DMA; i++) {
9dd78466	424	if (!pnp_check_dma(dev, i))
1da177e4 LT	425	goto fail;
	426	}
	427	}
	428	up(&pnp_res_mutex);
	429
	430	kfree(bak);
	431	return 0;
	432
1e0aa9ad	433	fail:
1da177e4 LT	434	dev->res = *bak;
	435	up(&pnp_res_mutex);
	436	kfree(bak);
	437	return -EINVAL;
	438	}
	439
	440	/**
	441	* pnp_auto_config_dev - automatically assigns resources to a device
	442	* @dev: pointer to the desired device
1da177e4 LT	443	*/
	444	int pnp_auto_config_dev(struct pnp_dev *dev)
	445	{
	446	struct pnp_option *dep;
	447	int i = 1;
	448
9dd78466 BH	449	if (!pnp_can_configure(dev)) {
	450	pnp_dbg("Device %s does not support resource configuration.",
	451	dev->dev.bus_id);
1da177e4 LT	452	return -ENODEV;
	453	}
	454
	455	if (!dev->dependent) {
	456	if (pnp_assign_resources(dev, 0))
	457	return 0;
	458	} else {
	459	dep = dev->dependent;
	460	do {
	461	if (pnp_assign_resources(dev, i))
	462	return 0;
	463	dep = dep->next;
	464	i++;
	465	} while (dep);
	466	}
	467
	468	pnp_err("Unable to assign resources to device %s.", dev->dev.bus_id);
	469	return -EBUSY;
	470	}
	471
68094e32 PO	472	/**
	473	* pnp_start_dev - low-level start of the PnP device
	474	* @dev: pointer to the desired device
	475	*
07d4e9af	476	* assumes that resources have already been allocated
68094e32	477	*/
68094e32 PO	478	int pnp_start_dev(struct pnp_dev *dev)
	479	{
	480	if (!pnp_can_write(dev)) {
9dd78466 BH	481	pnp_dbg("Device %s does not support activation.",
9dd78466 BH	482	dev->dev.bus_id);
68094e32 PO	483	return -EINVAL;
	484	}
	485
9dd78466	486	if (dev->protocol->set(dev, &dev->res) < 0) {
68094e32 PO	487	pnp_err("Failed to activate device %s.", dev->dev.bus_id);
	488	return -EIO;
	489	}
	490
	491	pnp_info("Device %s activated.", dev->dev.bus_id);
68094e32 PO	492	return 0;
	493	}
	494
	495	/**
	496	* pnp_stop_dev - low-level disable of the PnP device
	497	* @dev: pointer to the desired device
	498	*
	499	* does not free resources
	500	*/
68094e32 PO	501	int pnp_stop_dev(struct pnp_dev *dev)
	502	{
	503	if (!pnp_can_disable(dev)) {
9dd78466 BH	504	pnp_dbg("Device %s does not support disabling.",
9dd78466 BH	505	dev->dev.bus_id);
68094e32 PO	506	return -EINVAL;
68094e32 PO	507	}
9dd78466	508	if (dev->protocol->disable(dev) < 0) {
68094e32 PO	509	pnp_err("Failed to disable device %s.", dev->dev.bus_id);
	510	return -EIO;
	511	}
	512
	513	pnp_info("Device %s disabled.", dev->dev.bus_id);
68094e32 PO	514	return 0;
	515	}
	516
1da177e4 LT	517	/**
	518	* pnp_activate_dev - activates a PnP device for use
	519	* @dev: pointer to the desired device
	520	*
	521	* does not validate or set resources so be careful.
	522	*/
	523	int pnp_activate_dev(struct pnp_dev *dev)
	524	{
68094e32 PO	525	int error;
68094e32 PO	526
07d4e9af	527	if (dev->active)
9dd78466	528	return 0; /* the device is already active */
1da177e4 LT	529
	530	/* ensure resources are allocated */
	531	if (pnp_auto_config_dev(dev))
	532	return -EBUSY;
	533
68094e32 PO	534	error = pnp_start_dev(dev);
	535	if (error)
	536	return error;
1da177e4 LT	537
1da177e4 LT	538	dev->active = 1;
1da177e4 LT	539	return 1;
	540	}
	541
	542	/**
	543	* pnp_disable_dev - disables device
	544	* @dev: pointer to the desired device
	545	*
	546	* inform the correct pnp protocol so that resources can be used by other devices
	547	*/
	548	int pnp_disable_dev(struct pnp_dev *dev)
	549	{
68094e32 PO	550	int error;
68094e32 PO	551
07d4e9af	552	if (!dev->active)
9dd78466	553	return 0; /* the device is already disabled */
1da177e4	554
68094e32 PO	555	error = pnp_stop_dev(dev);
	556	if (error)
	557	return error;
1da177e4 LT	558
1da177e4 LT	559	dev->active = 0;
1da177e4 LT	560
	561	/* release the resources so that other devices can use them */
	562	down(&pnp_res_mutex);
	563	pnp_clean_resource_table(&dev->res);
	564	up(&pnp_res_mutex);
	565
	566	return 1;
	567	}
	568
	569	/**
	570	* pnp_resource_change - change one resource
	571	* @resource: pointer to resource to be changed
	572	* @start: start of region
	573	* @size: size of region
1da177e4	574	*/
b60ba834	575	void pnp_resource_change(struct resource *resource, resource_size_t start,
9dd78466	576	resource_size_t size)
1da177e4	577	{
1da177e4 LT	578	resource->flags &= ~(IORESOURCE_AUTO \| IORESOURCE_UNSET);
	579	resource->start = start;
	580	resource->end = start + size - 1;
	581	}
	582
1da177e4	583	EXPORT_SYMBOL(pnp_manual_config_dev);
68094e32 PO	584	EXPORT_SYMBOL(pnp_start_dev);
68094e32 PO	585	EXPORT_SYMBOL(pnp_stop_dev);
1da177e4 LT	586	EXPORT_SYMBOL(pnp_activate_dev);
	587	EXPORT_SYMBOL(pnp_disable_dev);
	588	EXPORT_SYMBOL(pnp_resource_change);
	589	EXPORT_SYMBOL(pnp_init_resource_table);