[mirror_ubuntu-zesty-kernel.git] / drivers / parport / procfs.c

/* Sysctl interface for parport devices.
 * 
 * Authors: David Campbell
 *          Tim Waugh <tim@cyberelk.demon.co.uk>
 *          Philip Blundell <philb@gnu.org>
 *          Andrea Arcangeli
 *          Riccardo Facchetti <fizban@tin.it>
 *
 * based on work by Grant Guenther <grant@torque.net>
 *              and Philip Blundell
 *
 * Cleaned up include files - Russell King <linux@arm.uk.linux.org>
 */

#include <linux/string.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/parport.h>
#include <linux/ctype.h>
#include <linux/sysctl.h>
#include <linux/device.h>

#include <linux/uaccess.h>

#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)

#define PARPORT_MIN_TIMESLICE_VALUE 1ul 
#define PARPORT_MAX_TIMESLICE_VALUE ((unsigned long) HZ)
#define PARPORT_MIN_SPINTIME_VALUE 1
#define PARPORT_MAX_SPINTIME_VALUE 1000

static int do_active_device(struct ctl_table *table, int write,
		      void __user *result, size_t *lenp, loff_t *ppos)
{
	struct parport *port = (struct parport *)table->extra1;
	char buffer[256];
	struct pardevice *dev;
	int len = 0;

	if (write)		/* can't happen anyway */
		return -EACCES;

	if (*ppos) {
		*lenp = 0;
		return 0;
	}
	
	for (dev = port->devices; dev ; dev = dev->next) {
		if(dev == port->cad) {
			len += sprintf(buffer, "%s\n", dev->name);
		}
	}

	if(!len) {
		len += sprintf(buffer, "%s\n", "none");
	}

	if (len > *lenp)
		len = *lenp;
	else
		*lenp = len;

	*ppos += len;

	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}

#ifdef CONFIG_PARPORT_1284
static int do_autoprobe(struct ctl_table *table, int write,
			void __user *result, size_t *lenp, loff_t *ppos)
{
	struct parport_device_info *info = table->extra2;
	const char *str;
	char buffer[256];
	int len = 0;

	if (write) /* permissions stop this */
		return -EACCES;

	if (*ppos) {
		*lenp = 0;
		return 0;
	}
	
	if ((str = info->class_name) != NULL)
		len += sprintf (buffer + len, "CLASS:%s;\n", str);

	if ((str = info->model) != NULL)
		len += sprintf (buffer + len, "MODEL:%s;\n", str);

	if ((str = info->mfr) != NULL)
		len += sprintf (buffer + len, "MANUFACTURER:%s;\n", str);

	if ((str = info->description) != NULL)
		len += sprintf (buffer + len, "DESCRIPTION:%s;\n", str);

	if ((str = info->cmdset) != NULL)
		len += sprintf (buffer + len, "COMMAND SET:%s;\n", str);

	if (len > *lenp)
		len = *lenp;
	else
		*lenp = len;

	*ppos += len;

	return copy_to_user (result, buffer, len) ? -EFAULT : 0;
}
#endif /* IEEE1284.3 support. */

static int do_hardware_base_addr(struct ctl_table *table, int write,
				 void __user *result,
				 size_t *lenp, loff_t *ppos)
{
	struct parport *port = (struct parport *)table->extra1;
	char buffer[20];
	int len = 0;

	if (*ppos) {
		*lenp = 0;
		return 0;
	}

	if (write) /* permissions prevent this anyway */
		return -EACCES;

	len += sprintf (buffer, "%lu\t%lu\n", port->base, port->base_hi);

	if (len > *lenp)
		len = *lenp;
	else
		*lenp = len;

	*ppos += len;

	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}

static int do_hardware_irq(struct ctl_table *table, int write,
			   void __user *result,
			   size_t *lenp, loff_t *ppos)
{
	struct parport *port = (struct parport *)table->extra1;
	char buffer[20];
	int len = 0;

	if (*ppos) {
		*lenp = 0;
		return 0;
	}

	if (write) /* permissions prevent this anyway */
		return -EACCES;

	len += sprintf (buffer, "%d\n", port->irq);

	if (len > *lenp)
		len = *lenp;
	else
		*lenp = len;

	*ppos += len;

	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}

static int do_hardware_dma(struct ctl_table *table, int write,
			   void __user *result,
			   size_t *lenp, loff_t *ppos)
{
	struct parport *port = (struct parport *)table->extra1;
	char buffer[20];
	int len = 0;

	if (*ppos) {
		*lenp = 0;
		return 0;
	}

	if (write) /* permissions prevent this anyway */
		return -EACCES;

	len += sprintf (buffer, "%d\n", port->dma);

	if (len > *lenp)
		len = *lenp;
	else
		*lenp = len;

	*ppos += len;

	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}

