[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>
 * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
 *	Bjorn Helgaas <bjorn.helgaas@hp.com>
 */

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

DEFINE_MUTEX(pnp_res_mutex);

static struct resource *pnp_find_resource(struct pnp_dev *dev,
					  unsigned char rule,
					  unsigned long type,
					  unsigned int bar)
{
	struct resource *res = pnp_get_resource(dev, type, bar);

	/* when the resource already exists, set its resource bits from rule */
	if (res) {
		res->flags &= ~IORESOURCE_BITS;
		res->flags |= rule & IORESOURCE_BITS;
	}

	return res;
}

static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
{
	struct resource *res, local_res;

	res = pnp_find_resource(dev, rule->flags, IORESOURCE_IO, idx);
	if (res) {
		pnp_dbg(&dev->dev, "  io %d already set to %#llx-%#llx "
			"flags %#lx\n", idx, (unsigned long long) res->start,
			(unsigned long long) res->end, res->flags);
		return 0;
	}

	res = &local_res;
	res->flags = rule->flags | IORESOURCE_AUTO;
	res->start = 0;
	res->end = 0;

	if (!rule->size) {
		res->flags |= IORESOURCE_DISABLED;
		pnp_dbg(&dev->dev, "  io %d disabled\n", idx);
		goto __add;
	}

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

	while (!pnp_check_port(dev, res)) {
		res->start += rule->align;
		res->end = res->start + rule->size - 1;
		if (res->start > rule->max || !rule->align) {
			pnp_dbg(&dev->dev, "  couldn't assign io %d "
				"(min %#llx max %#llx)\n", idx,
				(unsigned long long) rule->min,
				(unsigned long long) rule->max);
			return -EBUSY;
		}
	}

__add:
	pnp_add_io_resource(dev, res->start, res->end, res->flags);
	return 0;
}

static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
{
	struct resource *res, local_res;

	res = pnp_find_resource(dev, rule->flags, IORESOURCE_MEM, idx);
	if (res) {
		pnp_dbg(&dev->dev, "  mem %d already set to %#llx-%#llx "
			"flags %#lx\n", idx, (unsigned long long) res->start,
			(unsigned long long) res->end, res->flags);
		return 0;
	}

	res = &local_res;
	res->flags = rule->flags | IORESOURCE_AUTO;
	res->start = 0;
	res->end = 0;

	/* ??? rule->flags restricted to 8 bits, all tests bogus ??? */
	if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
		res->flags |= IORESOURCE_READONLY;
	if (rule->flags & IORESOURCE_MEM_RANGELENGTH)
		res->flags |= IORESOURCE_RANGELENGTH;
	if (rule->flags & IORESOURCE_MEM_SHADOWABLE)
		res->flags |= IORESOURCE_SHADOWABLE;

	if (!rule->size) {
		res->flags |= IORESOURCE_DISABLED;
		pnp_dbg(&dev->dev, "  mem %d disabled\n", idx);
		goto __add;
	}

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

	while (!pnp_check_mem(dev, res)) {
		res->start += rule->align;
		res->end = res->start + rule->size - 1;
		if (res->start > rule->max || !rule->align) {
			pnp_dbg(&dev->dev, "  couldn't assign mem %d "
				"(min %#llx max %#llx)\n", idx,
				(unsigned long long) rule->min,
				(unsigned long long) rule->max);
			return -EBUSY;
		}
	}

__add:
	pnp_add_mem_resource(dev, res->start, res->end, res->flags);
	return 0;
}

static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
{
	struct resource *res, local_res;
	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
	};

	res = pnp_find_resource(dev, rule->flags, IORESOURCE_IRQ, idx);
	if (res) {
		pnp_dbg(&dev->dev, "  irq %d already set to %d flags %#lx\n",
			idx, (int) res->start, res->flags);
		return 0;
	}

	res = &local_res;
	res->flags = rule->flags | IORESOURCE_AUTO;
	res->start = -1;
	res->end = -1;

	if (bitmap_empty(rule->map.bits, PNP_IRQ_NR)) {
		res->flags |= IORESOURCE_DISABLED;
		pnp_dbg(&dev->dev, "  irq %d disabled\n", idx);
		goto __add;
	}

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

	if (rule->flags & IORESOURCE_IRQ_OPTIONAL) {
		res->start = -1;
		res->end = -1;
		res->flags |= IORESOURCE_DISABLED;
		pnp_dbg(&dev->dev, "  irq %d disabled (optional)\n", idx);
		goto __add;
	}

	pnp_dbg(&dev->dev, "  couldn't assign irq %d\n", idx);
	return -EBUSY;

__add:
	pnp_add_irq_resource(dev, res->start, res->flags);
	return 0;
}

