[net-next-2.6.git] / arch / alpha / kernel / srm_env.c

/*
 * srm_env.c - Access to SRM environment
 *             variables through linux' procfs
 *
 * (C) 2001,2002,2006 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
 *
 * This driver is at all a modified version of Erik Mouw's
 * Documentation/DocBook/procfs_example.c, so: thank
 * you, Erik! He can be reached via email at
 * <J.A.K.Mouw@its.tudelft.nl>. It is based on an idea
 * provided by DEC^WCompaq^WIntel's "Jumpstart" CD. They
 * included a patch like this as well. Thanks for idea!
 *
 * This program is free software; you can redistribute
 * 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 that 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
 *
 */

#include <linux/kernel.h>
#include <linux/gfp.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/console.h>
#include <asm/uaccess.h>
#include <asm/machvec.h>

#define BASE_DIR	"srm_environment"	/* Subdir in /proc/		*/
#define NAMED_DIR	"named_variables"	/* Subdir for known variables	*/
#define NUMBERED_DIR	"numbered_variables"	/* Subdir for all variables	*/
#define VERSION		"0.0.6"			/* Module version		*/
#define NAME		"srm_env"		/* Module name			*/

MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
MODULE_LICENSE("GPL");

typedef struct _srm_env {
	char			*name;
	unsigned long		id;
	struct proc_dir_entry	*proc_entry;
} srm_env_t;

static struct proc_dir_entry	*base_dir;
static struct proc_dir_entry	*named_dir;
static struct proc_dir_entry	*numbered_dir;
static char			number[256][4];

static srm_env_t	srm_named_entries[] = {
	{ "auto_action",	ENV_AUTO_ACTION		},
	{ "boot_dev",		ENV_BOOT_DEV		},
	{ "bootdef_dev",	ENV_BOOTDEF_DEV		},
	{ "booted_dev",		ENV_BOOTED_DEV		},
	{ "boot_file",		ENV_BOOT_FILE		},
	{ "booted_file",	ENV_BOOTED_FILE		},
	{ "boot_osflags",	ENV_BOOT_OSFLAGS	},
	{ "booted_osflags",	ENV_BOOTED_OSFLAGS	},
	{ "boot_reset",		ENV_BOOT_RESET		},
	{ "dump_dev",		ENV_DUMP_DEV		},
	{ "enable_audit",	ENV_ENABLE_AUDIT	},
	{ "license",		ENV_LICENSE		},
	{ "char_set",		ENV_CHAR_SET		},
	{ "language",		ENV_LANGUAGE		},
	{ "tty_dev",		ENV_TTY_DEV		},
	{ NULL,			0			},
};
static srm_env_t	srm_numbered_entries[256];


static int srm_env_proc_show(struct seq_file *m, void *v)
{
	unsigned long	ret;
	srm_env_t	*entry;
	char		*page;

	entry = m->private;
	page = (char *)__get_free_page(GFP_USER);
	if (!page)
		return -ENOMEM;

	ret = callback_getenv(entry->id, page, PAGE_SIZE);

	if ((ret >> 61) == 0) {
		seq_write(m, page, ret);
		ret = 0;
	} else
		ret = -EFAULT;
	free_page((unsigned long)page);
	return ret;
}

static int srm_env_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, srm_env_proc_show, PDE(inode)->data);
}

static ssize_t srm_env_proc_write(struct file *file, const char __user *buffer,
				  size_t count, loff_t *pos)
{
	int res;
	srm_env_t	*entry = PDE(file->f_path.dentry->d_inode)->data;
	char		*buf = (char *) __get_free_page(GFP_USER);
	unsigned long	ret1, ret2;

	if (!buf)
		return -ENOMEM;

	res = -EINVAL;
	if (count >= PAGE_SIZE)
		goto out;

	res = -EFAULT;
	if (copy_from_user(buf, buffer, count))
		goto out;
	buf[count] = '\0';

	ret1 = callback_setenv(entry->id, buf, count);
	if ((ret1 >> 61) == 0) {
		do
			ret2 = callback_save_env();
		while((ret2 >> 61) == 1);
		res = (int) ret1;
	}

 out:
	free_page((unsigned long)buf);
	return res;
}

static const struct file_operations srm_env_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= srm_env_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= srm_env_proc_write,
};

static void
srm_env_cleanup(void)
{
	srm_env_t	*entry;
	unsigned long	var_num;

	if (base_dir) {
		/*
		 * Remove named entries
		 */
		if (named_dir) {
			entry = srm_named_entries;
			while (entry->name != NULL && entry->id != 0) {
				if (entry->proc_entry) {
					remove_proc_entry(entry->name,
							named_dir);
					entry->proc_entry = NULL;
				}
				entry++;
			}
			remove_proc_entry(NAMED_DIR, base_dir);
		}

		/*
		 * Remove numbered entries
		 */
		if (numbered_dir) {
			for (var_num = 0; var_num <= 255; var_num++) {
				entry =	&srm_numbered_entries[var_num];

				if (entry->proc_entry) {
					remove_proc_entry(entry->name,
							numbered_dir);
					entry->proc_entry	= NULL;
					entry->name		= NULL;
				}
			}
			remove_proc_entry(NUMBERED_DIR, base_dir);
		}

		remove_proc_entry(BASE_DIR, NULL);
	}

	return;
}

