[linux-2.6-block.git] / drivers / pnp / pnpbios / proc.c

/*
 * /proc/bus/pnp interface for Plug and Play devices
 *
 * Written by David Hinds, dahinds@users.sourceforge.net
 * Modified by Thomas Hood
 *
 * The .../devices and .../<node> and .../boot/<node> files are
 * utilized by the lspnp and setpnp utilities, supplied with the
 * pcmcia-cs package.
 *     http://pcmcia-cs.sourceforge.net
 *
 * The .../escd file is utilized by the lsescd utility written by
 * Gunther Mayer.
 *     http://home.t-online.de/home/gunther.mayer/lsescd
 *
 * The .../legacy_device_resources file is not used yet.
 *
 * The other files are human-readable.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/pnpbios.h>
#include <linux/init.h>

#include <asm/uaccess.h>

#include "pnpbios.h"

static struct proc_dir_entry *proc_pnp = NULL;
static struct proc_dir_entry *proc_pnp_boot = NULL;

static int proc_read_pnpconfig(char *buf, char **start, off_t pos,
			       int count, int *eof, void *data)
{
	struct pnp_isa_config_struc pnps;

	if (pnp_bios_isapnp_config(&pnps))
		return -EIO;
	return snprintf(buf, count,
			"structure_revision %d\n"
			"number_of_CSNs %d\n"
			"ISA_read_data_port 0x%x\n",
			pnps.revision, pnps.no_csns, pnps.isa_rd_data_port);
}

static int proc_read_escdinfo(char *buf, char **start, off_t pos,
			      int count, int *eof, void *data)
{
	struct escd_info_struc escd;

	if (pnp_bios_escd_info(&escd))
		return -EIO;
	return snprintf(buf, count,
			"min_ESCD_write_size %d\n"
			"ESCD_size %d\n"
			"NVRAM_base 0x%x\n",
			escd.min_escd_write_size,
			escd.escd_size, escd.nv_storage_base);
}

#define MAX_SANE_ESCD_SIZE (32*1024)
static int proc_read_escd(char *buf, char **start, off_t pos,
			  int count, int *eof, void *data)
{
	struct escd_info_struc escd;
	char *tmpbuf;
	int escd_size, escd_left_to_read, n;

	if (pnp_bios_escd_info(&escd))
		return -EIO;

	/* sanity check */
	if (escd.escd_size > MAX_SANE_ESCD_SIZE) {
		printk(KERN_ERR
		       "PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n");
		return -EFBIG;
	}

	tmpbuf = kzalloc(escd.escd_size, GFP_KERNEL);
	if (!tmpbuf)
		return -ENOMEM;

	if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) {
		kfree(tmpbuf);
		return -EIO;
	}

	escd_size =
	    (unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1]) * 256;

	/* sanity check */
	if (escd_size > MAX_SANE_ESCD_SIZE) {
		printk(KERN_ERR
		       "PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n");
		return -EFBIG;
	}

	escd_left_to_read = escd_size - pos;
	if (escd_left_to_read < 0)
		escd_left_to_read = 0;
	if (escd_left_to_read == 0)
		*eof = 1;
	n = min(count, escd_left_to_read);
	memcpy(buf, tmpbuf + pos, n);
	kfree(tmpbuf);
	*start = buf;
	return n;
}

static int proc_read_legacyres(char *buf, char **start, off_t pos,
			       int count, int *eof, void *data)
{
	/* Assume that the following won't overflow the buffer */
	if (pnp_bios_get_stat_res(buf))
		return -EIO;

	return count;		// FIXME: Return actual length
}

