[deliverable/linux.git] / arch / mips / lasat / sysctl.c

/*
 * Thomas Horsten <thh@lasat.com>
 * Copyright (C) 2000 LASAT Networks A/S.
 *
 *  This program is free software; you can distribute it and/or modify it
 *  under the terms of the GNU General Public License (Version 2) as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 * Routines specific to the LASAT boards
 */
#include <linux/types.h>
#include <asm/lasat/lasat.h>

#include <linux/module.h>
#include <linux/sysctl.h>
#include <linux/stddef.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/net.h>
#include <linux/inet.h>
#include <linux/uaccess.h>

#include <asm/time.h>

#ifdef CONFIG_DS1603
#include "ds1603.h"
#endif

/* Strategy function to write EEPROM after changing string entry */
int sysctl_lasatstring(ctl_table *table, int *name, int nlen,
		void *oldval, size_t *oldlenp,
		void *newval, size_t newlen)
{
	int r;

	r = sysctl_string(table, name,
			  nlen, oldval, oldlenp, newval, newlen);
	if (r < 0)
		return r;

	if (newval && newlen)
		lasat_write_eeprom_info();

	return 0;
}


/* And the same for proc */
int proc_dolasatstring(ctl_table *table, int write, struct file *filp,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	r = proc_dostring(table, write, filp, buffer, lenp, ppos);
	if ((!write) || r)
		return r;

	lasat_write_eeprom_info();

	return 0;
}

/* proc function to write EEPROM after changing int entry */
int proc_dolasatint(ctl_table *table, int write, struct file *filp,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
	if ((!write) || r)
		return r;

	lasat_write_eeprom_info();

	return 0;
}

#ifdef CONFIG_DS1603
static int rtctmp;

/* proc function to read/write RealTime Clock */
int proc_dolasatrtc(ctl_table *table, int write, struct file *filp,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	if (!write) {
		rtctmp = read_persistent_clock();
		/* check for time < 0 and set to 0 */
		if (rtctmp < 0)
			rtctmp = 0;
	}
	r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
	if (r)
		return r;

	if (write)
		rtc_mips_set_mmss(rtctmp);

	return 0;
}
#endif

/* Sysctl for setting the IP addresses */
int sysctl_lasat_intvec(ctl_table *table, int *name, int nlen,
		    void *oldval, size_t *oldlenp,
		    void *newval, size_t newlen)
{
	int r;

	r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen);
	if (r < 0)
		return r;

	if (newval && newlen)
		lasat_write_eeprom_info();

	return 0;
}

#ifdef CONFIG_DS1603
/* Same for RTC */
int sysctl_lasat_rtc(ctl_table *table, int *name, int nlen,
		    void *oldval, size_t *oldlenp,
		    void *newval, size_t newlen)
{
	int r;

	rtctmp = read_persistent_clock();
	if (rtctmp < 0)
		rtctmp = 0;
	r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen);
	if (r < 0)
		return r;
	if (newval && newlen)
		rtc_mips_set_mmss(rtctmp);

	return r;
}
#endif

#ifdef CONFIG_INET
int proc_lasat_ip(ctl_table *table, int write, struct file *filp,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	unsigned int ip;
	char *p, c;
	int len;
	char ipbuf[32];

	if (!table->data || !table->maxlen || !*lenp ||
	    (*ppos && !write)) {
		*lenp = 0;
		return 0;
	}

	if (write) {
		len = 0;
		p = buffer;
		while (len < *lenp) {
			if (get_user(c, p++))
				return -EFAULT;
			if (c == 0 || c == '\n')
				break;
			len++;
		}
		if (len >= sizeof(ipbuf)-1)
			len = sizeof(ipbuf) - 1;
		if (copy_from_user(ipbuf, buffer, len))
			return -EFAULT;
		ipbuf[len] = 0;
		*ppos += *lenp;
		/* Now see if we can convert it to a valid IP */
		ip = in_aton(ipbuf);
		*(unsigned int *)(table->data) = ip;
		lasat_write_eeprom_info();
	} else {
		ip = *(unsigned int *)(table->data);
		sprintf(ipbuf, "%d.%d.%d.%d",
			(ip)       & 0xff,
			(ip >>  8) & 0xff,
			(ip >> 16) & 0xff,
			(ip >> 24) & 0xff);
		len = strlen(ipbuf);
		if (len > *lenp)
			len = *lenp;
		if (len)
			if (copy_to_user(buffer, ipbuf, len))
				return -EFAULT;
		if (len < *lenp) {
			if (put_user('\n', ((char *) buffer) + len))
				return -EFAULT;
			len++;
		}
		*lenp = len;
		*ppos += len;
	}

	return 0;
}
#endif

