projects / openwrt / openwrt.git / blob
? search:


32278b37785570a8ad870ea36fbfbe426c72e62e
[openwrt/openwrt.git] / target / linux / brcm-2.4 / files / arch / mips / bcm947xx / nvram_linux.c
1 /*
2 * NVRAM variable manipulation (Linux kernel half)
3 *
4 * Copyright 2006, Broadcom Corporation
5 * All Rights Reserved.
6 *
7 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
9 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
10 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
11 *
12 * $Id: nvram_linux.c,v 1.19 2006/04/08 07:12:42 honor Exp $
13 */
14
15 #include <linux/config.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/interrupt.h>
21 #include <linux/spinlock.h>
22 #include <linux/slab.h>
23 #include <linux/bootmem.h>
24 #include <linux/wrapper.h>
25 #include <linux/fs.h>
26 #include <linux/miscdevice.h>
27 #include <linux/mtd/mtd.h>
28 #include <asm/addrspace.h>
29 #include <asm/io.h>
30 #include <asm/uaccess.h>
31
32 #include <typedefs.h>
33 #include <osl.h>
34 #include <bcmendian.h>
35 #include <bcmnvram.h>
36 #include <sbconfig.h>
37 #include <sbchipc.h>
38 #include <sbutils.h>
39 #include <hndmips.h>
40 #include <sflash.h>
41
42 /* In BSS to minimize text size and page aligned so it can be mmap()-ed */
43 static char nvram_buf[NVRAM_SPACE] __attribute__((aligned(PAGE_SIZE)));
44
45 #ifdef MODULE
46
47 #define early_nvram_get(name) nvram_get(name)
48
49 #else /* !MODULE */
50
51 /* Global SB handle */
52 extern void *bcm947xx_sbh;
53 extern spinlock_t bcm947xx_sbh_lock;
54
55 static int cfe_env;
56 extern char *cfe_env_get(char *nv_buf, const char *name);
57
58 /* Convenience */
59 #define sbh bcm947xx_sbh
60 #define sbh_lock bcm947xx_sbh_lock
61 #define KB * 1024
62 #define MB * 1024 * 1024
63
64 /* Probe for NVRAM header */
65 static void __init
66 early_nvram_init(void)
67 {
68 struct nvram_header *header;
69 chipcregs_t *cc;
70 struct sflash *info = NULL;
71 int i;
72 uint32 base, off, lim;
73 u32 *src, *dst;
74
75 if ((cc = sb_setcore(sbh, SB_CC, 0)) != NULL) {
76 base = KSEG1ADDR(SB_FLASH2);
77 switch (readl(&cc->capabilities) & CC_CAP_FLASH_MASK) {
78 case PFLASH:
79 lim = SB_FLASH2_SZ;
80 break;
81
82 case SFLASH_ST:
83 case SFLASH_AT:
84 if ((info = sflash_init(sbh,cc)) == NULL)
85 return;
86 lim = info->size;
87 break;
88
89 case FLASH_NONE:
90 default:
91 return;
92 }
93 } else {
94 /* extif assumed, Stop at 4 MB */
95 base = KSEG1ADDR(SB_FLASH1);
96 lim = SB_FLASH1_SZ;
97 }
98
99 /* XXX: hack for supporting the CFE environment stuff on WGT634U */
100 src = (u32 *) KSEG1ADDR(base + 8 * 1024 * 1024 - 0x2000);
101 dst = (u32 *) nvram_buf;
102 if ((lim == 0x02000000) && ((*src & 0xff00ff) == 0x000001)) {
103 printk("early_nvram_init: WGT634U NVRAM found.\n");
104
105 for (i = 0; i < 0x1ff0; i++) {
106 if (*src == 0xFFFFFFFF)
107 break;
108 *dst++ = *src++;
109 }
110 cfe_env = 1;
111 return;
112 }
113
114 off = FLASH_MIN;
115 while (off <= lim) {
116 /* Windowed flash access */
117 header = (struct nvram_header *) KSEG1ADDR(base + off - NVRAM_SPACE);
118 if (header->magic == NVRAM_MAGIC)
119 goto found;
120 off <<= 1;
121 }
122
123 /* Try embedded NVRAM at 4 KB and 1 KB as last resorts */
124 header = (struct nvram_header *) KSEG1ADDR(base + 4 KB);
125 if (header->magic == NVRAM_MAGIC)
126 goto found;
127
128 header = (struct nvram_header *) KSEG1ADDR(base + 1 KB);
129 if (header->magic == NVRAM_MAGIC)
130 goto found;
131
132 printk("early_nvram_init: NVRAM not found\n");
133 return;
134
135 found:
136 src = (u32 *) header;
137 dst = (u32 *) nvram_buf;
138 for (i = 0; i < sizeof(struct nvram_header); i += 4)
139 *dst++ = *src++;
140 for (; i < header->len && i < NVRAM_SPACE; i += 4)
141 *dst++ = ltoh32(*src++);
142 }
143
144 /* Early (before mm or mtd) read-only access to NVRAM */
145 static char * __init
146 early_nvram_get(const char *name)
147 {
148 char *var, *value, *end, *eq;
149
150 if (!name)
151 return NULL;
152
153 /* Too early? */
154 if (sbh == NULL)
155 return NULL;
156
157 if (!nvram_buf[0])
158 early_nvram_init();
159
160 if (cfe_env)
161 return cfe_env_get(nvram_buf, name);
162
163 /* Look for name=value and return value */
164 var = &nvram_buf[sizeof(struct nvram_header)];
165 end = nvram_buf + sizeof(nvram_buf) - 2;
166 end[0] = end[1] = '\0';
167 for (; *var; var = value + strlen(value) + 1) {
168 if (!(eq = strchr(var, '=')))
169 break;
170 value = eq + 1;
171 if ((eq - var) == strlen(name) && strncmp(var, name, (eq - var)) == 0)
172 return value;
173 }
174
175 return NULL;
176 }
177
178 static int __init
179 early_nvram_getall(char *buf, int count)
180 {
181 char *var, *end;
182 int len = 0;
183
184 /* Too early? */
185 if (sbh == NULL)
186 return -1;
187
188 if (!nvram_buf[0])
189 early_nvram_init();
190
191 bzero(buf, count);
192
193 /* Write name=value\0 ... \0\0 */
194 var = &nvram_buf[sizeof(struct nvram_header)];
195 end = nvram_buf + sizeof(nvram_buf) - 2;
196 end[0] = end[1] = '\0';
197 for (; *var; var += strlen(var) + 1) {
198 if ((count - len) <= (strlen(var) + 1))
199 break;
200 len += sprintf(buf + len, "%s", var) + 1;
201 }
202
203 return 0;
204 }
205 #endif /* !MODULE */
206
207 extern char * _nvram_get(const char *name);
208 extern int _nvram_set(const char *name, const char *value);
209 extern int _nvram_unset(const char *name);
210 extern int _nvram_getall(char *buf, int count);
211 extern int _nvram_commit(struct nvram_header *header);
212 extern int _nvram_init(void *sbh);
213 extern void _nvram_exit(void);
214
215 /* Globals */
216 static spinlock_t nvram_lock = SPIN_LOCK_UNLOCKED;
217 static struct semaphore nvram_sem;
218 static unsigned long nvram_offset = 0;
219 static int nvram_major = -1;
220 static devfs_handle_t nvram_handle = NULL;
221 static struct mtd_info *nvram_mtd = NULL;
222
223 int
224 _nvram_read(char *buf)
225 {
226 struct nvram_header *header = (struct nvram_header *) buf;
227 size_t len;
228
229 if (!nvram_mtd ||
230 MTD_READ(nvram_mtd, nvram_mtd->size - NVRAM_SPACE, NVRAM_SPACE, &len, buf) ||
231 len != NVRAM_SPACE ||
232 header->magic != NVRAM_MAGIC) {
233 /* Maybe we can recover some data from early initialization */
234 memcpy(buf, nvram_buf, NVRAM_SPACE);
235 }
236
237 return 0;
238 }
239
240 struct nvram_tuple *
241 _nvram_realloc(struct nvram_tuple *t, const char *name, const char *value)
242 {
243 if ((nvram_offset + strlen(value) + 1) > NVRAM_SPACE)
244 return NULL;
245
246 if (!t) {
247 if (!(t = kmalloc(sizeof(struct nvram_tuple) + strlen(name) + 1, GFP_ATOMIC)))
248 return NULL;
249
250 /* Copy name */
251 t->name = (char *) &t[1];
252 strcpy(t->name, name);
253
254 t->value = NULL;
255 }
256
257 /* Copy value */
258 if (!t->value || strcmp(t->value, value)) {
259 t->value = &nvram_buf[nvram_offset];
260 strcpy(t->value, value);
261 nvram_offset += strlen(value) + 1;
262 }
263
264 return t;
265 }
266
267 void
268 _nvram_free(struct nvram_tuple *t)
269 {
270 if (!t)
271 nvram_offset = 0;
272 else
273 kfree(t);
274 }
275
276 int
277 nvram_set(const char *name, const char *value)
278 {
279 unsigned long flags;
280 int ret;
281 struct nvram_header *header;
282
283 spin_lock_irqsave(&nvram_lock, flags);
284 if ((ret = _nvram_set(name, value))) {
285 /* Consolidate space and try again */
286 if ((header = kmalloc(NVRAM_SPACE, GFP_ATOMIC))) {
287 if (_nvram_commit(header) == 0)
288 ret = _nvram_set(name, value);
289 kfree(header);
290 }
291 }
292 spin_unlock_irqrestore(&nvram_lock, flags);
293
294 return ret;
295 }
296
297 char *
298 real_nvram_get(const char *name)
299 {
300 unsigned long flags;
301 char *value;
302
303 spin_lock_irqsave(&nvram_lock, flags);
304 value = _nvram_get(name);
305 spin_unlock_irqrestore(&nvram_lock, flags);
306
307 return value;
308 }
309
310 char *
311 nvram_get(const char *name)
312 {
313 if (nvram_major >= 0)
314 return real_nvram_get(name);
315 else
316 return early_nvram_get(name);
317 }
318
319 int
320 nvram_unset(const char *name)
321 {
322 unsigned long flags;
323 int ret;
324
325 spin_lock_irqsave(&nvram_lock, flags);
326 ret = _nvram_unset(name);
327 spin_unlock_irqrestore(&nvram_lock, flags);
328
329 return ret;
330 }
331
332 static void
333 erase_callback(struct erase_info *done)
334 {
335 wait_queue_head_t *wait_q = (wait_queue_head_t *) done->priv;
336 wake_up(wait_q);
337 }
338
339 int
340 nvram_commit(void)
341 {
342 char *buf;
343 size_t erasesize, len, magic_len;
344 unsigned int i;
345 int ret;
346 struct nvram_header *header;
347 unsigned long flags;
348 u_int32_t offset;
349 DECLARE_WAITQUEUE(wait, current);
350 wait_queue_head_t wait_q;
351 struct erase_info erase;
352 u_int32_t magic_offset = 0; /* Offset for writing MAGIC # */
353
354 if (!nvram_mtd) {
355 printk("nvram_commit: NVRAM not found\n");
356 return -ENODEV;
357 }
358
359 if (in_interrupt()) {
360 printk("nvram_commit: not committing in interrupt\n");
361 return -EINVAL;
362 }
363
364 /* Backup sector blocks to be erased */
365 erasesize = ROUNDUP(NVRAM_SPACE, nvram_mtd->erasesize);
366 if (!(buf = kmalloc(erasesize, GFP_KERNEL))) {
367 printk("nvram_commit: out of memory\n");
368 return -ENOMEM;
369 }
370
371 down(&nvram_sem);
372
373 if ((i = erasesize - NVRAM_SPACE) > 0) {
374 offset = nvram_mtd->size - erasesize;
375 len = 0;
376 ret = MTD_READ(nvram_mtd, offset, i, &len, buf);
377 if (ret || len != i) {
378 printk("nvram_commit: read error ret = %d, len = %d/%d\n", ret, len, i);
379 ret = -EIO;
380 goto done;
381 }
382 header = (struct nvram_header *)(buf + i);
383 magic_offset = i + ((void *)&header->magic - (void *)header);
384 } else {
385 offset = nvram_mtd->size - NVRAM_SPACE;
386 magic_offset = ((void *)&header->magic - (void *)header);
387 header = (struct nvram_header *)buf;
388 }
389
390 /* clear the existing magic # to mark the NVRAM as unusable
391 we can pull MAGIC bits low without erase */
392 header->magic = NVRAM_CLEAR_MAGIC; /* All zeros magic */
393
394 /* Unlock sector blocks (for Intel 28F320C3B flash) , 20060309 */
395 if(nvram_mtd->unlock)
396 nvram_mtd->unlock(nvram_mtd, offset, nvram_mtd->erasesize);
397
398 ret = MTD_WRITE(nvram_mtd, offset + magic_offset, sizeof(header->magic),
399 &magic_len, (char *)&header->magic);
400 if (ret || magic_len != sizeof(header->magic)) {
401 printk("nvram_commit: clear MAGIC error\n");
402 ret = -EIO;
403 goto done;
404 }
405
406 header->magic = NVRAM_MAGIC; /* reset MAGIC before we regenerate the NVRAM,
407 otherwise we'll have an incorrect CRC */
408 /* Regenerate NVRAM */
409 spin_lock_irqsave(&nvram_lock, flags);
410 ret = _nvram_commit(header);
411 spin_unlock_irqrestore(&nvram_lock, flags);
412 if (ret)
413 goto done;
414
415 /* Erase sector blocks */
416 init_waitqueue_head(&wait_q);
417 for (; offset < nvram_mtd->size - NVRAM_SPACE + header->len; offset += nvram_mtd->erasesize) {
418 erase.mtd = nvram_mtd;
419 erase.addr = offset;
420 erase.len = nvram_mtd->erasesize;
421 erase.callback = erase_callback;
422 erase.priv = (u_long) &wait_q;
423
424 set_current_state(TASK_INTERRUPTIBLE);
425 add_wait_queue(&wait_q, &wait);
426
427 /* Unlock sector blocks */
428 if (nvram_mtd->unlock)
429 nvram_mtd->unlock(nvram_mtd, offset, nvram_mtd->erasesize);
430
431 if ((ret = MTD_ERASE(nvram_mtd, &erase))) {
432 set_current_state(TASK_RUNNING);
433 remove_wait_queue(&wait_q, &wait);
434 printk("nvram_commit: erase error\n");
435 goto done;
436 }
437
438 /* Wait for erase to finish */
439 schedule();
440 remove_wait_queue(&wait_q, &wait);
441 }
442
443 /* Write partition up to end of data area */
444 header->magic = NVRAM_INVALID_MAGIC; /* All ones magic */
445 offset = nvram_mtd->size - erasesize;
446 i = erasesize - NVRAM_SPACE + header->len;
447 ret = MTD_WRITE(nvram_mtd, offset, i, &len, buf);
448 if (ret || len != i) {
449 printk("nvram_commit: write error\n");
450 ret = -EIO;
451 goto done;
452 }
453
454 /* Now mark the NVRAM in flash as "valid" by setting the correct
455 MAGIC # */
456 header->magic = NVRAM_MAGIC;
457 ret = MTD_WRITE(nvram_mtd, offset + magic_offset, sizeof(header->magic),
458 &magic_len, (char *)&header->magic);
459 if (ret || magic_len != sizeof(header->magic)) {
460 printk("nvram_commit: write MAGIC error\n");
461 ret = -EIO;
462 goto done;
463 }
464
465 /*
466 * Reading a few bytes back here will put the device
467 * back to the correct mode on certain flashes */
468 offset = nvram_mtd->size - erasesize;
469 ret = MTD_READ(nvram_mtd, offset, 4, &len, buf);
470
471 done:
472 up(&nvram_sem);
473 kfree(buf);
474
475 return ret;
476 }
477
478 int
479 nvram_getall(char *buf, int count)
480 {
481 unsigned long flags;
482 int ret;
483
484 spin_lock_irqsave(&nvram_lock, flags);
485 if (nvram_major >= 0)
486 ret = _nvram_getall(buf, count);
487 else
488 ret = early_nvram_getall(buf, count);
489 spin_unlock_irqrestore(&nvram_lock, flags);
490
491 return ret;
492 }
493
494
495
496
497
498
499
500 /* User mode interface below */
501
502 static ssize_t
503 dev_nvram_read(struct file *file, char *buf, size_t count, loff_t *ppos)
504 {
505 char tmp[100], *name = tmp, *value;
506 ssize_t ret;
507 unsigned long off;
508
509 if (count > sizeof(tmp)) {
510 if (!(name = kmalloc(count, GFP_KERNEL)))
511 return -ENOMEM;
512 }
513
514 if (copy_from_user(name, buf, count)) {
515 ret = -EFAULT;
516 goto done;
517 }
518
519 if (*name == '\0') {
520 /* Get all variables */
521 ret = nvram_getall(name, count);
522 if (ret == 0) {
523 if (copy_to_user(buf, name, count)) {
524 ret = -EFAULT;
525 goto done;
526 }
527 ret = count;
528 }
529 } else {
530 if (!(value = nvram_get(name))) {
531 ret = 0;
532 goto done;
533 }
534
535 /* Provide the offset into mmap() space */
536 off = (unsigned long) value - (unsigned long) nvram_buf;
537
538 if (put_user(off, (unsigned long *) buf)) {
539 ret = -EFAULT;
540 goto done;
541 }
542
543 ret = sizeof(unsigned long);
544 }
545
546 flush_cache_all();
547
548 done:
549 if (name != tmp)
550 kfree(name);
551
552 return ret;
553 }
554
555 static ssize_t
556 dev_nvram_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
557 {
558 char tmp[100], *name = tmp, *value;
559 ssize_t ret;
560
561 if (count > sizeof(tmp)) {
562 if (!(name = kmalloc(count, GFP_KERNEL)))
563 return -ENOMEM;
564 }
565
566 if (copy_from_user(name, buf, count)) {
567 ret = -EFAULT;
568 goto done;
569 }
570
571 value = name;
572 name = strsep(&value, "=");
573 if (value)
574 ret = nvram_set(name, value) ? : count;
575 else
576 ret = nvram_unset(name) ? : count;
577
578 done:
579 if (name != tmp)
580 kfree(name);
581
582 return ret;
583 }
584
585 static int
586 dev_nvram_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
587 {
588 if (cmd != NVRAM_MAGIC)
589 return -EINVAL;
590
591 return nvram_commit();
592 }
593
594 static int
595 dev_nvram_mmap(struct file *file, struct vm_area_struct *vma)
596 {
597 unsigned long offset = virt_to_phys(nvram_buf);
598
599 if (remap_page_range(vma->vm_start, offset, vma->vm_end-vma->vm_start,
600 vma->vm_page_prot))
601 return -EAGAIN;
602
603 return 0;
604 }
605
606 static int
607 dev_nvram_open(struct inode *inode, struct file * file)
608 {
609 MOD_INC_USE_COUNT;
610 return 0;
611 }
612
613 static int
614 dev_nvram_release(struct inode *inode, struct file * file)
615 {
616 MOD_DEC_USE_COUNT;
617 return 0;
618 }
619
620 static struct file_operations dev_nvram_fops = {
621 owner: THIS_MODULE,
622 open: dev_nvram_open,
623 release: dev_nvram_release,
624 read: dev_nvram_read,
625 write: dev_nvram_write,
626 ioctl: dev_nvram_ioctl,
627 mmap: dev_nvram_mmap,
628 };
629
630 static void
631 dev_nvram_exit(void)
632 {
633 int order = 0;
634 struct page *page, *end;
635
636 if (nvram_handle)
637 devfs_unregister(nvram_handle);
638
639 if (nvram_major >= 0)
640 devfs_unregister_chrdev(nvram_major, "nvram");
641
642 if (nvram_mtd)
643 put_mtd_device(nvram_mtd);
644
645 while ((PAGE_SIZE << order) < NVRAM_SPACE)
646 order++;
647 end = virt_to_page(nvram_buf + (PAGE_SIZE << order) - 1);
648 for (page = virt_to_page(nvram_buf); page <= end; page++)
649 mem_map_unreserve(page);
650
651 _nvram_exit();
652 }
653
654 static int __init
655 dev_nvram_init(void)
656 {
657 int order = 0, ret = 0;
658 struct page *page, *end;
659 unsigned int i;
660
661 /* Allocate and reserve memory to mmap() */
662 while ((PAGE_SIZE << order) < NVRAM_SPACE)
663 order++;
664 end = virt_to_page(nvram_buf + (PAGE_SIZE << order) - 1);
665 for (page = virt_to_page(nvram_buf); page <= end; page++)
666 mem_map_reserve(page);
667
668 #ifdef CONFIG_MTD
669 /* Find associated MTD device */
670 for (i = 0; i < MAX_MTD_DEVICES; i++) {
671 nvram_mtd = get_mtd_device(NULL, i);
672 if (nvram_mtd) {
673 if (!strcmp(nvram_mtd->name, "nvram") &&
674 nvram_mtd->size >= NVRAM_SPACE)
675 break;
676 put_mtd_device(nvram_mtd);
677 }
678 }
679 if (i >= MAX_MTD_DEVICES)
680 nvram_mtd = NULL;
681 #endif
682
683 /* Initialize hash table lock */
684 spin_lock_init(&nvram_lock);
685
686 /* Initialize commit semaphore */
687 init_MUTEX(&nvram_sem);
688
689 /* Register char device */
690 if ((nvram_major = devfs_register_chrdev(0, "nvram", &dev_nvram_fops)) < 0) {
691 ret = nvram_major;
692 goto err;
693 }
694
695 /* Initialize hash table */
696 _nvram_init(sbh);
697
698 /* Create /dev/nvram handle */
699 nvram_handle = devfs_register(NULL, "nvram", DEVFS_FL_NONE, nvram_major, 0,
700 S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, &dev_nvram_fops, NULL);
701
702 /* Set the SDRAM NCDL value into NVRAM if not already done */
703 if (getintvar(NULL, "sdram_ncdl") == 0) {
704 unsigned int ncdl;
705 char buf[] = "0x00000000";
706
707 if ((ncdl = sb_memc_get_ncdl(sbh))) {
708 sprintf(buf, "0x%08x", ncdl);
709 nvram_set("sdram_ncdl", buf);
710 nvram_commit();
711 }
712 }
713
714 return 0;
715
716 err:
717 dev_nvram_exit();
718 return ret;
719 }
720
721 module_init(dev_nvram_init);
722 module_exit(dev_nvram_exit);
OpenWrt Source Repository