[deliverable/linux.git] / arch / ia64 / sn / kernel / sn2 / prominfo_proc.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 1999,2001-2004, 2006 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * Module to export the system's Firmware Interface Tables, including
 * PROM revision numbers and banners, in /proc
 */
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/nodemask.h>
#include <asm/io.h>
#include <asm/sn/sn_sal.h>
#include <asm/sn/sn_cpuid.h>
#include <asm/sn/addrs.h>

MODULE_DESCRIPTION("PROM version reporting for /proc");
MODULE_AUTHOR("Chad Talbott");
MODULE_LICENSE("GPL");

/* Standard Intel FIT entry types */
#define FIT_ENTRY_FIT_HEADER	0x00	/* FIT header entry */
#define FIT_ENTRY_PAL_B		0x01	/* PAL_B entry */
/* Entries 0x02 through 0x0D reserved by Intel */
#define FIT_ENTRY_PAL_A_PROC	0x0E	/* Processor-specific PAL_A entry */
#define FIT_ENTRY_PAL_A		0x0F	/* PAL_A entry, same as... */
#define FIT_ENTRY_PAL_A_GEN	0x0F	/* ...Generic PAL_A entry */
#define FIT_ENTRY_UNUSED	0x7F	/* Unused (reserved by Intel?) */
/* OEM-defined entries range from 0x10 to 0x7E. */
#define FIT_ENTRY_SAL_A		0x10	/* SAL_A entry */
#define FIT_ENTRY_SAL_B		0x11	/* SAL_B entry */
#define FIT_ENTRY_SALRUNTIME	0x12	/* SAL runtime entry */
#define FIT_ENTRY_EFI		0x1F	/* EFI entry */
#define FIT_ENTRY_FPSWA		0x20	/* embedded fpswa entry */
#define FIT_ENTRY_VMLINUX	0x21	/* embedded vmlinux entry */

#define FIT_MAJOR_SHIFT	(32 + 8)
#define FIT_MAJOR_MASK	((1 << 8) - 1)
#define FIT_MINOR_SHIFT	32
#define FIT_MINOR_MASK	((1 << 8) - 1)

#define FIT_MAJOR(q)	\
	((unsigned) ((q) >> FIT_MAJOR_SHIFT) & FIT_MAJOR_MASK)
#define FIT_MINOR(q)	\
	((unsigned) ((q) >> FIT_MINOR_SHIFT) & FIT_MINOR_MASK)

#define FIT_TYPE_SHIFT	(32 + 16)
#define FIT_TYPE_MASK	((1 << 7) - 1)

#define FIT_TYPE(q)	\
	((unsigned) ((q) >> FIT_TYPE_SHIFT) & FIT_TYPE_MASK)

struct fit_type_map_t {
	unsigned char type;
	const char *name;
};

static const struct fit_type_map_t fit_entry_types[] = {
	{FIT_ENTRY_FIT_HEADER, "FIT Header"},
	{FIT_ENTRY_PAL_A_GEN, "Generic PAL_A"},
	{FIT_ENTRY_PAL_A_PROC, "Processor-specific PAL_A"},
	{FIT_ENTRY_PAL_A, "PAL_A"},
	{FIT_ENTRY_PAL_B, "PAL_B"},
	{FIT_ENTRY_SAL_A, "SAL_A"},
	{FIT_ENTRY_SAL_B, "SAL_B"},
	{FIT_ENTRY_SALRUNTIME, "SAL runtime"},
	{FIT_ENTRY_EFI, "EFI"},
	{FIT_ENTRY_VMLINUX, "Embedded Linux"},
	{FIT_ENTRY_FPSWA, "Embedded FPSWA"},
	{FIT_ENTRY_UNUSED, "Unused"},
	{0xff, "Error"},
};

static const char *fit_type_name(unsigned char type)
{
	struct fit_type_map_t const *mapp;

	for (mapp = fit_entry_types; mapp->type != 0xff; mapp++)
		if (type == mapp->type)
			return mapp->name;

	if ((type > FIT_ENTRY_PAL_A) && (type < FIT_ENTRY_UNUSED))
		return "OEM type";
	if ((type > FIT_ENTRY_PAL_B) && (type < FIT_ENTRY_PAL_A))
		return "Reserved";

	return "Unknown type";
}

static int
get_fit_entry(unsigned long nasid, int index, unsigned long *fentry,
	      char *banner, int banlen)
{
	return ia64_sn_get_fit_compt(nasid, index, fentry, banner, banlen);
}


/*
 * These two routines display the FIT table for each node.
 */