static int do_hardware_modes(struct ctl_table *table, int write,
			     void __user *result,
			     size_t *lenp, loff_t *ppos)
{
	struct parport *port = (struct parport *)table->extra1;
	char buffer[40];
	int len = 0;

	if (*ppos) {
		*lenp = 0;
		return 0;
	}

	if (write) /* permissions prevent this anyway */
		return -EACCES;

	{
#define printmode(x) {if(port->modes&PARPORT_MODE_##x){len+=sprintf(buffer+len,"%s%s",f?",":"",#x);f++;}}
		int f = 0;
		printmode(PCSPP);
		printmode(TRISTATE);
		printmode(COMPAT);
		printmode(EPP);
		printmode(ECP);
		printmode(DMA);
#undef printmode
	}
	buffer[len++] = '\n';

	if (len > *lenp)
		len = *lenp;
	else
		*lenp = len;

	*ppos += len;

	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}

#define PARPORT_PORT_DIR(CHILD) { .procname = NULL, .mode = 0555, .child = CHILD }
#define PARPORT_PARPORT_DIR(CHILD) { .procname = "parport", \
                                     .mode = 0555, .child = CHILD }
#define PARPORT_DEV_DIR(CHILD) { .procname = "dev", .mode = 0555, .child = CHILD }
#define PARPORT_DEVICES_ROOT_DIR  {  .procname = "devices", \
                                    .mode = 0555, .child = NULL }

static const unsigned long parport_min_timeslice_value =
PARPORT_MIN_TIMESLICE_VALUE;

static const unsigned long parport_max_timeslice_value =
PARPORT_MAX_TIMESLICE_VALUE;

static const  int parport_min_spintime_value =
PARPORT_MIN_SPINTIME_VALUE;

static const int parport_max_spintime_value =
PARPORT_MAX_SPINTIME_VALUE;


struct parport_sysctl_table {
	struct ctl_table_header *sysctl_header;
	struct ctl_table vars[12];
	struct ctl_table device_dir[2];
	struct ctl_table port_dir[2];
	struct ctl_table parport_dir[2];
	struct ctl_table dev_dir[2];
};

static const struct parport_sysctl_table parport_sysctl_template = {
	.sysctl_header = NULL,
        {
		{
			.procname	= "spintime",
			.data		= NULL,
			.maxlen		= sizeof(int),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_minmax,
			.extra1		= (void*) &parport_min_spintime_value,
			.extra2		= (void*) &parport_max_spintime_value
		},
		{
			.procname	= "base-addr",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_hardware_base_addr
		},
		{
			.procname	= "irq",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_hardware_irq
		},
		{
			.procname	= "dma",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_hardware_dma
		},
		{
			.procname	= "modes",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_hardware_modes
		},
		PARPORT_DEVICES_ROOT_DIR,
#ifdef CONFIG_PARPORT_1284
		{
			.procname	= "autoprobe",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_autoprobe
		},
		{
			.procname	= "autoprobe0",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_autoprobe
		},
		{
			.procname	= "autoprobe1",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_autoprobe
		},
		{
			.procname	= "autoprobe2",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_autoprobe
		},
		{
			.procname	= "autoprobe3",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_autoprobe
		},
#endif /* IEEE 1284 support */
		{}
	},
	{
		{
			.procname	= "active",
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0444,
			.proc_handler	= do_active_device
		},
		{}
	},
	{
		PARPORT_PORT_DIR(NULL),
		{}
	},
	{
		PARPORT_PARPORT_DIR(NULL),
		{}
	},
	{
		PARPORT_DEV_DIR(NULL),
		{}
	}
};

struct parport_device_sysctl_table
{
	struct ctl_table_header *sysctl_header;
	struct ctl_table vars[2];
	struct ctl_table device_dir[2];
	struct ctl_table devices_root_dir[2];
	struct ctl_table port_dir[2];
	struct ctl_table parport_dir[2];
	struct ctl_table dev_dir[2];
};

static const struct parport_device_sysctl_table
parport_device_sysctl_template = {
	.sysctl_header = NULL,
	{
		{
			.procname 	= "timeslice",
			.data		= NULL,
			.maxlen		= sizeof(unsigned long),
			.mode		= 0644,
			.proc_handler	= proc_doulongvec_ms_jiffies_minmax,
			.extra1		= (void*) &parport_min_timeslice_value,
			.extra2		= (void*) &parport_max_timeslice_value
		},
	},
	{
		{
			.procname	= NULL,
			.data		= NULL,
			.maxlen		= 0,
			.mode		= 0555,
			.child		= NULL
		},
		{}
	},
	{
		PARPORT_DEVICES_ROOT_DIR,
		{}
	},
	{
		PARPORT_PORT_DIR(NULL),
		{}
	},
	{
		PARPORT_PARPORT_DIR(NULL),
		{}
	},
	{
		PARPORT_DEV_DIR(NULL),
		{}
	}
};