static int proc_read_devices(char *buf, char **start, off_t pos,
			     int count, int *eof, void *data)
{
	struct pnp_bios_node *node;
	u8 nodenum;
	char *p = buf;

	if (pos >= 0xff)
		return 0;

	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
	if (!node)
		return -ENOMEM;

	for (nodenum = pos; nodenum < 0xff;) {
		u8 thisnodenum = nodenum;
		/* 26 = the number of characters per line sprintf'ed */
		if ((p - buf + 26) > count)
			break;
		if (pnp_bios_get_dev_node(&nodenum, PNPMODE_DYNAMIC, node))
			break;
		p += sprintf(p, "%02x\t%08x\t%02x:%02x:%02x\t%04x\n",
			     node->handle, node->eisa_id,
			     node->type_code[0], node->type_code[1],
			     node->type_code[2], node->flags);
		if (nodenum <= thisnodenum) {
			printk(KERN_ERR
			       "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
			       "PnPBIOS: proc_read_devices:",
			       (unsigned int)nodenum,
			       (unsigned int)thisnodenum);
			*eof = 1;
			break;
		}
	}
	kfree(node);
	if (nodenum == 0xff)
		*eof = 1;
	*start = (char *)((off_t) nodenum - pos);
	return p - buf;
}

static int proc_read_node(char *buf, char **start, off_t pos,
			  int count, int *eof, void *data)
{
	struct pnp_bios_node *node;
	int boot = (long)data >> 8;
	u8 nodenum = (long)data;
	int len;

	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
	if (!node)
		return -ENOMEM;
	if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
		kfree(node);
		return -EIO;
	}
	len = node->size - sizeof(struct pnp_bios_node);
	memcpy(buf, node->data, len);
	kfree(node);
	return len;
}

static int proc_write_node(struct file *file, const char __user * buf,
			   unsigned long count, void *data)
{
	struct pnp_bios_node *node;
	int boot = (long)data >> 8;
	u8 nodenum = (long)data;
	int ret = count;

	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
	if (!node)
		return -ENOMEM;
	if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
		ret = -EIO;
		goto out;
	}
	if (count != node->size - sizeof(struct pnp_bios_node)) {
		ret = -EINVAL;
		goto out;
	}
	if (copy_from_user(node->data, buf, count)) {
		ret = -EFAULT;
		goto out;
	}
	if (pnp_bios_set_dev_node(node->handle, boot, node) != 0) {
		ret = -EINVAL;
		goto out;
	}
	ret = count;
      out:
	kfree(node);
	return ret;
}

int pnpbios_interface_attach_device(struct pnp_bios_node *node)
{
	char name[3];
	struct proc_dir_entry *ent;

	sprintf(name, "%02x", node->handle);

	if (!proc_pnp)
		return -EIO;
	if (!pnpbios_dont_use_current_config) {
		ent = create_proc_entry(name, 0, proc_pnp);
		if (ent) {
			ent->read_proc = proc_read_node;
			ent->write_proc = proc_write_node;
			ent->data = (void *)(long)(node->handle);
		}
	}

	if (!proc_pnp_boot)
		return -EIO;
	ent = create_proc_entry(name, 0, proc_pnp_boot);
	if (ent) {
		ent->read_proc = proc_read_node;
		ent->write_proc = proc_write_node;
		ent->data = (void *)(long)(node->handle + 0x100);
		return 0;
	}

	return -EIO;
}

/*
 * When this is called, pnpbios functions are assumed to
 * work and the pnpbios_dont_use_current_config flag
 * should already have been set to the appropriate value
 */
int __init pnpbios_proc_init(void)
{
	proc_pnp = proc_mkdir("pnp", proc_bus);
	if (!proc_pnp)
		return -EIO;
	proc_pnp_boot = proc_mkdir("boot", proc_pnp);
	if (!proc_pnp_boot)
		return -EIO;
	create_proc_read_entry("devices", 0, proc_pnp, proc_read_devices, NULL);
	create_proc_read_entry("configuration_info", 0, proc_pnp,
			       proc_read_pnpconfig, NULL);
	create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo,
			       NULL);
	create_proc_read_entry("escd", S_IRUSR, proc_pnp, proc_read_escd, NULL);
	create_proc_read_entry("legacy_device_resources", 0, proc_pnp,
			       proc_read_legacyres, NULL);

	return 0;
}