#ifdef CONFIG_ISA_DMA_API
static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
{
	struct resource *res, local_res;
	int i;

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

	res = pnp_find_resource(dev, rule->flags, IORESOURCE_DMA, idx);
	if (res) {
		pnp_dbg(&dev->dev, "  dma %d already set to %d flags %#lx\n",
			idx, (int) res->start, res->flags);
		return 0;
	}

	res = &local_res;
	res->flags = rule->flags | IORESOURCE_AUTO;
	res->start = -1;
	res->end = -1;

	if (!rule->map) {
		res->flags |= IORESOURCE_DISABLED;
		pnp_dbg(&dev->dev, "  dma %d disabled\n", idx);
		goto __add;
	}

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

	pnp_dbg(&dev->dev, "  couldn't assign dma %d\n", idx);
	return -EBUSY;

__add:
	pnp_add_dma_resource(dev, res->start, res->flags);
	return 0;
}
#endif /* CONFIG_ISA_DMA_API */

void pnp_init_resources(struct pnp_dev *dev)
{
	pnp_free_resources(dev);
}

static void pnp_clean_resource_table(struct pnp_dev *dev)
{
	struct pnp_resource *pnp_res, *tmp;

	list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) {
		if (pnp_res->res.flags & IORESOURCE_AUTO)
			pnp_free_resource(pnp_res);
	}
}

/**
 * pnp_assign_resources - assigns resources to the device based on the specified dependent number
 * @dev: pointer to the desired device
 * @set: the dependent function number
 */
static int pnp_assign_resources(struct pnp_dev *dev, int set)
{
	struct pnp_option *option;
	int nport = 0, nmem = 0, nirq = 0;
	int ndma __maybe_unused = 0;
	int ret = 0;

	pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set);
	mutex_lock(&pnp_res_mutex);
	pnp_clean_resource_table(dev);

	list_for_each_entry(option, &dev->options, list) {
		if (pnp_option_is_dependent(option) &&
		    pnp_option_set(option) != set)
				continue;

		switch (option->type) {
		case IORESOURCE_IO:
			ret = pnp_assign_port(dev, &option->u.port, nport++);
			break;
		case IORESOURCE_MEM:
			ret = pnp_assign_mem(dev, &option->u.mem, nmem++);
			break;
		case IORESOURCE_IRQ:
			ret = pnp_assign_irq(dev, &option->u.irq, nirq++);
			break;
#ifdef CONFIG_ISA_DMA_API
		case IORESOURCE_DMA:
			ret = pnp_assign_dma(dev, &option->u.dma, ndma++);
			break;
#endif
		default:
			ret = -EINVAL;
			break;
		}
		if (ret < 0)
			break;
	}

	mutex_unlock(&pnp_res_mutex);
	if (ret < 0) {
		pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret);
		pnp_clean_resource_table(dev);
	} else
		dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded");
	return ret;
}

