[mirror_ubuntu-artful-kernel.git] / drivers / pnp / support.c

/*
 * support.c - standard functions for the use of pnp protocol drivers
 *
 * 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/module.h>
#include <linux/ctype.h>
#include <linux/pnp.h>
#include "base.h"

/**
 * pnp_is_active - Determines if a device is active based on its current
 *	resources
 * @dev: pointer to the desired PnP device
 */
int pnp_is_active(struct pnp_dev *dev)
{
	/*
	 * I don't think this is very reliable because pnp_disable_dev()
	 * only clears out auto-assigned resources.
	 */
	if (!pnp_port_start(dev, 0) && pnp_port_len(dev, 0) <= 1 &&
	    !pnp_mem_start(dev, 0) && pnp_mem_len(dev, 0) <= 1 &&
	    pnp_irq(dev, 0) == -1 && pnp_dma(dev, 0) == -1)
		return 0;
	else
		return 1;
}

EXPORT_SYMBOL(pnp_is_active);

/*
 * Functionally similar to acpi_ex_eisa_id_to_string(), but that's
 * buried in the ACPI CA, and we can't depend on it being present.
 */
void pnp_eisa_id_to_string(u32 id, char *str)
{
	id = be32_to_cpu(id);

	/*
	 * According to the specs, the first three characters are five-bit
	 * compressed ASCII, and the left-over high order bit should be zero.
	 * However, the Linux ISAPNP code historically used six bits for the
	 * first character, and there seem to be IDs that depend on that,
	 * e.g., "nEC8241" in the Linux 8250_pnp serial driver and the
	 * FreeBSD sys/pc98/cbus/sio_cbus.c driver.
	 */
	str[0] = 'A' + ((id >> 26) & 0x3f) - 1;
	str[1] = 'A' + ((id >> 21) & 0x1f) - 1;
	str[2] = 'A' + ((id >> 16) & 0x1f) - 1;
	str[3] = hex_asc_hi(id >> 8);
	str[4] = hex_asc_lo(id >> 8);
	str[5] = hex_asc_hi(id);
	str[6] = hex_asc_lo(id);
	str[7] = '\0';
}

char *pnp_resource_type_name(struct resource *res)
{
	switch (pnp_resource_type(res)) {
	case IORESOURCE_IO:
		return "io";
	case IORESOURCE_MEM:
		return "mem";
	case IORESOURCE_IRQ:
		return "irq";
	case IORESOURCE_DMA:
		return "dma";
	}
	return NULL;
}

void dbg_pnp_show_resources(struct pnp_dev *dev, char *desc)
{
	char buf[128];
	int len;
	struct pnp_resource *pnp_res;
	struct resource *res;

	if (list_empty(&dev->resources)) {
		pnp_dbg(&dev->dev, "%s: no current resources\n", desc);
		return;
	}

	pnp_dbg(&dev->dev, "%s: current resources:\n", desc);
	list_for_each_entry(pnp_res, &dev->resources, list) {
		res = &pnp_res->res;
		len = 0;

		len += scnprintf(buf + len, sizeof(buf) - len, "  %-3s ",
				 pnp_resource_type_name(res));

		if (res->flags & IORESOURCE_DISABLED) {
			pnp_dbg(&dev->dev, "%sdisabled\n", buf);
			continue;
		}

		switch (pnp_resource_type(res)) {
		case IORESOURCE_IO:
		case IORESOURCE_MEM:
			len += scnprintf(buf + len, sizeof(buf) - len,
					 "%#llx-%#llx flags %#lx",
					 (unsigned long long) res->start,
					 (unsigned long long) res->end,
					 res->flags);
			break;
		case IORESOURCE_IRQ:
		case IORESOURCE_DMA:
			len += scnprintf(buf + len, sizeof(buf) - len,
					 "%lld flags %#lx",
					 (unsigned long long) res->start,
					 res->flags);
			break;
		}
		pnp_dbg(&dev->dev, "%s\n", buf);
	}
}

char *pnp_option_priority_name(struct pnp_option *option)
{
	switch (pnp_option_priority(option)) {
	case PNP_RES_PRIORITY_PREFERRED:
		return "preferred";
	case PNP_RES_PRIORITY_ACCEPTABLE:
		return "acceptable";
	case PNP_RES_PRIORITY_FUNCTIONAL:
		return "functional";
	}
	return "invalid";
}

