2 * NVRAM variable manipulation (Linux kernel half)
4 * Copyright 2006, Broadcom Corporation
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.
14 #include <linux/config.h>
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/interrupt.h>
20 #include <linux/spinlock.h>
21 #include <linux/slab.h>
22 #include <linux/bootmem.h>
23 #include <linux/wrapper.h>
25 #include <linux/miscdevice.h>
26 #include <linux/mtd/mtd.h>
27 #include <asm/addrspace.h>
29 #include <asm/uaccess.h>
33 #include <bcmendian.h>
41 /* In BSS to minimize text size and page aligned so it can be mmap()-ed */
42 static char nvram_buf
[NVRAM_SPACE
] __attribute__((aligned(PAGE_SIZE
)));
46 #define early_nvram_get(name) nvram_get(name)
50 /* Global SB handle */
51 extern void *bcm947xx_sbh
;
52 extern spinlock_t bcm947xx_sbh_lock
;
55 extern char *cfe_env_get(char *nv_buf
, const char *name
);
58 #define sbh bcm947xx_sbh
59 #define sbh_lock bcm947xx_sbh_lock
61 #define MB * 1024 * 1024
63 /* Probe for NVRAM header */
65 early_nvram_init(void)
67 struct nvram_header
*header
;
69 struct sflash
*info
= NULL
;
71 uint32 base
, off
, lim
;
74 if ((cc
= sb_setcore(sbh
, SB_CC
, 0)) != NULL
) {
75 base
= KSEG1ADDR(SB_FLASH2
);
76 switch (readl(&cc
->capabilities
) & CC_CAP_FLASH_MASK
) {
83 if ((info
= sflash_init(sbh
,cc
)) == NULL
)
93 /* extif assumed, Stop at 4 MB */
94 base
= KSEG1ADDR(SB_FLASH1
);
98 /* XXX: hack for supporting the CFE environment stuff on WGT634U */
99 src
= (u32
*) KSEG1ADDR(base
+ 8 * 1024 * 1024 - 0x2000);
100 dst
= (u32
*) nvram_buf
;
101 if ((lim
== 0x02000000) && ((*src
& 0xff00ff) == 0x000001)) {
102 printk("early_nvram_init: WGT634U NVRAM found.\n");
104 for (i
= 0; i
< 0x1ff0; i
++) {
105 if (*src
== 0xFFFFFFFF)
115 /* Windowed flash access */
116 header
= (struct nvram_header
*) KSEG1ADDR(base
+ off
- NVRAM_SPACE
);
117 if (header
->magic
== NVRAM_MAGIC
)
122 /* Try embedded NVRAM at 4 KB and 1 KB as last resorts */
123 header
= (struct nvram_header
*) KSEG1ADDR(base
+ 4 KB
);
124 if (header
->magic
== NVRAM_MAGIC
)
127 header
= (struct nvram_header
*) KSEG1ADDR(base
+ 1 KB
);
128 if (header
->magic
== NVRAM_MAGIC
)
131 printk("early_nvram_init: NVRAM not found\n");
135 src
= (u32
*) header
;
136 dst
= (u32
*) nvram_buf
;
137 for (i
= 0; i
< sizeof(struct nvram_header
); i
+= 4)
139 for (; i
< header
->len
&& i
< NVRAM_SPACE
; i
+= 4)
140 *dst
++ = ltoh32(*src
++);
143 /* Early (before mm or mtd) read-only access to NVRAM */
145 early_nvram_get(const char *name
)
147 char *var
, *value
, *end
, *eq
;
160 return cfe_env_get(nvram_buf
, name
);
162 /* Look for name=value and return value */
163 var
= &nvram_buf
[sizeof(struct nvram_header
)];
164 end
= nvram_buf
+ sizeof(nvram_buf
) - 2;
165 end
[0] = end
[1] = '\0';
166 for (; *var
; var
= value
+ strlen(value
) + 1) {
167 if (!(eq
= strchr(var
, '=')))
170 if ((eq
- var
) == strlen(name
) && strncmp(var
, name
, (eq
- var
)) == 0)
178 early_nvram_getall(char *buf
, int count
)
192 /* Write name=value\0 ... \0\0 */
193 var
= &nvram_buf
[sizeof(struct nvram_header
)];
194 end
= nvram_buf
+ sizeof(nvram_buf
) - 2;
195 end
[0] = end
[1] = '\0';
196 for (; *var
; var
+= strlen(var
) + 1) {
197 if ((count
- len
) <= (strlen(var
) + 1))
199 len
+= sprintf(buf
+ len
, "%s", var
) + 1;
206 extern char * _nvram_get(const char *name
);
207 extern int _nvram_set(const char *name
, const char *value
);
208 extern int _nvram_unset(const char *name
);
209 extern int _nvram_getall(char *buf
, int count
);
210 extern int _nvram_commit(struct nvram_header
*header
);
211 extern int _nvram_init(void *sbh
);
212 extern void _nvram_exit(void);
215 static spinlock_t nvram_lock
= SPIN_LOCK_UNLOCKED
;
216 static struct semaphore nvram_sem
;
217 static unsigned long nvram_offset
= 0;
218 static int nvram_major
= -1;
219 static devfs_handle_t nvram_handle
= NULL
;
220 static struct mtd_info
*nvram_mtd
= NULL
;
223 _nvram_read(char *buf
)
225 struct nvram_header
*header
= (struct nvram_header
*) buf
;
229 MTD_READ(nvram_mtd
, nvram_mtd
->size
- NVRAM_SPACE
, NVRAM_SPACE
, &len
, buf
) ||
230 len
!= NVRAM_SPACE
||
231 header
->magic
!= NVRAM_MAGIC
) {
232 /* Maybe we can recover some data from early initialization */
233 memcpy(buf
, nvram_buf
, NVRAM_SPACE
);
240 _nvram_realloc(struct nvram_tuple
*t
, const char *name
, const char *value
)
242 if ((nvram_offset
+ strlen(value
) + 1) > NVRAM_SPACE
)
246 if (!(t
= kmalloc(sizeof(struct nvram_tuple
) + strlen(name
) + 1, GFP_ATOMIC
)))
250 t
->name
= (char *) &t
[1];
251 strcpy(t
->name
, name
);
257 if (!t
->value
|| strcmp(t
->value
, value
)) {
258 t
->value
= &nvram_buf
[nvram_offset
];
259 strcpy(t
->value
, value
);
260 nvram_offset
+= strlen(value
) + 1;
267 _nvram_free(struct nvram_tuple
*t
)
276 nvram_set(const char *name
, const char *value
)
280 struct nvram_header
*header
;
282 spin_lock_irqsave(&nvram_lock
, flags
);
283 if ((ret
= _nvram_set(name
, value
))) {
284 /* Consolidate space and try again */
285 if ((header
= kmalloc(NVRAM_SPACE
, GFP_ATOMIC
))) {
286 if (_nvram_commit(header
) == 0)
287 ret
= _nvram_set(name
, value
);
291 spin_unlock_irqrestore(&nvram_lock
, flags
);
297 real_nvram_get(const char *name
)
302 spin_lock_irqsave(&nvram_lock
, flags
);
303 value
= _nvram_get(name
);
304 spin_unlock_irqrestore(&nvram_lock
, flags
);
310 nvram_get(const char *name
)
312 if (nvram_major
>= 0)
313 return real_nvram_get(name
);
315 return early_nvram_get(name
);
319 nvram_unset(const char *name
)
324 spin_lock_irqsave(&nvram_lock
, flags
);
325 ret
= _nvram_unset(name
);
326 spin_unlock_irqrestore(&nvram_lock
, flags
);
332 erase_callback(struct erase_info
*done
)
334 wait_queue_head_t
*wait_q
= (wait_queue_head_t
*) done
->priv
;
342 size_t erasesize
, len
, magic_len
;
345 struct nvram_header
*header
;
348 DECLARE_WAITQUEUE(wait
, current
);
349 wait_queue_head_t wait_q
;
350 struct erase_info erase
;
351 u_int32_t magic_offset
= 0; /* Offset for writing MAGIC # */
354 printk("nvram_commit: NVRAM not found\n");
358 if (in_interrupt()) {
359 printk("nvram_commit: not committing in interrupt\n");
363 /* Backup sector blocks to be erased */
364 erasesize
= ROUNDUP(NVRAM_SPACE
, nvram_mtd
->erasesize
);
365 if (!(buf
= kmalloc(erasesize
, GFP_KERNEL
))) {
366 printk("nvram_commit: out of memory\n");
372 if ((i
= erasesize
- NVRAM_SPACE
) > 0) {
373 offset
= nvram_mtd
->size
- erasesize
;
375 ret
= MTD_READ(nvram_mtd
, offset
, i
, &len
, buf
);
376 if (ret
|| len
!= i
) {
377 printk("nvram_commit: read error ret = %d, len = %d/%d\n", ret
, len
, i
);
381 header
= (struct nvram_header
*)(buf
+ i
);
382 magic_offset
= i
+ ((void *)&header
->magic
- (void *)header
);
384 offset
= nvram_mtd
->size
- NVRAM_SPACE
;
385 magic_offset
= ((void *)&header
->magic
- (void *)header
);
386 header
= (struct nvram_header
*)buf
;
389 /* clear the existing magic # to mark the NVRAM as unusable
390 we can pull MAGIC bits low without erase */
391 header
->magic
= NVRAM_CLEAR_MAGIC
; /* All zeros magic */
393 /* Unlock sector blocks (for Intel 28F320C3B flash) , 20060309 */
394 if(nvram_mtd
->unlock
)
395 nvram_mtd
->unlock(nvram_mtd
, offset
, nvram_mtd
->erasesize
);
397 ret
= MTD_WRITE(nvram_mtd
, offset
+ magic_offset
, sizeof(header
->magic
),
398 &magic_len
, (char *)&header
->magic
);
399 if (ret
|| magic_len
!= sizeof(header
->magic
)) {
400 printk("nvram_commit: clear MAGIC error\n");
405 header
->magic
= NVRAM_MAGIC
; /* reset MAGIC before we regenerate the NVRAM,
406 otherwise we'll have an incorrect CRC */
407 /* Regenerate NVRAM */
408 spin_lock_irqsave(&nvram_lock
, flags
);
409 ret
= _nvram_commit(header
);
410 spin_unlock_irqrestore(&nvram_lock
, flags
);
414 /* Erase sector blocks */
415 init_waitqueue_head(&wait_q
);
416 for (; offset
< nvram_mtd
->size
- NVRAM_SPACE
+ header
->len
; offset
+= nvram_mtd
->erasesize
) {
417 erase
.mtd
= nvram_mtd
;
419 erase
.len
= nvram_mtd
->erasesize
;
420 erase
.callback
= erase_callback
;
421 erase
.priv
= (u_long
) &wait_q
;
423 set_current_state(TASK_INTERRUPTIBLE
);
424 add_wait_queue(&wait_q
, &wait
);
426 /* Unlock sector blocks */
427 if (nvram_mtd
->unlock
)
428 nvram_mtd
->unlock(nvram_mtd
, offset
, nvram_mtd
->erasesize
);
430 if ((ret
= MTD_ERASE(nvram_mtd
, &erase
))) {
431 set_current_state(TASK_RUNNING
);
432 remove_wait_queue(&wait_q
, &wait
);
433 printk("nvram_commit: erase error\n");
437 /* Wait for erase to finish */
439 remove_wait_queue(&wait_q
, &wait
);
442 /* Write partition up to end of data area */
443 header
->magic
= NVRAM_INVALID_MAGIC
; /* All ones magic */
444 offset
= nvram_mtd
->size
- erasesize
;
445 i
= erasesize
- NVRAM_SPACE
+ header
->len
;
446 ret
= MTD_WRITE(nvram_mtd
, offset
, i
, &len
, buf
);
447 if (ret
|| len
!= i
) {
448 printk("nvram_commit: write error\n");
453 /* Now mark the NVRAM in flash as "valid" by setting the correct
455 header
->magic
= NVRAM_MAGIC
;
456 ret
= MTD_WRITE(nvram_mtd
, offset
+ magic_offset
, sizeof(header
->magic
),
457 &magic_len
, (char *)&header
->magic
);
458 if (ret
|| magic_len
!= sizeof(header
->magic
)) {
459 printk("nvram_commit: write MAGIC error\n");
465 * Reading a few bytes back here will put the device
466 * back to the correct mode on certain flashes */
467 offset
= nvram_mtd
->size
- erasesize
;
468 ret
= MTD_READ(nvram_mtd
, offset
, 4, &len
, buf
);
478 nvram_getall(char *buf
, int count
)
483 spin_lock_irqsave(&nvram_lock
, flags
);
484 if (nvram_major
>= 0)
485 ret
= _nvram_getall(buf
, count
);
487 ret
= early_nvram_getall(buf
, count
);
488 spin_unlock_irqrestore(&nvram_lock
, flags
);
499 /* User mode interface below */
502 dev_nvram_read(struct file
*file
, char *buf
, size_t count
, loff_t
*ppos
)
504 char tmp
[100], *name
= tmp
, *value
;
508 if (count
> sizeof(tmp
)) {
509 if (!(name
= kmalloc(count
, GFP_KERNEL
)))
513 if (copy_from_user(name
, buf
, count
)) {
519 /* Get all variables */
520 ret
= nvram_getall(name
, count
);
522 if (copy_to_user(buf
, name
, count
)) {
529 if (!(value
= nvram_get(name
))) {
534 /* Provide the offset into mmap() space */
535 off
= (unsigned long) value
- (unsigned long) nvram_buf
;
537 if (put_user(off
, (unsigned long *) buf
)) {
542 ret
= sizeof(unsigned long);
555 dev_nvram_write(struct file
*file
, const char *buf
, size_t count
, loff_t
*ppos
)
557 char tmp
[100], *name
= tmp
, *value
;
560 if (count
> sizeof(tmp
)) {
561 if (!(name
= kmalloc(count
, GFP_KERNEL
)))
565 if (copy_from_user(name
, buf
, count
)) {
571 name
= strsep(&value
, "=");
573 ret
= nvram_set(name
, value
) ? : count
;
575 ret
= nvram_unset(name
) ? : count
;
585 dev_nvram_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
587 if (cmd
!= NVRAM_MAGIC
)
590 return nvram_commit();
594 dev_nvram_mmap(struct file
*file
, struct vm_area_struct
*vma
)
596 unsigned long offset
= virt_to_phys(nvram_buf
);
598 if (remap_page_range(vma
->vm_start
, offset
, vma
->vm_end
-vma
->vm_start
,
606 dev_nvram_open(struct inode
*inode
, struct file
* file
)
613 dev_nvram_release(struct inode
*inode
, struct file
* file
)
619 static struct file_operations dev_nvram_fops
= {
621 open
: dev_nvram_open
,
622 release
: dev_nvram_release
,
623 read
: dev_nvram_read
,
624 write
: dev_nvram_write
,
625 ioctl
: dev_nvram_ioctl
,
626 mmap
: dev_nvram_mmap
,
633 struct page
*page
, *end
;
636 devfs_unregister(nvram_handle
);
638 if (nvram_major
>= 0)
639 devfs_unregister_chrdev(nvram_major
, "nvram");
642 put_mtd_device(nvram_mtd
);
644 while ((PAGE_SIZE
<< order
) < NVRAM_SPACE
)
646 end
= virt_to_page(nvram_buf
+ (PAGE_SIZE
<< order
) - 1);
647 for (page
= virt_to_page(nvram_buf
); page
<= end
; page
++)
648 mem_map_unreserve(page
);
656 int order
= 0, ret
= 0;
657 struct page
*page
, *end
;
660 /* Allocate and reserve memory to mmap() */
661 while ((PAGE_SIZE
<< order
) < NVRAM_SPACE
)
663 end
= virt_to_page(nvram_buf
+ (PAGE_SIZE
<< order
) - 1);
664 for (page
= virt_to_page(nvram_buf
); page
<= end
; page
++)
665 mem_map_reserve(page
);
668 /* Find associated MTD device */
669 for (i
= 0; i
< MAX_MTD_DEVICES
; i
++) {
670 nvram_mtd
= get_mtd_device(NULL
, i
);
672 if (!strcmp(nvram_mtd
->name
, "nvram") &&
673 nvram_mtd
->size
>= NVRAM_SPACE
)
675 put_mtd_device(nvram_mtd
);
678 if (i
>= MAX_MTD_DEVICES
)
682 /* Initialize hash table lock */
683 spin_lock_init(&nvram_lock
);
685 /* Initialize commit semaphore */
686 init_MUTEX(&nvram_sem
);
688 /* Register char device */
689 if ((nvram_major
= devfs_register_chrdev(0, "nvram", &dev_nvram_fops
)) < 0) {
694 /* Initialize hash table */
697 /* Create /dev/nvram handle */
698 nvram_handle
= devfs_register(NULL
, "nvram", DEVFS_FL_NONE
, nvram_major
, 0,
699 S_IFCHR
| S_IRUSR
| S_IWUSR
| S_IRGRP
, &dev_nvram_fops
, NULL
);
701 /* Set the SDRAM NCDL value into NVRAM if not already done */
702 if (getintvar(NULL
, "sdram_ncdl") == 0) {
704 char buf
[] = "0x00000000";
706 if ((ncdl
= sb_memc_get_ncdl(sbh
))) {
707 sprintf(buf
, "0x%08x", ncdl
);
708 nvram_set("sdram_ncdl", buf
);
720 module_init(dev_nvram_init
);
721 module_exit(dev_nvram_exit
);