1 | // SPDX-License-Identifier: GPL-2.0-only |
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 | * |
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 |
29 | * 1.3 Wim Van Sebroeck: convert PRINT_PROC to seq_file |
30 | */ |
31 | |
32 | #define NVRAM_VERSION "1.3" |
33 | |
34 | #include <linux/module.h> |
35 | #include <linux/nvram.h> |
36 | #include <linux/types.h> |
37 | #include <linux/errno.h> |
38 | #include <linux/miscdevice.h> |
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> |
44 | #include <linux/seq_file.h> |
45 | #include <linux/slab.h> |
46 | #include <linux/spinlock.h> |
47 | #include <linux/io.h> |
48 | #include <linux/uaccess.h> |
49 | #include <linux/mutex.h> |
50 | #include <linux/pagemap.h> |
51 | |
52 | #ifdef CONFIG_PPC |
53 | #include <asm/nvram.h> |
54 | #endif |
55 | |
56 | static DEFINE_MUTEX(nvram_mutex); |
57 | static DEFINE_SPINLOCK(nvram_state_lock); |
58 | static int nvram_open_cnt; /* #times opened */ |
59 | static int nvram_open_mode; /* special open modes */ |
60 | static ssize_t nvram_size; |
61 | #define NVRAM_WRITE 1 /* opened for writing (exclusive) */ |
62 | #define NVRAM_EXCL 2 /* opened with O_EXCL */ |
63 | |
64 | #ifdef CONFIG_X86 |
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 |
72 | * NVRAM_FIRST_BYTE offset. Pass them offsets into NVRAM as if you did not |
73 | * know about the RTC cruft. |
74 | */ |
75 | |
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 | |
84 | static unsigned char __nvram_read_byte(int i) |
85 | { |
86 | return CMOS_READ(NVRAM_FIRST_BYTE + i); |
87 | } |
88 | |
89 | static unsigned char pc_nvram_read_byte(int i) |
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(lock: &rtc_lock, flags); |
97 | return c; |
98 | } |
99 | |
100 | /* This races nicely with trying to read with checksum checking (nvram_read) */ |
101 | static void __nvram_write_byte(unsigned char c, int i) |
102 | { |
103 | CMOS_WRITE(c, NVRAM_FIRST_BYTE + i); |
104 | } |
105 | |
106 | static void pc_nvram_write_byte(unsigned char c, int i) |
107 | { |
108 | unsigned long flags; |
109 | |
110 | spin_lock_irqsave(&rtc_lock, flags); |
111 | __nvram_write_byte(c, i); |
112 | spin_unlock_irqrestore(lock: &rtc_lock, flags); |
113 | } |
114 | |
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 | |
120 | static int __nvram_check_checksum(void) |
121 | { |
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; |
131 | } |
132 | |
133 | static void __nvram_set_checksum(void) |
134 | { |
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(c: sum >> 8, PC_CKS_LOC); |
141 | __nvram_write_byte(c: sum & 0xff, PC_CKS_LOC + 1); |
142 | } |
143 | |
144 | static long pc_nvram_set_checksum(void) |
145 | { |
146 | spin_lock_irq(lock: &rtc_lock); |
147 | __nvram_set_checksum(); |
148 | spin_unlock_irq(lock: &rtc_lock); |
149 | return 0; |
150 | } |
151 | |
152 | static long pc_nvram_initialize(void) |
153 | { |
154 | ssize_t i; |
155 | |
156 | spin_lock_irq(lock: &rtc_lock); |
157 | for (i = 0; i < NVRAM_BYTES; ++i) |
158 | __nvram_write_byte(c: 0, i); |
159 | __nvram_set_checksum(); |
160 | spin_unlock_irq(lock: &rtc_lock); |
161 | return 0; |
162 | } |
163 | |
164 | static ssize_t pc_nvram_get_size(void) |
165 | { |
166 | return NVRAM_BYTES; |
167 | } |
168 | |
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(lock: &rtc_lock); |
175 | if (!__nvram_check_checksum()) { |
176 | spin_unlock_irq(lock: &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(lock: &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(lock: &rtc_lock); |
193 | if (!__nvram_check_checksum()) { |
194 | spin_unlock_irq(lock: &rtc_lock); |
195 | return -EIO; |
196 | } |
197 | for (i = *ppos; count > 0 && i < NVRAM_BYTES; --count, ++i, ++p) |
198 | __nvram_write_byte(c: *p, i); |
199 | __nvram_set_checksum(); |
200 | spin_unlock_irq(lock: &rtc_lock); |
201 | |
202 | *ppos = i; |
203 | return p - buf; |
204 | } |
205 | |
206 | const struct nvram_ops arch_nvram_ops = { |
207 | .read = pc_nvram_read, |
208 | .write = pc_nvram_write, |
209 | .read_byte = pc_nvram_read_byte, |
210 | .write_byte = pc_nvram_write_byte, |
211 | .get_size = pc_nvram_get_size, |
212 | .set_checksum = pc_nvram_set_checksum, |
213 | .initialize = pc_nvram_initialize, |
214 | }; |
215 | EXPORT_SYMBOL(arch_nvram_ops); |
216 | #endif /* CONFIG_X86 */ |
217 | |
218 | /* |
219 | * The are the file operation function for user access to /dev/nvram |
220 | */ |
221 | |
222 | static loff_t nvram_misc_llseek(struct file *file, loff_t offset, int origin) |
223 | { |
224 | return generic_file_llseek_size(file, offset, whence: origin, MAX_LFS_FILESIZE, |
225 | eof: nvram_size); |
226 | } |
227 | |
228 | static ssize_t nvram_misc_read(struct file *file, char __user *buf, |
229 | size_t count, loff_t *ppos) |
230 | { |
231 | char *tmp; |
232 | ssize_t ret; |
233 | |
234 | |
235 | if (*ppos >= nvram_size) |
236 | return 0; |
237 | |
238 | count = min_t(size_t, count, nvram_size - *ppos); |
239 | count = min_t(size_t, count, PAGE_SIZE); |
240 | |
241 | tmp = kmalloc(size: count, GFP_KERNEL); |
242 | if (!tmp) |
243 | return -ENOMEM; |
244 | |
245 | ret = nvram_read(buf: tmp, count, ppos); |
246 | if (ret <= 0) |
247 | goto out; |
248 | |
249 | if (copy_to_user(to: buf, from: tmp, n: ret)) { |
250 | *ppos -= ret; |
251 | ret = -EFAULT; |
252 | } |
253 | |
254 | out: |
255 | kfree(objp: tmp); |
256 | return ret; |
257 | } |
258 | |
259 | static ssize_t nvram_misc_write(struct file *file, const char __user *buf, |
260 | size_t count, loff_t *ppos) |
261 | { |
262 | char *tmp; |
263 | ssize_t ret; |
264 | |
265 | if (*ppos >= nvram_size) |
266 | return 0; |
267 | |
268 | count = min_t(size_t, count, nvram_size - *ppos); |
269 | count = min_t(size_t, count, PAGE_SIZE); |
270 | |
271 | tmp = memdup_user(buf, count); |
272 | if (IS_ERR(ptr: tmp)) |
273 | return PTR_ERR(ptr: tmp); |
274 | |
275 | ret = nvram_write(buf: tmp, count, ppos); |
276 | kfree(objp: tmp); |
277 | return ret; |
278 | } |
279 | |
280 | static long nvram_misc_ioctl(struct file *file, unsigned int cmd, |
281 | unsigned long arg) |
282 | { |
283 | long ret = -ENOTTY; |
284 | |
285 | switch (cmd) { |
286 | #ifdef CONFIG_PPC |
287 | case OBSOLETE_PMAC_NVRAM_GET_OFFSET: |
288 | pr_warn("nvram: Using obsolete PMAC_NVRAM_GET_OFFSET ioctl\n" ); |
289 | fallthrough; |
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); |
302 | if (offset < 0) |
303 | return -EINVAL; |
304 | if (copy_to_user((void __user *)arg, |
305 | &offset, sizeof(offset)) != 0) |
306 | return -EFAULT; |
307 | ret = 0; |
308 | } |
309 | #endif |
310 | break; |
311 | #ifdef CONFIG_PPC32 |
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; |
320 | #endif |
321 | #elif defined(CONFIG_X86) || defined(CONFIG_M68K) |
322 | case NVRAM_INIT: |
323 | /* initialize NVRAM contents and checksum */ |
324 | if (!capable(CAP_SYS_ADMIN)) |
325 | return -EACCES; |
326 | |
327 | if (arch_nvram_ops.initialize != NULL) { |
328 | mutex_lock(&nvram_mutex); |
329 | ret = arch_nvram_ops.initialize(); |
330 | mutex_unlock(lock: &nvram_mutex); |
331 | } |
332 | break; |
333 | case NVRAM_SETCKS: |
334 | /* just set checksum, contents unchanged (maybe useful after |
335 | * checksum garbaged somehow...) */ |
336 | if (!capable(CAP_SYS_ADMIN)) |
337 | return -EACCES; |
338 | |
339 | if (arch_nvram_ops.set_checksum != NULL) { |
340 | mutex_lock(&nvram_mutex); |
341 | ret = arch_nvram_ops.set_checksum(); |
342 | mutex_unlock(lock: &nvram_mutex); |
343 | } |
344 | break; |
345 | #endif /* CONFIG_X86 || CONFIG_M68K */ |
346 | } |
347 | return ret; |
348 | } |
349 | |
350 | static int nvram_misc_open(struct inode *inode, struct file *file) |
351 | { |
352 | spin_lock(lock: &nvram_state_lock); |
353 | |
354 | /* Prevent multiple readers/writers if desired. */ |
355 | if ((nvram_open_cnt && (file->f_flags & O_EXCL)) || |
356 | (nvram_open_mode & NVRAM_EXCL)) { |
357 | spin_unlock(lock: &nvram_state_lock); |
358 | return -EBUSY; |
359 | } |
360 | |
361 | #if defined(CONFIG_X86) || defined(CONFIG_M68K) |
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)) { |
365 | spin_unlock(lock: &nvram_state_lock); |
366 | return -EBUSY; |
367 | } |
368 | #endif |
369 | |
370 | if (file->f_flags & O_EXCL) |
371 | nvram_open_mode |= NVRAM_EXCL; |
372 | if (file->f_mode & FMODE_WRITE) |
373 | nvram_open_mode |= NVRAM_WRITE; |
374 | nvram_open_cnt++; |
375 | |
376 | spin_unlock(lock: &nvram_state_lock); |
377 | |
378 | return 0; |
379 | } |
380 | |
381 | static int nvram_misc_release(struct inode *inode, struct file *file) |
382 | { |
383 | spin_lock(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; |
390 | if (file->f_mode & FMODE_WRITE) |
391 | nvram_open_mode &= ~NVRAM_WRITE; |
392 | |
393 | spin_unlock(lock: &nvram_state_lock); |
394 | |
395 | return 0; |
396 | } |
397 | |
398 | #if defined(CONFIG_X86) && defined(CONFIG_PROC_FS) |
399 | static const char * const floppy_types[] = { |
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 | |
404 | static const char * const gfx_types[] = { |
405 | "EGA, VGA, ... (with BIOS)" , |
406 | "CGA (40 cols)" , |
407 | "CGA (80 cols)" , |
408 | "monochrome" , |
409 | }; |
410 | |
411 | static void pc_nvram_proc_read(unsigned char *nvram, struct seq_file *seq, |
412 | void *offset) |
413 | { |
414 | int checksum; |
415 | int type; |
416 | |
417 | spin_lock_irq(lock: &rtc_lock); |
418 | checksum = __nvram_check_checksum(); |
419 | spin_unlock_irq(lock: &rtc_lock); |
420 | |
421 | seq_printf(m: seq, fmt: "Checksum status: %svalid\n" , checksum ? "" : "not " ); |
422 | |
423 | seq_printf(m: seq, fmt: "# floppies : %d\n" , |
424 | (nvram[6] & 1) ? (nvram[6] >> 6) + 1 : 0); |
425 | seq_printf(m: seq, fmt: "Floppy 0 type : " ); |
426 | type = nvram[2] >> 4; |
427 | if (type < ARRAY_SIZE(floppy_types)) |
428 | seq_printf(m: seq, fmt: "%s\n" , floppy_types[type]); |
429 | else |
430 | seq_printf(m: seq, fmt: "%d (unknown)\n" , type); |
431 | seq_printf(m: seq, fmt: "Floppy 1 type : " ); |
432 | type = nvram[2] & 0x0f; |
433 | if (type < ARRAY_SIZE(floppy_types)) |
434 | seq_printf(m: seq, fmt: "%s\n" , floppy_types[type]); |
435 | else |
436 | seq_printf(m: seq, fmt: "%d (unknown)\n" , type); |
437 | |
438 | seq_printf(m: seq, fmt: "HD 0 type : " ); |
439 | type = nvram[4] >> 4; |
440 | if (type) |
441 | seq_printf(m: seq, fmt: "%02x\n" , type == 0x0f ? nvram[11] : type); |
442 | else |
443 | seq_printf(m: seq, fmt: "none\n" ); |
444 | |
445 | seq_printf(m: seq, fmt: "HD 1 type : " ); |
446 | type = nvram[4] & 0x0f; |
447 | if (type) |
448 | seq_printf(m: seq, fmt: "%02x\n" , type == 0x0f ? nvram[12] : type); |
449 | else |
450 | seq_printf(m: seq, fmt: "none\n" ); |
451 | |
452 | seq_printf(m: seq, fmt: "HD type 48 data: %d/%d/%d C/H/S, precomp %d, lz %d\n" , |
453 | nvram[18] | (nvram[19] << 8), |
454 | nvram[20], nvram[25], |
455 | nvram[21] | (nvram[22] << 8), nvram[23] | (nvram[24] << 8)); |
456 | seq_printf(m: seq, fmt: "HD type 49 data: %d/%d/%d C/H/S, precomp %d, lz %d\n" , |
457 | nvram[39] | (nvram[40] << 8), |
458 | nvram[41], nvram[46], |
459 | nvram[42] | (nvram[43] << 8), nvram[44] | (nvram[45] << 8)); |
460 | |
461 | seq_printf(m: seq, fmt: "DOS base memory: %d kB\n" , nvram[7] | (nvram[8] << 8)); |
462 | seq_printf(m: seq, fmt: "Extended memory: %d kB (configured), %d kB (tested)\n" , |
463 | nvram[9] | (nvram[10] << 8), nvram[34] | (nvram[35] << 8)); |
464 | |
465 | seq_printf(m: seq, fmt: "Gfx adapter : %s\n" , |
466 | gfx_types[(nvram[6] >> 4) & 3]); |
467 | |
468 | seq_printf(m: seq, fmt: "FPU : %sinstalled\n" , |
469 | (nvram[6] & 2) ? "" : "not " ); |
470 | |
471 | return; |
472 | } |
473 | |
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(lock: &rtc_lock); |
480 | for (i = 0; i < NVRAM_BYTES; ++i) |
481 | contents[i] = __nvram_read_byte(i); |
482 | spin_unlock_irq(lock: &rtc_lock); |
483 | |
484 | pc_nvram_proc_read(nvram: contents, seq, offset); |
485 | |
486 | return 0; |
487 | } |
488 | #endif /* CONFIG_X86 && CONFIG_PROC_FS */ |
489 | |
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 | |
510 | nvram_size = nvram_get_size(); |
511 | if (nvram_size < 0) |
512 | return nvram_size; |
513 | |
514 | ret = misc_register(misc: &nvram_misc); |
515 | if (ret) { |
516 | pr_err("nvram: can't misc_register on minor=%d\n" , NVRAM_MINOR); |
517 | return ret; |
518 | } |
519 | |
520 | #if defined(CONFIG_X86) && defined(CONFIG_PROC_FS) |
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(misc: &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 | { |
534 | #if defined(CONFIG_X86) && defined(CONFIG_PROC_FS) |
535 | remove_proc_entry("driver/nvram" , NULL); |
536 | #endif |
537 | misc_deregister(misc: &nvram_misc); |
538 | } |
539 | |
540 | module_init(nvram_module_init); |
541 | module_exit(nvram_module_exit); |
542 | |
543 | MODULE_LICENSE("GPL" ); |
544 | MODULE_ALIAS_MISCDEV(NVRAM_MINOR); |
545 | MODULE_ALIAS("devname:nvram" ); |
546 | |