struct parport_default_sysctl_table
{
	struct ctl_table_header *sysctl_header;
	struct ctl_table vars[3];
	struct ctl_table default_dir[2];
	struct ctl_table parport_dir[2];
	struct ctl_table dev_dir[2];
};

static struct parport_default_sysctl_table
parport_default_sysctl_table = {
	.sysctl_header	= NULL,
	{
		{
			.procname	= "timeslice",
			.data		= &parport_default_timeslice,
			.maxlen		= sizeof(parport_default_timeslice),
			.mode		= 0644,
			.proc_handler	= proc_doulongvec_ms_jiffies_minmax,
			.extra1		= (void*) &parport_min_timeslice_value,
			.extra2		= (void*) &parport_max_timeslice_value
		},
		{
			.procname	= "spintime",
			.data		= &parport_default_spintime,
			.maxlen		= sizeof(parport_default_spintime),
			.mode		= 0644,
			.proc_handler	= proc_dointvec_minmax,
			.extra1		= (void*) &parport_min_spintime_value,
			.extra2		= (void*) &parport_max_spintime_value
		},
		{}
	},
	{
		{
			.procname	= "default",
			.mode		= 0555,
			.child		= parport_default_sysctl_table.vars
		},
		{}
	},
	{
		PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir),
		{}
	},
	{
		PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir),
		{}
	}
};


int parport_proc_register(struct parport *port)
{
	struct parport_sysctl_table *t;
	int i;

	t = kmemdup(&parport_sysctl_template, sizeof(*t), GFP_KERNEL);
	if (t == NULL)
		return -ENOMEM;

	t->device_dir[0].extra1 = port;

	for (i = 0; i < 5; i++)
		t->vars[i].extra1 = port;

	t->vars[0].data = &port->spintime;
	t->vars[5].child = t->device_dir;
	
	for (i = 0; i < 5; i++)
		t->vars[6 + i].extra2 = &port->probe_info[i];

	t->port_dir[0].procname = port->name;

	t->port_dir[0].child = t->vars;
	t->parport_dir[0].child = t->port_dir;
	t->dev_dir[0].child = t->parport_dir;

	t->sysctl_header = register_sysctl_table(t->dev_dir);
	if (t->sysctl_header == NULL) {
		kfree(t);
		t = NULL;
	}
	port->sysctl_table = t;
	return 0;
}

int parport_proc_unregister(struct parport *port)
{
	if (port->sysctl_table) {
		struct parport_sysctl_table *t = port->sysctl_table;
		port->sysctl_table = NULL;
		unregister_sysctl_table(t->sysctl_header);
		kfree(t);
	}
	return 0;
}

int parport_device_proc_register(struct pardevice *device)
{
	struct parport_device_sysctl_table *t;
	struct parport * port = device->port;
	
	t = kmemdup(&parport_device_sysctl_template, sizeof(*t), GFP_KERNEL);
	if (t == NULL)
		return -ENOMEM;

	t->dev_dir[0].child = t->parport_dir;
	t->parport_dir[0].child = t->port_dir;
	t->port_dir[0].procname = port->name;
	t->port_dir[0].child = t->devices_root_dir;
	t->devices_root_dir[0].child = t->device_dir;

	t->device_dir[0].procname = device->name;
	t->device_dir[0].child = t->vars;
	t->vars[0].data = &device->timeslice;

	t->sysctl_header = register_sysctl_table(t->dev_dir);
	if (t->sysctl_header == NULL) {
		kfree(t);
		t = NULL;
	}
	device->sysctl_table = t;
	return 0;
}

int parport_device_proc_unregister(struct pardevice *device)
{
	if (device->sysctl_table) {
		struct parport_device_sysctl_table *t = device->sysctl_table;
		device->sysctl_table = NULL;
		unregister_sysctl_table(t->sysctl_header);
		kfree(t);
	}
	return 0;
}

static int __init parport_default_proc_register(void)
{
	int ret;

	parport_default_sysctl_table.sysctl_header =
		register_sysctl_table(parport_default_sysctl_table.dev_dir);
	if (!parport_default_sysctl_table.sysctl_header)
		return -ENOMEM;
	ret = parport_bus_init();
	if (ret) {
		unregister_sysctl_table(parport_default_sysctl_table.
					sysctl_header);
		return ret;
	}
	return 0;
}

