Remove obsolete #include <linux/config.h>
[linux-2.6.git] / 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  * 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/module.h>
61 #include <linux/init.h>
62 #include <linux/proc_fs.h>
63 #include <asm/console.h>
64 #include <asm/uaccess.h>
65 #include <asm/machvec.h>
66
67 #define BASE_DIR        "srm_environment"       /* Subdir in /proc/             */
68 #define NAMED_DIR       "named_variables"       /* Subdir for known variables   */
69 #define NUMBERED_DIR    "numbered_variables"    /* Subdir for all variables     */
70 #define VERSION         "0.0.5"                 /* Module version               */
71 #define NAME            "srm_env"               /* Module name                  */
72
73 MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
74 MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
75 MODULE_LICENSE("GPL");
76
77 typedef struct _srm_env {
78         char                    *name;
79         unsigned long           id;
80         struct proc_dir_entry   *proc_entry;
81 } srm_env_t;
82
83 static struct proc_dir_entry    *base_dir;
84 static struct proc_dir_entry    *named_dir;
85 static struct proc_dir_entry    *numbered_dir;
86 static char                     number[256][4];
87
88 static srm_env_t        srm_named_entries[] = {
89         { "auto_action",        ENV_AUTO_ACTION         },
90         { "boot_dev",           ENV_BOOT_DEV            },
91         { "bootdef_dev",        ENV_BOOTDEF_DEV         },
92         { "booted_dev",         ENV_BOOTED_DEV          },
93         { "boot_file",          ENV_BOOT_FILE           },
94         { "booted_file",        ENV_BOOTED_FILE         },
95         { "boot_osflags",       ENV_BOOT_OSFLAGS        },
96         { "booted_osflags",     ENV_BOOTED_OSFLAGS      },
97         { "boot_reset",         ENV_BOOT_RESET          },
98         { "dump_dev",           ENV_DUMP_DEV            },
99         { "enable_audit",       ENV_ENABLE_AUDIT        },
100         { "license",            ENV_LICENSE             },
101         { "char_set",           ENV_CHAR_SET            },
102         { "language",           ENV_LANGUAGE            },
103         { "tty_dev",            ENV_TTY_DEV             },
104         { NULL,                 0                       },
105 };
106 static srm_env_t        srm_numbered_entries[256];
107
108
109
110 static int
111 srm_env_read(char *page, char **start, off_t off, int count, int *eof,
112                 void *data)
113 {
114         int             nbytes;
115         unsigned long   ret;
116         srm_env_t       *entry;
117
118         if(off != 0)
119                 return -EFAULT;
120
121         entry   = (srm_env_t *) data;
122         ret     = callback_getenv(entry->id, page, count);
123
124         if((ret >> 61) == 0)
125                 nbytes = (int) ret;
126         else
127                 nbytes = -EFAULT;
128
129         return nbytes;
130 }
131
132
133 static int
134 srm_env_write(struct file *file, const char __user *buffer, unsigned long count,
135                 void *data)
136 {
137         int res;
138         srm_env_t       *entry;
139         char            *buf = (char *) __get_free_page(GFP_USER);
140         unsigned long   ret1, ret2;
141
142         entry = (srm_env_t *) data;
143
144         if (!buf)
145                 return -ENOMEM;
146
147         res = -EINVAL;
148         if (count >= PAGE_SIZE)
149                 goto out;
150
151         res = -EFAULT;
152         if (copy_from_user(buf, buffer, count))
153                 goto out;
154         buf[count] = '\0';
155
156         ret1 = callback_setenv(entry->id, buf, count);
157         if ((ret1 >> 61) == 0) {
158                 do 
159                         ret2 = callback_save_env();
160                 while((ret2 >> 61) == 1);
161                 res = (int) ret1;
162         }
163
164  out:
165         free_page((unsigned long)buf);
166         return res;
167 }
168
169 static void
170 srm_env_cleanup(void)
171 {
172         srm_env_t       *entry;
173         unsigned long   var_num;
174
175         if(base_dir) {
176                 /*
177                  * Remove named entries
178                  */
179                 if(named_dir) {
180                         entry = srm_named_entries;
181                         while(entry->name != NULL && entry->id != 0) {
182                                 if(entry->proc_entry) {
183                                         remove_proc_entry(entry->name,
184                                                         named_dir);
185                                         entry->proc_entry = NULL;
186                                 }
187                                 entry++;
188                         }
189                         remove_proc_entry(NAMED_DIR, base_dir);
190                 }
191
192                 /*
193                  * Remove numbered entries
194                  */
195                 if(numbered_dir) {
196                         for(var_num = 0; var_num <= 255; var_num++) {
197                                 entry = &srm_numbered_entries[var_num];
198
199                                 if(entry->proc_entry) {
200                                         remove_proc_entry(entry->name,
201                                                         numbered_dir);
202                                         entry->proc_entry       = NULL;
203                                         entry->name             = NULL;
204                                 }
205                         }
206                         remove_proc_entry(NUMBERED_DIR, base_dir);
207                 }
208
209                 remove_proc_entry(BASE_DIR, NULL);
210         }
211
212         return;
213 }
214
215
216 static int __init
217 srm_env_init(void)
218 {
219         srm_env_t       *entry;
220         unsigned long   var_num;
221
222         /*
223          * Check system
224          */
225         if(!alpha_using_srm) {
226                 printk(KERN_INFO "%s: This Alpha system doesn't "
227                                 "know about SRM (or you've booted "
228                                 "SRM->MILO->Linux, which gets "
229                                 "misdetected)...\n", __FUNCTION__);
230                 return -ENODEV;
231         }
232
233         /*
234          * Init numbers
235          */
236         for(var_num = 0; var_num <= 255; var_num++)
237                 sprintf(number[var_num], "%ld", var_num);
238
239         /*
240          * Create base directory
241          */
242         base_dir = proc_mkdir(BASE_DIR, NULL);
243         if(base_dir == NULL) {
244                 printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
245                                 BASE_DIR);
246                 goto cleanup;
247         }
248         base_dir->owner = THIS_MODULE;
249
250         /*
251          * Create per-name subdirectory
252          */
253         named_dir = proc_mkdir(NAMED_DIR, base_dir);
254         if(named_dir == NULL) {
255                 printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
256                                 BASE_DIR, NAMED_DIR);
257                 goto cleanup;
258         }
259         named_dir->owner = THIS_MODULE;
260
261         /*
262          * Create per-number subdirectory
263          */
264         numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
265         if(numbered_dir == NULL) {
266                 printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
267                                 BASE_DIR, NUMBERED_DIR);
268                 goto cleanup;
269
270         }
271         numbered_dir->owner = THIS_MODULE;
272
273         /*
274          * Create all named nodes
275          */
276         entry = srm_named_entries;
277         while(entry->name != NULL && entry->id != 0) {
278                 entry->proc_entry = create_proc_entry(entry->name,
279                                 0644, named_dir);
280                 if(entry->proc_entry == NULL)
281                         goto cleanup;
282
283                 entry->proc_entry->data         = (void *) entry;
284                 entry->proc_entry->owner        = THIS_MODULE;
285                 entry->proc_entry->read_proc    = srm_env_read;
286                 entry->proc_entry->write_proc   = srm_env_write;
287
288                 entry++;
289         }
290
291         /*
292          * Create all numbered nodes
293          */
294         for(var_num = 0; var_num <= 255; var_num++) {
295                 entry = &srm_numbered_entries[var_num];
296                 entry->name = number[var_num];
297
298                 entry->proc_entry = create_proc_entry(entry->name,
299                                 0644, numbered_dir);
300                 if(entry->proc_entry == NULL)
301                         goto cleanup;
302
303                 entry->id                       = var_num;
304                 entry->proc_entry->data         = (void *) entry;
305                 entry->proc_entry->owner        = THIS_MODULE;
306                 entry->proc_entry->read_proc    = srm_env_read;
307                 entry->proc_entry->write_proc   = srm_env_write;
308         }
309
310         printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
311                         VERSION);
312
313         return 0;
314
315 cleanup:
316         srm_env_cleanup();
317
318         return -ENOMEM;
319 }
320
321
322 static void __exit
323 srm_env_exit(void)
324 {
325         srm_env_cleanup();
326         printk(KERN_INFO "%s: unloaded successfully\n", NAME);
327
328         return;
329 }
330
331
332 module_init(srm_env_init);
333 module_exit(srm_env_exit);
334