xref: /openbmc/linux/drivers/char/nvram.c (revision df561f66)
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 
__nvram_read_byte(int i)84 static unsigned char __nvram_read_byte(int i)
85 {
86 	return CMOS_READ(NVRAM_FIRST_BYTE + i);
87 }
88 
pc_nvram_read_byte(int i)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(&rtc_lock, flags);
97 	return c;
98 }
99 
100 /* This races nicely with trying to read with checksum checking (nvram_read) */
__nvram_write_byte(unsigned char c,int i)101 static void __nvram_write_byte(unsigned char c, int i)
102 {
103 	CMOS_WRITE(c, NVRAM_FIRST_BYTE + i);
104 }
105 
pc_nvram_write_byte(unsigned char c,int i)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(&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 
__nvram_check_checksum(void)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 
__nvram_set_checksum(void)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(sum >> 8, PC_CKS_LOC);
141 	__nvram_write_byte(sum & 0xff, PC_CKS_LOC + 1);
142 }
143 
pc_nvram_set_checksum(void)144 static long pc_nvram_set_checksum(void)
145 {
146 	spin_lock_irq(&rtc_lock);
147 	__nvram_set_checksum();
148 	spin_unlock_irq(&rtc_lock);
149 	return 0;
150 }
151 
pc_nvram_initialize(void)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);
159 	__nvram_set_checksum();
160 	spin_unlock_irq(&rtc_lock);
161 	return 0;
162 }
163 
pc_nvram_get_size(void)164 static ssize_t pc_nvram_get_size(void)
165 {
166 	return NVRAM_BYTES;
167 }
168 
pc_nvram_read(char * buf,size_t count,loff_t * ppos)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 
pc_nvram_write(char * buf,size_t count,loff_t * ppos)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 
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 
nvram_misc_llseek(struct file * file,loff_t offset,int origin)222 static loff_t nvram_misc_llseek(struct file *file, loff_t offset, int origin)
223 {
224 	return generic_file_llseek_size(file, offset, origin, MAX_LFS_FILESIZE,
225 					nvram_size);
226 }
227 
nvram_misc_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)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(count, GFP_KERNEL);
242 	if (!tmp)
243 		return -ENOMEM;
244 
245 	ret = nvram_read(tmp, count, ppos);
246 	if (ret <= 0)
247 		goto out;
248 
249 	if (copy_to_user(buf, tmp, ret)) {
250 		*ppos -= ret;
251 		ret = -EFAULT;
252 	}
253 
254 out:
255 	kfree(tmp);
256 	return ret;
257 }
258 
nvram_misc_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)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(tmp))
273 		return PTR_ERR(tmp);
274 
275 	ret = nvram_write(tmp, count, ppos);
276 	kfree(tmp);
277 	return ret;
278 }
279 
nvram_misc_ioctl(struct file * file,unsigned int cmd,unsigned long arg)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(&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(&nvram_mutex);
343 		}
344 		break;
345 #endif /* CONFIG_X86 || CONFIG_M68K */
346 	}
347 	return ret;
348 }
349 
nvram_misc_open(struct inode * inode,struct file * file)350 static int nvram_misc_open(struct inode *inode, struct file *file)
351 {
352 	spin_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(&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(&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(&nvram_state_lock);
377 
378 	return 0;
379 }
380 
nvram_misc_release(struct inode * inode,struct file * file)381 static int nvram_misc_release(struct inode *inode, struct file *file)
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;
390 	if (file->f_mode & FMODE_WRITE)
391 		nvram_open_mode &= ~NVRAM_WRITE;
392 
393 	spin_unlock(&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 
pc_nvram_proc_read(unsigned char * nvram,struct seq_file * seq,void * offset)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(&rtc_lock);
418 	checksum = __nvram_check_checksum();
419 	spin_unlock_irq(&rtc_lock);
420 
421 	seq_printf(seq, "Checksum status: %svalid\n", checksum ? "" : "not ");
422 
423 	seq_printf(seq, "# floppies     : %d\n",
424 	    (nvram[6] & 1) ? (nvram[6] >> 6) + 1 : 0);
425 	seq_printf(seq, "Floppy 0 type  : ");
426 	type = nvram[2] >> 4;
427 	if (type < ARRAY_SIZE(floppy_types))
428 		seq_printf(seq, "%s\n", floppy_types[type]);
429 	else
430 		seq_printf(seq, "%d (unknown)\n", type);
431 	seq_printf(seq, "Floppy 1 type  : ");
432 	type = nvram[2] & 0x0f;
433 	if (type < ARRAY_SIZE(floppy_types))
434 		seq_printf(seq, "%s\n", floppy_types[type]);
435 	else
436 		seq_printf(seq, "%d (unknown)\n", type);
437 
438 	seq_printf(seq, "HD 0 type      : ");
439 	type = nvram[4] >> 4;
440 	if (type)
441 		seq_printf(seq, "%02x\n", type == 0x0f ? nvram[11] : type);
442 	else
443 		seq_printf(seq, "none\n");
444 
445 	seq_printf(seq, "HD 1 type      : ");
446 	type = nvram[4] & 0x0f;
447 	if (type)
448 		seq_printf(seq, "%02x\n", type == 0x0f ? nvram[12] : type);
449 	else
450 		seq_printf(seq, "none\n");
451 
452 	seq_printf(seq, "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(seq, "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(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",
463 	    nvram[9] | (nvram[10] << 8), nvram[34] | (nvram[35] << 8));
464 
465 	seq_printf(seq, "Gfx adapter    : %s\n",
466 	    gfx_types[(nvram[6] >> 4) & 3]);
467 
468 	seq_printf(seq, "FPU            : %sinstalled\n",
469 	    (nvram[6] & 2) ? "" : "not ");
470 
471 	return;
472 }
473 
nvram_proc_read(struct seq_file * seq,void * offset)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 }
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 
nvram_module_init(void)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(&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(&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 
nvram_module_exit(void)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(&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