void __exit pnpbios_proc_exit(void)
{
	int i;
	char name[3];

	if (!proc_pnp)
		return;

	for (i = 0; i < 0xff; i++) {
		sprintf(name, "%02x", i);
		if (!pnpbios_dont_use_current_config)
			remove_proc_entry(name, proc_pnp);
		remove_proc_entry(name, proc_pnp_boot);
	}
	remove_proc_entry("legacy_device_resources", proc_pnp);
	remove_proc_entry("escd", proc_pnp);
	remove_proc_entry("escd_info", proc_pnp);
	remove_proc_entry("configuration_info", proc_pnp);
	remove_proc_entry("devices", proc_pnp);
	remove_proc_entry("boot", proc_pnp);
	remove_proc_entry("pnp", proc_bus);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* /proc/bus/pnp interface for Plug and Play devices
	3	*
	4	* Written by David Hinds, dahinds@users.sourceforge.net
	5	* Modified by Thomas Hood
	6	*
	7	* The .../devices and .../<node> and .../boot/<node> files are
	8	* utilized by the lspnp and setpnp utilities, supplied with the
	9	* pcmcia-cs package.
	10	* http://pcmcia-cs.sourceforge.net
	11	*
	12	* The .../escd file is utilized by the lsescd utility written by
	13	* Gunther Mayer.
	14	* http://home.t-online.de/home/gunther.mayer/lsescd
	15	*
	16	* The .../legacy_device_resources file is not used yet.
	17	*
	18	* The other files are human-readable.
	19	*/
	20
1da177e4 LT	21	#include <linux/module.h>
	22	#include <linux/kernel.h>
	23	#include <linux/slab.h>
	24	#include <linux/types.h>
	25	#include <linux/proc_fs.h>
	26	#include <linux/pnpbios.h>
	27	#include <linux/init.h>
	28
	29	#include <asm/uaccess.h>
	30
	31	#include "pnpbios.h"
	32
	33	static struct proc_dir_entry *proc_pnp = NULL;
	34	static struct proc_dir_entry *proc_pnp_boot = NULL;
	35
	36	static int proc_read_pnpconfig(char buf, char *start, off_t pos,
9dd78466	37	int count, int eof, void data)
1da177e4 LT	38	{
	39	struct pnp_isa_config_struc pnps;
	40
	41	if (pnp_bios_isapnp_config(&pnps))
	42	return -EIO;
	43	return snprintf(buf, count,
9dd78466 BH	44	"structure_revision %d\n"
	45	"number_of_CSNs %d\n"
	46	"ISA_read_data_port 0x%x\n",
	47	pnps.revision, pnps.no_csns, pnps.isa_rd_data_port);
1da177e4 LT	48	}
	49
	50	static int proc_read_escdinfo(char buf, char *start, off_t pos,
9dd78466	51	int count, int eof, void data)
1da177e4 LT	52	{
	53	struct escd_info_struc escd;
	54
	55	if (pnp_bios_escd_info(&escd))
	56	return -EIO;
	57	return snprintf(buf, count,
9dd78466 BH	58	"min_ESCD_write_size %d\n"
	59	"ESCD_size %d\n"
	60	"NVRAM_base 0x%x\n",
	61	escd.min_escd_write_size,
	62	escd.escd_size, escd.nv_storage_base);
1da177e4 LT	63	}
	64
	65	#define MAX_SANE_ESCD_SIZE (32*1024)
	66	static int proc_read_escd(char buf, char *start, off_t pos,
9dd78466	67	int count, int eof, void data)
1da177e4 LT	68	{
	69	struct escd_info_struc escd;
	70	char *tmpbuf;
	71	int escd_size, escd_left_to_read, n;
	72
	73	if (pnp_bios_escd_info(&escd))
	74	return -EIO;
	75
	76	/* sanity check */
	77	if (escd.escd_size > MAX_SANE_ESCD_SIZE) {
9dd78466 BH	78	printk(KERN_ERR
9dd78466 BH	79	"PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n");
1da177e4 LT	80	return -EFBIG;
	81	}
	82
cd861280	83	tmpbuf = kzalloc(escd.escd_size, GFP_KERNEL);
9dd78466 BH	84	if (!tmpbuf)
9dd78466 BH	85	return -ENOMEM;
1da177e4 LT	86
	87	if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) {
	88	kfree(tmpbuf);
	89	return -EIO;
	90	}
	91
9dd78466 BH	92	escd_size =
9dd78466 BH	93	(unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1]) * 256;
1da177e4 LT	94
	95	/* sanity check */
	96	if (escd_size > MAX_SANE_ESCD_SIZE) {
9dd78466 BH	97	printk(KERN_ERR
9dd78466 BH	98	"PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n");
1da177e4 LT	99	return -EFBIG;
	100	}
	101
	102	escd_left_to_read = escd_size - pos;