void dbg_pnp_show_option(struct pnp_dev *dev, struct pnp_option *option)
{
	char buf[128];
	int len = 0, i;
	struct pnp_port *port;
	struct pnp_mem *mem;
	struct pnp_irq *irq;
	struct pnp_dma *dma;

	if (pnp_option_is_dependent(option))
		len += scnprintf(buf + len, sizeof(buf) - len,
				 "  dependent set %d (%s) ",
				 pnp_option_set(option),
				 pnp_option_priority_name(option));
	else
		len += scnprintf(buf + len, sizeof(buf) - len,
				 "  independent ");

	switch (option->type) {
	case IORESOURCE_IO:
		port = &option->u.port;
		len += scnprintf(buf + len, sizeof(buf) - len, "io  min %#llx "
				 "max %#llx align %lld size %lld flags %#x",
				 (unsigned long long) port->min,
				 (unsigned long long) port->max,
				 (unsigned long long) port->align,
				 (unsigned long long) port->size, port->flags);
		break;
	case IORESOURCE_MEM:
		mem = &option->u.mem;
		len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx "
				 "max %#llx align %lld size %lld flags %#x",
				 (unsigned long long) mem->min,
				 (unsigned long long) mem->max,
				 (unsigned long long) mem->align,
				 (unsigned long long) mem->size, mem->flags);
		break;
	case IORESOURCE_IRQ:
		irq = &option->u.irq;
		len += scnprintf(buf + len, sizeof(buf) - len, "irq");
		if (bitmap_empty(irq->map.bits, PNP_IRQ_NR))
			len += scnprintf(buf + len, sizeof(buf) - len,
					 " <none>");
		else {
			for (i = 0; i < PNP_IRQ_NR; i++)
				if (test_bit(i, irq->map.bits))
					len += scnprintf(buf + len,
							 sizeof(buf) - len,
							 " %d", i);
		}
		len += scnprintf(buf + len, sizeof(buf) - len, " flags %#x",
				 irq->flags);
		if (irq->flags & IORESOURCE_IRQ_OPTIONAL)
			len += scnprintf(buf + len, sizeof(buf) - len,
					 " (optional)");
		break;
	case IORESOURCE_DMA:
		dma = &option->u.dma;
		len += scnprintf(buf + len, sizeof(buf) - len, "dma");
		if (!dma->map)
			len += scnprintf(buf + len, sizeof(buf) - len,
					 " <none>");
		else {
			for (i = 0; i < 8; i++)
				if (dma->map & (1 << i))
					len += scnprintf(buf + len,
							 sizeof(buf) - len,
							 " %d", i);
		}
		len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) "
				 "flags %#x", dma->map, dma->flags);
		break;
	}
	pnp_dbg(&dev->dev, "%s\n", buf);
}
Commit	Line	Data
1da177e4	1	/*
07d4e9af	2	* support.c - standard functions for the use of pnp protocol drivers
1da177e4 LT	3	*
1da177e4 LT	4	* Copyright 2003 Adam Belay <ambx1@neo.rr.com>
1f32ca31 BH	5	* Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
1f32ca31 BH	6	* Bjorn Helgaas <bjorn.helgaas@hp.com>
1da177e4 LT	7	*/
1da177e4 LT	8
1da177e4 LT	9	#include <linux/module.h>
1da177e4 LT	10	#include <linux/ctype.h>
1da177e4 LT	11	#include <linux/pnp.h>
	12	#include "base.h"
	13
	14	/**
07d4e9af BH	15	* pnp_is_active - Determines if a device is active based on its current
07d4e9af BH	16	* resources
1da177e4	17	* @dev: pointer to the desired PnP device
1da177e4	18	*/
9dd78466	19	int pnp_is_active(struct pnp_dev *dev)
1da177e4	20	{
aee3ad81 BH	21	/*
	22	* I don't think this is very reliable because pnp_disable_dev()
	23	* only clears out auto-assigned resources.
	24	*/
1da177e4 LT	25	if (!pnp_port_start(dev, 0) && pnp_port_len(dev, 0) <= 1 &&
1da177e4 LT	26	!pnp_mem_start(dev, 0) && pnp_mem_len(dev, 0) <= 1 &&
9dd78466 BH	27	pnp_irq(dev, 0) == -1 && pnp_dma(dev, 0) == -1)
9dd78466 BH	28	return 0;
1da177e4 LT	29	else
	30	return 1;
	31	}
	32
