[deliverable/linux.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;

	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;
}
#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
1da177e4	214	for (i = 0; i < 8; i++) {
9dd78466	215	if (rule->map & (1 << xtab[i])) {
28ccffcf	216	res->start = res->end = xtab[i];
aee3ad81 BH	217	if (pnp_check_dma(dev, res))
aee3ad81 BH	218	goto __add;
1da177e4 LT	219	}
1da177e4 LT	220	}
7ef36390	221	#ifdef MAX_DMA_CHANNELS
28ccffcf	222	res->start = res->end = MAX_DMA_CHANNELS;
7ef36390	223	#endif
aee3ad81	224	res->flags \|= IORESOURCE_DISABLED;
2f53432c	225	pnp_dbg(&dev->dev, " disable dma %d\n", idx);
1da177e4	226
aee3ad81 BH	227	__add:
aee3ad81 BH	228	pnp_add_dma_resource(dev, res->start, res->flags);
6e906f0e	229	return 0;
d948a8da	230	}
586f83e2	231	#endif /* CONFIG_ISA_DMA_API */
d948a8da	232
2cd13930	233	void pnp_init_resources(struct pnp_dev *dev)
1da177e4	234	{
aee3ad81	235	pnp_free_resources(dev);
1da177e4 LT	236	}
1da177e4 LT	237
6969c7ed	238	static void pnp_clean_resource_table(struct pnp_dev *dev)
1da177e4	239	{
aee3ad81 BH	240	struct pnp_resource pnp_res, tmp;
	241
	242	list_for_each_entry_safe(pnp_res, tmp, &dev->resources, list) {
	243	if (pnp_res->res.flags & IORESOURCE_AUTO)
	244	pnp_free_resource(pnp_res);
1da177e4 LT	245	}
	246	}
	247
	248	/**
	249	* pnp_assign_resources - assigns resources to the device based on the specified dependent number
	250	* @dev: pointer to the desired device
1f32ca31	251	* @set: the dependent function number
1da177e4	252	*/
1f32ca31	253	static int pnp_assign_resources(struct pnp_dev *dev, int set)
1da177e4	254	{
1f32ca31	255	struct pnp_option *option;
586f83e2 DR	256	int nport = 0, nmem = 0, nirq = 0;
586f83e2 DR	257	int ndma __maybe_unused = 0;
1f32ca31	258	int ret = 0;
1da177e4	259
2f53432c	260	pnp_dbg(&dev->dev, "pnp_assign_resources, try dependent set %d\n", set);
b3bd86e2	261	mutex_lock(&pnp_res_mutex);
6969c7ed	262	pnp_clean_resource_table(dev);
1da177e4	263
1f32ca31 BH	264	list_for_each_entry(option, &dev->options, list) {
	265	if (pnp_option_is_dependent(option) &&
	266	pnp_option_set(option) != set)
	267	continue;
	268
	269	switch (option->type) {
	270	case IORESOURCE_IO:
	271	ret = pnp_assign_port(dev, &option->u.port, nport++);
	272	break;
	273	case IORESOURCE_MEM:
	274	ret = pnp_assign_mem(dev, &option->u.mem, nmem++);
	275	break;
	276	case IORESOURCE_IRQ:
	277	ret = pnp_assign_irq(dev, &option->u.irq, nirq++);
	278	break;
586f83e2	279	#ifdef CONFIG_ISA_DMA_API
1f32ca31 BH	280	case IORESOURCE_DMA:
	281	ret = pnp_assign_dma(dev, &option->u.dma, ndma++);
	282	break;
586f83e2	283	#endif
1f32ca31 BH	284	default:
	285	ret = -EINVAL;
	286	break;
1da177e4	287	}
1f32ca31 BH	288	if (ret < 0)
	289	break;
	290	}
1da177e4	291
b3bd86e2	292	mutex_unlock(&pnp_res_mutex);
1f32ca31	293	if (ret < 0) {
2f53432c	294	pnp_dbg(&dev->dev, "pnp_assign_resources failed (%d)\n", ret);
1f32ca31 BH	295	pnp_clean_resource_table(dev);
	296	} else
	297	dbg_pnp_show_resources(dev, "pnp_assign_resources succeeded");
	298	return ret;
1da177e4 LT	299	}
1da177e4 LT	300
1da177e4 LT	301	/**
	302	* pnp_auto_config_dev - automatically assigns resources to a device
	303	* @dev: pointer to the desired device
1da177e4 LT	304	*/
	305	int pnp_auto_config_dev(struct pnp_dev *dev)
	306	{
1f32ca31	307	int i, ret;
1da177e4	308
9dd78466	309	if (!pnp_can_configure(dev)) {
2f53432c	310	pnp_dbg(&dev->dev, "configuration not supported\n");
1da177e4 LT	311	return -ENODEV;
	312	}
	313
1f32ca31 BH	314	ret = pnp_assign_resources(dev, 0);
	315	if (ret == 0)
	316	return 0;
	317
	318	for (i = 1; i < dev->num_dependent_sets; i++) {
	319	ret = pnp_assign_resources(dev, i);
	320	if (ret == 0)
1da177e4	321	return 0;
1da177e4 LT	322	}
1da177e4 LT	323
a05d0781	324	dev_err(&dev->dev, "unable to assign resources\n");
1f32ca31	325	return ret;
1da177e4 LT	326	}
1da177e4 LT	327
68094e32 PO	328	/**
	329	* pnp_start_dev - low-level start of the PnP device
	330	* @dev: pointer to the desired device
	331	*
07d4e9af	332	* assumes that resources have already been allocated
68094e32	333	*/
68094e32 PO	334	int pnp_start_dev(struct pnp_dev *dev)
	335	{
	336	if (!pnp_can_write(dev)) {
2f53432c	337	pnp_dbg(&dev->dev, "activation not supported\n");
68094e32 PO	338	return -EINVAL;
	339	}
	340
81b5c75f	341	dbg_pnp_show_resources(dev, "pnp_start_dev");
59284cb4	342	if (dev->protocol->set(dev) < 0) {
a05d0781	343	dev_err(&dev->dev, "activation failed\n");
68094e32 PO	344	return -EIO;
	345	}
	346
a05d0781	347	dev_info(&dev->dev, "activated\n");
68094e32 PO	348	return 0;
	349	}
	350
	351	/**
	352	* pnp_stop_dev - low-level disable of the PnP device
	353	* @dev: pointer to the desired device
	354	*
	355	* does not free resources
	356	*/