9dd78466 BH	103	if (escd_left_to_read < 0)
	104	escd_left_to_read = 0;
	105	if (escd_left_to_read == 0)
	106	*eof = 1;
	107	n = min(count, escd_left_to_read);
1da177e4 LT	108	memcpy(buf, tmpbuf + pos, n);
	109	kfree(tmpbuf);
	110	*start = buf;
	111	return n;
	112	}
	113
	114	static int proc_read_legacyres(char buf, char *start, off_t pos,
9dd78466	115	int count, int eof, void data)
1da177e4 LT	116	{
1da177e4 LT	117	/* Assume that the following won't overflow the buffer */
9dd78466	118	if (pnp_bios_get_stat_res(buf))
1da177e4 LT	119	return -EIO;
1da177e4 LT	120
9dd78466	121	return count; // FIXME: Return actual length
1da177e4 LT	122	}
	123
	124	static int proc_read_devices(char buf, char *start, off_t pos,
9dd78466	125	int count, int eof, void data)
1da177e4 LT	126	{
	127	struct pnp_bios_node *node;
	128	u8 nodenum;
	129	char *p = buf;
	130
	131	if (pos >= 0xff)
	132	return 0;
	133
cd861280	134	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
9dd78466 BH	135	if (!node)
9dd78466 BH	136	return -ENOMEM;
1da177e4	137
9dd78466	138	for (nodenum = pos; nodenum < 0xff;) {
1da177e4 LT	139	u8 thisnodenum = nodenum;
	140	/* 26 = the number of characters per line sprintf'ed */
	141	if ((p - buf + 26) > count)
	142	break;
	143	if (pnp_bios_get_dev_node(&nodenum, PNPMODE_DYNAMIC, node))
	144	break;
	145	p += sprintf(p, "%02x\t%08x\t%02x:%02x:%02x\t%04x\n",
	146	node->handle, node->eisa_id,
	147	node->type_code[0], node->type_code[1],
	148	node->type_code[2], node->flags);
	149	if (nodenum <= thisnodenum) {
9dd78466 BH	150	printk(KERN_ERR
	151	"%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
	152	"PnPBIOS: proc_read_devices:",
	153	(unsigned int)nodenum,
	154	(unsigned int)thisnodenum);
1da177e4 LT	155	*eof = 1;
	156	break;
	157	}
	158	}
	159	kfree(node);
	160	if (nodenum == 0xff)
	161	*eof = 1;
9dd78466	162	start = (char )((off_t) nodenum - pos);
1da177e4 LT	163	return p - buf;
	164	}
	165
	166	static int proc_read_node(char buf, char *start, off_t pos,
9dd78466	167	int count, int eof, void data)
1da177e4 LT	168	{
	169	struct pnp_bios_node *node;
	170	int boot = (long)data >> 8;
	171	u8 nodenum = (long)data;
	172	int len;
	173
cd861280	174	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
9dd78466 BH	175	if (!node)
9dd78466 BH	176	return -ENOMEM;
1da177e4 LT	177	if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
	178	kfree(node);
	179	return -EIO;
	180	}
	181	len = node->size - sizeof(struct pnp_bios_node);
	182	memcpy(buf, node->data, len);
	183	kfree(node);
	184	return len;
	185	}
	186