/**
 * 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)
{
	int i, ret;

	if (!pnp_can_configure(dev)) {
		pnp_dbg(&dev->dev, "configuration not supported\n");
		return -ENODEV;
	}

	ret = pnp_assign_resources(dev, 0);
	if (ret == 0)
		return 0;

	for (i = 1; i < dev->num_dependent_sets; i++) {
		ret = pnp_assign_resources(dev, i);
		if (ret == 0)
			return 0;
	}

	dev_err(&dev->dev, "unable to assign resources\n");
	return ret;
}

/**
 * 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(&dev->dev, "activation not supported\n");
		return -EINVAL;
	}

	dbg_pnp_show_resources(dev, "pnp_start_dev");
	if (dev->protocol->set(dev) < 0) {
		dev_err(&dev->dev, "activation failed\n");
		return -EIO;
	}

	dev_info(&dev->dev, "activated\n");
	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(&dev->dev, "disabling not supported\n");
		return -EINVAL;
	}
	if (dev->protocol->disable(dev) < 0) {
		dev_err(&dev->dev, "disable failed\n");
		return -EIO;
	}

	dev_info(&dev->dev, "disabled\n");
	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;

	/* 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 0;
}

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

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

	dev->active = 0;

	/* release the resources so that other devices can use them */
	mutex_lock(&pnp_res_mutex);
	pnp_clean_resource_table(dev);
	mutex_unlock(&pnp_res_mutex);

	return 0;
}

EXPORT_SYMBOL(pnp_start_dev);
EXPORT_SYMBOL(pnp_stop_dev);
EXPORT_SYMBOL(pnp_activate_dev);
EXPORT_SYMBOL(pnp_disable_dev);
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>
1f32ca31 BH	6	* Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
1f32ca31 BH	7	* Bjorn Helgaas <bjorn.helgaas@hp.com>
1da177e4 LT	8	*/
1da177e4 LT	9
1da177e4 LT	10	#include <linux/errno.h>
	11	#include <linux/module.h>
	12	#include <linux/init.h>
	13	#include <linux/kernel.h>
1da177e4	14	#include <linux/pnp.h>
4e57b681	15	#include <linux/bitmap.h>
b3bd86e2	16	#include <linux/mutex.h>
1da177e4 LT	17	#include "base.h"
1da177e4 LT	18
b3bd86e2	19	DEFINE_MUTEX(pnp_res_mutex);
1da177e4	20
13cde3b2 WS	21	static struct resource pnp_find_resource(struct pnp_dev dev,
	22	unsigned char rule,
	23	unsigned long type,
	24	unsigned int bar)
	25	{
	26	struct resource *res = pnp_get_resource(dev, type, bar);
	27
	28	/* when the resource already exists, set its resource bits from rule */
	29	if (res) {
	30	res->flags &= ~IORESOURCE_BITS;
	31	res->flags \|= rule & IORESOURCE_BITS;
	32	}
	33
	34	return res;
	35	}
	36