static int sysctl_lasat_prid(ctl_table *table, int *name, int nlen,
				     void *oldval, size_t *oldlenp,
				     void *newval, size_t newlen)
{
	int r;

	r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen);
	if (r < 0)
		return r;
	if (newval && newlen) {
		lasat_board_info.li_eeprom_info.prid = *(int *)newval;
		lasat_write_eeprom_info();
		lasat_init_board_info();
	}
	return 0;
}

int proc_lasat_prid(ctl_table *table, int write, struct file *filp,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
	if (r < 0)
		return r;
	if (write) {
		lasat_board_info.li_eeprom_info.prid =
			lasat_board_info.li_prid;
		lasat_write_eeprom_info();
		lasat_init_board_info();
	}
	return 0;
}

extern int lasat_boot_to_service;

static ctl_table lasat_table[] = {
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "cpu-hz",
		.data		= &lasat_board_info.li_cpu_hz,
		.maxlen		= sizeof(int),
		.mode		= 0444,
		.proc_handler	= &proc_dointvec,
		.strategy	= &sysctl_intvec
	},
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "bus-hz",
		.data		= &lasat_board_info.li_bus_hz,
		.maxlen		= sizeof(int),
		.mode		= 0444,
		.proc_handler	= &proc_dointvec,
		.strategy	= &sysctl_intvec
	},
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "bmid",
		.data		= &lasat_board_info.li_bmid,
		.maxlen		= sizeof(int),
		.mode		= 0444,
		.proc_handler	= &proc_dointvec,
		.strategy	= &sysctl_intvec
	},
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "prid",
		.data		= &lasat_board_info.li_prid,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_lasat_prid,
		.strategy	= &sysctl_lasat_prid
	},
#ifdef CONFIG_INET
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "ipaddr",
		.data		= &lasat_board_info.li_eeprom_info.ipaddr,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_lasat_ip,
		.strategy	= &sysctl_lasat_intvec
	},
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "netmask",
		.data		= &lasat_board_info.li_eeprom_info.netmask,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_lasat_ip,
		.strategy	= &sysctl_lasat_intvec
	},
#endif
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "passwd_hash",
		.data		= &lasat_board_info.li_eeprom_info.passwd_hash,
		.maxlen		=
			sizeof(lasat_board_info.li_eeprom_info.passwd_hash),
		.mode		= 0600,
		.proc_handler	= &proc_dolasatstring,
		.strategy	= &sysctl_lasatstring
	},
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "boot-service",
		.data		= &lasat_boot_to_service,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec,
		.strategy	= &sysctl_intvec
	},
#ifdef CONFIG_DS1603
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "rtc",
		.data		= &rtctmp,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_dolasatrtc,
		.strategy	= &sysctl_lasat_rtc
	},
#endif
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "namestr",
		.data		= &lasat_board_info.li_namestr,
		.maxlen		= sizeof(lasat_board_info.li_namestr),
		.mode		= 0444,
		.proc_handler	= &proc_dostring,
		.strategy	= &sysctl_string
	},
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "typestr",
		.data		= &lasat_board_info.li_typestr,
		.maxlen		= sizeof(lasat_board_info.li_typestr),
		.mode		= 0444,
		.proc_handler	= &proc_dostring,
		.strategy	= &sysctl_string
	},
	{}
};