static void __exit parport_default_proc_unregister(void)
{
	if (parport_default_sysctl_table.sysctl_header) {
		unregister_sysctl_table(parport_default_sysctl_table.
					sysctl_header);
		parport_default_sysctl_table.sysctl_header = NULL;
	}
	parport_bus_exit();
}

#else /* no sysctl or no procfs*/

int parport_proc_register(struct parport *pp)
{
	return 0;
}

int parport_proc_unregister(struct parport *pp)
{
	return 0;
}

int parport_device_proc_register(struct pardevice *device)
{
	return 0;
}

int parport_device_proc_unregister(struct pardevice *device)
{
	return 0;
}

static int __init parport_default_proc_register (void)
{
	return parport_bus_init();
}

static void __exit parport_default_proc_unregister (void)
{
	parport_bus_exit();
}
#endif

subsys_initcall(parport_default_proc_register)
module_exit(parport_default_proc_unregister)
Commit	Line	Data
1da177e4 LT	1	/* Sysctl interface for parport devices.
1da177e4 LT	2	*
bdca3f20	3	* Authors: David Campbell
1da177e4 LT	4	* Tim Waugh <tim@cyberelk.demon.co.uk>
	5	* Philip Blundell <philb@gnu.org>
	6	* Andrea Arcangeli
	7	* Riccardo Facchetti <fizban@tin.it>
	8	*
	9	* based on work by Grant Guenther <grant@torque.net>
	10	* and Philip Blundell
	11	*
	12	* Cleaned up include files - Russell King <linux@arm.uk.linux.org>
	13	*/
	14
	15	#include <linux/string.h>
1da177e4 LT	16	#include <linux/init.h>
	17	#include <linux/module.h>
	18	#include <linux/errno.h>
	19	#include <linux/kernel.h>
	20	#include <linux/slab.h>
	21	#include <linux/parport.h>
	22	#include <linux/ctype.h>
	23	#include <linux/sysctl.h>
6fa45a22	24	#include <linux/device.h>
1da177e4	25
7c0f6ba6	26	#include <linux/uaccess.h>
1da177e4 LT	27
	28	#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
	29
	30	#define PARPORT_MIN_TIMESLICE_VALUE 1ul
	31	#define PARPORT_MAX_TIMESLICE_VALUE ((unsigned long) HZ)
	32	#define PARPORT_MIN_SPINTIME_VALUE 1
	33	#define PARPORT_MAX_SPINTIME_VALUE 1000
	34
be424c63	35	static int do_active_device(struct ctl_table *table, int write,
1da177e4 LT	36	void __user result, size_t lenp, loff_t *ppos)
	37	{
	38	struct parport port = (struct parport )table->extra1;
	39	char buffer[256];
	40	struct pardevice *dev;
	41	int len = 0;
	42
	43	if (write) /* can't happen anyway */
	44	return -EACCES;
	45
	46	if (*ppos) {
	47	*lenp = 0;
	48	return 0;
	49	}
	50
	51	for (dev = port->devices; dev ; dev = dev->next) {
	52	if(dev == port->cad) {
	53	len += sprintf(buffer, "%s\n", dev->name);
	54	}
	55	}
	56
	57	if(!len) {
	58	len += sprintf(buffer, "%s\n", "none");
	59	}
	60
	61	if (len > *lenp)
	62	len = *lenp;
	63	else
	64	*lenp = len;
	65
	66	*ppos += len;
	67
	68	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
	69	}
	70
	71	#ifdef CONFIG_PARPORT_1284
be424c63	72	static int do_autoprobe(struct ctl_table *table, int write,
1da177e4 LT	73	void __user result, size_t lenp, loff_t *ppos)
	74	{
	75	struct parport_device_info *info = table->extra2;
	76	const char *str;
	77	char buffer[256];
	78	int len = 0;
	79
	80	if (write) /* permissions stop this */
	81	return -EACCES;
	82
	83	if (*ppos) {
	84	*lenp = 0;
	85	return 0;
	86	}
	87
	88	if ((str = info->class_name) != NULL)
	89	len += sprintf (buffer + len, "CLASS:%s;\n", str);
	90
	91	if ((str = info->model) != NULL)
	92	len += sprintf (buffer + len, "MODEL:%s;\n", str);
	93
	94	if ((str = info->mfr) != NULL)
	95	len += sprintf (buffer + len, "MANUFACTURER:%s;\n", str);
	96
	97	if ((str = info->description) != NULL)
	98	len += sprintf (buffer + len, "DESCRIPTION:%s;\n", str);
	99
	100	if ((str = info->cmdset) != NULL)
	101	len += sprintf (buffer + len, "COMMAND SET:%s;\n", str);
	102
	103	if (len > *lenp)
	104	len = *lenp;
	105	else
	106	*lenp = len;
	107
	108	*ppos += len;
	109
	110	return copy_to_user (result, buffer, len) ? -EFAULT : 0;
	111	}
	112	#endif /* IEEE1284.3 support. */
	113