9dd78466 BH	187	static int proc_write_node(struct file file, const char __user buf,
9dd78466 BH	188	unsigned long count, void *data)
1da177e4 LT	189	{
	190	struct pnp_bios_node *node;
	191	int boot = (long)data >> 8;
	192	u8 nodenum = (long)data;
	193	int ret = count;
	194
cd861280	195	node = kzalloc(node_info.max_node_size, GFP_KERNEL);
1da177e4 LT	196	if (!node)
	197	return -ENOMEM;
	198	if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
	199	ret = -EIO;
	200	goto out;
	201	}
	202	if (count != node->size - sizeof(struct pnp_bios_node)) {
	203	ret = -EINVAL;
	204	goto out;
	205	}
	206	if (copy_from_user(node->data, buf, count)) {
	207	ret = -EFAULT;
	208	goto out;
	209	}
	210	if (pnp_bios_set_dev_node(node->handle, boot, node) != 0) {
	211	ret = -EINVAL;
	212	goto out;
	213	}
	214	ret = count;
9dd78466	215	out:
1da177e4 LT	216	kfree(node);
	217	return ret;
	218	}
	219
9dd78466	220	int pnpbios_interface_attach_device(struct pnp_bios_node *node)
1da177e4 LT	221	{
	222	char name[3];
	223	struct proc_dir_entry *ent;
	224
	225	sprintf(name, "%02x", node->handle);
	226
	227	if (!proc_pnp)
	228	return -EIO;
9dd78466	229	if (!pnpbios_dont_use_current_config) {
1da177e4 LT	230	ent = create_proc_entry(name, 0, proc_pnp);
	231	if (ent) {
	232	ent->read_proc = proc_read_node;
	233	ent->write_proc = proc_write_node;
	234	ent->data = (void *)(long)(node->handle);
	235	}
	236	}
	237
	238	if (!proc_pnp_boot)
	239	return -EIO;
	240	ent = create_proc_entry(name, 0, proc_pnp_boot);
	241	if (ent) {
	242	ent->read_proc = proc_read_node;
	243	ent->write_proc = proc_write_node;
9dd78466	244	ent->data = (void *)(long)(node->handle + 0x100);
1da177e4 LT	245	return 0;
	246	}
	247
	248	return -EIO;
	249	}
	250
	251	/*
	252	* When this is called, pnpbios functions are assumed to
	253	* work and the pnpbios_dont_use_current_config flag
	254	* should already have been set to the appropriate value
	255	*/
9dd78466	256	int __init pnpbios_proc_init(void)
1da177e4 LT	257	{
	258	proc_pnp = proc_mkdir("pnp", proc_bus);
	259	if (!proc_pnp)
	260	return -EIO;
	261	proc_pnp_boot = proc_mkdir("boot", proc_pnp);
	262	if (!proc_pnp_boot)
	263	return -EIO;
	264	create_proc_read_entry("devices", 0, proc_pnp, proc_read_devices, NULL);
9dd78466 BH	265	create_proc_read_entry("configuration_info", 0, proc_pnp,
	266	proc_read_pnpconfig, NULL);
	267	create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo,
	268	NULL);
1da177e4	269	create_proc_read_entry("escd", S_IRUSR, proc_pnp, proc_read_escd, NULL);
9dd78466 BH	270	create_proc_read_entry("legacy_device_resources", 0, proc_pnp,
9dd78466 BH	271	proc_read_legacyres, NULL);
1da177e4 LT	272
	273	return 0;
	274	}
	275
	276	void __exit pnpbios_proc_exit(void)
	277	{
	278	int i;
	279	char name[3];
	280
	281	if (!proc_pnp)
	282	return;
	283
9dd78466	284	for (i = 0; i < 0xff; i++) {
1da177e4	285	sprintf(name, "%02x", i);
9dd78466	286	if (!pnpbios_dont_use_current_config)
1da177e4 LT	287	remove_proc_entry(name, proc_pnp);
	288	remove_proc_entry(name, proc_pnp_boot);
	289	}
	290	remove_proc_entry("legacy_device_resources", proc_pnp);
	291	remove_proc_entry("escd", proc_pnp);
	292	remove_proc_entry("escd_info", proc_pnp);
	293	remove_proc_entry("configuration_info", proc_pnp);
	294	remove_proc_entry("devices", proc_pnp);
	295	remove_proc_entry("boot", proc_pnp);
	296	remove_proc_entry("pnp", proc_bus);
1da177e4	297	}