1da177e4 LT	37	static int pnp_assign_port(struct pnp_dev dev, struct pnp_port rule, int idx)
1da177e4 LT	38	{
aee3ad81	39	struct resource *res, local_res;
1da177e4	40
13cde3b2	41	res = pnp_find_resource(dev, rule->flags, IORESOURCE_IO, idx);
aee3ad81	42	if (res) {
2f53432c	43	pnp_dbg(&dev->dev, " io %d already set to %#llx-%#llx "
28ccffcf BH	44	"flags %#lx\n", idx, (unsigned long long) res->start,
28ccffcf BH	45	(unsigned long long) res->end, res->flags);
6e906f0e	46	return 0;
81b5c75f BH	47	}
81b5c75f BH	48
aee3ad81 BH	49	res = &local_res;
	50	res->flags = rule->flags \| IORESOURCE_AUTO;
	51	res->start = 0;
	52	res->end = 0;
1da177e4 LT	53
1da177e4 LT	54	if (!rule->size) {
28ccffcf	55	res->flags \|= IORESOURCE_DISABLED;
2f53432c	56	pnp_dbg(&dev->dev, " io %d disabled\n", idx);
aee3ad81	57	goto __add;
1da177e4 LT	58	}
1da177e4 LT	59
28ccffcf BH	60	res->start = rule->min;
28ccffcf BH	61	res->end = res->start + rule->size - 1;
1da177e4	62
f5d94ff0	63	while (!pnp_check_port(dev, res)) {
28ccffcf BH	64	res->start += rule->align;
	65	res->end = res->start + rule->size - 1;
	66	if (res->start > rule->max \|\| !rule->align) {
2f53432c	67	pnp_dbg(&dev->dev, " couldn't assign io %d "
fcfb7ce3 BH	68	"(min %#llx max %#llx)\n", idx,
	69	(unsigned long long) rule->min,
	70	(unsigned long long) rule->max);
6e906f0e	71	return -EBUSY;
81b5c75f	72	}
1da177e4	73	}
aee3ad81 BH	74
	75	__add:
	76	pnp_add_io_resource(dev, res->start, res->end, res->flags);
6e906f0e	77	return 0;
1da177e4 LT	78	}
	79
	80	static int pnp_assign_mem(struct pnp_dev dev, struct pnp_mem rule, int idx)
	81	{
aee3ad81	82	struct resource *res, local_res;
1da177e4	83
13cde3b2	84	res = pnp_find_resource(dev, rule->flags, IORESOURCE_MEM, idx);
aee3ad81	85	if (res) {
2f53432c	86	pnp_dbg(&dev->dev, " mem %d already set to %#llx-%#llx "
28ccffcf BH	87	"flags %#lx\n", idx, (unsigned long long) res->start,
28ccffcf BH	88	(unsigned long long) res->end, res->flags);
6e906f0e	89	return 0;
81b5c75f BH	90	}
81b5c75f BH	91
aee3ad81 BH	92	res = &local_res;
	93	res->flags = rule->flags \| IORESOURCE_AUTO;
	94	res->start = 0;
	95	res->end = 0;
1da177e4	96
13cde3b2	97	/* ??? rule->flags restricted to 8 bits, all tests bogus ??? */
1da177e4	98	if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
28ccffcf	99	res->flags \|= IORESOURCE_READONLY;
1da177e4	100	if (rule->flags & IORESOURCE_MEM_RANGELENGTH)
28ccffcf	101	res->flags \|= IORESOURCE_RANGELENGTH;
1da177e4	102	if (rule->flags & IORESOURCE_MEM_SHADOWABLE)
28ccffcf	103	res->flags \|= IORESOURCE_SHADOWABLE;
1da177e4 LT	104
1da177e4 LT	105	if (!rule->size) {
28ccffcf	106	res->flags \|= IORESOURCE_DISABLED;
2f53432c	107	pnp_dbg(&dev->dev, " mem %d disabled\n", idx);
aee3ad81	108	goto __add;
1da177e4 LT	109	}
1da177e4 LT	110
28ccffcf BH	111	res->start = rule->min;
28ccffcf BH	112	res->end = res->start + rule->size - 1;
1da177e4	113
f5d94ff0	114	while (!pnp_check_mem(dev, res)) {
28ccffcf BH	115	res->start += rule->align;
	116	res->end = res->start + rule->size - 1;
	117	if (res->start > rule->max \|\| !rule->align) {
2f53432c	118	pnp_dbg(&dev->dev, " couldn't assign mem %d "
fcfb7ce3 BH	119	"(min %#llx max %#llx)\n", idx,
	120	(unsigned long long) rule->min,
	121	(unsigned long long) rule->max);
6e906f0e	122	return -EBUSY;
81b5c75f	123	}
1da177e4	124	}
aee3ad81 BH	125
	126	__add:
	127	pnp_add_mem_resource(dev, res->start, res->end, res->flags);
6e906f0e	128	return 0;
1da177e4 LT	129	}
1da177e4 LT	130
9dd78466	131	static int pnp_assign_irq(struct pnp_dev dev, struct pnp_irq rule, int idx)
1da177e4	132	{
aee3ad81	133	struct resource *res, local_res;
1da177e4 LT	134	int i;
	135
	136	/* IRQ priority: this table is good for i386 */
	137	static unsigned short xtab[16] = {
	138	5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
	139	};
	140
13cde3b2	141	res = pnp_find_resource(dev, rule->flags, IORESOURCE_IRQ, idx);
aee3ad81	142	if (res) {
2f53432c	143	pnp_dbg(&dev->dev, " irq %d already set to %d flags %#lx\n",
28ccffcf	144	idx, (int) res->start, res->flags);
6e906f0e	145	return 0;
81b5c75f BH	146	}
81b5c75f BH	147
aee3ad81 BH	148	res = &local_res;
	149	res->flags = rule->flags \| IORESOURCE_AUTO;
	150	res->start = -1;
	151	res->end = -1;
1da177e4	152
7aefff51	153	if (bitmap_empty(rule->map.bits, PNP_IRQ_NR)) {
28ccffcf	154	res->flags \|= IORESOURCE_DISABLED;
2f53432c	155	pnp_dbg(&dev->dev, " irq %d disabled\n", idx);
aee3ad81	156	goto __add;
1da177e4 LT	157	}
	158
	159	/* TBD: need check for >16 IRQ */
7aefff51	160	res->start = find_next_bit(rule->map.bits, PNP_IRQ_NR, 16);
28ccffcf BH	161	if (res->start < PNP_IRQ_NR) {
28ccffcf BH	162	res->end = res->start;
aee3ad81	163	goto __add;
1da177e4 LT	164	}
1da177e4 LT	165	for (i = 0; i < 16; i++) {
7aefff51	166	if (test_bit(xtab[i], rule->map.bits)) {
28ccffcf	167	res->start = res->end = xtab[i];
aee3ad81 BH	168	if (pnp_check_irq(dev, res))
aee3ad81 BH	169	goto __add;
1da177e4 LT	170	}
1da177e4 LT	171	}
d5ebde6e BH	172
	173	if (rule->flags & IORESOURCE_IRQ_OPTIONAL) {
	174	res->start = -1;
	175	res->end = -1;
	176	res->flags \|= IORESOURCE_DISABLED;
2f53432c	177	pnp_dbg(&dev->dev, " irq %d disabled (optional)\n", idx);
d5ebde6e BH	178	goto __add;
	179	}
	180
2f53432c	181	pnp_dbg(&dev->dev, " couldn't assign irq %d\n", idx);
6e906f0e	182	return -EBUSY;
aee3ad81 BH	183
	184	__add:
	185	pnp_add_irq_resource(dev, res->start, res->flags);
6e906f0e	186	return 0;
1da177e4 LT	187	}
1da177e4 LT	188
586f83e2	189	#ifdef CONFIG_ISA_DMA_API
6e906f0e	190	static int pnp_assign_dma(struct pnp_dev dev, struct pnp_dma rule, int idx)
1da177e4	191	{
aee3ad81	192	struct resource *res, local_res;
1da177e4 LT	193	int i;
	194
	195	/* DMA priority: this table is good for i386 */
	196	static unsigned short xtab[8] = {
	197	1, 3, 5, 6, 7, 0, 2, 4
	198	};
	199
13cde3b2	200	res = pnp_find_resource(dev, rule->flags, IORESOURCE_DMA, idx);
aee3ad81	201	if (res) {
2f53432c	202	pnp_dbg(&dev->dev, " dma %d already set to %d flags %#lx\n",
28ccffcf	203	idx, (int) res->start, res->flags);
6e906f0e	204	return 0;
81b5c75f BH	205	}
81b5c75f BH	206
aee3ad81 BH	207	res = &local_res;
	208	res->flags = rule->flags \| IORESOURCE_AUTO;
	209	res->start = -1;
	210	res->end = -1;
1da177e4	211
bdf0eb3a DF	212	if (!rule->map) {
	213	res->flags \|= IORESOURCE_DISABLED;
	214	pnp_dbg(&dev->dev, " dma %d disabled\n", idx);
	215	goto __add;
	216	}
	217
1da177e4	218	for (i = 0; i < 8; i++) {
9dd78466	219	if (rule->map & (1 << xtab[i])) {
28ccffcf	220	res->start = res->end = xtab[i];
aee3ad81 BH	221	if (pnp_check_dma(dev, res))
aee3ad81 BH	222	goto __add;
1da177e4 LT	223	}
1da177e4 LT	224	}
bdf0eb3a DF	225
	226	pnp_dbg(&dev->dev, " couldn't assign dma %d\n", idx);
	227	return -EBUSY;
1da177e4	228
aee3ad81 BH	229	__add:
aee3ad81 BH	230	pnp_add_dma_resource(dev, res->start, res->flags);
6e906f0e	231	return 0;
d948a8da	232	}
586f83e2	233	#endif /* CONFIG_ISA_DMA_API */
d948a8da	234
2cd13930	235	void pnp_init_resources(struct pnp_dev *dev)
1da177e4	236	{
aee3ad81	237	pnp_free_resources(dev);
1da177e4 LT	238	}
1da177e4 LT	239
6969c7ed	240	static void pnp_clean_resource_table(struct pnp_dev *dev)
1da177e4	241	{
aee3ad81 BH	242	struct pnp_resource pnp_res, tmp;
	243
	244	list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) {
	245	if (pnp_res->res.flags & IORESOURCE_AUTO)
	246	pnp_free_resource(pnp_res);
1da177e4 LT	247	}
	248	}
	249
	250	/**
	251	* pnp_assign_resources - assigns resources to the device based on the specified dependent number
	252	* @dev: pointer to the desired device
1f32ca31	253	* @set: the dependent function number
1da177e4	254	*/
1f32ca31	255	static int pnp_assign_resources(struct pnp_dev *dev, int set)
1da177e4	256	{
1f32ca31	257	struct pnp_option *option;
586f83e2 DR	258	int nport = 0, nmem = 0, nirq = 0;
586f83e2 DR	259	int ndma __maybe_unused = 0;
1f32ca31	260	int ret = 0;
1da177e4	261
2f53432c	262	pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set);
b3bd86e2	263	mutex_lock(&pnp_res_mutex);
6969c7ed	264	pnp_clean_resource_table(dev);
1da177e4	265
1f32ca31 BH	266	list_for_each_entry(option, &dev->options, list) {
	267	if (pnp_option_is_dependent(option) &&
	268	pnp_option_set(option) != set)
	269	continue;
	270
	271	switch (option->type) {
	272	case IORESOURCE_IO:
	273	ret = pnp_assign_port(dev, &option->u.port, nport++);
	274	break;
	275	case IORESOURCE_MEM:
	276	ret = pnp_assign_mem(dev, &option->u.mem, nmem++);
	277	break;
	278	case IORESOURCE_IRQ:
	279	ret = pnp_assign_irq(dev, &option->u.irq, nirq++);
	280	break;
586f83e2	281	#ifdef CONFIG_ISA_DMA_API
1f32ca31 BH	282	case IORESOURCE_DMA:
	283	ret = pnp_assign_dma(dev, &option->u.dma, ndma++);
	284	break;
586f83e2	285	#endif
1f32ca31 BH	286	default:
	287	ret = -EINVAL;
	288	break;
1da177e4	289	}
1f32ca31 BH	290	if (ret < 0)
	291	break;
	292	}