static int __init
srm_env_init(void)
{
	srm_env_t	*entry;
	unsigned long	var_num;

	/*
	 * Check system
	 */
	if (!alpha_using_srm) {
		printk(KERN_INFO "%s: This Alpha system doesn't "
				"know about SRM (or you've booted "
				"SRM->MILO->Linux, which gets "
				"misdetected)...\n", __func__);
		return -ENODEV;
	}

	/*
	 * Init numbers
	 */
	for (var_num = 0; var_num <= 255; var_num++)
		sprintf(number[var_num], "%ld", var_num);

	/*
	 * Create base directory
	 */
	base_dir = proc_mkdir(BASE_DIR, NULL);
	if (!base_dir) {
		printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
				BASE_DIR);
		goto cleanup;
	}

	/*
	 * Create per-name subdirectory
	 */
	named_dir = proc_mkdir(NAMED_DIR, base_dir);
	if (!named_dir) {
		printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
				BASE_DIR, NAMED_DIR);
		goto cleanup;
	}

	/*
	 * Create per-number subdirectory
	 */
	numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
	if (!numbered_dir) {
		printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
				BASE_DIR, NUMBERED_DIR);
		goto cleanup;

	}

	/*
	 * Create all named nodes
	 */
	entry = srm_named_entries;
	while (entry->name && entry->id) {
		entry->proc_entry = proc_create_data(entry->name, 0644, named_dir,
						     &srm_env_proc_fops, entry);
		if (!entry->proc_entry)
			goto cleanup;
		entry++;
	}

	/*
	 * Create all numbered nodes
	 */
	for (var_num = 0; var_num <= 255; var_num++) {
		entry = &srm_numbered_entries[var_num];
		entry->name = number[var_num];

		entry->proc_entry = proc_create_data(entry->name, 0644, numbered_dir,
						     &srm_env_proc_fops, entry);
		if (!entry->proc_entry)
			goto cleanup;

		entry->id			= var_num;
	}

	printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
			VERSION);

	return 0;

cleanup:
	srm_env_cleanup();

	return -ENOMEM;
}

static void __exit
srm_env_exit(void)
{
	srm_env_cleanup();
	printk(KERN_INFO "%s: unloaded successfully\n", NAME);

	return;
}