static void dump_fit_entry(struct seq_file *m, unsigned long *fentry)
{
	unsigned type;

	type = FIT_TYPE(fentry[1]);
	seq_printf(m, "%02x %-25s %x.%02x %016lx %u\n",
		   type,
		   fit_type_name(type),
		   FIT_MAJOR(fentry[1]), FIT_MINOR(fentry[1]),
		   fentry[0],
		   /* mult by sixteen to get size in bytes */
		   (unsigned)(fentry[1] & 0xffffff) * 16);
}


/*
 * We assume that the fit table will be small enough that we can print
 * the whole thing into one page.  (This is true for our default 16kB
 * pages -- each entry is about 60 chars wide when printed.)  I read
 * somewhere that the maximum size of the FIT is 128 entries, so we're
 * OK except for 4kB pages (and no one is going to do that on SN
 * anyway).
 */
static int proc_fit_show(struct seq_file *m, void *v)
{
	unsigned long nasid = (unsigned long)m->private;
	unsigned long fentry[2];
	int index;

	for (index=0;;index++) {
		BUG_ON(index * 60 > PAGE_SIZE);
		if (get_fit_entry(nasid, index, fentry, NULL, 0))
			break;
		dump_fit_entry(m, fentry);
	}
	return 0;
}

static int proc_fit_open(struct inode *inode, struct file *file)
{
	return single_open(file, proc_fit_show, PDE_DATA(inode));
}