1da177e4	293
b3bd86e2	294	mutex_unlock(&pnp_res_mutex);
1f32ca31	295	if (ret < 0) {
2f53432c	296	pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret);
1f32ca31 BH	297	pnp_clean_resource_table(dev);
	298	} else
	299	dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded");
	300	return ret;
1da177e4 LT	301	}
1da177e4 LT	302
1da177e4 LT	303	/**
	304	* pnp_auto_config_dev - automatically assigns resources to a device
	305	* @dev: pointer to the desired device
1da177e4 LT	306	*/
	307	int pnp_auto_config_dev(struct pnp_dev *dev)
	308	{
1f32ca31	309	int i, ret;
1da177e4	310
9dd78466	311	if (!pnp_can_configure(dev)) {
2f53432c	312	pnp_dbg(&dev->dev, "configuration not supported\n");
1da177e4 LT	313	return -ENODEV;
	314	}
	315
1f32ca31 BH	316	ret = pnp_assign_resources(dev, 0);
	317	if (ret == 0)
	318	return 0;
	319
	320	for (i = 1; i < dev->num_dependent_sets; i++) {
	321	ret = pnp_assign_resources(dev, i);
	322	if (ret == 0)
1da177e4	323	return 0;
1da177e4 LT	324	}
1da177e4 LT	325
a05d0781	326	dev_err(&dev->dev, "unable to assign resources\n");
1f32ca31	327	return ret;
1da177e4 LT	328	}
1da177e4 LT	329
68094e32 PO	330	/**
	331	* pnp_start_dev - low-level start of the PnP device
	332	* @dev: pointer to the desired device
	333	*
07d4e9af	334	* assumes that resources have already been allocated
68094e32	335	*/
68094e32 PO	336	int pnp_start_dev(struct pnp_dev *dev)
	337	{
	338	if (!pnp_can_write(dev)) {
2f53432c	339	pnp_dbg(&dev->dev, "activation not supported\n");
68094e32 PO	340	return -EINVAL;
	341	}
	342
81b5c75f	343	dbg_pnp_show_resources(dev, "pnp_start_dev");
59284cb4	344	if (dev->protocol->set(dev) < 0) {
a05d0781	345	dev_err(&dev->dev, "activation failed\n");
68094e32 PO	346	return -EIO;
	347	}
	348
a05d0781	349	dev_info(&dev->dev, "activated\n");
68094e32 PO	350	return 0;
	351	}
	352
	353	/**
	354	* pnp_stop_dev - low-level disable of the PnP device
	355	* @dev: pointer to the desired device
	356	*
	357	* does not free resources
	358	*/