static ctl_table lasat_root_table[] = {
	{
		.ctl_name	= CTL_UNNUMBERED,
		.procname	= "lasat",
		.mode		=  0555,
		.child		= lasat_table
	},
	{}
};

static int __init lasat_register_sysctl(void)
{
	struct ctl_table_header *lasat_table_header;

	lasat_table_header =
		register_sysctl_table(lasat_root_table);
	if (!lasat_table_header) {
		printk(KERN_ERR "Unable to register LASAT sysctl\n");
		return -ENOMEM;
	}

	return 0;
}

__initcall(lasat_register_sysctl);
Commit	Line	Data
1f21d2bd BM	1	/*
	2	* Thomas Horsten <thh@lasat.com>
	3	* Copyright (C) 2000 LASAT Networks A/S.
	4	*
	5	* This program is free software; you can distribute it and/or modify it
	6	* under the terms of the GNU General Public License (Version 2) as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	12	* for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along
	15	* with this program; if not, write to the Free Software Foundation, Inc.,
	16	* 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
	17	*
	18	* Routines specific to the LASAT boards
	19	*/
	20	#include <linux/types.h>
	21	#include <asm/lasat/lasat.h>
	22
	23	#include <linux/module.h>
	24	#include <linux/sysctl.h>
	25	#include <linux/stddef.h>
	26	#include <linux/init.h>
	27	#include <linux/fs.h>
	28	#include <linux/ctype.h>
	29	#include <linux/string.h>
	30	#include <linux/net.h>
	31	#include <linux/inet.h>
1f21d2bd BM	32	#include <linux/uaccess.h>
1f21d2bd BM	33
4b550488 RB	34	#include <asm/time.h>
4b550488 RB	35
1f34f2e4	36	#ifdef CONFIG_DS1603
1f21d2bd	37	#include "ds1603.h"
1f34f2e4	38	#endif
1f21d2bd BM	39
	40	/* Strategy function to write EEPROM after changing string entry */
	41	int sysctl_lasatstring(ctl_table table, int name, int nlen,
	42	void oldval, size_t oldlenp,
	43	void *newval, size_t newlen)
	44	{
	45	int r;
	46
1f21d2bd BM	47	r = sysctl_string(table, name,
1f21d2bd BM	48	nlen, oldval, oldlenp, newval, newlen);
1f34f2e4	49	if (r < 0)
1f21d2bd	50	return r;
1f34f2e4	51
1f21d2bd BM	52	if (newval && newlen)
1f21d2bd BM	53	lasat_write_eeprom_info();
1f21d2bd	54
1f34f2e4	55	return 0;
1f21d2bd BM	56	}
	57
	58
	59	/* And the same for proc */
	60	int proc_dolasatstring(ctl_table table, int write, struct file filp,
	61	void buffer, size_t lenp, loff_t *ppos)
	62	{
	63	int r;
	64
1f21d2bd	65	r = proc_dostring(table, write, filp, buffer, lenp, ppos);
1f34f2e4	66	if ((!write) \|\| r)
1f21d2bd	67	return r;
1f34f2e4	68
1f21d2bd	69	lasat_write_eeprom_info();
1f21d2bd BM	70
	71	return 0;
	72	}
	73
	74	/* proc function to write EEPROM after changing int entry */
	75	int proc_dolasatint(ctl_table table, int write, struct file filp,
	76	void buffer, size_t lenp, loff_t *ppos)
	77	{
	78	int r;
	79
1f21d2bd	80	r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
1f34f2e4	81	if ((!write) \|\| r)
1f21d2bd	82	return r;
1f34f2e4	83
1f21d2bd	84	lasat_write_eeprom_info();
1f21d2bd BM	85
	86	return 0;
	87	}
	88
