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