[linux-2.6-block.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,
		void *oldval, size_t *oldlenp,
		void *newval, size_t newlen)
{
	int r;

	r = sysctl_string(table, 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,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	r = proc_dostring(table, write, 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,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	r = proc_dointvec(table, write, 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,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	struct timespec ts;
	int r;

	if (!write) {
		read_persistent_clock(&ts);
		rtctmp = ts.tv_sec;
		/* check for time < 0 and set to 0 */
		if (rtctmp < 0)
			rtctmp = 0;
	}
	r = proc_dointvec(table, write, 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,
		    void *oldval, size_t *oldlenp,
		    void *newval, size_t newlen)
{
	int r;

	r = sysctl_intvec(table, 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,
		    void *oldval, size_t *oldlenp,
		    void *newval, size_t newlen)
{
	struct timespec ts;
	int r;

	read_persistent_clock(&ts);
	rtctmp = ts.tv_sec;
	if (rtctmp < 0)
		rtctmp = 0;
	r = sysctl_intvec(table, 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,
		       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,
				     void *oldval, size_t *oldlenp,
				     void *newval, size_t newlen)
{
	int r;

	r = sysctl_intvec(table, 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,
		       void *buffer, size_t *lenp, loff_t *ppos)
{
	int r;

	r = proc_dointvec(table, write, 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
1f21d2bd BM	40	/* Strategy function to write EEPROM after changing string entry */
f221e726	41	int sysctl_lasatstring(ctl_table *table,
1f21d2bd BM	42	void oldval, size_t oldlenp,
	43	void *newval, size_t newlen)
	44	{
	45	int r;
	46
f221e726	47	r = sysctl_string(table, oldval, oldlenp, newval, newlen);
1f34f2e4	48	if (r < 0)
1f21d2bd	49	return r;
1f34f2e4	50
1f21d2bd BM	51	if (newval && newlen)
1f21d2bd BM	52	lasat_write_eeprom_info();
1f21d2bd	53
1f34f2e4	54	return 0;
1f21d2bd BM	55	}
	56
	57
	58	/* And the same for proc */
8d65af78	59	int proc_dolasatstring(ctl_table *table, int write,
1f21d2bd BM	60	void buffer, size_t lenp, loff_t *ppos)
	61	{
	62	int r;
	63
8d65af78	64	r = proc_dostring(table, write, buffer, lenp, ppos);
1f34f2e4	65	if ((!write) \|\| r)
1f21d2bd	66	return r;
1f34f2e4	67
1f21d2bd	68	lasat_write_eeprom_info();
1f21d2bd BM	69
	70	return 0;
	71	}
	72
	73	/* proc function to write EEPROM after changing int entry */
8d65af78	74	int proc_dolasatint(ctl_table *table, int write,
1f21d2bd BM	75	void buffer, size_t lenp, loff_t *ppos)
	76	{
	77	int r;
	78
8d65af78	79	r = proc_dointvec(table, write, buffer, lenp, ppos);
1f34f2e4	80	if ((!write) \|\| r)
1f21d2bd	81	return r;
1f34f2e4	82
1f21d2bd	83	lasat_write_eeprom_info();
1f21d2bd BM	84
	85	return 0;
	86	}
	87
1f34f2e4	88	#ifdef CONFIG_DS1603
1f21d2bd BM	89	static int rtctmp;
1f21d2bd BM	90
1f21d2bd	91	/* proc function to read/write RealTime Clock */
8d65af78	92	int proc_dolasatrtc(ctl_table *table, int write,
1f21d2bd BM	93	void buffer, size_t lenp, loff_t *ppos)
1f21d2bd BM	94	{
d4f587c6	95	struct timespec ts;
1f21d2bd BM	96	int r;
1f21d2bd BM	97
1f21d2bd	98	if (!write) {
d4f587c6 MS	99	read_persistent_clock(&ts);
d4f587c6 MS	100	rtctmp = ts.tv_sec;
1f21d2bd BM	101	/* check for time < 0 and set to 0 */
	102	if (rtctmp < 0)
	103	rtctmp = 0;
	104	}
8d65af78	105	r = proc_dointvec(table, write, buffer, lenp, ppos);
1f34f2e4	106	if (r)
1f21d2bd	107	return r;
1f34f2e4 TH	108
	109	if (write)
	110	rtc_mips_set_mmss(rtctmp);
1f21d2bd BM	111
	112	return 0;
	113	}
	114	#endif
	115
	116	/* Sysctl for setting the IP addresses */
f221e726	117	int sysctl_lasat_intvec(ctl_table *table,
1f21d2bd BM	118	void oldval, size_t oldlenp,
	119	void *newval, size_t newlen)
	120	{
	121	int r;
	122
f221e726	123	r = sysctl_intvec(table, oldval, oldlenp, newval, newlen);
1f34f2e4	124	if (r < 0)
1f21d2bd	125	return r;
1f34f2e4	126
1f21d2bd BM	127	if (newval && newlen)
1f21d2bd BM	128	lasat_write_eeprom_info();
1f21d2bd	129
1f34f2e4	130	return 0;
1f21d2bd BM	131	}
	132
	133	#ifdef CONFIG_DS1603
	134	/* Same for RTC */
f221e726	135	int sysctl_lasat_rtc(ctl_table *table,
1f21d2bd BM	136	void oldval, size_t oldlenp,
	137	void *newval, size_t newlen)
	138	{
d4f587c6	139	struct timespec ts;
1f21d2bd BM	140	int r;
1f21d2bd BM	141
d4f587c6 MS	142	read_persistent_clock(&ts);
d4f587c6 MS	143	rtctmp = ts.tv_sec;
1f21d2bd BM	144	if (rtctmp < 0)
1f21d2bd BM	145	rtctmp = 0;
f221e726	146	r = sysctl_intvec(table, oldval, oldlenp, newval, newlen);
1f34f2e4	147	if (r < 0)
1f21d2bd	148	return r;
1f21d2bd	149	if (newval && newlen)
4b550488	150	rtc_mips_set_mmss(rtctmp);
1f21d2bd	151
1f34f2e4	152	return r;
1f21d2bd BM	153	}
	154	#endif
	155
	156	#ifdef CONFIG_INET
8d65af78	157	int proc_lasat_ip(ctl_table *table, int write,
1f21d2bd BM	158	void buffer, size_t lenp, loff_t *ppos)
	159	{
	160	unsigned int ip;
	161	char *p, c;
	162	int len;
1f34f2e4	163	char ipbuf[32];
1f21d2bd BM	164
	165	if (!table->data \|\| !table->maxlen \|\| !*lenp \|\|
	166	(*ppos && !write)) {
	167	*lenp = 0;
	168	return 0;
	169	}
	170
1f21d2bd BM	171	if (write) {
	172	len = 0;
	173	p = buffer;
	174	while (len < *lenp) {
1f34f2e4	175	if (get_user(c, p++))
1f21d2bd	176	return -EFAULT;
1f21d2bd BM	177	if (c == 0 \|\| c == '\n')
	178	break;
	179	len++;
	180	}
1f34f2e4 TH	181	if (len >= sizeof(ipbuf)-1)
	182	len = sizeof(ipbuf) - 1;
	183	if (copy_from_user(ipbuf, buffer, len))
1f21d2bd	184	return -EFAULT;
1f34f2e4	185	ipbuf[len] = 0;
1f21d2bd BM	186	ppos += lenp;
1f21d2bd BM	187	/* Now see if we can convert it to a valid IP */
1f34f2e4	188	ip = in_aton(ipbuf);
1f21d2bd BM	189	(unsigned int )(table->data) = ip;
	190	lasat_write_eeprom_info();
	191	} else {
	192	ip = (unsigned int )(table->data);
1f34f2e4	193	sprintf(ipbuf, "%d.%d.%d.%d",
1f21d2bd BM	194	(ip) & 0xff,
	195	(ip >> 8) & 0xff,
	196	(ip >> 16) & 0xff,
	197	(ip >> 24) & 0xff);
1f34f2e4	198	len = strlen(ipbuf);
1f21d2bd BM	199	if (len > *lenp)
	200	len = *lenp;
	201	if (len)
1f34f2e4	202	if (copy_to_user(buffer, ipbuf, len))
1f21d2bd	203	return -EFAULT;
1f21d2bd	204	if (len < *lenp) {
1f34f2e4	205	if (put_user('\n', ((char *) buffer) + len))
1f21d2bd	206	return -EFAULT;
1f21d2bd BM	207	len++;
	208	}
	209	*lenp = len;
	210	*ppos += len;
	211	}
1f21d2bd BM	212
	213	return 0;
	214	}
1f34f2e4	215	#endif
1f21d2bd	216
f221e726	217	static int sysctl_lasat_prid(ctl_table *table,
1f21d2bd BM	218	void oldval, size_t oldlenp,
	219	void *newval, size_t newlen)
	220	{
	221	int r;
	222
f221e726	223	r = sysctl_intvec(table, oldval, oldlenp, newval, newlen);
1f34f2e4	224	if (r < 0)
1f21d2bd	225	return r;
1f21d2bd	226	if (newval && newlen) {
1f34f2e4	227	lasat_board_info.li_eeprom_info.prid = (int )newval;
1f21d2bd BM	228	lasat_write_eeprom_info();
	229	lasat_init_board_info();
	230	}
1f21d2bd BM	231	return 0;
	232	}
	233
8d65af78	234	int proc_lasat_prid(ctl_table *table, int write,
1f21d2bd BM	235	void buffer, size_t lenp, loff_t *ppos)
	236	{
	237	int r;
	238
8d65af78	239	r = proc_dointvec(table, write, buffer, lenp, ppos);
1f34f2e4	240	if (r < 0)
1f21d2bd	241	return r;
1f34f2e4 TH	242	if (write) {
	243	lasat_board_info.li_eeprom_info.prid =
	244	lasat_board_info.li_prid;
	245	lasat_write_eeprom_info();
	246	lasat_init_board_info();
1f21d2bd	247	}
1f21d2bd BM	248	return 0;
	249	}
	250
	251	extern int lasat_boot_to_service;
	252
1f21d2bd BM	253	static ctl_table lasat_table[] = {
	254	{
	255	.ctl_name = CTL_UNNUMBERED,
	256	.procname = "cpu-hz",
	257	.data = &lasat_board_info.li_cpu_hz,
	258	.maxlen = sizeof(int),
	259	.mode = 0444,
	260	.proc_handler = &proc_dointvec,
	261	.strategy = &sysctl_intvec
	262	},
	263	{
	264	.ctl_name = CTL_UNNUMBERED,
	265	.procname = "bus-hz",
	266	.data = &lasat_board_info.li_bus_hz,
	267	.maxlen = sizeof(int),
	268	.mode = 0444,
	269	.proc_handler = &proc_dointvec,
	270	.strategy = &sysctl_intvec
	271	},
	272	{
	273	.ctl_name = CTL_UNNUMBERED,
	274	.procname = "bmid",
	275	.data = &lasat_board_info.li_bmid,
	276	.maxlen = sizeof(int),
	277	.mode = 0444,
	278	.proc_handler = &proc_dointvec,
	279	.strategy = &sysctl_intvec
	280	},
	281	{
	282	.ctl_name = CTL_UNNUMBERED,
	283	.procname = "prid",
	284	.data = &lasat_board_info.li_prid,
	285	.maxlen = sizeof(int),
	286	.mode = 0644,
1f34f2e4 TH	287	.proc_handler = &proc_lasat_prid,
1f34f2e4 TH	288	.strategy = &sysctl_lasat_prid
1f21d2bd BM	289	},
	290	#ifdef CONFIG_INET
	291	{
	292	.ctl_name = CTL_UNNUMBERED,
	293	.procname = "ipaddr",
	294	.data = &lasat_board_info.li_eeprom_info.ipaddr,
	295	.maxlen = sizeof(int),
	296	.mode = 0644,
	297	.proc_handler = &proc_lasat_ip,
	298	.strategy = &sysctl_lasat_intvec
	299	},
	300	{
1f34f2e4	301	.ctl_name = CTL_UNNUMBERED,
1f21d2bd BM	302	.procname = "netmask",
	303	.data = &lasat_board_info.li_eeprom_info.netmask,
	304	.maxlen = sizeof(int),
	305	.mode = 0644,
	306	.proc_handler = &proc_lasat_ip,
	307	.strategy = &sysctl_lasat_intvec
	308	},
1f21d2bd BM	309	#endif
	310	{
	311	.ctl_name = CTL_UNNUMBERED,
	312	.procname = "passwd_hash",
	313	.data = &lasat_board_info.li_eeprom_info.passwd_hash,
	314	.maxlen =
	315	sizeof(lasat_board_info.li_eeprom_info.passwd_hash),
	316	.mode = 0600,
	317	.proc_handler = &proc_dolasatstring,
	318	.strategy = &sysctl_lasatstring
	319	},
	320	{
	321	.ctl_name = CTL_UNNUMBERED,
	322	.procname = "boot-service",
	323	.data = &lasat_boot_to_service,
	324	.maxlen = sizeof(int),
	325	.mode = 0644,
	326	.proc_handler = &proc_dointvec,
	327	.strategy = &sysctl_intvec
	328	},
	329	#ifdef CONFIG_DS1603
	330	{
	331	.ctl_name = CTL_UNNUMBERED,
	332	.procname = "rtc",
	333	.data = &rtctmp,
	334	.maxlen = sizeof(int),
	335	.mode = 0644,
	336	.proc_handler = &proc_dolasatrtc,
	337	.strategy = &sysctl_lasat_rtc
	338	},
	339	#endif
	340	{
	341	.ctl_name = CTL_UNNUMBERED,
	342	.procname = "namestr",
	343	.data = &lasat_board_info.li_namestr,
	344	.maxlen = sizeof(lasat_board_info.li_namestr),
	345	.mode = 0444,
1f34f2e4	346	.proc_handler = &proc_dostring,
1f21d2bd BM	347	.strategy = &sysctl_string
	348	},
	349	{
	350	.ctl_name = CTL_UNNUMBERED,
	351	.procname = "typestr",
	352	.data = &lasat_board_info.li_typestr,
	353	.maxlen = sizeof(lasat_board_info.li_typestr),
	354	.mode = 0444,
	355	.proc_handler = &proc_dostring,
	356	.strategy = &sysctl_string
	357	},
	358	{}
	359	};
	360
	361	static ctl_table lasat_root_table[] = {
	362	{
	363	.ctl_name = CTL_UNNUMBERED,
	364	.procname = "lasat",
	365	.mode = 0555,
	366	.child = lasat_table
	367	},
	368	{}
	369	};
	370
	371	static int __init lasat_register_sysctl(void)
	372	{
	373	struct ctl_table_header *lasat_table_header;
	374
	375	lasat_table_header =
	376	register_sysctl_table(lasat_root_table);
1f34f2e4 TH	377	if (!lasat_table_header) {
	378	printk(KERN_ERR "Unable to register LASAT sysctl\n");
	379	return -ENOMEM;
	380	}
1f21d2bd BM	381
	382	return 0;
	383	}
	384
	385	__initcall(lasat_register_sysctl);