LXR linux/arch/ia64/sn/kernel/sn2/prominfo

   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
  21MODULE_DESCRIPTION("PROM version reporting for /proc");
  22MODULE_AUTHOR("Chad Talbott");
  23MODULE_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
  57struct fit_type_map_t {
  58        unsigned char type;
  59        const char *name;
  60};
  61
  62static 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
  78static 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
  94static int
  95get_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 */
 105static 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 */
 128static int
 129dump_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
 146static int
 147dump_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 */
 173static int
 174proc_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
 188static int
 189read_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
 200static int
 201read_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 */
 214int __init prominfo_init(void);
 215void __exit prominfo_exit(void);
 216
 217module_init(prominfo_init);
 218module_exit(prominfo_exit);
 219
 220static struct proc_dir_entry **proc_entries;
 221static struct proc_dir_entry *sgi_prominfo_entry;
 222
 223#define NODE_NAME_LEN 11
 224
 225int __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
 263void __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}
 280