68094e32 PO	357	int pnp_stop_dev(struct pnp_dev *dev)
	358	{
	359	if (!pnp_can_disable(dev)) {
2f53432c	360	pnp_dbg(&dev->dev, "disabling not supported\n");
68094e32 PO	361	return -EINVAL;
68094e32 PO	362	}
9dd78466	363	if (dev->protocol->disable(dev) < 0) {
a05d0781	364	dev_err(&dev->dev, "disable failed\n");
68094e32 PO	365	return -EIO;
	366	}
	367
a05d0781	368	dev_info(&dev->dev, "disabled\n");
68094e32 PO	369	return 0;
	370	}
	371
1da177e4 LT	372	/**
	373	* pnp_activate_dev - activates a PnP device for use
	374	* @dev: pointer to the desired device
	375	*
	376	* does not validate or set resources so be careful.
	377	*/
	378	int pnp_activate_dev(struct pnp_dev *dev)
	379	{
68094e32 PO	380	int error;
68094e32 PO	381
07d4e9af	382	if (dev->active)
cc8259a6	383	return 0;
1da177e4 LT	384
	385	/* ensure resources are allocated */
	386	if (pnp_auto_config_dev(dev))
	387	return -EBUSY;
	388
68094e32 PO	389	error = pnp_start_dev(dev);
	390	if (error)
	391	return error;
1da177e4 LT	392
1da177e4 LT	393	dev->active = 1;
cc8259a6	394	return 0;
1da177e4 LT	395	}
	396
	397	/**
	398	* pnp_disable_dev - disables device
	399	* @dev: pointer to the desired device
	400	*
	401	* inform the correct pnp protocol so that resources can be used by other devices
	402	*/
	403	int pnp_disable_dev(struct pnp_dev *dev)
	404	{
68094e32 PO	405	int error;
68094e32 PO	406
07d4e9af	407	if (!dev->active)
cc8259a6	408	return 0;
1da177e4	409
68094e32 PO	410	error = pnp_stop_dev(dev);
	411	if (error)
	412	return error;
1da177e4 LT	413
1da177e4 LT	414	dev->active = 0;
1da177e4 LT	415
1da177e4 LT	416	/* release the resources so that other devices can use them */
b3bd86e2	417	mutex_lock(&pnp_res_mutex);
6969c7ed	418	pnp_clean_resource_table(dev);
b3bd86e2	419	mutex_unlock(&pnp_res_mutex);
1da177e4	420
cc8259a6	421	return 0;
1da177e4 LT	422	}
1da177e4 LT	423
68094e32 PO	424	EXPORT_SYMBOL(pnp_start_dev);
68094e32 PO	425	EXPORT_SYMBOL(pnp_stop_dev);
1da177e4 LT	426	EXPORT_SYMBOL(pnp_activate_dev);
1da177e4 LT	427	EXPORT_SYMBOL(pnp_disable_dev);