module_init(srm_env_init);
module_exit(srm_env_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* srm_env.c - Access to SRM environment
	3	* variables through linux' procfs
	4	*
16b7f4dc	5	* (C) 2001,2002,2006 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
1da177e4 LT	6	*
	7	* This driver is at all a modified version of Erik Mouw's
	8	* Documentation/DocBook/procfs_example.c, so: thank
	9	* you, Erik! He can be reached via email at
	10	* <J.A.K.Mouw@its.tudelft.nl>. It is based on an idea
	11	* provided by DEC^WCompaq^WIntel's "Jumpstart" CD. They
	12	* included a patch like this as well. Thanks for idea!
	13	*
	14	* This program is free software; you can redistribute
	15	* it and/or modify it under the terms of the GNU General
	16	* Public License version 2 as published by the Free Software
	17	* Foundation.
	18	*
	19	* This program is distributed in the hope that it will be
	20	* useful, but WITHOUT ANY WARRANTY; without even the implied
	21	* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
	22	* PURPOSE. See the GNU General Public License for more
	23	* details.
16b7f4dc	24	*
1da177e4 LT	25	* You should have received a copy of the GNU General Public
	26	* License along with this program; if not, write to the
	27	* Free Software Foundation, Inc., 59 Temple Place,
	28	* Suite 330, Boston, MA 02111-1307 USA
	29	*
	30	*/
	31
1da177e4	32	#include <linux/kernel.h>
5a0e3ad6	33	#include <linux/gfp.h>
1da177e4 LT	34	#include <linux/module.h>
	35	#include <linux/init.h>
	36	#include <linux/proc_fs.h>
0ead0f84	37	#include <linux/seq_file.h>
1da177e4 LT	38	#include <asm/console.h>
	39	#include <asm/uaccess.h>
	40	#include <asm/machvec.h>
	41
	42	#define BASE_DIR "srm_environment" /* Subdir in /proc/ */
	43	#define NAMED_DIR "named_variables" /* Subdir for known variables */
	44	#define NUMBERED_DIR "numbered_variables" /* Subdir for all variables */
16b7f4dc	45	#define VERSION "0.0.6" /* Module version */
1da177e4 LT	46	#define NAME "srm_env" /* Module name */
	47
	48	MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
	49	MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
	50	MODULE_LICENSE("GPL");
	51
	52	typedef struct _srm_env {
	53	char *name;
	54	unsigned long id;
	55	struct proc_dir_entry *proc_entry;
	56	} srm_env_t;
	57
	58	static struct proc_dir_entry *base_dir;
	59	static struct proc_dir_entry *named_dir;
	60	static struct proc_dir_entry *numbered_dir;
	61	static char number[256][4];
	62
	63	static srm_env_t srm_named_entries[] = {
	64	{ "auto_action", ENV_AUTO_ACTION },
	65	{ "boot_dev", ENV_BOOT_DEV },
	66	{ "bootdef_dev", ENV_BOOTDEF_DEV },
	67	{ "booted_dev", ENV_BOOTED_DEV },
	68	{ "boot_file", ENV_BOOT_FILE },
	69	{ "booted_file", ENV_BOOTED_FILE },
	70	{ "boot_osflags", ENV_BOOT_OSFLAGS },
	71	{ "booted_osflags", ENV_BOOTED_OSFLAGS },
	72	{ "boot_reset", ENV_BOOT_RESET },
	73	{ "dump_dev", ENV_DUMP_DEV },
	74	{ "enable_audit", ENV_ENABLE_AUDIT },
	75	{ "license", ENV_LICENSE },
	76	{ "char_set", ENV_CHAR_SET },
	77	{ "language", ENV_LANGUAGE },
	78	{ "tty_dev", ENV_TTY_DEV },
	79	{ NULL, 0 },
	80	};
	81	static srm_env_t srm_numbered_entries[256];
	82
	83
0ead0f84	84	static int srm_env_proc_show(struct seq_file m, void v)
1da177e4	85	{
1da177e4 LT	86	unsigned long ret;
1da177e4 LT	87	srm_env_t *entry;
0ead0f84	88	char *page;
1da177e4	89
af96f8a3	90	entry = m->private;
0ead0f84 AD	91	page = (char *)__get_free_page(GFP_USER);
	92	if (!page)
	93	return -ENOMEM;
1da177e4	94
0ead0f84	95	ret = callback_getenv(entry->id, page, PAGE_SIZE);
1da177e4	96
16b7f4dc	97	if ((ret >> 61) == 0) {
0ead0f84 AD	98	seq_write(m, page, ret);
0ead0f84 AD	99	ret = 0;
16b7f4dc	100	} else
0ead0f84 AD	101	ret = -EFAULT;
	102	free_page((unsigned long)page);
	103	return ret;
	104	}
1da177e4	105
0ead0f84 AD	106	static int srm_env_proc_open(struct inode inode, struct file file)
	107	{
	108	return single_open(file, srm_env_proc_show, PDE(inode)->data);
1da177e4 LT	109	}
1da177e4 LT	110
0ead0f84 AD	111	static ssize_t srm_env_proc_write(struct file file, const char __user buffer,
0ead0f84 AD	112	size_t count, loff_t *pos)
1da177e4 LT	113	{
1da177e4 LT	114	int res;
0ead0f84	115	srm_env_t *entry = PDE(file->f_path.dentry->d_inode)->data;
1da177e4 LT	116	char buf = (char ) __get_free_page(GFP_USER);
	117	unsigned long ret1, ret2;
	118
1da177e4 LT	119	if (!buf)
	120	return -ENOMEM;
	121
	122	res = -EINVAL;
	123	if (count >= PAGE_SIZE)
	124	goto out;
	125
	126	res = -EFAULT;
	127	if (copy_from_user(buf, buffer, count))
	128	goto out;
	129	buf[count] = '\0';
	130
	131	ret1 = callback_setenv(entry->id, buf, count);
	132	if ((ret1 >> 61) == 0) {
16b7f4dc	133	do
1da177e4 LT	134	ret2 = callback_save_env();
	135	while((ret2 >> 61) == 1);
	136	res = (int) ret1;
	137	}
	138
	139	out:
	140	free_page((unsigned long)buf);
	141	return res;
	142	}
	143
0ead0f84 AD	144	static const struct file_operations srm_env_proc_fops = {
	145	.owner = THIS_MODULE,
	146	.open = srm_env_proc_open,
	147	.read = seq_read,
	148	.llseek = seq_lseek,
	149	.release = single_release,
	150	.write = srm_env_proc_write,
	151	};
	152
1da177e4 LT	153	static void
	154	srm_env_cleanup(void)
	155	{
	156	srm_env_t *entry;
	157	unsigned long var_num;
	158
16b7f4dc	159	if (base_dir) {
1da177e4 LT	160	/*
	161	* Remove named entries
	162	*/
16b7f4dc	163	if (named_dir) {
1da177e4	164	entry = srm_named_entries;
16b7f4dc JBG	165	while (entry->name != NULL && entry->id != 0) {
16b7f4dc JBG	166	if (entry->proc_entry) {
1da177e4 LT	167	remove_proc_entry(entry->name,
	168	named_dir);
	169	entry->proc_entry = NULL;
	170	}
	171	entry++;
	172	}
	173	remove_proc_entry(NAMED_DIR, base_dir);
	174	}
	175
	176	/*
	177	* Remove numbered entries
	178	*/
16b7f4dc JBG	179	if (numbered_dir) {
16b7f4dc JBG	180	for (var_num = 0; var_num <= 255; var_num++) {
1da177e4 LT	181	entry = &srm_numbered_entries[var_num];
1da177e4 LT	182
16b7f4dc	183	if (entry->proc_entry) {
1da177e4 LT	184	remove_proc_entry(entry->name,
	185	numbered_dir);
	186	entry->proc_entry = NULL;
	187	entry->name = NULL;
	188	}
	189	}
	190	remove_proc_entry(NUMBERED_DIR, base_dir);
	191	}
	192
	193	remove_proc_entry(BASE_DIR, NULL);
	194	}
	195
	196	return;
	197	}
	198
1da177e4 LT	199	static int __init
	200	srm_env_init(void)
	201	{
	202	srm_env_t *entry;
	203	unsigned long var_num;
	204
	205	/*
	206	* Check system
	207	*/
16b7f4dc	208	if (!alpha_using_srm) {
1da177e4 LT	209	printk(KERN_INFO "%s: This Alpha system doesn't "
	210	"know about SRM (or you've booted "
	211	"SRM->MILO->Linux, which gets "
bbb8d343	212	"misdetected)...\n", __func__);
1da177e4 LT	213	return -ENODEV;
	214	}
	215
	216	/*
	217	* Init numbers
	218	*/
16b7f4dc	219	for (var_num = 0; var_num <= 255; var_num++)
1da177e4 LT	220	sprintf(number[var_num], "%ld", var_num);
	221
	222	/*
	223	* Create base directory
	224	*/
	225	base_dir = proc_mkdir(BASE_DIR, NULL);
16b7f4dc	226	if (!base_dir) {
1da177e4 LT	227	printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
	228	BASE_DIR);
	229	goto cleanup;
	230	}
1da177e4 LT	231
	232	/*
	233	* Create per-name subdirectory
	234	*/
	235	named_dir = proc_mkdir(NAMED_DIR, base_dir);
16b7f4dc	236	if (!named_dir) {
1da177e4 LT	237	printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
	238	BASE_DIR, NAMED_DIR);
	239	goto cleanup;
	240	}