be424c63 JP	114	static int do_hardware_base_addr(struct ctl_table *table, int write,
	115	void __user *result,
	116	size_t lenp, loff_t ppos)
1da177e4 LT	117	{
	118	struct parport port = (struct parport )table->extra1;
	119	char buffer[20];
	120	int len = 0;
	121
	122	if (*ppos) {
	123	*lenp = 0;
	124	return 0;
	125	}
	126
	127	if (write) /* permissions prevent this anyway */
	128	return -EACCES;
	129
	130	len += sprintf (buffer, "%lu\t%lu\n", port->base, port->base_hi);
	131
	132	if (len > *lenp)
	133	len = *lenp;
	134	else
	135	*lenp = len;
	136
	137	*ppos += len;
	138
	139	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
	140	}
	141
be424c63 JP	142	static int do_hardware_irq(struct ctl_table *table, int write,
	143	void __user *result,
	144	size_t lenp, loff_t ppos)
1da177e4 LT	145	{
	146	struct parport port = (struct parport )table->extra1;
	147	char buffer[20];
	148	int len = 0;
	149
	150	if (*ppos) {
	151	*lenp = 0;
	152	return 0;
	153	}
	154
	155	if (write) /* permissions prevent this anyway */
	156	return -EACCES;
	157
	158	len += sprintf (buffer, "%d\n", port->irq);
	159
	160	if (len > *lenp)
	161	len = *lenp;
	162	else
	163	*lenp = len;
	164
	165	*ppos += len;
	166
	167	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
	168	}
	169
be424c63 JP	170	static int do_hardware_dma(struct ctl_table *table, int write,
	171	void __user *result,
	172	size_t lenp, loff_t ppos)
1da177e4 LT	173	{
	174	struct parport port = (struct parport )table->extra1;
	175	char buffer[20];
	176	int len = 0;
	177
	178	if (*ppos) {
	179	*lenp = 0;
	180	return 0;
	181	}
	182
	183	if (write) /* permissions prevent this anyway */
	184	return -EACCES;
	185
	186	len += sprintf (buffer, "%d\n", port->dma);
	187
	188	if (len > *lenp)
	189	len = *lenp;
	190	else
	191	*lenp = len;
	192
	193	*ppos += len;
	194
	195	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
	196	}
	197
be424c63 JP	198	static int do_hardware_modes(struct ctl_table *table, int write,
	199	void __user *result,
	200	size_t lenp, loff_t ppos)
1da177e4 LT	201	{
	202	struct parport port = (struct parport )table->extra1;
	203	char buffer[40];
	204	int len = 0;
	205
	206	if (*ppos) {
	207	*lenp = 0;
	208	return 0;
	209	}
	210
	211	if (write) /* permissions prevent this anyway */
	212	return -EACCES;
	213
	214	{
	215	#define printmode(x) {if(port->modes&PARPORT_MODE_##x){len+=sprintf(buffer+len,"%s%s",f?",":"",#x);f++;}}
	216	int f = 0;
	217	printmode(PCSPP);
	218	printmode(TRISTATE);
	219	printmode(COMPAT);
	220	printmode(EPP);
	221	printmode(ECP);
	222	printmode(DMA);
	223	#undef printmode
	224	}
	225	buffer[len++] = '\n';
	226
	227	if (len > *lenp)
	228	len = *lenp;
	229	else
	230	*lenp = len;
	231
	232	*ppos += len;
	233
	234	return copy_to_user(result, buffer, len) ? -EFAULT : 0;
	235	}
	236