1f34f2e4	89	#ifdef CONFIG_DS1603
1f21d2bd BM	90	static int rtctmp;
1f21d2bd BM	91
1f21d2bd BM	92	/* proc function to read/write RealTime Clock */
	93	int proc_dolasatrtc(ctl_table table, int write, struct file filp,
	94	void buffer, size_t lenp, loff_t *ppos)
	95	{
	96	int r;
	97
1f21d2bd	98	if (!write) {
4b550488	99	rtctmp = read_persistent_clock();
1f21d2bd BM	100	/* check for time < 0 and set to 0 */
	101	if (rtctmp < 0)
	102	rtctmp = 0;
	103	}
	104	r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
1f34f2e4	105	if (r)
1f21d2bd	106	return r;
1f34f2e4 TH	107
	108	if (write)
	109	rtc_mips_set_mmss(rtctmp);
1f21d2bd BM	110
	111	return 0;
	112	}
	113	#endif
	114
	115	/* Sysctl for setting the IP addresses */
	116	int sysctl_lasat_intvec(ctl_table table, int name, int nlen,
	117	void oldval, size_t oldlenp,
	118	void *newval, size_t newlen)
	119	{
	120	int r;
	121
1f21d2bd	122	r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen);
1f34f2e4	123	if (r < 0)
1f21d2bd	124	return r;
1f34f2e4	125
1f21d2bd BM	126	if (newval && newlen)
1f21d2bd BM	127	lasat_write_eeprom_info();
1f21d2bd	128
1f34f2e4	129	return 0;
1f21d2bd BM	130	}
	131
	132	#ifdef CONFIG_DS1603
	133	/* Same for RTC */
	134	int sysctl_lasat_rtc(ctl_table table, int name, int nlen,
	135	void oldval, size_t oldlenp,
	136	void *newval, size_t newlen)
	137	{
	138	int r;
	139
4b550488	140	rtctmp = read_persistent_clock();
1f21d2bd BM	141	if (rtctmp < 0)
	142	rtctmp = 0;
	143	r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen);
1f34f2e4	144	if (r < 0)
1f21d2bd	145	return r;
1f21d2bd	146	if (newval && newlen)
4b550488	147	rtc_mips_set_mmss(rtctmp);
1f21d2bd	148
1f34f2e4	149	return r;
1f21d2bd BM	150	}
	151	#endif
	152
	153	#ifdef CONFIG_INET
1f21d2bd BM	154	int proc_lasat_ip(ctl_table table, int write, struct file filp,
	155	void buffer, size_t lenp, loff_t *ppos)
	156	{
	157	unsigned int ip;
	158	char *p, c;
	159	int len;
1f34f2e4	160	char ipbuf[32];
1f21d2bd BM	161
	162	if (!table->data \|\| !table->maxlen \|\| !*lenp \|\|
	163	(*ppos && !write)) {
	164	*lenp = 0;
	165	return 0;
	166	}
	167
1f21d2bd BM	168	if (write) {
	169	len = 0;
	170	p = buffer;
	171	while (len < *lenp) {
1f34f2e4	172	if (get_user(c, p++))
1f21d2bd	173	return -EFAULT;
1f21d2bd BM	174	if (c == 0 \|\| c == '\n')
	175	break;
	176	len++;
	177	}
1f34f2e4 TH	178	if (len >= sizeof(ipbuf)-1)
	179	len = sizeof(ipbuf) - 1;
	180	if (copy_from_user(ipbuf, buffer, len))
1f21d2bd	181	return -EFAULT;
1f34f2e4	182	ipbuf[len] = 0;
1f21d2bd BM	183	ppos += lenp;
1f21d2bd BM	184	/* Now see if we can convert it to a valid IP */
1f34f2e4	185	ip = in_aton(ipbuf);
1f21d2bd BM	186	(unsigned int )(table->data) = ip;
	187	lasat_write_eeprom_info();
	188	} else {
	189	ip = (unsigned int )(table->data);
1f34f2e4	190	sprintf(ipbuf, "%d.%d.%d.%d",
1f21d2bd BM	191	(ip) & 0xff,
	192	(ip >> 8) & 0xff,
	193	(ip >> 16) & 0xff,
	194	(ip >> 24) & 0xff);
1f34f2e4	195	len = strlen(ipbuf);
1f21d2bd BM	196	if (len > *lenp)
	197	len = *lenp;
	198	if (len)
1f34f2e4	199	if (copy_to_user(buffer, ipbuf, len))
1f21d2bd	200	return -EFAULT;
1f21d2bd	201	if (len < *lenp) {
1f34f2e4	202	if (put_user('\n', ((char *) buffer) + len))
1f21d2bd	203	return -EFAULT;
1f21d2bd BM	204	len++;
	205	}
	206	*lenp = len;
	207	*ppos += len;
	208	}
1f21d2bd BM	209
	210	return 0;
	211	}