68094e32 PO	359	int pnp_stop_dev(struct pnp_dev *dev)
	360	{
	361	if (!pnp_can_disable(dev)) {
2f53432c	362	pnp_dbg(&dev->dev, "disabling not supported\n");
68094e32 PO	363	return -EINVAL;
68094e32 PO	364	}
9dd78466	365	if (dev->protocol->disable(dev) < 0) {
a05d0781	366	dev_err(&dev->dev, "disable failed\n");
68094e32 PO	367	return -EIO;
	368	}
	369
a05d0781	370	dev_info(&dev->dev, "disabled\n");
68094e32 PO	371	return 0;
	372	}
	373
1da177e4 LT	374	/**
	375	* pnp_activate_dev - activates a PnP device for use
	376	* @dev: pointer to the desired device
	377	*
	378	* does not validate or set resources so be careful.
	379	*/
	380	int pnp_activate_dev(struct pnp_dev *dev)
	381	{
68094e32 PO	382	int error;
68094e32 PO	383
07d4e9af	384	if (dev->active)
cc8259a6	385	return 0;
1da177e4 LT	386
	387	/* ensure resources are allocated */
	388	if (pnp_auto_config_dev(dev))
	389	return -EBUSY;
	390
68094e32 PO	391	error = pnp_start_dev(dev);
	392	if (error)
	393	return error;
1da177e4 LT	394
1da177e4 LT	395	dev->active = 1;
cc8259a6	396	return 0;
1da177e4 LT	397	}
	398
	399	/**
	400	* pnp_disable_dev - disables device
	401	* @dev: pointer to the desired device
	402	*
	403	* inform the correct pnp protocol so that resources can be used by other devices
	404	*/
	405	int pnp_disable_dev(struct pnp_dev *dev)
	406	{
68094e32 PO	407	int error;
68094e32 PO	408
07d4e9af	409	if (!dev->active)
cc8259a6	410	return 0;
1da177e4	411
68094e32 PO	412	error = pnp_stop_dev(dev);
	413	if (error)
	414	return error;
1da177e4 LT	415
1da177e4 LT	416	dev->active = 0;
1da177e4 LT	417
1da177e4 LT	418	/* release the resources so that other devices can use them */
b3bd86e2	419	mutex_lock(&pnp_res_mutex);
6969c7ed	420	pnp_clean_resource_table(dev);
b3bd86e2	421	mutex_unlock(&pnp_res_mutex);
1da177e4	422
cc8259a6	423	return 0;
1da177e4 LT	424	}
1da177e4 LT	425
68094e32 PO	426	EXPORT_SYMBOL(pnp_start_dev);
68094e32 PO	427	EXPORT_SYMBOL(pnp_stop_dev);
1da177e4 LT	428	EXPORT_SYMBOL(pnp_activate_dev);
1da177e4 LT	429	EXPORT_SYMBOL(pnp_disable_dev);