894d2491 EB	237	#define PARPORT_PORT_DIR(CHILD) { .procname = NULL, .mode = 0555, .child = CHILD }
894d2491 EB	238	#define PARPORT_PARPORT_DIR(CHILD) { .procname = "parport", \
2564b7bd	239	.mode = 0555, .child = CHILD }
894d2491	240	#define PARPORT_DEV_DIR(CHILD) { .procname = "dev", .mode = 0555, .child = CHILD }
25398a15	241	#define PARPORT_DEVICES_ROOT_DIR { .procname = "devices", \
2564b7bd	242	.mode = 0555, .child = NULL }
1da177e4 LT	243
	244	static const unsigned long parport_min_timeslice_value =
	245	PARPORT_MIN_TIMESLICE_VALUE;
	246
	247	static const unsigned long parport_max_timeslice_value =
	248	PARPORT_MAX_TIMESLICE_VALUE;
	249
	250	static const int parport_min_spintime_value =
	251	PARPORT_MIN_SPINTIME_VALUE;
	252
	253	static const int parport_max_spintime_value =
	254	PARPORT_MAX_SPINTIME_VALUE;
	255
	256
	257	struct parport_sysctl_table {
	258	struct ctl_table_header *sysctl_header;
be424c63 JP	259	struct ctl_table vars[12];
	260	struct ctl_table device_dir[2];
	261	struct ctl_table port_dir[2];
	262	struct ctl_table parport_dir[2];
	263	struct ctl_table dev_dir[2];
1da177e4 LT	264	};
	265
	266	static const struct parport_sysctl_table parport_sysctl_template = {
2564b7bd	267	.sysctl_header = NULL,
1da177e4	268	{
2564b7bd	269	{
2564b7bd EB	270	.procname = "spintime",
	271	.data = NULL,
	272	.maxlen = sizeof(int),
	273	.mode = 0644,
6d456111	274	.proc_handler = proc_dointvec_minmax,
2564b7bd EB	275	.extra1 = (void*) &parport_min_spintime_value,
	276	.extra2 = (void*) &parport_max_spintime_value
	277	},
	278	{
2564b7bd EB	279	.procname = "base-addr",
	280	.data = NULL,
	281	.maxlen = 0,
	282	.mode = 0444,
6d456111	283	.proc_handler = do_hardware_base_addr
2564b7bd EB	284	},
2564b7bd EB	285	{
2564b7bd EB	286	.procname = "irq",
	287	.data = NULL,
	288	.maxlen = 0,
	289	.mode = 0444,
6d456111	290	.proc_handler = do_hardware_irq
2564b7bd EB	291	},
2564b7bd EB	292	{
2564b7bd EB	293	.procname = "dma",
	294	.data = NULL,
	295	.maxlen = 0,
	296	.mode = 0444,
6d456111	297	.proc_handler = do_hardware_dma
2564b7bd EB	298	},
2564b7bd EB	299	{
2564b7bd EB	300	.procname = "modes",
	301	.data = NULL,
	302	.maxlen = 0,
	303	.mode = 0444,
6d456111	304	.proc_handler = do_hardware_modes
2564b7bd	305	},
1da177e4 LT	306	PARPORT_DEVICES_ROOT_DIR,
1da177e4 LT	307	#ifdef CONFIG_PARPORT_1284
2564b7bd	308	{
2564b7bd EB	309	.procname = "autoprobe",
	310	.data = NULL,
	311	.maxlen = 0,
	312	.mode = 0444,
6d456111	313	.proc_handler = do_autoprobe
2564b7bd EB	314	},
2564b7bd EB	315	{
2564b7bd EB	316	.procname = "autoprobe0",
	317	.data = NULL,
	318	.maxlen = 0,
	319	.mode = 0444,
6d456111	320	.proc_handler = do_autoprobe
2564b7bd EB	321	},
2564b7bd EB	322	{
2564b7bd EB	323	.procname = "autoprobe1",
	324	.data = NULL,
	325	.maxlen = 0,
	326	.mode = 0444,
6d456111	327	.proc_handler = do_autoprobe
2564b7bd EB	328	},
2564b7bd EB	329	{
2564b7bd EB	330	.procname = "autoprobe2",
	331	.data = NULL,
	332	.maxlen = 0,
	333	.mode = 0444,
6d456111	334	.proc_handler = do_autoprobe
2564b7bd EB	335	},
2564b7bd EB	336	{
2564b7bd EB	337	.procname = "autoprobe3",
	338	.data = NULL,
	339	.maxlen = 0,
	340	.mode = 0444,
6d456111	341	.proc_handler = do_autoprobe
2564b7bd	342	},
1da177e4	343	#endif /* IEEE 1284 support */
2564b7bd	344	{}
1da177e4	345	},
2564b7bd EB	346	{
2564b7bd EB	347	{
2564b7bd EB	348	.procname = "active",
	349	.data = NULL,
	350	.maxlen = 0,
	351	.mode = 0444,
6d456111	352	.proc_handler = do_active_device
2564b7bd EB	353	},
	354	{}
	355	},
	356	{
	357	PARPORT_PORT_DIR(NULL),
	358	{}
	359	},
	360	{
	361	PARPORT_PARPORT_DIR(NULL),
	362	{}
	363	},
	364	{
	365	PARPORT_DEV_DIR(NULL),
	366	{}
	367	}
1da177e4 LT	368	};
	369
	370	struct parport_device_sysctl_table
	371	{
	372	struct ctl_table_header *sysctl_header;
be424c63 JP	373	struct ctl_table vars[2];
	374	struct ctl_table device_dir[2];
	375	struct ctl_table devices_root_dir[2];
	376	struct ctl_table port_dir[2];
	377	struct ctl_table parport_dir[2];
	378	struct ctl_table dev_dir[2];
1da177e4 LT	379	};
	380
	381	static const struct parport_device_sysctl_table
	382	parport_device_sysctl_template = {
2564b7bd EB	383	.sysctl_header = NULL,
	384	{
	385	{
2564b7bd EB	386	.procname = "timeslice",
2564b7bd EB	387	.data = NULL,
60af8803	388	.maxlen = sizeof(unsigned long),
2564b7bd	389	.mode = 0644,
6d456111	390	.proc_handler = proc_doulongvec_ms_jiffies_minmax,
2564b7bd EB	391	.extra1 = (void*) &parport_min_timeslice_value,
	392	.extra2 = (void*) &parport_max_timeslice_value
	393	},
	394	},
	395	{
	396	{
2564b7bd EB	397	.procname = NULL,
	398	.data = NULL,
	399	.maxlen = 0,
	400	.mode = 0555,
	401	.child = NULL
	402	},
	403	{}
	404	},
1da177e4	405	{
2564b7bd EB	406	PARPORT_DEVICES_ROOT_DIR,
	407	{}
	408	},
	409	{
	410	PARPORT_PORT_DIR(NULL),
	411	{}
1da177e4	412	},
2564b7bd EB	413	{
	414	PARPORT_PARPORT_DIR(NULL),
	415	{}
	416	},
	417	{
	418	PARPORT_DEV_DIR(NULL),
	419	{}
	420	}
1da177e4 LT	421	};
	422
	423	struct parport_default_sysctl_table
	424	{
	425	struct ctl_table_header *sysctl_header;
be424c63 JP	426	struct ctl_table vars[3];
	427	struct ctl_table default_dir[2];
	428	struct ctl_table parport_dir[2];
	429	struct ctl_table dev_dir[2];
1da177e4 LT	430	};
1da177e4 LT	431
1da177e4 LT	432	static struct parport_default_sysctl_table
1da177e4 LT	433	parport_default_sysctl_table = {
2564b7bd EB	434	.sysctl_header = NULL,
	435	{
	436	{
2564b7bd EB	437	.procname = "timeslice",
	438	.data = &parport_default_timeslice,
	439	.maxlen = sizeof(parport_default_timeslice),
	440	.mode = 0644,
6d456111	441	.proc_handler = proc_doulongvec_ms_jiffies_minmax,
2564b7bd EB	442	.extra1 = (void*) &parport_min_timeslice_value,
	443	.extra2 = (void*) &parport_max_timeslice_value
	444	},
	445	{
2564b7bd EB	446	.procname = "spintime",
	447	.data = &parport_default_spintime,
	448	.maxlen = sizeof(parport_default_spintime),
	449	.mode = 0644,
6d456111	450	.proc_handler = proc_dointvec_minmax,
2564b7bd EB	451	.extra1 = (void*) &parport_min_spintime_value,
	452	.extra2 = (void*) &parport_max_spintime_value
	453	},
	454	{}
	455	},
1da177e4	456	{
2564b7bd	457	{
2564b7bd EB	458	.procname = "default",
	459	.mode = 0555,
	460	.child = parport_default_sysctl_table.vars
	461	},
	462	{}
1da177e4	463	},
1da177e4	464	{
2564b7bd EB	465	PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir),
	466	{}
	467	},
	468	{
	469	PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir),
	470	{}
	471	}
