[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/config.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/nodemask.h>
#include <asm/system.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 int dump_fit_entry(char *page, unsigned long *fentry)
{
	unsigned type;

	type = FIT_TYPE(fentry[1]);
	return sprintf(page, "%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
dump_fit(char *page, unsigned long nasid)
{
	unsigned long fentry[2];
	int index;
	char *p;

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

	return p - page;
}

static int
dump_version(char *page, unsigned long nasid)
{
	unsigned long fentry[2];
	char banner[128];
	int index;
	int len;

	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;
	}

	len = sprintf(page, "%x.%02x\n", FIT_MAJOR(fentry[1]),
		      FIT_MINOR(fentry[1]));
	page += len;

	if (banner[0])
		len += snprintf(page, PAGE_SIZE-len, "%s\n", banner);

	return len;
}

/* same as in proc_misc.c */
static int
proc_calc_metrics(char *page, char **start, off_t off, int count, int *eof,
		  int len)
{
	if (len <= off + count)
		*eof = 1;
	*start = page + off;
	len -= off;
	if (len > count)
		len = count;
	if (len < 0)
		len = 0;
	return len;
}

static int
read_version_entry(char *page, char **start, off_t off, int count, int *eof,
		   void *data)
{
	int len;

	/* data holds the NASID of the node */
	len = dump_version(page, (unsigned long)data);
	len = proc_calc_metrics(page, start, off, count, eof, len);
	return len;
}

static int
read_fit_entry(char *page, char **start, off_t off, int count, int *eof,
	       void *data)
{
	int len;

	/* data holds the NASID of the node */
	len = dump_fit(page, (unsigned long)data);
	len = proc_calc_metrics(page, start, off, count, eof, len);

	return len;
}

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

module_init(prominfo_init);
module_exit(prominfo_exit);

static struct proc_dir_entry **proc_entries;
static struct proc_dir_entry *sgi_prominfo_entry;

#define NODE_NAME_LEN 11

int __init prominfo_init(void)
{
	struct proc_dir_entry **entp;
	struct proc_dir_entry *p;
	cnodeid_t cnodeid;
	unsigned long nasid;
	int size;
	char name[NODE_NAME_LEN];

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

	size = num_online_nodes() * sizeof(struct proc_dir_entry *);
	proc_entries = kzalloc(size, GFP_KERNEL);
	if (!proc_entries)
		return -ENOMEM;

	sgi_prominfo_entry = proc_mkdir("sgi_prominfo", NULL);

	entp = proc_entries;
	for_each_online_node(cnodeid) {
		sprintf(name, "node%d", cnodeid);
		*entp = proc_mkdir(name, sgi_prominfo_entry);
		nasid = cnodeid_to_nasid(cnodeid);
		p = create_proc_read_entry("fit", 0, *entp, read_fit_entry,
					   (void *)nasid);
		if (p)
			p->owner = THIS_MODULE;
		p = create_proc_read_entry("version", 0, *entp,
					   read_version_entry, (void *)nasid);
		if (p)
			p->owner = THIS_MODULE;
		entp++;
	}

	return 0;
}

void __exit prominfo_exit(void)
{
	struct proc_dir_entry **entp;
	unsigned int cnodeid;
	char name[NODE_NAME_LEN];

	entp = proc_entries;
	for_each_online_node(cnodeid) {
		remove_proc_entry("fit", *entp);
		remove_proc_entry("version", *entp);
		sprintf(name, "node%d", cnodeid);
		remove_proc_entry(name, sgi_prominfo_entry);
		entp++;
	}
	remove_proc_entry("sgi_prominfo", NULL);
	kfree(proc_entries);
}
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	*/
	11	#include <linux/config.h>
	12	#include <linux/module.h>
	13	#include <linux/slab.h>
	14	#include <linux/proc_fs.h>
	15	#include <linux/nodemask.h>
	16	#include <asm/system.h>
	17	#include <asm/io.h>
	18	#include <asm/sn/sn_sal.h>
	19	#include <asm/sn/sn_cpuid.h>
	20	#include <asm/sn/addrs.h>
	21
	22	MODULE_DESCRIPTION("PROM version reporting for /proc");
	23	MODULE_AUTHOR("Chad Talbott");
	24	MODULE_LICENSE("GPL");
	25
	26	/* Standard Intel FIT entry types */
	27	#define FIT_ENTRY_FIT_HEADER 0x00 /* FIT header entry */
	28	#define FIT_ENTRY_PAL_B 0x01 /* PAL_B entry */
	29	/* Entries 0x02 through 0x0D reserved by Intel */
	30	#define FIT_ENTRY_PAL_A_PROC 0x0E /* Processor-specific PAL_A entry */
	31	#define FIT_ENTRY_PAL_A 0x0F /* PAL_A entry, same as... */
	32	#define FIT_ENTRY_PAL_A_GEN 0x0F /* ...Generic PAL_A entry */
	33	#define FIT_ENTRY_UNUSED 0x7F /* Unused (reserved by Intel?) */
	34	/* OEM-defined entries range from 0x10 to 0x7E. */
	35	#define FIT_ENTRY_SAL_A 0x10 /* SAL_A entry */
	36	#define FIT_ENTRY_SAL_B 0x11 /* SAL_B entry */
	37	#define FIT_ENTRY_SALRUNTIME 0x12 /* SAL runtime entry */
	38	#define FIT_ENTRY_EFI 0x1F /* EFI entry */
	39	#define FIT_ENTRY_FPSWA 0x20 /* embedded fpswa entry */
	40	#define FIT_ENTRY_VMLINUX 0x21 /* embedded vmlinux entry */
	41
	42	#define FIT_MAJOR_SHIFT (32 + 8)
	43	#define FIT_MAJOR_MASK ((1 << 8) - 1)
	44	#define FIT_MINOR_SHIFT 32
	45	#define FIT_MINOR_MASK ((1 << 8) - 1)
	46
	47	#define FIT_MAJOR(q) \
	48	((unsigned) ((q) >> FIT_MAJOR_SHIFT) & FIT_MAJOR_MASK)
	49	#define FIT_MINOR(q) \
	50	((unsigned) ((q) >> FIT_MINOR_SHIFT) & FIT_MINOR_MASK)
	51
	52	#define FIT_TYPE_SHIFT (32 + 16)
	53	#define FIT_TYPE_MASK ((1 << 7) - 1)
	54
	55	#define FIT_TYPE(q) \
	56	((unsigned) ((q) >> FIT_TYPE_SHIFT) & FIT_TYPE_MASK)
	57
	58	struct fit_type_map_t {
	59	unsigned char type;
	60	const char *name;
	61	};
	62
	63	static const struct fit_type_map_t fit_entry_types[] = {
	64	{FIT_ENTRY_FIT_HEADER, "FIT Header"},
	65	{FIT_ENTRY_PAL_A_GEN, "Generic PAL_A"},
	66	{FIT_ENTRY_PAL_A_PROC, "Processor-specific PAL_A"},
	67	{FIT_ENTRY_PAL_A, "PAL_A"},
	68	{FIT_ENTRY_PAL_B, "PAL_B"},
	69	{FIT_ENTRY_SAL_A, "SAL_A"},
	70	{FIT_ENTRY_SAL_B, "SAL_B"},
71	{FIT_ENTRY_SALRUNTIME, "SAL runtime"},
72	{FIT_ENTRY_EFI, "EFI"},
73	{FIT_ENTRY_VMLINUX, "Embedded Linux"},
74	{FIT_ENTRY_FPSWA, "Embedded FPSWA"},
75	{FIT_ENTRY_UNUSED, "Unused"},
76	{0xff, "Error"},
77	};
78
79	static const char *fit_type_name(unsigned char type)
80	{
81	struct fit_type_map_t const *mapp;
82
83	for (mapp = fit_entry_types; mapp->type != 0xff; mapp++)
84	if (type == mapp->type)
85	return mapp->name;
86
87	if ((type > FIT_ENTRY_PAL_A) && (type < FIT_ENTRY_UNUSED))
88	return "OEM type";
89	if ((type > FIT_ENTRY_PAL_B) && (type < FIT_ENTRY_PAL_A))
90	return "Reserved";
91
92	return "Unknown type";
93	}
94
95	static int
96	get_fit_entry(unsigned long nasid, int index, unsigned long *fentry,
97	char *banner, int banlen)
98	{
99	return ia64_sn_get_fit_compt(nasid, index, fentry, banner, banlen);
100	}
101
102
103	/*
104	* These two routines display the FIT table for each node.
105	*/
106	static int dump_fit_entry(char page, unsigned long fentry)
107	{
108	unsigned type;
109
110	type = FIT_TYPE(fentry[1]);
111	return sprintf(page, "%02x %-25s %x.%02x %016lx %u\n",
112	type,
113	fit_type_name(type),
114	FIT_MAJOR(fentry[1]), FIT_MINOR(fentry[1]),
115	fentry[0],
116	/* mult by sixteen to get size in bytes */
117	(unsigned)(fentry[1] & 0xffffff) * 16);
118	}
119
120
121	/*
122	* We assume that the fit table will be small enough that we can print
123	* the whole thing into one page. (This is true for our default 16kB
124	* pages -- each entry is about 60 chars wide when printed.) I read
125	* somewhere that the maximum size of the FIT is 128 entries, so we're
126	* OK except for 4kB pages (and no one is going to do that on SN
127	* anyway).
128	*/
129	static int
130	dump_fit(char *page, unsigned long nasid)
131	{
132	unsigned long fentry[2];
133	int index;
134	char *p;
135
136	p = page;
137	for (index=0;;index++) {
138	BUG_ON(index * 60 > PAGE_SIZE);
139	if (get_fit_entry(nasid, index, fentry, NULL, 0))
140	break;
141	p += dump_fit_entry(p, fentry);
142	}
143
144	return p - page;
145	}
146
147	static int
148	dump_version(char *page, unsigned long nasid)
149	{
150	unsigned long fentry[2];
151	char banner[128];
152	int index;
153	int len;
154
155	for (index = 0; ; index++) {
156	if (get_fit_entry(nasid, index, fentry, banner,
157	sizeof(banner)))
158	return 0;
159	if (FIT_TYPE(fentry[1]) == FIT_ENTRY_SAL_A)
160	break;
161	}
162
163	len = sprintf(page, "%x.%02x\n", FIT_MAJOR(fentry[1]),
164	FIT_MINOR(fentry[1]));
165	page += len;
166
167	if (banner[0])
168	len += snprintf(page, PAGE_SIZE-len, "%s\n", banner);
169
170	return len;
171	}
172
173	/* same as in proc_misc.c */
174	static int
175	proc_calc_metrics(char page, char start, off_t off, int count, int eof,
176	int len)
177	{
178	if (len <= off + count)
179	*eof = 1;
180	*start = page + off;
181	len -= off;
182	if (len > count)
183	len = count;
184	if (len < 0)
185	len = 0;
186	return len;
187	}
188
189	static int
190	read_version_entry(char page, char start, off_t off, int count, int eof,
191	void *data)
192	{
8ed9b2c7	193	int len;
1da177e4 LT	194
	195	/* data holds the NASID of the node */
	196	len = dump_version(page, (unsigned long)data);
	197	len = proc_calc_metrics(page, start, off, count, eof, len);
	198	return len;
	199	}
	200
	201	static int
	202	read_fit_entry(char page, char start, off_t off, int count, int eof,
	203	void *data)
	204	{
8ed9b2c7	205	int len;
1da177e4 LT	206
	207	/* data holds the NASID of the node */
	208	len = dump_fit(page, (unsigned long)data);
	209	len = proc_calc_metrics(page, start, off, count, eof, len);
	210
	211	return len;
	212	}
	213
	214	/* module entry points */
	215	int __init prominfo_init(void);
	216	void __exit prominfo_exit(void);
	217
	218	module_init(prominfo_init);
	219	module_exit(prominfo_exit);
	220
	221	static struct proc_dir_entry **proc_entries;
	222	static struct proc_dir_entry *sgi_prominfo_entry;
	223
	224	#define NODE_NAME_LEN 11
	225
	226	int __init prominfo_init(void)
	227	{
	228	struct proc_dir_entry **entp;
	229	struct proc_dir_entry *p;
	230	cnodeid_t cnodeid;
	231	unsigned long nasid;
8ed9b2c7	232	int size;
1da177e4 LT	233	char name[NODE_NAME_LEN];
	234
	235	if (!ia64_platform_is("sn2"))
	236	return 0;
	237
8ed9b2c7 JS	238	size = num_online_nodes() * sizeof(struct proc_dir_entry *);
	239	proc_entries = kzalloc(size, GFP_KERNEL);
	240	if (!proc_entries)
	241	return -ENOMEM;
1da177e4 LT	242
	243	sgi_prominfo_entry = proc_mkdir("sgi_prominfo", NULL);
	244
	245	entp = proc_entries;
	246	for_each_online_node(cnodeid) {
	247	sprintf(name, "node%d", cnodeid);
	248	*entp = proc_mkdir(name, sgi_prominfo_entry);
	249	nasid = cnodeid_to_nasid(cnodeid);
8ed9b2c7 JS	250	p = create_proc_read_entry("fit", 0, *entp, read_fit_entry,
8ed9b2c7 JS	251	(void *)nasid);
1da177e4 LT	252	if (p)
1da177e4 LT	253	p->owner = THIS_MODULE;
8ed9b2c7 JS	254	p = create_proc_read_entry("version", 0, *entp,
8ed9b2c7 JS	255	read_version_entry, (void *)nasid);
1da177e4 LT	256	if (p)
	257	p->owner = THIS_MODULE;
	258	entp++;
	259	}
	260
	261	return 0;
	262	}
	263
	264	void __exit prominfo_exit(void)
	265	{
	266	struct proc_dir_entry **entp;
8ed9b2c7	267	unsigned int cnodeid;
1da177e4 LT	268	char name[NODE_NAME_LEN];
	269
	270	entp = proc_entries;
	271	for_each_online_node(cnodeid) {
	272	remove_proc_entry("fit", *entp);
	273	remove_proc_entry("version", *entp);
	274	sprintf(name, "node%d", cnodeid);
	275	remove_proc_entry(name, sgi_prominfo_entry);
	276	entp++;
	277	}
	278	remove_proc_entry("sgi_prominfo", NULL);
	279	kfree(proc_entries);
	280	}