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