1da177e4 LT	472	};
	473
	474
	475	int parport_proc_register(struct parport *port)
	476	{
	477	struct parport_sysctl_table *t;
	478	int i;
	479
2451a848	480	t = kmemdup(&parport_sysctl_template, sizeof(*t), GFP_KERNEL);
1da177e4 LT	481	if (t == NULL)
1da177e4 LT	482	return -ENOMEM;
1da177e4 LT	483
	484	t->device_dir[0].extra1 = port;
	485
25398a15	486	for (i = 0; i < 5; i++)
1da177e4 LT	487	t->vars[i].extra1 = port;
	488
	489	t->vars[0].data = &port->spintime;
	490	t->vars[5].child = t->device_dir;
	491
	492	for (i = 0; i < 5; i++)
	493	t->vars[6 + i].extra2 = &port->probe_info[i];
	494
	495	t->port_dir[0].procname = port->name;
1da177e4 LT	496
	497	t->port_dir[0].child = t->vars;
	498	t->parport_dir[0].child = t->port_dir;
	499	t->dev_dir[0].child = t->parport_dir;
	500
0b4d4147	501	t->sysctl_header = register_sysctl_table(t->dev_dir);
1da177e4 LT	502	if (t->sysctl_header == NULL) {
	503	kfree(t);
	504	t = NULL;
	505	}
	506	port->sysctl_table = t;
	507	return 0;
	508	}
	509
	510	int parport_proc_unregister(struct parport *port)
	511	{
	512	if (port->sysctl_table) {
	513	struct parport_sysctl_table *t = port->sysctl_table;
	514	port->sysctl_table = NULL;
	515	unregister_sysctl_table(t->sysctl_header);
	516	kfree(t);
	517	}
	518	return 0;
	519	}
	520
	521	int parport_device_proc_register(struct pardevice *device)
	522	{
	523	struct parport_device_sysctl_table *t;
	524	struct parport * port = device->port;
	525
2451a848	526	t = kmemdup(&parport_device_sysctl_template, sizeof(*t), GFP_KERNEL);
1da177e4 LT	527	if (t == NULL)
1da177e4 LT	528	return -ENOMEM;
1da177e4 LT	529
	530	t->dev_dir[0].child = t->parport_dir;
	531	t->parport_dir[0].child = t->port_dir;
	532	t->port_dir[0].procname = port->name;
1da177e4 LT	533	t->port_dir[0].child = t->devices_root_dir;
	534	t->devices_root_dir[0].child = t->device_dir;
	535
1da177e4	536	t->device_dir[0].procname = device->name;
1da177e4 LT	537	t->device_dir[0].child = t->vars;
	538	t->vars[0].data = &device->timeslice;
	539
0b4d4147	540	t->sysctl_header = register_sysctl_table(t->dev_dir);
1da177e4 LT	541	if (t->sysctl_header == NULL) {
	542	kfree(t);
	543	t = NULL;
	544	}
	545	device->sysctl_table = t;
	546	return 0;
	547	}
	548
	549	int parport_device_proc_unregister(struct pardevice *device)
	550	{
	551	if (device->sysctl_table) {
	552	struct parport_device_sysctl_table *t = device->sysctl_table;
	553	device->sysctl_table = NULL;
	554	unregister_sysctl_table(t->sysctl_header);
	555	kfree(t);
	556	}
	557	return 0;
	558	}
	559
	560	static int __init parport_default_proc_register(void)
	561	{
6fa45a22 SM	562	int ret;
6fa45a22 SM	563
1da177e4	564	parport_default_sysctl_table.sysctl_header =
0b4d4147	565	register_sysctl_table(parport_default_sysctl_table.dev_dir);
6fa45a22 SM	566	if (!parport_default_sysctl_table.sysctl_header)
	567	return -ENOMEM;
	568	ret = parport_bus_init();
	569	if (ret) {
	570	unregister_sysctl_table(parport_default_sysctl_table.
	571	sysctl_header);
	572	return ret;
	573	}
1da177e4 LT	574	return 0;
	575	}
	576
	577	static void __exit parport_default_proc_unregister(void)
	578	{
	579	if (parport_default_sysctl_table.sysctl_header) {
	580	unregister_sysctl_table(parport_default_sysctl_table.
	581	sysctl_header);
	582	parport_default_sysctl_table.sysctl_header = NULL;
	583	}
6fa45a22	584	parport_bus_exit();
1da177e4 LT	585	}
	586
	587	#else /* no sysctl or no procfs*/
	588
	589	int parport_proc_register(struct parport *pp)
	590	{
	591	return 0;
	592	}
	593
	594	int parport_proc_unregister(struct parport *pp)
	595	{
	596	return 0;
	597	}
	598
	599	int parport_device_proc_register(struct pardevice *device)
	600	{
	601	return 0;
	602	}
	603
	604	int parport_device_proc_unregister(struct pardevice *device)
	605	{
	606	return 0;
	607	}
	608
	609	static int __init parport_default_proc_register (void)
	610	{
6fa45a22	611	return parport_bus_init();
1da177e4 LT	612	}
	613
	614	static void __exit parport_default_proc_unregister (void)
	615	{
6fa45a22	616	parport_bus_exit();
1da177e4 LT	617	}
	618	#endif
	619
bbca503b	620	subsys_initcall(parport_default_proc_register)
1da177e4	621	module_exit(parport_default_proc_unregister)