arch/alpha/kernel/srm_env.c

   1 /*
   2  * srm_env.c - Access to SRM environment
   3  *             variables through linux' procfs
   4  *
   5  * Copyright (C) 2001-2002 Jan-Benedict Glaw <jbglaw@lug-owl.de>
   6  *
   7  * This driver is at all a modified version of Erik Mouw's
   8  * ./linux/Documentation/DocBook/procfs_example.c, so: thank
   9  * you, Erik! He can be reached via email at
  10  * <J.A.K.Mouw@its.tudelft.nl>. It is based on an idea
  11  * provided by DEC^WCompaq^WIntel's "Jumpstart" CD. They
  12  * included a patch like this as well. Thanks for idea!
  13  *
  14  * This program is free software; you can redistribute
  15  * it and/or modify it under the terms of the GNU General
  16  * Public License version 2 as published by the Free Software
  17  * Foundation.
  18  *
  19  * This program is distributed in the hope that it will be
  20  * useful, but WITHOUT ANY WARRANTY; without even the implied
  21  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  22  * PURPOSE.  See the GNU General Public License for more
  23  * details.
  24  *
  25  * You should have received a copy of the GNU General Public
  26  * License along with this program; if not, write to the
  27  * Free Software Foundation, Inc., 59 Temple Place,
  28  * Suite 330, Boston, MA  02111-1307  USA
  29  *
  30  */
  31
  32 /*
  33  * Changelog
  34  * ~~~~~~~~~
  35  *
  36  * Thu, 22 Aug 2002 15:10:43 +0200
  37  *      - Update Config.help entry. I got a number of emails asking
  38  *        me to tell their senders if they could make use of this
  39  *        piece of code... So: "SRM is something like BIOS for your
  40  *        Alpha"
  41  *      - Update code formatting a bit to better conform CodingStyle
  42  *        rules.
  43  *      - So this is v0.0.5, with no changes (except formatting)
  44  *
  45  * Wed, 22 May 2002 00:11:21 +0200
  46  *      - Fix typo on comment (SRC -> SRM)
  47  *      - Call this "Version 0.0.4"
  48  *
  49  * Tue,  9 Apr 2002 18:44:40 +0200
  50  *      - Implement access by variable name and additionally
  51  *        by number. This is done by creating two subdirectories
  52  *        where one holds all names (like the old directory
  53  *        did) and the other holding 256 files named like "0",
  54  *        "1" and so on.
  55  *      - Call this "Version 0.0.3"
  56  *
  57  */
  58
  59 #include <linux/kernel.h>
  60 #include <linux/config.h>
  61 #include <linux/module.h>
  62 #include <linux/init.h>
  63 #include <linux/proc_fs.h>
  64 #include <asm/console.h>
  65 #include <asm/uaccess.h>
  66 #include <asm/machvec.h>
  67
  68 #define BASE_DIR        "srm_environment"       /* Subdir in /proc/             */
  69 #define NAMED_DIR       "named_variables"       /* Subdir for known variables   */
  70 #define NUMBERED_DIR    "numbered_variables"    /* Subdir for all variables     */
  71 #define VERSION         "0.0.5"                 /* Module version               */
  72 #define NAME            "srm_env"               /* Module name                  */
  73
  74 MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
  75 MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
  76 MODULE_LICENSE("GPL");
  77
  78 typedef struct _srm_env {
  79         char                    *name;
  80         unsigned long           id;
  81         struct proc_dir_entry   *proc_entry;
  82 } srm_env_t;
  83
  84 static struct proc_dir_entry    *base_dir;
  85 static struct proc_dir_entry    *named_dir;
  86 static struct proc_dir_entry    *numbered_dir;
  87 static char                     number[256][4];
  88
  89 static srm_env_t        srm_named_entries[] = {
  90         { "auto_action",        ENV_AUTO_ACTION         },
  91         { "boot_dev",           ENV_BOOT_DEV            },
  92         { "bootdef_dev",        ENV_BOOTDEF_DEV         },
  93         { "booted_dev",         ENV_BOOTED_DEV          },
  94         { "boot_file",          ENV_BOOT_FILE           },
  95         { "booted_file",        ENV_BOOTED_FILE         },
  96         { "boot_osflags",       ENV_BOOT_OSFLAGS        },
  97         { "booted_osflags",     ENV_BOOTED_OSFLAGS      },
  98         { "boot_reset",         ENV_BOOT_RESET          },
  99         { "dump_dev",           ENV_DUMP_DEV            },
 100         { "enable_audit",       ENV_ENABLE_AUDIT        },
 101         { "license",            ENV_LICENSE             },
 102         { "char_set",           ENV_CHAR_SET            },
 103         { "language",           ENV_LANGUAGE            },
 104         { "tty_dev",            ENV_TTY_DEV             },
 105         { NULL,                 0                       },
 106 };
 107 static srm_env_t        srm_numbered_entries[256];
 108
 109
 110
 111 static int
 112 srm_env_read(char *page, char **start, off_t off, int count, int *eof,
 113                 void *data)
 114 {
 115         int             nbytes;
 116         unsigned long   ret;
 117         srm_env_t       *entry;
 118
 119         MOD_INC_USE_COUNT;
 120
 121         if(off != 0) {
 122                 MOD_DEC_USE_COUNT;
 123                 return -EFAULT;
 124         }
 125
 126         entry   = (srm_env_t *) data;
 127         ret     = callback_getenv(entry->id, page, count);
 128
 129         if((ret >> 61) == 0)
 130                 nbytes = (int) ret;
 131         else
 132                 nbytes = -EFAULT;
 133
 134         MOD_DEC_USE_COUNT;
 135
 136         return nbytes;
 137 }
 138
 139
 140 static int
 141 srm_env_write(struct file *file, const char *buffer, unsigned long count,
 142                 void *data)
 143 {
 144 #define BUFLEN  512
 145         int             nbytes;
 146         srm_env_t       *entry;
 147         char            buf[BUFLEN];
 148         unsigned long   ret1, ret2;
 149
 150         MOD_INC_USE_COUNT;
 151
 152         entry = (srm_env_t *) data;
 153
 154         nbytes = strlen(buffer) + 1;
 155         if(nbytes > BUFLEN) {
 156                 MOD_DEC_USE_COUNT;
 157                 return -ENOMEM;
 158         }
 159
 160         /* memcpy(aligned_buffer, buffer, nbytes) */
 161
 162         if(copy_from_user(buf, buffer, count)) {
 163                 MOD_DEC_USE_COUNT;
 164                 return -EFAULT;
 165         }
 166         buf[count] = 0x00;
 167
 168         ret1 = callback_setenv(entry->id, buf, count);
 169         if((ret1 >> 61) == 0) {
 170                 do
 171                         ret2 = callback_save_env();
 172                 while((ret2 >> 61) == 1);
 173                 nbytes = (int) ret1;
 174         } else
 175                 nbytes = -EFAULT;
 176
 177         MOD_DEC_USE_COUNT;
 178
 179         return nbytes;
 180 }
 181
 182
 183 static void
 184 srm_env_cleanup(void)
 185 {
 186         srm_env_t       *entry;
 187         unsigned long   var_num;
 188
 189         if(base_dir) {
 190                 /*
 191                  * Remove named entries
 192                  */
 193                 if(named_dir) {
 194                         entry = srm_named_entries;
 195                         while(entry->name != NULL && entry->id != 0) {
 196                                 if(entry->proc_entry) {
 197                                         remove_proc_entry(entry->name,
 198                                                         named_dir);
 199                                         entry->proc_entry = NULL;
 200                                 }
 201                                 entry++;
 202                         }
 203                         remove_proc_entry(NAMED_DIR, base_dir);
 204                 }
 205
 206                 /*
 207                  * Remove numbered entries
 208                  */
 209                 if(numbered_dir) {
 210                         for(var_num = 0; var_num <= 255; var_num++) {
 211                                 entry = &srm_numbered_entries[var_num];
 212
 213                                 if(entry->proc_entry) {
 214                                         remove_proc_entry(entry->name,
 215                                                         numbered_dir);
 216                                         entry->proc_entry       = NULL;
 217                                         entry->name             = NULL;
 218                                 }
 219                         }
 220                         remove_proc_entry(NUMBERED_DIR, base_dir);
 221                 }
 222
 223                 remove_proc_entry(BASE_DIR, NULL);
 224         }
 225
 226         return;
 227 }
 228
 229
 230 static int __init
 231 srm_env_init(void)
 232 {
 233         srm_env_t       *entry;
 234         unsigned long   var_num;
 235
 236         /*
 237          * Check system
 238          */
 239         if(!alpha_using_srm) {
 240                 printk(KERN_INFO "%s: This Alpha system doesn't "
 241                                 "know about SRM (or you've booted "
 242                                 "SRM->MILO->Linux, which gets "
 243                                 "misdetected)...\n", __FUNCTION__);
 244                 return -ENODEV;
 245         }
 246
 247         /*
 248          * Init numbers
 249          */
 250         for(var_num = 0; var_num <= 255; var_num++)
 251                 sprintf(number[var_num], "%ld", var_num);
 252
 253         /*
 254          * Create base directory
 255          */
 256         base_dir = proc_mkdir(BASE_DIR, NULL);
 257         if(base_dir == NULL) {
 258                 printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
 259                                 BASE_DIR);
 260                 goto cleanup;
 261         }
 262         base_dir->owner = THIS_MODULE;
 263
 264         /*
 265          * Create per-name subdirectory
 266          */
 267         named_dir = proc_mkdir(NAMED_DIR, base_dir);
 268         if(named_dir == NULL) {
 269                 printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
 270                                 BASE_DIR, NAMED_DIR);
 271                 goto cleanup;
 272         }
 273         named_dir->owner = THIS_MODULE;
 274
 275         /*
 276          * Create per-number subdirectory
 277          */
 278         numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
 279         if(numbered_dir == NULL) {
 280                 printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
 281                                 BASE_DIR, NUMBERED_DIR);
 282                 goto cleanup;
 283
 284         }
 285         numbered_dir->owner = THIS_MODULE;
 286
 287         /*
 288          * Create all named nodes
 289          */
 290         entry = srm_named_entries;
 291         while(entry->name != NULL && entry->id != 0) {
 292                 entry->proc_entry = create_proc_entry(entry->name,
 293                                 0644, named_dir);
 294                 if(entry->proc_entry == NULL)
 295                         goto cleanup;
 296
 297                 entry->proc_entry->data         = (void *) entry;
 298                 entry->proc_entry->owner        = THIS_MODULE;
 299                 entry->proc_entry->read_proc    = srm_env_read;
 300                 entry->proc_entry->write_proc   = srm_env_write;
 301
 302                 entry++;
 303         }
 304
 305         /*
 306          * Create all numbered nodes
 307          */
 308         for(var_num = 0; var_num <= 255; var_num++) {
 309                 entry = &srm_numbered_entries[var_num];
 310                 entry->name = number[var_num];
 311
 312                 entry->proc_entry = create_proc_entry(entry->name,
 313                                 0644, numbered_dir);
 314                 if(entry->proc_entry == NULL)
 315                         goto cleanup;
 316
 317                 entry->id                       = var_num;
 318                 entry->proc_entry->data         = (void *) entry;
 319                 entry->proc_entry->owner        = THIS_MODULE;
 320                 entry->proc_entry->read_proc    = srm_env_read;
 321                 entry->proc_entry->write_proc   = srm_env_write;
 322         }
 323
 324         printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
 325                         VERSION);
 326
 327         return 0;
 328
 329 cleanup:
 330         srm_env_cleanup();
 331
 332         return -ENOMEM;
 333 }
 334
 335
 336 static void __exit
 337 srm_env_exit(void)
 338 {
 339         srm_env_cleanup();
 340         printk(KERN_INFO "%s: unloaded successfully\n", NAME);
 341
 342         return;
 343 }
 344
 345
 346 module_init(srm_env_init);
 347 module_exit(srm_env_exit);
 348