1da177e4 LT	241
	242	/*
	243	* Create per-number subdirectory
	244	*/
	245	numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
16b7f4dc	246	if (!numbered_dir) {
1da177e4 LT	247	printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
	248	BASE_DIR, NUMBERED_DIR);
	249	goto cleanup;
	250
	251	}
1da177e4 LT	252
	253	/*
	254	* Create all named nodes
	255	*/
	256	entry = srm_named_entries;
16b7f4dc	257	while (entry->name && entry->id) {
0ead0f84 AD	258	entry->proc_entry = proc_create_data(entry->name, 0644, named_dir,
0ead0f84 AD	259	&srm_env_proc_fops, entry);
16b7f4dc	260	if (!entry->proc_entry)
1da177e4	261	goto cleanup;
1da177e4 LT	262	entry++;
	263	}
	264
	265	/*
	266	* Create all numbered nodes
	267	*/
16b7f4dc	268	for (var_num = 0; var_num <= 255; var_num++) {
1da177e4 LT	269	entry = &srm_numbered_entries[var_num];
	270	entry->name = number[var_num];
	271
0ead0f84 AD	272	entry->proc_entry = proc_create_data(entry->name, 0644, numbered_dir,
0ead0f84 AD	273	&srm_env_proc_fops, entry);
16b7f4dc	274	if (!entry->proc_entry)
1da177e4 LT	275	goto cleanup;
	276
	277	entry->id = var_num;
1da177e4 LT	278	}
	279
	280	printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
	281	VERSION);
	282
	283	return 0;
	284
	285	cleanup:
	286	srm_env_cleanup();
	287
	288	return -ENOMEM;
	289	}
	290
1da177e4 LT	291	static void __exit
	292	srm_env_exit(void)
	293	{
	294	srm_env_cleanup();
	295	printk(KERN_INFO "%s: unloaded successfully\n", NAME);
	296
	297	return;
	298	}
	299
1da177e4 LT	300	module_init(srm_env_init);
1da177e4 LT	301	module_exit(srm_env_exit);