x86: optimise x86's do_page_fault (C entry point for the page fault path)
[linux-2.6.git] / arch / ia64 / sn / kernel / sn2 / prominfo_proc.c
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/system.h>
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  */
105 static int dump_fit_entry(char *page, unsigned long *fentry)
106 {
107         unsigned type;
108
109         type = FIT_TYPE(fentry[1]);
110         return sprintf(page, "%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);
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  */
128 static int
129 dump_fit(char *page, unsigned long nasid)
130 {
131         unsigned long fentry[2];
132         int index;
133         char *p;
134
135         p = page;
136         for (index=0;;index++) {
137                 BUG_ON(index * 60 > PAGE_SIZE);
138                 if (get_fit_entry(nasid, index, fentry, NULL, 0))
139                         break;
140                 p += dump_fit_entry(p, fentry);
141         }
142
143         return p - page;
144 }
145
146 static int
147 dump_version(char *page, unsigned long nasid)
148 {
149         unsigned long fentry[2];
150         char banner[128];
151         int index;
152         int len;
153
154         for (index = 0; ; index++) {
155                 if (get_fit_entry(nasid, index, fentry, banner,
156                                   sizeof(banner)))
157                         return 0;
158                 if (FIT_TYPE(fentry[1]) == FIT_ENTRY_SAL_A)
159                         break;
160         }
161
162         len = sprintf(page, "%x.%02x\n", FIT_MAJOR(fentry[1]),
163                       FIT_MINOR(fentry[1]));
164         page += len;
165
166         if (banner[0])
167                 len += snprintf(page, PAGE_SIZE-len, "%s\n", banner);
168
169         return len;
170 }
171
172 /* same as in proc_misc.c */
173 static int
174 proc_calc_metrics(char *page, char **start, off_t off, int count, int *eof,
175                   int len)
176 {
177         if (len <= off + count)
178                 *eof = 1;
179         *start = page + off;
180         len -= off;
181         if (len > count)
182                 len = count;
183         if (len < 0)
184                 len = 0;
185         return len;
186 }
187
188 static int
189 read_version_entry(char *page, char **start, off_t off, int count, int *eof,
190                    void *data)
191 {
192         int len;
193
194         /* data holds the NASID of the node */
195         len = dump_version(page, (unsigned long)data);
196         len = proc_calc_metrics(page, start, off, count, eof, len);
197         return len;
198 }
199
200 static int
201 read_fit_entry(char *page, char **start, off_t off, int count, int *eof,
202                void *data)
203 {
204         int len;
205
206         /* data holds the NASID of the node */
207         len = dump_fit(page, (unsigned long)data);
208         len = proc_calc_metrics(page, start, off, count, eof, len);
209
210         return len;
211 }
212
213 /* module entry points */
214 int __init prominfo_init(void);
215 void __exit prominfo_exit(void);
216
217 module_init(prominfo_init);
218 module_exit(prominfo_exit);
219
220 static struct proc_dir_entry **proc_entries;
221 static struct proc_dir_entry *sgi_prominfo_entry;
222
223 #define NODE_NAME_LEN 11
224
225 int __init prominfo_init(void)
226 {
227         struct proc_dir_entry **entp;
228         struct proc_dir_entry *p;
229         cnodeid_t cnodeid;
230         unsigned long nasid;
231         int size;
232         char name[NODE_NAME_LEN];
233
234         if (!ia64_platform_is("sn2"))
235                 return 0;
236
237         size = num_online_nodes() * sizeof(struct proc_dir_entry *);
238         proc_entries = kzalloc(size, GFP_KERNEL);
239         if (!proc_entries)
240                 return -ENOMEM;
241
242         sgi_prominfo_entry = proc_mkdir("sgi_prominfo", NULL);
243
244         entp = proc_entries;
245         for_each_online_node(cnodeid) {
246                 sprintf(name, "node%d", cnodeid);
247                 *entp = proc_mkdir(name, sgi_prominfo_entry);
248                 nasid = cnodeid_to_nasid(cnodeid);
249                 p = create_proc_read_entry("fit", 0, *entp, read_fit_entry,
250                                            (void *)nasid);
251                 if (p)
252                         p->owner = THIS_MODULE;
253                 p = create_proc_read_entry("version", 0, *entp,
254                                            read_version_entry, (void *)nasid);
255                 if (p)
256                         p->owner = THIS_MODULE;
257                 entp++;
258         }
259
260         return 0;
261 }
262
263 void __exit prominfo_exit(void)
264 {
265         struct proc_dir_entry **entp;
266         unsigned int cnodeid;
267         char name[NODE_NAME_LEN];
268
269         entp = proc_entries;
270         for_each_online_node(cnodeid) {
271                 remove_proc_entry("fit", *entp);
272                 remove_proc_entry("version", *entp);
273                 sprintf(name, "node%d", cnodeid);
274                 remove_proc_entry(name, sgi_prominfo_entry);
275                 entp++;
276         }
277         remove_proc_entry("sgi_prominfo", NULL);
278         kfree(proc_entries);
279 }