[net-next-2.6.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 int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
{
	struct resource *res, local_res;

	res = pnp_get_resource(dev, 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_get_resource(dev, 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;

	if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
		res->flags |= IORESOURCE_READONLY;
	if (rule->flags & IORESOURCE_MEM_CACHEABLE)
		res->flags |= IORESOURCE_CACHEABLE;
	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_get_resource(dev, 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;
}

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_get_resource(dev, 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;

	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;
		}
	}
#ifdef MAX_DMA_CHANNELS
	res->start = res->end = MAX_DMA_CHANNELS;
#endif
	res->flags |= IORESOURCE_DISABLED;
	pnp_dbg(&dev->dev, "  disable dma %d\n", idx);

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

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