1da177e4	33	EXPORT_SYMBOL(pnp_is_active);
25eb8461 BH	34
	35	/*
	36	* Functionally similar to acpi_ex_eisa_id_to_string(), but that's
	37	* buried in the ACPI CA, and we can't depend on it being present.
	38	*/
	39	void pnp_eisa_id_to_string(u32 id, char *str)
	40	{
	41	id = be32_to_cpu(id);
	42
	43	/*
	44	* According to the specs, the first three characters are five-bit
	45	* compressed ASCII, and the left-over high order bit should be zero.
	46	* However, the Linux ISAPNP code historically used six bits for the
	47	* first character, and there seem to be IDs that depend on that,
	48	* e.g., "nEC8241" in the Linux 8250_pnp serial driver and the
	49	* FreeBSD sys/pc98/cbus/sio_cbus.c driver.
	50	*/
	51	str[0] = 'A' + ((id >> 26) & 0x3f) - 1;
	52	str[1] = 'A' + ((id >> 21) & 0x1f) - 1;
	53	str[2] = 'A' + ((id >> 16) & 0x1f) - 1;
3fc95772 HH	54	str[3] = hex_asc_hi(id >> 8);
	55	str[4] = hex_asc_lo(id >> 8);
	56	str[5] = hex_asc_hi(id);
	57	str[6] = hex_asc_lo(id);
25eb8461 BH	58	str[7] = '\0';
25eb8461 BH	59	}
81b5c75f	60
9fdee4e0 BH	61	char pnp_resource_type_name(struct resource res)
	62	{
	63	switch (pnp_resource_type(res)) {
	64	case IORESOURCE_IO:
	65	return "io";
	66	case IORESOURCE_MEM:
	67	return "mem";
	68	case IORESOURCE_IRQ:
	69	return "irq";
	70	case IORESOURCE_DMA:
	71	return "dma";
	72	}
	73	return NULL;
	74	}
	75
81b5c75f BH	76	void dbg_pnp_show_resources(struct pnp_dev dev, char desc)
81b5c75f BH	77	{
aee3ad81	78	char buf[128];
ea44c1d6	79	int len;
aee3ad81	80	struct pnp_resource *pnp_res;
81b5c75f	81	struct resource *res;
81b5c75f	82
819beac3	83	if (list_empty(&dev->resources)) {
2f53432c	84	pnp_dbg(&dev->dev, "%s: no current resources\n", desc);
819beac3 BH	85	return;
	86	}
	87
2f53432c	88	pnp_dbg(&dev->dev, "%s: current resources:\n", desc);
aee3ad81 BH	89	list_for_each_entry(pnp_res, &dev->resources, list) {
aee3ad81 BH	90	res = &pnp_res->res;
ea44c1d6	91	len = 0;
81b5c75f	92
ea44c1d6 BH	93	len += scnprintf(buf + len, sizeof(buf) - len, " %-3s ",
ea44c1d6 BH	94	pnp_resource_type_name(res));
aee3ad81 BH	95
aee3ad81 BH	96	if (res->flags & IORESOURCE_DISABLED) {
2f53432c	97	pnp_dbg(&dev->dev, "%sdisabled\n", buf);
aee3ad81 BH	98	continue;
	99	}
	100
	101	switch (pnp_resource_type(res)) {
	102	case IORESOURCE_IO:
	103	case IORESOURCE_MEM:
ea44c1d6 BH	104	len += scnprintf(buf + len, sizeof(buf) - len,
	105	"%#llx-%#llx flags %#lx",
	106	(unsigned long long) res->start,
	107	(unsigned long long) res->end,
	108	res->flags);
aee3ad81 BH	109	break;
	110	case IORESOURCE_IRQ:
	111	case IORESOURCE_DMA:
ea44c1d6 BH	112	len += scnprintf(buf + len, sizeof(buf) - len,
	113	"%lld flags %#lx",
	114	(unsigned long long) res->start,
	115	res->flags);
aee3ad81 BH	116	break;
aee3ad81 BH	117	}
2f53432c	118	pnp_dbg(&dev->dev, "%s\n", buf);
81b5c75f	119	}
81b5c75f	120	}
1f32ca31 BH	121
	122	char pnp_option_priority_name(struct pnp_option option)
	123	{
	124	switch (pnp_option_priority(option)) {
	125	case PNP_RES_PRIORITY_PREFERRED:
	126	return "preferred";
	127	case PNP_RES_PRIORITY_ACCEPTABLE:
	128	return "acceptable";
	129	case PNP_RES_PRIORITY_FUNCTIONAL:
	130	return "functional";
	131	}
	132	return "invalid";
	133	}
	134
	135	void dbg_pnp_show_option(struct pnp_dev dev, struct pnp_option option)
	136	{
1f32ca31 BH	137	char buf[128];
	138	int len = 0, i;
	139	struct pnp_port *port;
	140	struct pnp_mem *mem;
	141	struct pnp_irq *irq;
	142	struct pnp_dma *dma;
	143
	144	if (pnp_option_is_dependent(option))
ea44c1d6 BH	145	len += scnprintf(buf + len, sizeof(buf) - len,
	146	" dependent set %d (%s) ",
	147	pnp_option_set(option),
	148	pnp_option_priority_name(option));
1f32ca31	149	else
ea44c1d6 BH	150	len += scnprintf(buf + len, sizeof(buf) - len,
ea44c1d6 BH	151	" independent ");
1f32ca31 BH	152
	153	switch (option->type) {
	154	case IORESOURCE_IO:
	155	port = &option->u.port;
ea44c1d6 BH	156	len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx "
	157	"max %#llx align %lld size %lld flags %#x",
	158	(unsigned long long) port->min,
	159	(unsigned long long) port->max,
	160	(unsigned long long) port->align,
	161	(unsigned long long) port->size, port->flags);
1f32ca31 BH	162	break;
	163	case IORESOURCE_MEM:
	164	mem = &option->u.mem;
ea44c1d6 BH	165	len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx "
	166	"max %#llx align %lld size %lld flags %#x",
	167	(unsigned long long) mem->min,
	168	(unsigned long long) mem->max,
	169	(unsigned long long) mem->align,
	170	(unsigned long long) mem->size, mem->flags);