1f34f2e4	212	#endif
1f21d2bd	213
1f34f2e4	214	static int sysctl_lasat_prid(ctl_table table, int name, int nlen,
1f21d2bd BM	215	void oldval, size_t oldlenp,
	216	void *newval, size_t newlen)
	217	{
	218	int r;
	219
1f21d2bd	220	r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen);
1f34f2e4	221	if (r < 0)
1f21d2bd	222	return r;
1f21d2bd	223	if (newval && newlen) {
1f34f2e4	224	lasat_board_info.li_eeprom_info.prid = (int )newval;
1f21d2bd BM	225	lasat_write_eeprom_info();
	226	lasat_init_board_info();
	227	}
1f21d2bd BM	228	return 0;
	229	}
	230
1f34f2e4	231	int proc_lasat_prid(ctl_table table, int write, struct file filp,
1f21d2bd BM	232	void buffer, size_t lenp, loff_t *ppos)
	233	{
	234	int r;
	235
1f21d2bd	236	r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
1f34f2e4	237	if (r < 0)
1f21d2bd	238	return r;
1f34f2e4 TH	239	if (write) {
	240	lasat_board_info.li_eeprom_info.prid =
	241	lasat_board_info.li_prid;
	242	lasat_write_eeprom_info();
	243	lasat_init_board_info();
1f21d2bd	244	}
1f21d2bd BM	245	return 0;
	246	}
	247
	248	extern int lasat_boot_to_service;
	249