static const struct file_operations proc_fit_fops = {
	.open		= proc_fit_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int proc_version_show(struct seq_file *m, void *v)
{
	unsigned long nasid = (unsigned long)m->private;
	unsigned long fentry[2];
	char banner[128];
	int index;

	for (index = 0; ; index++) {
		if (get_fit_entry(nasid, index, fentry, banner,
				  sizeof(banner)))
			return 0;
		if (FIT_TYPE(fentry[1]) == FIT_ENTRY_SAL_A)
			break;
	}

	seq_printf(m, "%x.%02x\n", FIT_MAJOR(fentry[1]), FIT_MINOR(fentry[1]));

	if (banner[0])
		seq_printf(m, "%s\n", banner);
	return 0;
}

static int proc_version_open(struct inode *inode, struct file *file)
{
	return single_open(file, proc_version_show, PDE_DATA(inode));
}

static const struct file_operations proc_version_fops = {
	.open		= proc_version_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

/* module entry points */
int __init prominfo_init(void);
void __exit prominfo_exit(void);

module_init(prominfo_init);
module_exit(prominfo_exit);

#define NODE_NAME_LEN 11

int __init prominfo_init(void)
{
	struct proc_dir_entry *sgi_prominfo_entry;
	cnodeid_t cnodeid;

	if (!ia64_platform_is("sn2"))
		return 0;

	sgi_prominfo_entry = proc_mkdir("sgi_prominfo", NULL);
	if (!sgi_prominfo_entry)
		return -ENOMEM;

	for_each_online_node(cnodeid) {
		struct proc_dir_entry *dir;
		unsigned long nasid;
		char name[NODE_NAME_LEN];

		sprintf(name, "node%d", cnodeid);
		dir = proc_mkdir(name, sgi_prominfo_entry);
		if (!dir)
			continue;
		nasid = cnodeid_to_nasid(cnodeid);
		proc_create_data("fit", 0, dir,
				 &proc_fit_fops, (void *)nasid);
		proc_create_data("version", 0, dir,
				 &proc_version_fops, (void *)nasid);
	}
	return 0;
}

void __exit prominfo_exit(void)
{
	remove_proc_subtree("sgi_prominfo", NULL);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
8ed9b2c7	6	* Copyright (C) 1999,2001-2004, 2006 Silicon Graphics, Inc. All Rights Reserved.
1da177e4 LT	7	*
	8	* Module to export the system's Firmware Interface Tables, including
	9	* PROM revision numbers and banners, in /proc
	10	*/
1da177e4 LT	11	#include <linux/module.h>
	12	#include <linux/slab.h>
	13	#include <linux/proc_fs.h>
e781c3d7	14	#include <linux/seq_file.h>
1da177e4	15	#include <linux/nodemask.h>
1da177e4 LT	16	#include <asm/io.h>
	17	#include <asm/sn/sn_sal.h>
	18	#include <asm/sn/sn_cpuid.h>
	19	#include <asm/sn/addrs.h>
	20
	21	MODULE_DESCRIPTION("PROM version reporting for /proc");
	22	MODULE_AUTHOR("Chad Talbott");
	23	MODULE_LICENSE("GPL");
	24
	25	/* Standard Intel FIT entry types */
	26	#define FIT_ENTRY_FIT_HEADER 0x00 /* FIT header entry */
	27	#define FIT_ENTRY_PAL_B 0x01 /* PAL_B entry */
	28	/* Entries 0x02 through 0x0D reserved by Intel */
	29	#define FIT_ENTRY_PAL_A_PROC 0x0E /* Processor-specific PAL_A entry */
	30	#define FIT_ENTRY_PAL_A 0x0F /* PAL_A entry, same as... */
	31	#define FIT_ENTRY_PAL_A_GEN 0x0F /* ...Generic PAL_A entry */
	32	#define FIT_ENTRY_UNUSED 0x7F /* Unused (reserved by Intel?) */
	33	/* OEM-defined entries range from 0x10 to 0x7E. */
	34	#define FIT_ENTRY_SAL_A 0x10 /* SAL_A entry */
	35	#define FIT_ENTRY_SAL_B 0x11 /* SAL_B entry */
	36	#define FIT_ENTRY_SALRUNTIME 0x12 /* SAL runtime entry */
	37	#define FIT_ENTRY_EFI 0x1F /* EFI entry */
	38	#define FIT_ENTRY_FPSWA 0x20 /* embedded fpswa entry */
	39	#define FIT_ENTRY_VMLINUX 0x21 /* embedded vmlinux entry */
	40
	41	#define FIT_MAJOR_SHIFT (32 + 8)
	42	#define FIT_MAJOR_MASK ((1 << 8) - 1)
	43	#define FIT_MINOR_SHIFT 32
	44	#define FIT_MINOR_MASK ((1 << 8) - 1)
	45
	46	#define FIT_MAJOR(q) \
	47	((unsigned) ((q) >> FIT_MAJOR_SHIFT) & FIT_MAJOR_MASK)
	48	#define FIT_MINOR(q) \
	49	((unsigned) ((q) >> FIT_MINOR_SHIFT) & FIT_MINOR_MASK)
	50
	51	#define FIT_TYPE_SHIFT (32 + 16)
	52	#define FIT_TYPE_MASK ((1 << 7) - 1)
	53
	54	#define FIT_TYPE(q) \
	55	((unsigned) ((q) >> FIT_TYPE_SHIFT) & FIT_TYPE_MASK)
	56
	57	struct fit_type_map_t {
	58	unsigned char type;
	59	const char *name;
	60	};
	61
	62	static const struct fit_type_map_t fit_entry_types[] = {
	63	{FIT_ENTRY_FIT_HEADER, "FIT Header"},
	64	{FIT_ENTRY_PAL_A_GEN, "Generic PAL_A"},
	65	{FIT_ENTRY_PAL_A_PROC, "Processor-specific PAL_A"},
	66	{FIT_ENTRY_PAL_A, "PAL_A"},
	67	{FIT_ENTRY_PAL_B, "PAL_B"},
	68	{FIT_ENTRY_SAL_A, "SAL_A"},
	69	{FIT_ENTRY_SAL_B, "SAL_B"},
	70	{FIT_ENTRY_SALRUNTIME, "SAL runtime"},
	71	{FIT_ENTRY_EFI, "EFI"},
	72	{FIT_ENTRY_VMLINUX, "Embedded Linux"},
	73	{FIT_ENTRY_FPSWA, "Embedded FPSWA"},
	74	{FIT_ENTRY_UNUSED, "Unused"},
	75	{0xff, "Error"},
	76	};
	77
	78	static const char *fit_type_name(unsigned char type)
	79	{
80	struct fit_type_map_t const *mapp;
81
82	for (mapp = fit_entry_types; mapp->type != 0xff; mapp++)
83	if (type == mapp->type)
84	return mapp->name;
85
86	if ((type > FIT_ENTRY_PAL_A) && (type < FIT_ENTRY_UNUSED))
87	return "OEM type";
88	if ((type > FIT_ENTRY_PAL_B) && (type < FIT_ENTRY_PAL_A))
89	return "Reserved";
90
91	return "Unknown type";
92	}
93
94	static int
95	get_fit_entry(unsigned long nasid, int index, unsigned long *fentry,
96	char *banner, int banlen)
97	{
98	return ia64_sn_get_fit_compt(nasid, index, fentry, banner, banlen);
99	}
100
101
102	/*
103	* These two routines display the FIT table for each node.
104	*/
e781c3d7	105	static void dump_fit_entry(struct seq_file m, unsigned long fentry)
1da177e4 LT	106	{
	107	unsigned type;
	108
	109	type = FIT_TYPE(fentry[1]);
e781c3d7 DH	110	seq_printf(m, "%02x %-25s %x.%02x %016lx %u\n",
	111	type,
	112	fit_type_name(type),
	113	FIT_MAJOR(fentry[1]), FIT_MINOR(fentry[1]),
	114	fentry[0],
	115	/* mult by sixteen to get size in bytes */
	116	(unsigned)(fentry[1] & 0xffffff) * 16);
1da177e4 LT	117	}
	118
	119
	120	/*
	121	* We assume that the fit table will be small enough that we can print
	122	* the whole thing into one page. (This is true for our default 16kB
	123	* pages -- each entry is about 60 chars wide when printed.) I read
	124	* somewhere that the maximum size of the FIT is 128 entries, so we're
	125	* OK except for 4kB pages (and no one is going to do that on SN
	126	* anyway).
	127	*/
e781c3d7	128	static int proc_fit_show(struct seq_file m, void v)
1da177e4	129	{
e781c3d7	130	unsigned long nasid = (unsigned long)m->private;
1da177e4 LT	131	unsigned long fentry[2];
1da177e4 LT	132	int index;
1da177e4	133
1da177e4 LT	134	for (index=0;;index++) {
	135	BUG_ON(index * 60 > PAGE_SIZE);
	136	if (get_fit_entry(nasid, index, fentry, NULL, 0))
	137	break;
e781c3d7	138	dump_fit_entry(m, fentry);
1da177e4	139	}
e781c3d7 DH	140	return 0;
e781c3d7 DH	141	}
1da177e4	142
e781c3d7 DH	143	static int proc_fit_open(struct inode inode, struct file file)
	144	{
	145	return single_open(file, proc_fit_show, PDE_DATA(inode));
1da177e4 LT	146	}
1da177e4 LT	147
e781c3d7 DH	148	static const struct file_operations proc_fit_fops = {
	149	.open = proc_fit_open,
	150	.read = seq_read,
	151	.llseek = seq_lseek,
75401461	152	.release = single_release,
e781c3d7 DH	153	};
	154
	155	static int proc_version_show(struct seq_file m, void v)
1da177e4	156	{
e781c3d7	157	unsigned long nasid = (unsigned long)m->private;
1da177e4 LT	158	unsigned long fentry[2];
	159	char banner[128];
	160	int index;
1da177e4 LT	161
	162	for (index = 0; ; index++) {
	163	if (get_fit_entry(nasid, index, fentry, banner,
	164	sizeof(banner)))
	165	return 0;
	166	if (FIT_TYPE(fentry[1]) == FIT_ENTRY_SAL_A)
	167	break;
	168	}
	169
e781c3d7	170	seq_printf(m, "%x.%02x\n", FIT_MAJOR(fentry[1]), FIT_MINOR(fentry[1]));
1da177e4 LT	171
1da177e4 LT	172	if (banner[0])
e781c3d7 DH	173	seq_printf(m, "%s\n", banner);
e781c3d7 DH	174	return 0;
1da177e4 LT	175	}
1da177e4 LT	176
e781c3d7	177	static int proc_version_open(struct inode inode, struct file file)
1da177e4	178	{
e781c3d7	179	return single_open(file, proc_version_show, PDE_DATA(inode));
1da177e4 LT	180	}
1da177e4 LT	181
e781c3d7 DH	182	static const struct file_operations proc_version_fops = {
	183	.open = proc_version_open,
	184	.read = seq_read,
	185	.llseek = seq_lseek,
75401461	186	.release = single_release,
e781c3d7	187	};
1da177e4 LT	188
	189	/* module entry points */
	190	int __init prominfo_init(void);
	191	void __exit prominfo_exit(void);
	192
	193	module_init(prominfo_init);
	194	module_exit(prominfo_exit);
	195
1da177e4 LT	196	#define NODE_NAME_LEN 11
	197
	198	int __init prominfo_init(void)
	199	{
e781c3d7	200	struct proc_dir_entry *sgi_prominfo_entry;
1da177e4	201	cnodeid_t cnodeid;
1da177e4 LT	202
	203	if (!ia64_platform_is("sn2"))
	204	return 0;
	205
1da177e4	206	sgi_prominfo_entry = proc_mkdir("sgi_prominfo", NULL);
6ea1511e AV	207	if (!sgi_prominfo_entry)
6ea1511e AV	208	return -ENOMEM;
1da177e4	209
1da177e4	210	for_each_online_node(cnodeid) {
6ea1511e AV	211	struct proc_dir_entry *dir;
	212	unsigned long nasid;
	213	char name[NODE_NAME_LEN];
	214
1da177e4	215	sprintf(name, "node%d", cnodeid);
6ea1511e AV	216	dir = proc_mkdir(name, sgi_prominfo_entry);
	217	if (!dir)
	218	continue;
1da177e4	219	nasid = cnodeid_to_nasid(cnodeid);
e781c3d7 DH	220	proc_create_data("fit", 0, dir,
	221	&proc_fit_fops, (void *)nasid);
	222	proc_create_data("version", 0, dir,
	223	&proc_version_fops, (void *)nasid);
1da177e4	224	}
1da177e4 LT	225	return 0;
	226	}
	227
	228	void __exit prominfo_exit(void)
	229	{
6ea1511e	230	remove_proc_subtree("sgi_prominfo", NULL);
1da177e4	231	}