1f32ca31 BH	171	break;
	172	case IORESOURCE_IRQ:
	173	irq = &option->u.irq;
ea44c1d6	174	len += scnprintf(buf + len, sizeof(buf) - len, "irq");
1f32ca31	175	if (bitmap_empty(irq->map.bits, PNP_IRQ_NR))
ea44c1d6 BH	176	len += scnprintf(buf + len, sizeof(buf) - len,
ea44c1d6 BH	177	" <none>");
1f32ca31 BH	178	else {
	179	for (i = 0; i < PNP_IRQ_NR; i++)
	180	if (test_bit(i, irq->map.bits))
ea44c1d6 BH	181	len += scnprintf(buf + len,
	182	sizeof(buf) - len,
	183	" %d", i);
1f32ca31	184	}
ea44c1d6 BH	185	len += scnprintf(buf + len, sizeof(buf) - len, " flags %#x",
ea44c1d6 BH	186	irq->flags);
1f32ca31	187	if (irq->flags & IORESOURCE_IRQ_OPTIONAL)
ea44c1d6 BH	188	len += scnprintf(buf + len, sizeof(buf) - len,
ea44c1d6 BH	189	" (optional)");
1f32ca31 BH	190	break;
	191	case IORESOURCE_DMA:
	192	dma = &option->u.dma;
ea44c1d6	193	len += scnprintf(buf + len, sizeof(buf) - len, "dma");
1f32ca31	194	if (!dma->map)
ea44c1d6 BH	195	len += scnprintf(buf + len, sizeof(buf) - len,
ea44c1d6 BH	196	" <none>");
1f32ca31 BH	197	else {
	198	for (i = 0; i < 8; i++)
	199	if (dma->map & (1 << i))
ea44c1d6 BH	200	len += scnprintf(buf + len,
	201	sizeof(buf) - len,
	202	" %d", i);
1f32ca31	203	}
ea44c1d6 BH	204	len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) "
ea44c1d6 BH	205	"flags %#x", dma->map, dma->flags);
1f32ca31 BH	206	break;
1f32ca31 BH	207	}
2f53432c	208	pnp_dbg(&dev->dev, "%s\n", buf);
1f32ca31	209	}