Commit | Line | Data |
---|---|---|
09c434b8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * CMOS/NV-RAM driver for Linux | |
4 | * | |
5 | * Copyright (C) 1997 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de> | |
6 | * idea by and with help from Richard Jelinek <rj@suse.de> | |
7 | * Portions copyright (c) 2001,2002 Sun Microsystems (thockin@sun.com) | |
8 | * | |
9 | * This driver allows you to access the contents of the non-volatile memory in | |
10 | * the mc146818rtc.h real-time clock. This chip is built into all PCs and into | |
11 | * many Atari machines. In the former it's called "CMOS-RAM", in the latter | |
12 | * "NVRAM" (NV stands for non-volatile). | |
13 | * | |
14 | * The data are supplied as a (seekable) character device, /dev/nvram. The | |
15 | * size of this file is dependent on the controller. The usual size is 114, | |
16 | * the number of freely available bytes in the memory (i.e., not used by the | |
17 | * RTC itself). | |
18 | * | |
19 | * Checksums over the NVRAM contents are managed by this driver. In case of a | |
20 | * bad checksum, reads and writes return -EIO. The checksum can be initialized | |
21 | * to a sane state either by ioctl(NVRAM_INIT) (clear whole NVRAM) or | |
22 | * ioctl(NVRAM_SETCKS) (doesn't change contents, just makes checksum valid | |
23 | * again; use with care!) | |
24 | * | |
1da177e4 LT |
25 | * 1.1 Cesar Barros: SMP locking fixes |
26 | * added changelog | |
27 | * 1.2 Erik Gilling: Cobalt Networks support | |
28 | * Tim Hockin: general cleanup, Cobalt support | |
8587b33f | 29 | * 1.3 Wim Van Sebroeck: convert PRINT_PROC to seq_file |
1da177e4 LT |
30 | */ |
31 | ||
8587b33f | 32 | #define NVRAM_VERSION "1.3" |
1da177e4 LT |
33 | |
34 | #include <linux/module.h> | |
1da177e4 | 35 | #include <linux/nvram.h> |
1da177e4 LT |
36 | #include <linux/types.h> |
37 | #include <linux/errno.h> | |
38 | #include <linux/miscdevice.h> | |
1da177e4 LT |
39 | #include <linux/ioport.h> |
40 | #include <linux/fcntl.h> | |
41 | #include <linux/mc146818rtc.h> | |
42 | #include <linux/init.h> | |
43 | #include <linux/proc_fs.h> | |
8587b33f | 44 | #include <linux/seq_file.h> |
109b3a89 | 45 | #include <linux/slab.h> |
1da177e4 | 46 | #include <linux/spinlock.h> |
971ddcf8 WVS |
47 | #include <linux/io.h> |
48 | #include <linux/uaccess.h> | |
613655fa | 49 | #include <linux/mutex.h> |
b808b1d6 | 50 | #include <linux/pagemap.h> |
1da177e4 | 51 | |
95ac14b8 FT |
52 | #ifdef CONFIG_PPC |
53 | #include <asm/nvram.h> | |
54 | #endif | |
1da177e4 | 55 | |
613655fa | 56 | static DEFINE_MUTEX(nvram_mutex); |
1da177e4 LT |
57 | static DEFINE_SPINLOCK(nvram_state_lock); |
58 | static int nvram_open_cnt; /* #times opened */ | |
59 | static int nvram_open_mode; /* special open modes */ | |
d5bbb502 | 60 | static ssize_t nvram_size; |
1da177e4 LT |
61 | #define NVRAM_WRITE 1 /* opened for writing (exclusive) */ |
62 | #define NVRAM_EXCL 2 /* opened with O_EXCL */ | |
63 | ||
d5bbb502 | 64 | #ifdef CONFIG_X86 |
1da177e4 LT |
65 | /* |
66 | * These functions are provided to be called internally or by other parts of | |
67 | * the kernel. It's up to the caller to ensure correct checksum before reading | |
68 | * or after writing (needs to be done only once). | |
69 | * | |
70 | * It is worth noting that these functions all access bytes of general | |
71 | * purpose memory in the NVRAM - that is to say, they all add the | |
971ddcf8 | 72 | * NVRAM_FIRST_BYTE offset. Pass them offsets into NVRAM as if you did not |
1da177e4 LT |
73 | * know about the RTC cruft. |
74 | */ | |
75 | ||
437ace37 FT |
76 | #define NVRAM_BYTES (128 - NVRAM_FIRST_BYTE) |
77 | ||
78 | /* Note that *all* calls to CMOS_READ and CMOS_WRITE must be done with | |
79 | * rtc_lock held. Due to the index-port/data-port design of the RTC, we | |
80 | * don't want two different things trying to get to it at once. (e.g. the | |
81 | * periodic 11 min sync from kernel/time/ntp.c vs. this driver.) | |
82 | */ | |
83 | ||
1278cf66 | 84 | static unsigned char __nvram_read_byte(int i) |
1da177e4 LT |
85 | { |
86 | return CMOS_READ(NVRAM_FIRST_BYTE + i); | |
87 | } | |
88 | ||
1278cf66 | 89 | static unsigned char pc_nvram_read_byte(int i) |
1da177e4 LT |
90 | { |
91 | unsigned long flags; | |
92 | unsigned char c; | |
93 | ||
94 | spin_lock_irqsave(&rtc_lock, flags); | |
95 | c = __nvram_read_byte(i); | |
96 | spin_unlock_irqrestore(&rtc_lock, flags); | |
97 | return c; | |
98 | } | |
99 | ||
100 | /* This races nicely with trying to read with checksum checking (nvram_read) */ | |
1278cf66 | 101 | static void __nvram_write_byte(unsigned char c, int i) |
1da177e4 LT |
102 | { |
103 | CMOS_WRITE(c, NVRAM_FIRST_BYTE + i); | |
104 | } | |
105 | ||
1278cf66 | 106 | static void pc_nvram_write_byte(unsigned char c, int i) |
1da177e4 LT |
107 | { |
108 | unsigned long flags; | |
109 | ||
110 | spin_lock_irqsave(&rtc_lock, flags); | |
111 | __nvram_write_byte(c, i); | |
112 | spin_unlock_irqrestore(&rtc_lock, flags); | |
113 | } | |
114 | ||
437ace37 FT |
115 | /* On PCs, the checksum is built only over bytes 2..31 */ |
116 | #define PC_CKS_RANGE_START 2 | |
117 | #define PC_CKS_RANGE_END 31 | |
118 | #define PC_CKS_LOC 32 | |
119 | ||
1278cf66 | 120 | static int __nvram_check_checksum(void) |
1da177e4 | 121 | { |
437ace37 FT |
122 | int i; |
123 | unsigned short sum = 0; | |
124 | unsigned short expect; | |
125 | ||
126 | for (i = PC_CKS_RANGE_START; i <= PC_CKS_RANGE_END; ++i) | |
127 | sum += __nvram_read_byte(i); | |
128 | expect = __nvram_read_byte(PC_CKS_LOC)<<8 | | |
129 | __nvram_read_byte(PC_CKS_LOC+1); | |
130 | return (sum & 0xffff) == expect; | |
1da177e4 | 131 | } |
1da177e4 | 132 | |
971ddcf8 | 133 | static void __nvram_set_checksum(void) |
1da177e4 | 134 | { |
437ace37 FT |
135 | int i; |
136 | unsigned short sum = 0; | |
137 | ||
138 | for (i = PC_CKS_RANGE_START; i <= PC_CKS_RANGE_END; ++i) | |
139 | sum += __nvram_read_byte(i); | |
140 | __nvram_write_byte(sum >> 8, PC_CKS_LOC); | |
141 | __nvram_write_byte(sum & 0xff, PC_CKS_LOC + 1); | |
1da177e4 LT |
142 | } |
143 | ||
2d58636e | 144 | static long pc_nvram_set_checksum(void) |
1da177e4 | 145 | { |
2d58636e FT |
146 | spin_lock_irq(&rtc_lock); |
147 | __nvram_set_checksum(); | |
148 | spin_unlock_irq(&rtc_lock); | |
149 | return 0; | |
150 | } | |
1da177e4 | 151 | |
2d58636e FT |
152 | static long pc_nvram_initialize(void) |
153 | { | |
154 | ssize_t i; | |
155 | ||
156 | spin_lock_irq(&rtc_lock); | |
157 | for (i = 0; i < NVRAM_BYTES; ++i) | |
158 | __nvram_write_byte(0, i); | |
1da177e4 | 159 | __nvram_set_checksum(); |
2d58636e FT |
160 | spin_unlock_irq(&rtc_lock); |
161 | return 0; | |
1da177e4 LT |
162 | } |
163 | ||
d5bbb502 FT |
164 | static ssize_t pc_nvram_get_size(void) |
165 | { | |
166 | return NVRAM_BYTES; | |
167 | } | |
168 | ||
109b3a89 FT |
169 | static ssize_t pc_nvram_read(char *buf, size_t count, loff_t *ppos) |
170 | { | |
171 | char *p = buf; | |
172 | loff_t i; | |
173 | ||
174 | spin_lock_irq(&rtc_lock); | |
175 | if (!__nvram_check_checksum()) { | |
176 | spin_unlock_irq(&rtc_lock); | |
177 | return -EIO; | |
178 | } | |
179 | for (i = *ppos; count > 0 && i < NVRAM_BYTES; --count, ++i, ++p) | |
180 | *p = __nvram_read_byte(i); | |
181 | spin_unlock_irq(&rtc_lock); | |
182 | ||
183 | *ppos = i; | |
184 | return p - buf; | |
185 | } | |
186 | ||
187 | static ssize_t pc_nvram_write(char *buf, size_t count, loff_t *ppos) | |
188 | { | |
189 | char *p = buf; | |
190 | loff_t i; | |
191 | ||
192 | spin_lock_irq(&rtc_lock); | |
193 | if (!__nvram_check_checksum()) { | |
194 | spin_unlock_irq(&rtc_lock); | |
195 | return -EIO; | |
196 | } | |
197 | for (i = *ppos; count > 0 && i < NVRAM_BYTES; --count, ++i, ++p) | |
198 | __nvram_write_byte(*p, i); | |
199 | __nvram_set_checksum(); | |
200 | spin_unlock_irq(&rtc_lock); | |
201 | ||
202 | *ppos = i; | |
203 | return p - buf; | |
204 | } | |
205 | ||
d5bbb502 | 206 | const struct nvram_ops arch_nvram_ops = { |
109b3a89 FT |
207 | .read = pc_nvram_read, |
208 | .write = pc_nvram_write, | |
d5bbb502 FT |
209 | .read_byte = pc_nvram_read_byte, |
210 | .write_byte = pc_nvram_write_byte, | |
211 | .get_size = pc_nvram_get_size, | |
2d58636e FT |
212 | .set_checksum = pc_nvram_set_checksum, |
213 | .initialize = pc_nvram_initialize, | |
d5bbb502 FT |
214 | }; |
215 | EXPORT_SYMBOL(arch_nvram_ops); | |
216 | #endif /* CONFIG_X86 */ | |
217 | ||
1da177e4 LT |
218 | /* |
219 | * The are the file operation function for user access to /dev/nvram | |
220 | */ | |
221 | ||
cb8d8006 | 222 | static loff_t nvram_misc_llseek(struct file *file, loff_t offset, int origin) |
1da177e4 | 223 | { |
b808b1d6 | 224 | return generic_file_llseek_size(file, offset, origin, MAX_LFS_FILESIZE, |
d5bbb502 | 225 | nvram_size); |
1da177e4 LT |
226 | } |
227 | ||
cb8d8006 FT |
228 | static ssize_t nvram_misc_read(struct file *file, char __user *buf, |
229 | size_t count, loff_t *ppos) | |
1da177e4 | 230 | { |
109b3a89 FT |
231 | char *tmp; |
232 | ssize_t ret; | |
1da177e4 | 233 | |
1da177e4 | 234 | |
109b3a89 FT |
235 | if (*ppos >= nvram_size) |
236 | return 0; | |
1da177e4 | 237 | |
109b3a89 FT |
238 | count = min_t(size_t, count, nvram_size - *ppos); |
239 | count = min_t(size_t, count, PAGE_SIZE); | |
1da177e4 | 240 | |
109b3a89 FT |
241 | tmp = kmalloc(count, GFP_KERNEL); |
242 | if (!tmp) | |
243 | return -ENOMEM; | |
1da177e4 | 244 | |
109b3a89 FT |
245 | ret = nvram_read(tmp, count, ppos); |
246 | if (ret <= 0) | |
247 | goto out; | |
1da177e4 | 248 | |
109b3a89 FT |
249 | if (copy_to_user(buf, tmp, ret)) { |
250 | *ppos -= ret; | |
251 | ret = -EFAULT; | |
252 | } | |
1da177e4 | 253 | |
109b3a89 FT |
254 | out: |
255 | kfree(tmp); | |
256 | return ret; | |
1da177e4 LT |
257 | } |
258 | ||
cb8d8006 FT |
259 | static ssize_t nvram_misc_write(struct file *file, const char __user *buf, |
260 | size_t count, loff_t *ppos) | |
1da177e4 | 261 | { |
109b3a89 FT |
262 | char *tmp; |
263 | ssize_t ret; | |
a01c7800 | 264 | |
109b3a89 FT |
265 | if (*ppos >= nvram_size) |
266 | return 0; | |
1da177e4 | 267 | |
109b3a89 FT |
268 | count = min_t(size_t, count, nvram_size - *ppos); |
269 | count = min_t(size_t, count, PAGE_SIZE); | |
1da177e4 | 270 | |
109b3a89 FT |
271 | tmp = memdup_user(buf, count); |
272 | if (IS_ERR(tmp)) | |
273 | return PTR_ERR(tmp); | |
1da177e4 | 274 | |
109b3a89 FT |
275 | ret = nvram_write(tmp, count, ppos); |
276 | kfree(tmp); | |
277 | return ret; | |
1da177e4 LT |
278 | } |
279 | ||
cb8d8006 FT |
280 | static long nvram_misc_ioctl(struct file *file, unsigned int cmd, |
281 | unsigned long arg) | |
1da177e4 | 282 | { |
2d58636e | 283 | long ret = -ENOTTY; |
1da177e4 LT |
284 | |
285 | switch (cmd) { | |
95ac14b8 FT |
286 | #ifdef CONFIG_PPC |
287 | case OBSOLETE_PMAC_NVRAM_GET_OFFSET: | |
288 | pr_warn("nvram: Using obsolete PMAC_NVRAM_GET_OFFSET ioctl\n"); | |
df561f66 | 289 | fallthrough; |
95ac14b8 FT |
290 | case IOC_NVRAM_GET_OFFSET: |
291 | ret = -EINVAL; | |
292 | #ifdef CONFIG_PPC_PMAC | |
293 | if (machine_is(powermac)) { | |
294 | int part, offset; | |
295 | ||
296 | if (copy_from_user(&part, (void __user *)arg, | |
297 | sizeof(part)) != 0) | |
298 | return -EFAULT; | |
299 | if (part < pmac_nvram_OF || part > pmac_nvram_NR) | |
300 | return -EINVAL; | |
301 | offset = pmac_get_partition(part); | |
20e07af7 FT |
302 | if (offset < 0) |
303 | return -EINVAL; | |
95ac14b8 FT |
304 | if (copy_to_user((void __user *)arg, |
305 | &offset, sizeof(offset)) != 0) | |
306 | return -EFAULT; | |
307 | ret = 0; | |
308 | } | |
309 | #endif | |
310 | break; | |
20e07af7 | 311 | #ifdef CONFIG_PPC32 |
95ac14b8 FT |
312 | case IOC_NVRAM_SYNC: |
313 | if (ppc_md.nvram_sync != NULL) { | |
314 | mutex_lock(&nvram_mutex); | |
315 | ppc_md.nvram_sync(); | |
316 | mutex_unlock(&nvram_mutex); | |
317 | } | |
318 | ret = 0; | |
319 | break; | |
20e07af7 | 320 | #endif |
95ac14b8 | 321 | #elif defined(CONFIG_X86) || defined(CONFIG_M68K) |
1da177e4 LT |
322 | case NVRAM_INIT: |
323 | /* initialize NVRAM contents and checksum */ | |
324 | if (!capable(CAP_SYS_ADMIN)) | |
325 | return -EACCES; | |
326 | ||
2d58636e FT |
327 | if (arch_nvram_ops.initialize != NULL) { |
328 | mutex_lock(&nvram_mutex); | |
329 | ret = arch_nvram_ops.initialize(); | |
330 | mutex_unlock(&nvram_mutex); | |
331 | } | |
332 | break; | |
1da177e4 | 333 | case NVRAM_SETCKS: |
971ddcf8 | 334 | /* just set checksum, contents unchanged (maybe useful after |
1da177e4 LT |
335 | * checksum garbaged somehow...) */ |
336 | if (!capable(CAP_SYS_ADMIN)) | |
337 | return -EACCES; | |
338 | ||
2d58636e FT |
339 | if (arch_nvram_ops.set_checksum != NULL) { |
340 | mutex_lock(&nvram_mutex); | |
341 | ret = arch_nvram_ops.set_checksum(); | |
342 | mutex_unlock(&nvram_mutex); | |
343 | } | |
344 | break; | |
95ac14b8 | 345 | #endif /* CONFIG_X86 || CONFIG_M68K */ |
1da177e4 | 346 | } |
2d58636e | 347 | return ret; |
1da177e4 LT |
348 | } |
349 | ||
cb8d8006 | 350 | static int nvram_misc_open(struct inode *inode, struct file *file) |
1da177e4 LT |
351 | { |
352 | spin_lock(&nvram_state_lock); | |
353 | ||
2d58636e | 354 | /* Prevent multiple readers/writers if desired. */ |
1da177e4 | 355 | if ((nvram_open_cnt && (file->f_flags & O_EXCL)) || |
2d58636e FT |
356 | (nvram_open_mode & NVRAM_EXCL)) { |
357 | spin_unlock(&nvram_state_lock); | |
358 | return -EBUSY; | |
359 | } | |
360 | ||
95ac14b8 | 361 | #if defined(CONFIG_X86) || defined(CONFIG_M68K) |
2d58636e FT |
362 | /* Prevent multiple writers if the set_checksum ioctl is implemented. */ |
363 | if ((arch_nvram_ops.set_checksum != NULL) && | |
364 | (file->f_mode & FMODE_WRITE) && (nvram_open_mode & NVRAM_WRITE)) { | |
1da177e4 LT |
365 | spin_unlock(&nvram_state_lock); |
366 | return -EBUSY; | |
367 | } | |
95ac14b8 | 368 | #endif |
1da177e4 LT |
369 | |
370 | if (file->f_flags & O_EXCL) | |
371 | nvram_open_mode |= NVRAM_EXCL; | |
aeb5d727 | 372 | if (file->f_mode & FMODE_WRITE) |
1da177e4 LT |
373 | nvram_open_mode |= NVRAM_WRITE; |
374 | nvram_open_cnt++; | |
375 | ||
376 | spin_unlock(&nvram_state_lock); | |
377 | ||
378 | return 0; | |
379 | } | |
380 | ||
cb8d8006 | 381 | static int nvram_misc_release(struct inode *inode, struct file *file) |
1da177e4 LT |
382 | { |
383 | spin_lock(&nvram_state_lock); | |
384 | ||
385 | nvram_open_cnt--; | |
386 | ||
387 | /* if only one instance is open, clear the EXCL bit */ | |
388 | if (nvram_open_mode & NVRAM_EXCL) | |
389 | nvram_open_mode &= ~NVRAM_EXCL; | |
aeb5d727 | 390 | if (file->f_mode & FMODE_WRITE) |
1da177e4 LT |
391 | nvram_open_mode &= ~NVRAM_WRITE; |
392 | ||
393 | spin_unlock(&nvram_state_lock); | |
394 | ||
395 | return 0; | |
396 | } | |
397 | ||
d5bbb502 | 398 | #if defined(CONFIG_X86) && defined(CONFIG_PROC_FS) |
a116eaf1 | 399 | static const char * const floppy_types[] = { |
1da177e4 LT |
400 | "none", "5.25'' 360k", "5.25'' 1.2M", "3.5'' 720k", "3.5'' 1.44M", |
401 | "3.5'' 2.88M", "3.5'' 2.88M" | |
402 | }; | |
403 | ||
a116eaf1 | 404 | static const char * const gfx_types[] = { |
1da177e4 LT |
405 | "EGA, VGA, ... (with BIOS)", |
406 | "CGA (40 cols)", | |
407 | "CGA (80 cols)", | |
408 | "monochrome", | |
409 | }; | |
410 | ||
437ace37 FT |
411 | static void pc_nvram_proc_read(unsigned char *nvram, struct seq_file *seq, |
412 | void *offset) | |
1da177e4 LT |
413 | { |
414 | int checksum; | |
415 | int type; | |
416 | ||
417 | spin_lock_irq(&rtc_lock); | |
418 | checksum = __nvram_check_checksum(); | |
419 | spin_unlock_irq(&rtc_lock); | |
420 | ||
8587b33f | 421 | seq_printf(seq, "Checksum status: %svalid\n", checksum ? "" : "not "); |
1da177e4 | 422 | |
8587b33f | 423 | seq_printf(seq, "# floppies : %d\n", |
1da177e4 | 424 | (nvram[6] & 1) ? (nvram[6] >> 6) + 1 : 0); |
8587b33f | 425 | seq_printf(seq, "Floppy 0 type : "); |
1da177e4 | 426 | type = nvram[2] >> 4; |
fe971071 | 427 | if (type < ARRAY_SIZE(floppy_types)) |
8587b33f | 428 | seq_printf(seq, "%s\n", floppy_types[type]); |
1da177e4 | 429 | else |
8587b33f WVS |
430 | seq_printf(seq, "%d (unknown)\n", type); |
431 | seq_printf(seq, "Floppy 1 type : "); | |
1da177e4 | 432 | type = nvram[2] & 0x0f; |
fe971071 | 433 | if (type < ARRAY_SIZE(floppy_types)) |
8587b33f | 434 | seq_printf(seq, "%s\n", floppy_types[type]); |
1da177e4 | 435 | else |
8587b33f | 436 | seq_printf(seq, "%d (unknown)\n", type); |
1da177e4 | 437 | |
8587b33f | 438 | seq_printf(seq, "HD 0 type : "); |
1da177e4 LT |
439 | type = nvram[4] >> 4; |
440 | if (type) | |
8587b33f | 441 | seq_printf(seq, "%02x\n", type == 0x0f ? nvram[11] : type); |
1da177e4 | 442 | else |
8587b33f | 443 | seq_printf(seq, "none\n"); |
1da177e4 | 444 | |
8587b33f | 445 | seq_printf(seq, "HD 1 type : "); |
1da177e4 LT |
446 | type = nvram[4] & 0x0f; |
447 | if (type) | |
8587b33f | 448 | seq_printf(seq, "%02x\n", type == 0x0f ? nvram[12] : type); |
1da177e4 | 449 | else |
8587b33f | 450 | seq_printf(seq, "none\n"); |
1da177e4 | 451 | |
8587b33f | 452 | seq_printf(seq, "HD type 48 data: %d/%d/%d C/H/S, precomp %d, lz %d\n", |
1da177e4 LT |
453 | nvram[18] | (nvram[19] << 8), |
454 | nvram[20], nvram[25], | |
455 | nvram[21] | (nvram[22] << 8), nvram[23] | (nvram[24] << 8)); | |
8587b33f | 456 | seq_printf(seq, "HD type 49 data: %d/%d/%d C/H/S, precomp %d, lz %d\n", |
1da177e4 LT |
457 | nvram[39] | (nvram[40] << 8), |
458 | nvram[41], nvram[46], | |
459 | nvram[42] | (nvram[43] << 8), nvram[44] | (nvram[45] << 8)); | |
460 | ||
8587b33f WVS |
461 | seq_printf(seq, "DOS base memory: %d kB\n", nvram[7] | (nvram[8] << 8)); |
462 | seq_printf(seq, "Extended memory: %d kB (configured), %d kB (tested)\n", | |
1da177e4 LT |
463 | nvram[9] | (nvram[10] << 8), nvram[34] | (nvram[35] << 8)); |
464 | ||
8587b33f WVS |
465 | seq_printf(seq, "Gfx adapter : %s\n", |
466 | gfx_types[(nvram[6] >> 4) & 3]); | |
1da177e4 | 467 | |
8587b33f | 468 | seq_printf(seq, "FPU : %sinstalled\n", |
1da177e4 LT |
469 | (nvram[6] & 2) ? "" : "not "); |
470 | ||
8587b33f | 471 | return; |
1da177e4 | 472 | } |
1da177e4 | 473 | |
cb8d8006 FT |
474 | static int nvram_proc_read(struct seq_file *seq, void *offset) |
475 | { | |
476 | unsigned char contents[NVRAM_BYTES]; | |
477 | int i = 0; | |
478 | ||
479 | spin_lock_irq(&rtc_lock); | |
480 | for (i = 0; i < NVRAM_BYTES; ++i) | |
481 | contents[i] = __nvram_read_byte(i); | |
482 | spin_unlock_irq(&rtc_lock); | |
483 | ||
484 | pc_nvram_proc_read(contents, seq, offset); | |
485 | ||
486 | return 0; | |
487 | } | |
d5bbb502 | 488 | #endif /* CONFIG_X86 && CONFIG_PROC_FS */ |
1da177e4 | 489 | |
cb8d8006 FT |
490 | static const struct file_operations nvram_misc_fops = { |
491 | .owner = THIS_MODULE, | |
492 | .llseek = nvram_misc_llseek, | |
493 | .read = nvram_misc_read, | |
494 | .write = nvram_misc_write, | |
495 | .unlocked_ioctl = nvram_misc_ioctl, | |
496 | .open = nvram_misc_open, | |
497 | .release = nvram_misc_release, | |
498 | }; | |
499 | ||
500 | static struct miscdevice nvram_misc = { | |
501 | NVRAM_MINOR, | |
502 | "nvram", | |
503 | &nvram_misc_fops, | |
504 | }; | |
505 | ||
506 | static int __init nvram_module_init(void) | |
507 | { | |
508 | int ret; | |
509 | ||
d5bbb502 FT |
510 | nvram_size = nvram_get_size(); |
511 | if (nvram_size < 0) | |
512 | return nvram_size; | |
513 | ||
cb8d8006 FT |
514 | ret = misc_register(&nvram_misc); |
515 | if (ret) { | |
516 | pr_err("nvram: can't misc_register on minor=%d\n", NVRAM_MINOR); | |
517 | return ret; | |
518 | } | |
519 | ||
d5bbb502 | 520 | #if defined(CONFIG_X86) && defined(CONFIG_PROC_FS) |
cb8d8006 FT |
521 | if (!proc_create_single("driver/nvram", 0, NULL, nvram_proc_read)) { |
522 | pr_err("nvram: can't create /proc/driver/nvram\n"); | |
523 | misc_deregister(&nvram_misc); | |
524 | return -ENOMEM; | |
525 | } | |
526 | #endif | |
527 | ||
528 | pr_info("Non-volatile memory driver v" NVRAM_VERSION "\n"); | |
529 | return 0; | |
530 | } | |
531 | ||
532 | static void __exit nvram_module_exit(void) | |
533 | { | |
d5bbb502 | 534 | #if defined(CONFIG_X86) && defined(CONFIG_PROC_FS) |
cb8d8006 FT |
535 | remove_proc_entry("driver/nvram", NULL); |
536 | #endif | |
537 | misc_deregister(&nvram_misc); | |
538 | } | |
539 | ||
540 | module_init(nvram_module_init); | |
541 | module_exit(nvram_module_exit); | |
542 | ||
1da177e4 | 543 | MODULE_LICENSE("GPL"); |
1da177e4 | 544 | MODULE_ALIAS_MISCDEV(NVRAM_MINOR); |
7fc0ac05 | 545 | MODULE_ALIAS("devname:nvram"); |