1f21d2bd BM	250	static ctl_table lasat_table[] = {
	251	{
	252	.ctl_name = CTL_UNNUMBERED,
	253	.procname = "cpu-hz",
	254	.data = &lasat_board_info.li_cpu_hz,
	255	.maxlen = sizeof(int),
	256	.mode = 0444,
	257	.proc_handler = &proc_dointvec,
	258	.strategy = &sysctl_intvec
	259	},
	260	{
	261	.ctl_name = CTL_UNNUMBERED,
	262	.procname = "bus-hz",
	263	.data = &lasat_board_info.li_bus_hz,
	264	.maxlen = sizeof(int),
	265	.mode = 0444,
	266	.proc_handler = &proc_dointvec,
	267	.strategy = &sysctl_intvec
	268	},
	269	{
	270	.ctl_name = CTL_UNNUMBERED,
	271	.procname = "bmid",
	272	.data = &lasat_board_info.li_bmid,
	273	.maxlen = sizeof(int),
	274	.mode = 0444,
	275	.proc_handler = &proc_dointvec,
	276	.strategy = &sysctl_intvec
	277	},
	278	{
	279	.ctl_name = CTL_UNNUMBERED,
	280	.procname = "prid",
	281	.data = &lasat_board_info.li_prid,
	282	.maxlen = sizeof(int),
	283	.mode = 0644,
1f34f2e4 TH	284	.proc_handler = &proc_lasat_prid,
1f34f2e4 TH	285	.strategy = &sysctl_lasat_prid
1f21d2bd BM	286	},
	287	#ifdef CONFIG_INET
	288	{
	289	.ctl_name = CTL_UNNUMBERED,
	290	.procname = "ipaddr",
	291	.data = &lasat_board_info.li_eeprom_info.ipaddr,
	292	.maxlen = sizeof(int),
	293	.mode = 0644,
	294	.proc_handler = &proc_lasat_ip,
	295	.strategy = &sysctl_lasat_intvec
	296	},
	297	{
1f34f2e4	298	.ctl_name = CTL_UNNUMBERED,
1f21d2bd BM	299	.procname = "netmask",
	300	.data = &lasat_board_info.li_eeprom_info.netmask,
	301	.maxlen = sizeof(int),
	302	.mode = 0644,
	303	.proc_handler = &proc_lasat_ip,
	304	.strategy = &sysctl_lasat_intvec
	305	},
1f21d2bd BM	306	#endif
	307	{
	308	.ctl_name = CTL_UNNUMBERED,
	309	.procname = "passwd_hash",
	310	.data = &lasat_board_info.li_eeprom_info.passwd_hash,
	311	.maxlen =
	312	sizeof(lasat_board_info.li_eeprom_info.passwd_hash),
	313	.mode = 0600,
	314	.proc_handler = &proc_dolasatstring,
	315	.strategy = &sysctl_lasatstring
	316	},
	317	{
	318	.ctl_name = CTL_UNNUMBERED,
	319	.procname = "boot-service",
	320	.data = &lasat_boot_to_service,
	321	.maxlen = sizeof(int),
	322	.mode = 0644,
	323	.proc_handler = &proc_dointvec,
	324	.strategy = &sysctl_intvec
	325	},
	326	#ifdef CONFIG_DS1603
	327	{
	328	.ctl_name = CTL_UNNUMBERED,
	329	.procname = "rtc",
	330	.data = &rtctmp,
	331	.maxlen = sizeof(int),
	332	.mode = 0644,
	333	.proc_handler = &proc_dolasatrtc,
	334	.strategy = &sysctl_lasat_rtc
	335	},
	336	#endif
	337	{
	338	.ctl_name = CTL_UNNUMBERED,
	339	.procname = "namestr",
	340	.data = &lasat_board_info.li_namestr,
	341	.maxlen = sizeof(lasat_board_info.li_namestr),
	342	.mode = 0444,
1f34f2e4	343	.proc_handler = &proc_dostring,
1f21d2bd BM	344	.strategy = &sysctl_string
	345	},
	346	{
	347	.ctl_name = CTL_UNNUMBERED,
	348	.procname = "typestr",
	349	.data = &lasat_board_info.li_typestr,
	350	.maxlen = sizeof(lasat_board_info.li_typestr),
	351	.mode = 0444,
	352	.proc_handler = &proc_dostring,
	353	.strategy = &sysctl_string
	354	},
	355	{}
	356	};
	357
	358	static ctl_table lasat_root_table[] = {
	359	{
	360	.ctl_name = CTL_UNNUMBERED,
	361	.procname = "lasat",
	362	.mode = 0555,
	363	.child = lasat_table
	364	},
	365	{}
	366	};
	367
	368	static int __init lasat_register_sysctl(void)
	369	{
	370	struct ctl_table_header *lasat_table_header;
	371
	372	lasat_table_header =
	373	register_sysctl_table(lasat_root_table);
1f34f2e4 TH	374	if (!lasat_table_header) {
	375	printk(KERN_ERR "Unable to register LASAT sysctl\n");
	376	return -ENOMEM;
	377	}
1f21d2bd BM	378
	379	return 0;
	380	}
	381
	382	__initcall(lasat_register_sysctl);