2 * NVRAM variable manipulation (Linux kernel half)
6 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
7 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
9 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
11 * $Id: nvram_linux.c,v 1.8 2008/07/04 01:15:09 Exp $
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>
24 #include <linux/miscdevice.h>
25 #include <linux/mtd/mtd.h>
26 //#include <mtd/mtd-user.h>
27 #include <asm/addrspace.h>
29 #include <asm/uaccess.h>
30 #include <asm/cacheflush.h>
33 #include <bcmendian.h>
41 #include <linux/delay.h>
46 /* In BSS to minimize text size and page aligned so it can be mmap()-ed */
47 static char nvram_buf
[NVRAM_SPACE
] __attribute__((aligned(PAGE_SIZE
)));
48 static char *nvram_commit_buf
= NULL
;
50 //#define CFE_UPDATE // added by Chen-I for mac/regulation update
52 //#include <sbextif.h>
54 extern void bcm947xx_watchdog_disable(void);
56 #define CFE_SPACE 256*1024
57 #define CFE_NVRAM_START 0x00000
58 #define CFE_NVRAM_END 0x01fff
59 #define CFE_NVRAM_SPACE 64*1024
60 static struct mtd_info
*cfe_mtd
= NULL
;
61 static char *CFE_NVRAM_PREFIX
="asuscfe";
62 static char *CFE_NVRAM_COMMIT
="asuscfecommit";
63 static char *CFE_NVRAM_WATCHDOG
="asuscfewatchdog";
64 char *cfe_buf
;// = NULL;
65 struct nvram_header
*cfe_nvram_header
; // = NULL;
67 static u_int32_t cfe_offset
;
68 static u_int32_t cfe_embedded_size
;
69 static int get_embedded_block(struct mtd_info
*mtd
, char *buf
, size_t erasesize
,
70 u_int32_t
*offset
, struct nvram_header
**header
, u_int32_t
*emb_size
);
72 static int cfe_init(void);
73 static int cfe_update(const char *keyword
, const char *value
);
74 static int cfe_dump(void);
75 static int cfe_commit(void);
83 #define early_nvram_get(name) nvram_get(name)
87 /* Global SB handle */
88 extern si_t
*bcm947xx_sih
;
89 extern spinlock_t bcm947xx_sih_lock
;
92 #define sih bcm947xx_sih
93 #define sih_lock bcm947xx_sih_lock
95 #define MB * 1024 * 1024
97 //#define NLS_XFR 1 /* added by Jiahao for WL500gP */
100 #include <linux/nls.h>
102 static char *NLS_NVRAM_U2C
="asusnlsu2c";
103 static char *NLS_NVRAM_C2U
="asusnlsc2u";
109 asusnls_u2c(char *name
)
113 struct nls_table
*nls
;
116 strcpy(codebuf
, name
);
117 codepage
=codebuf
+strlen(NLS_NVRAM_U2C
);
118 if((xfrstr
=strchr(codepage
, '_')))
122 /* debug message, start */
124 printk("%s, xfr from utf8 to %s\n", xfrstr, codepage);
126 printk("utf8: %d, ", strlen(xfrstr));
127 for(j=0;j<strlen(xfrstr);j++)
128 printk("%X ", (unsigned char)xfrstr[j]);
131 /* debug message, end */
133 nls
=load_nls(codepage
);
136 printk("NLS table is null!!\n");
140 if (ret
=utf8_mbstowcs(unibuf
, xfrstr
, strlen(xfrstr
)))
143 for (i
= 0; (i
< ret
) && unibuf
[i
]; i
++) {
145 charlen
= nls
->uni2char(unibuf
[i
], &name
[len
], NLS_MAX_CHARSET_SIZE
);
159 /* debug message, start */
162 printk("unicode: %d, ", ret);
164 printk("%X ", unibuf[i]);
166 printk("local: %d, ", strlen(name));
167 for (i=0;i<strlen(name);i++)
168 printk("%X ", (unsigned char)name[i]);
170 printk("local: %s\n", name);
172 /* debug message, end */
176 printk("can not xfr from utf8 to %s\n", codepage
);
188 asusnls_c2u(char *name
)
192 struct nls_table
*nls
;
195 strcpy(codebuf
, name
);
196 codepage
=codebuf
+strlen(NLS_NVRAM_C2U
);
197 if((xfrstr
=strchr(codepage
, '_')))
202 /* debug message, start */
204 printk("%s, xfr from %s to utf8\n", xfrstr, codepage);
205 printk("local: %d, ", strlen(xfrstr));
207 for (j=0;j<strlen(xfrstr);j++)
208 printk("%X ", (unsigned char)xfrstr[j]);
210 printk("local: %s\n", xfrstr);
212 /* debug message, end */
215 nls
=load_nls(codepage
);
218 printk("NLS table is null!!\n");
224 int len
= strlen(xfrstr
);
225 for (i
= 0; len
&& *xfrstr
; i
++, xfrstr
+= charlen
, len
-= charlen
) { /* string to unicode */
226 charlen
= nls
->char2uni(xfrstr
, len
, &unibuf
[i
]);
228 //unibuf[i] = 0x003f; /* a question mark */
236 ret
=utf8_wcstombs(name
, unibuf
, 1024); /* unicode to utf-8, 1024 is size of array unibuf */
239 /* debug message, start */
242 printk("unicode: %d, ", i);
244 printk("%X ", unibuf[k]);
246 printk("utf-8: %s, %d, ", name, strlen(name));
247 for (i=0;i<strlen(name);i++)
248 printk("%X ", (unsigned char)name[i]);
251 /* debug message, end */
254 printk("can not xfr from %s to utf8\n", codepage
);
272 printk("nvram xfr 1: %s\n", buf
);
273 if (copy_from_user(name
, buf
, strlen(buf
)+1)) {
278 if (strncmp(tmpbuf
, NLS_NVRAM_U2C
, strlen(NLS_NVRAM_U2C
))==0)
282 else if (strncmp(buf
, NLS_NVRAM_C2U
, strlen(NLS_NVRAM_C2U
))==0)
289 printk("nvram xfr 2: %s\n", tmpbuf
);
292 if (copy_to_user(buf
, tmpbuf
, strlen(tmpbuf
)+1))
297 printk("nvram xfr 3: %s\n", tmpbuf
);
306 nvram_valid(struct nvram_header
*header
)
308 return (header
->magic
== NVRAM_MAGIC
) &&
309 (header
->len
>= sizeof(struct nvram_header
)) && (header
->len
<= NVRAM_SPACE
)
311 && (nvram_calc_crc(header
) == (uint8
) header
->crc_ver_init
))
316 /* Probe for NVRAM header */
318 early_nvram_init(void)
320 struct nvram_header
*header
;
322 struct sflash
*info
= NULL
;
324 uint32 base
, off
, lim
;
326 #ifdef NFLASH_SUPPORT
328 struct nflash
*nfl_info
= NULL
;
332 if ((cc
= si_setcore(sih
, CC_CORE_ID
, 0)) != NULL
) {
333 #ifdef NFLASH_SUPPORT
334 if ((sih
->ccrev
>= 38) && ((sih
->chipst
& (1 << 4)) != 0)) {
336 base
= KSEG1ADDR(SI_FLASH1
);
338 fltype
= readl(&cc
->capabilities
) & CC_CAP_FLASH_MASK
;
339 base
= KSEG1ADDR(SI_FLASH2
);
343 base
= KSEG1ADDR(SI_FLASH2
);
344 switch (readl(&cc
->capabilities
) & CC_CAP_FLASH_MASK
)
346 switch (readl(&cc
->capabilities
) & CC_CAP_FLASH_MASK
) {
353 if ((info
= sflash_init(sih
, cc
)) == NULL
)
357 #ifdef NFLASH_SUPPORT
359 if ((nfl_info
= nflash_init(sih
, cc
)) == NULL
)
369 /* extif assumed, Stop at 4 MB */
370 base
= KSEG1ADDR(SI_FLASH1
);
373 #ifdef NFLASH_SUPPORT
374 if (nfl_info
!= NULL
) {
375 blocksize
= nfl_info
->blocksize
;
378 if (nflash_checkbadb(sih
, cc
, off
) != 0) {
382 header
= (struct nvram_header
*) KSEG1ADDR(base
+ off
);
383 if (header
->magic
== NVRAM_MAGIC
)
384 if (nvram_calc_crc(header
) == (uint8
) header
->crc_ver_init
) {
394 #ifdef NVRAM_64K_SUPPORT
395 header
= (struct nvram_header
*) KSEG1ADDR(base
+ lim
- 0x8000);
396 if(header
->magic
==0xffffffff) {
397 header
= (struct nvram_header
*) KSEG1ADDR(base
+ 1 KB
);
398 if (nvram_valid(header
))
404 /* Windowed flash access */
405 header
= (struct nvram_header
*) KSEG1ADDR(base
+ off
- NVRAM_SPACE
);
406 if (nvram_valid(header
))
410 #ifdef NFLASH_SUPPORT
414 /* Try embedded NVRAM at 4 KB and 1 KB as last resorts */
415 header
= (struct nvram_header
*) KSEG1ADDR(base
+ 4 KB
);
416 if (nvram_valid(header
))
419 header
= (struct nvram_header
*) KSEG1ADDR(base
+ 1 KB
);
420 if (nvram_valid(header
))
426 src
= (u32
*) header
;
427 dst
= (u32
*) nvram_buf
;
428 for (i
= 0; i
< sizeof(struct nvram_header
); i
+= 4)
430 for (; i
< header
->len
&& i
< NVRAM_SPACE
; i
+= 4)
431 *dst
++ = ltoh32(*src
++);
436 /* Early (before mm or mtd) read-only access to NVRAM */
438 early_nvram_get(const char *name
)
440 char *var
, *value
, *end
, *eq
;
450 if (early_nvram_init() != 0) {
451 printk("early_nvram_get: Failed reading nvram var %s\n", name
);
455 /* Look for name=value and return value */
456 var
= &nvram_buf
[sizeof(struct nvram_header
)];
457 end
= nvram_buf
+ sizeof(nvram_buf
) - 2;
458 end
[0] = end
[1] = '\0';
459 for (; *var
; var
= value
+ strlen(value
) + 1) {
460 if (!(eq
= strchr(var
, '=')))
463 if ((eq
- var
) == strlen(name
) && strncmp(var
, name
, (eq
- var
)) == 0)
471 early_nvram_getall(char *buf
, int count
)
481 if (early_nvram_init() != 0) {
482 printk("early_nvram_getall: Failed reading nvram var\n");
488 /* Write name=value\0 ... \0\0 */
489 var
= &nvram_buf
[sizeof(struct nvram_header
)];
490 end
= nvram_buf
+ sizeof(nvram_buf
) - 2;
491 end
[0] = end
[1] = '\0';
492 for (; *var
; var
+= strlen(var
) + 1) {
493 if ((count
- len
) <= (strlen(var
) + 1))
495 len
+= sprintf(buf
+ len
, "%s", var
) + 1;
502 extern char * _nvram_get(const char *name
);
503 extern int _nvram_set(const char *name
, const char *value
);
504 extern int _nvram_unset(const char *name
);
505 extern int _nvram_getall(char *buf
, int count
);
506 extern int _nvram_commit(struct nvram_header
*header
);
507 extern int _nvram_init(void *sih
);
508 extern void _nvram_exit(void);
511 static spinlock_t nvram_lock
= SPIN_LOCK_UNLOCKED
;
512 static struct semaphore nvram_sem
;
513 static unsigned long nvram_offset
= 0;
514 static int nvram_major
= -1;
515 static struct class *nvram_class
= NULL
;
516 static struct mtd_info
*nvram_mtd
= NULL
;
519 _nvram_read(char *buf
)
521 struct nvram_header
*header
= (struct nvram_header
*) buf
;
524 #ifdef NFLASH_SUPPORT
527 if (nvram_mtd
->type
== MTD_NANDFLASH
)
530 offset
= nvram_mtd
->size
- NVRAM_SPACE
;
533 nvram_mtd
->read(nvram_mtd
, offset
, NVRAM_SPACE
, &len
, buf
) ||
534 len
!= NVRAM_SPACE
||
535 !nvram_valid(header
)) {
536 /* Maybe we can recover some data from early initialization */
537 memcpy(buf
, nvram_buf
, NVRAM_SPACE
);
541 nvram_mtd
->read(nvram_mtd
, nvram_mtd
->size
- NVRAM_SPACE
, NVRAM_SPACE
, &len
, buf
) ||
542 len
!= NVRAM_SPACE
||
543 !nvram_valid(header
)) {
544 /* Maybe we can recover some data from early initialization */
545 memcpy(buf
, nvram_buf
, NVRAM_SPACE
);
553 _nvram_realloc(struct nvram_tuple
*t
, const char *name
, const char *value
)
555 if ((nvram_offset
+ strlen(value
) + 1) > NVRAM_SPACE
)
559 if (!(t
= kmalloc(sizeof(struct nvram_tuple
) + strlen(name
) + 1, GFP_ATOMIC
)))
563 t
->name
= (char *) &t
[1];
564 strcpy(t
->name
, name
);
570 if (!t
->value
|| strcmp(t
->value
, value
)) {
571 t
->value
= &nvram_buf
[nvram_offset
];
572 strcpy(t
->value
, value
);
573 nvram_offset
+= strlen(value
) + 1;
580 _nvram_free(struct nvram_tuple
*t
)
589 nvram_init(void *sih
)
595 nvram_set(const char *name
, const char *value
)
599 struct nvram_header
*header
;
605 spin_lock_irqsave(&nvram_lock
, flags
);
607 //printk("nvram_set: name = %s, value = %s!\n", name, value);
608 #ifdef CFE_UPDATE //write back to default sector as well, Chen-I
609 if(strncmp(name
, CFE_NVRAM_PREFIX
, strlen(CFE_NVRAM_PREFIX
))==0)
611 if(strcmp(name
, CFE_NVRAM_COMMIT
)==0)
613 else if(strcmp(name
, "asuscfe_dump") == 0)
615 else if(strcmp(name
, CFE_NVRAM_WATCHDOG
)==0)
617 bcm947xx_watchdog_disable();
621 cfe_update(name
+strlen(CFE_NVRAM_PREFIX
), value
);
622 _nvram_set(name
+strlen(CFE_NVRAM_PREFIX
), value
);
629 if (strncmp(name
, "wlx_", 4) == 0) {
630 memset(wps_name
, 0, sizeof(wps_name
));
631 sprintf(wps_name
, "wl0_%s", name
+4);
632 ret
= _nvram_set(wps_name
, value
);
633 spin_unlock_irqrestore(&nvram_lock
, flags
);
637 if (strncmp(name
, "wl0_", 4) == 0)
639 /* Authentication mode */
640 if (strncmp(name
, "wl0_akm", 7) == 0) {
641 if (strncmp(value
, "psk2", 4) == 0) { // WPA2-Personal
642 _nvram_set("wl_auth_mode", "psk");
643 _nvram_set("wl_wpa_mode", "2");
645 else if (strncmp(value
, "psk ", 4) == 0) { // WPA-Auto-Personal
646 _nvram_set("wl_auth_mode", "psk");
647 _nvram_set("wl_wpa_mode", "0");
649 else if (strncmp(value
, "psk", 3) == 0) { // WPA-Personal
650 _nvram_set("wl_auth_mode", "psk");
651 _nvram_set("wl_wpa_mode", "1");
653 else if (strncmp(value
, "wpa2", 4) == 0) { // WPA2-Enterprise
654 _nvram_set("wl_auth_mode", "wpa2");
656 else if (strncmp(value
, "wpa ", 4) == 0) { // WPA-Auto-Enterprise
657 _nvram_set("wl_wpa_mode", "4");
658 _nvram_set("wl_auth_mode", "wpa");
660 else if (strncmp(value
, "wpa", 3) == 0) { // WPA-Enterprise
661 _nvram_set("wl_wpa_mode", "3");
662 _nvram_set("wl_auth_mode", "wpa");
664 _nvram_set("wl_akm", value
);
667 else if (strcmp(name
, "wl0_wpa_psk") == 0) {
668 _nvram_set("wl_wpa_psk", value
);
672 else if ((strncmp(name
, "wl0_key", 7) == 0 )) {
674 wep_len
= strlen (value
);
675 memset(wps_name
, 0, sizeof(wps_name
));
677 if ((wep_len
== 5) || (wep_len
== 10)) { /* wl0_key1~4*/
678 // _nvram_set ("wl0_wep_x", "1");
679 _nvram_set ("wl_wep_x", "1");
680 sprintf(wps_name
, "wl_%s", name
+4);
682 else if ((wep_len
== 13) || (wep_len
== 26)) {
683 // _nvram_set ("wl0_wep_x", "2");
684 _nvram_set ("wl_wep_x", "2");
685 sprintf(wps_name
, "wl_%s", name
+4);
687 else { /* wl0_key index */
688 sprintf(wps_name
, "wl_%s", name
+4);
690 _nvram_set(wps_name
, value
);
693 else if (strcmp(name
, "wl0_ssid") == 0) {
694 // _nvram_set("wl0_ssid2", value);
695 // _nvram_set("wl_ssid2", value);
696 _nvram_set("wl_ssid", value
);
698 else if (strcmp(name
, "wl0_crypto") == 0) {
699 _nvram_set("wl_crypto", value
);
701 else if (strncmp(name
, "wl0_wps", 7) == 0) {
702 memset(wps_name
, 0, sizeof(wps_name
));
703 sprintf(wps_name
, "wl_%s", name
+4);
704 _nvram_set(wps_name
, value
);
708 else if (strncmp(name
, "wps_random_ssid_prefix", 22) == 0) {
709 memset(wps_name
, 0, sizeof(wps_name
));
710 sprintf(wps_name
, "ASUS_");
711 ret
= _nvram_set("wps_random_ssid_prefix", wps_name
);
712 spin_unlock_irqrestore(&nvram_lock
, flags
);
716 if (strcmp(name
, "lan_wps_oob") == 0) {
717 if (strcmp(value
, "disabled") == 0) {
718 _nvram_set("wps_config_state", "1");
719 _nvram_set("wl_wps_config_state", "1");
720 _nvram_set("wl0_wps_config_state", "1");
721 } else if (strcmp(value
, "enabled") == 0) {
722 _nvram_set("wps_config_state", "0");
723 _nvram_set("wl_wps_config_state", "0");
724 _nvram_set("wl0_wps_config_state", "0");
728 if (strcmp(name
, "wps_config_state") == 0) {
729 if (strcmp(value
, "0") == 0)
730 _nvram_set("lan_wps_oob", "enabled");
731 else if (strcmp(value
, "1") == 0)
732 _nvram_set("lan_wps_oob", "disabled");
735 if ((strcmp(name
, "wl_wps_config_state") == 0) || (strcmp(name
, "wl0_wps_config_state") == 0))
736 _nvram_set("wps_config_state", value
);
739 // else if ((strncmp(name, "wps_proc_status", 15) == 0 ) && (strcmp(value, "4"))) /* WPS success*/
740 // _nvram_set("wps_config_state", "1");
743 if(!strcmp(name
, "wl0_ssid"))
744 _nvram_set("wl_ssid", value
);
745 if(!strcmp(name
, "wl0_ssid"))
746 _nvram_set("wl_ssid", value
);
747 /* Set Wireless encryption */
748 if (!strcmp(name
, "wl0_akm")) {
749 _nvram_set("wl_auth_mode", "psk");
750 _nvram_set("wl_wpa_mode", "1");
752 else if (!strcmp("wl0_akm", "psk2")) {
753 _nvram_set("wl_auth_mode", "psk");
754 _nvram_set("wl_wpa_mode", "2");
756 else if (nvram_match("wl0_akm", "wpa")) {
757 _nvram_set("wl_auth_mode", "wpa");
758 _nvram_set("wl_wpa_mode", "3");
760 else if (nvram_match("wl0_akm", "wpa2")) {
761 _nvram_set("wl_auth_mode", "wpa2");
764 _nvram_set("wl_auth_mode", nvram_get("wl0_auth_mode"));
768 if ((ret
= _nvram_set(name
, value
))) {
769 /* Consolidate space and try again */
770 if ((header
= kmalloc(NVRAM_SPACE
, GFP_ATOMIC
))) {
771 if (_nvram_commit(header
) == 0)
772 ret
= _nvram_set(name
, value
);
776 spin_unlock_irqrestore(&nvram_lock
, flags
);
782 real_nvram_get(const char *name
)
787 spin_lock_irqsave(&nvram_lock
, flags
);
788 value
= _nvram_get(name
);
789 spin_unlock_irqrestore(&nvram_lock
, flags
);
795 nvram_get(const char *name
)
797 if (nvram_major
>= 0)
798 return real_nvram_get(name
);
800 return early_nvram_get(name
);
804 nvram_unset(const char *name
)
809 spin_lock_irqsave(&nvram_lock
, flags
);
810 #ifdef CFE_UPDATE //unset variable in embedded nvram
811 if(strncmp(name
, CFE_NVRAM_PREFIX
, strlen(CFE_NVRAM_PREFIX
))==0)
813 if((ret
= cfe_update(name
+strlen(CFE_NVRAM_PREFIX
), NULL
)) == 0)
815 ret
= _nvram_unset(name
+strlen(CFE_NVRAM_PREFIX
));
820 ret
= _nvram_unset(name
);
821 spin_unlock_irqrestore(&nvram_lock
, flags
);
827 erase_callback(struct erase_info
*done
)
829 wait_queue_head_t
*wait_q
= (wait_queue_head_t
*) done
->priv
;
833 #ifdef NFLASH_SUPPORT
835 nvram_nflash_commit(void)
838 size_t len
, magic_len
;
841 struct nvram_header
*header
;
844 struct erase_info erase
;
846 if (!(buf
= kmalloc(NVRAM_SPACE
, GFP_KERNEL
))) {
847 printk("nvram_commit: out of memory\n");
853 /* read header for checking */
855 i
= sizeof(struct nvram_header
);
856 ret
= nvram_mtd
->read(nvram_mtd
, offset
, i
, &len
, buf
);
857 if (ret
|| len
!= i
) {
858 printk("nvram_commit: read error ret = %d, len = %d/%d\n", ret
, len
, i
);
863 header
= (struct nvram_header
*)buf
;
864 /* do NOT commit after loaddefault */
865 if (header
->magic
== NVRAM_INVALID_MAGIC
) {
866 printk(KERN_EMERG
"nvram_commit: NOT allow commit, magic = 0x%x\n",
873 header
= (struct nvram_header
*)buf
;
874 header
->magic
= NVRAM_MAGIC
;
875 /* reset MAGIC before we regenerate the NVRAM,
876 * otherwise we'll have an incorrect CRC
878 /* Regenerate NVRAM */
879 spin_lock_irqsave(&nvram_lock
, flags
);
880 ret
= _nvram_commit(header
);
881 spin_unlock_irqrestore(&nvram_lock
, flags
);
885 /* Write partition up to end of data area */
887 ret
= nvram_mtd
->write(nvram_mtd
, offset
, i
, &len
, buf
);
888 if (ret
|| len
!= i
) {
889 printk("nvram_commit: write error\n");
907 size_t erasesize
, len
, magic_len
;
910 struct nvram_header
*header
;
913 DECLARE_WAITQUEUE(wait
, current
);
914 wait_queue_head_t wait_q
;
915 struct erase_info erase
;
916 u_int32_t magic_offset
= 0; /* Offset for writing MAGIC # */
919 printk("nvram_commit: NVRAM not found\n");
923 if (in_interrupt()) {
924 printk("nvram_commit: not committing in interrupt\n");
928 #ifdef NFLASH_SUPPORT
929 if (nvram_mtd
->type
== MTD_NANDFLASH
)
930 return nvram_nflash_commit();
932 /* Backup sector blocks to be erased */
933 erasesize
= ROUNDUP(NVRAM_SPACE
, nvram_mtd
->erasesize
);
935 if (!(buf
= kmalloc(erasesize
, GFP_KERNEL
))) {
936 printk("nvram_commit: out of memory\n");
942 if ((i
= erasesize
- NVRAM_SPACE
) > 0) {
943 offset
= nvram_mtd
->size
- erasesize
;
945 ret
= nvram_mtd
->read(nvram_mtd
, offset
, i
, &len
, nvram_commit_buf
);
946 if (ret
|| len
!= i
) {
947 printk("nvram_commit: read error ret = %d, len = %d/%d\n", ret
, len
, i
);
951 header
= (struct nvram_header
*)(nvram_commit_buf
+ i
);
952 magic_offset
= i
+ ((void *)&header
->magic
- (void *)header
);
954 offset
= nvram_mtd
->size
- NVRAM_SPACE
;
955 magic_offset
= ((void *)&header
->magic
- (void *)header
);
956 header
= (struct nvram_header
*)nvram_commit_buf
;
959 /* clear the existing magic # to mark the NVRAM as unusable
960 * we can pull MAGIC bits low without erase
962 header
->magic
= NVRAM_CLEAR_MAGIC
; /* All zeros magic */
963 /* Unlock sector blocks */
964 if (nvram_mtd
->unlock
)
965 nvram_mtd
->unlock(nvram_mtd
, offset
, nvram_mtd
->erasesize
);
966 ret
= nvram_mtd
->write(nvram_mtd
, offset
+ magic_offset
, sizeof(header
->magic
),
967 &magic_len
, (char *)&header
->magic
);
968 if (ret
|| magic_len
!= sizeof(header
->magic
)) {
969 printk("nvram_commit: clear MAGIC error\n");
974 header
->magic
= NVRAM_MAGIC
;
975 /* reset MAGIC before we regenerate the NVRAM,
976 * otherwise we'll have an incorrect CRC
978 /* Regenerate NVRAM */
979 spin_lock_irqsave(&nvram_lock
, flags
);
980 ret
= _nvram_commit(header
);
981 spin_unlock_irqrestore(&nvram_lock
, flags
);
985 /* Erase sector blocks */
986 init_waitqueue_head(&wait_q
);
987 for (; offset
< nvram_mtd
->size
- NVRAM_SPACE
+ header
->len
;
988 offset
+= nvram_mtd
->erasesize
) {
990 erase
.mtd
= nvram_mtd
;
992 erase
.len
= nvram_mtd
->erasesize
;
993 erase
.callback
= erase_callback
;
994 erase
.priv
= (u_long
) &wait_q
;
996 set_current_state(TASK_INTERRUPTIBLE
);
997 add_wait_queue(&wait_q
, &wait
);
999 /* Unlock sector blocks */
1000 if (nvram_mtd
->unlock
)
1001 nvram_mtd
->unlock(nvram_mtd
, offset
, nvram_mtd
->erasesize
);
1003 if ((ret
= nvram_mtd
->erase(nvram_mtd
, &erase
))) {
1004 set_current_state(TASK_RUNNING
);
1005 remove_wait_queue(&wait_q
, &wait
);
1006 printk("nvram_commit: erase error\n");
1010 /* Wait for erase to finish */
1012 remove_wait_queue(&wait_q
, &wait
);
1015 /* Write partition up to end of data area */
1016 header
->magic
= NVRAM_INVALID_MAGIC
; /* All ones magic */
1017 offset
= nvram_mtd
->size
- erasesize
;
1018 i
= erasesize
- NVRAM_SPACE
+ header
->len
;
1019 ret
= nvram_mtd
->write(nvram_mtd
, offset
, i
, &len
, nvram_commit_buf
);
1020 if (ret
|| len
!= i
) {
1021 printk("nvram_commit: write error\n");
1026 /* Now mark the NVRAM in flash as "valid" by setting the correct
1029 header
->magic
= NVRAM_MAGIC
;
1030 ret
= nvram_mtd
->write(nvram_mtd
, offset
+ magic_offset
, sizeof(header
->magic
),
1031 &magic_len
, (char *)&header
->magic
);
1032 if (ret
|| magic_len
!= sizeof(header
->magic
)) {
1033 printk("nvram_commit: write MAGIC error\n");
1038 offset
= nvram_mtd
->size
- erasesize
;
1039 ret
= nvram_mtd
->read(nvram_mtd
, offset
, 4, &len
, nvram_commit_buf
);
1041 #ifdef NVRAM_64K_SUPPORT /*Only for RT-N66U upgrade from nvram 32K -> 64K*/
1042 if(header
->len
< 0x8001){
1048 log_buf
=0x01020304;
1049 ret
= nvram_mtd
->write(nvram_mtd
, offset_t
, sizeof(log_buf
), &log_len
, &log_buf
);
1062 nvram_getall(char *buf
, int count
)
1064 unsigned long flags
;
1067 spin_lock_irqsave(&nvram_lock
, flags
);
1068 if (nvram_major
>= 0)
1069 ret
= _nvram_getall(buf
, count
);
1071 ret
= early_nvram_getall(buf
, count
);
1072 spin_unlock_irqrestore(&nvram_lock
, flags
);
1077 EXPORT_SYMBOL(nvram_init
);
1078 EXPORT_SYMBOL(nvram_get
);
1079 EXPORT_SYMBOL(nvram_getall
);
1080 EXPORT_SYMBOL(nvram_set
);
1081 EXPORT_SYMBOL(nvram_unset
);
1082 EXPORT_SYMBOL(nvram_commit
);
1084 /* User mode interface below */
1087 dev_nvram_read(struct file
*file
, char *buf
, size_t count
, loff_t
*ppos
)
1089 char tmp
[100], *name
= tmp
, *value
;
1093 if (count
> sizeof(tmp
)) {
1094 if (!(name
= kmalloc(count
, GFP_KERNEL
)))
1098 if (copy_from_user(name
, buf
, count
)) {
1103 if (*name
== '\0') {
1104 /* Get all variables */
1105 ret
= nvram_getall(name
, count
);
1107 if (copy_to_user(buf
, name
, count
)) {
1114 if (!(value
= nvram_get(name
))) {
1119 /* Provide the offset into mmap() space */
1120 off
= (unsigned long) value
- (unsigned long) nvram_buf
;
1122 if (put_user(off
, (unsigned long *) buf
)) {
1127 ret
= sizeof(unsigned long);
1140 dev_nvram_write(struct file
*file
, const char *buf
, size_t count
, loff_t
*ppos
)
1142 char tmp
[100], *name
= tmp
, *value
;
1145 if (count
> sizeof(tmp
)) {
1146 if (!(name
= kmalloc(count
, GFP_KERNEL
)))
1150 if (copy_from_user(name
, buf
, count
)) {
1156 name
= strsep(&value
, "=");
1158 ret
= nvram_set(name
, value
) ? : count
;
1160 ret
= nvram_unset(name
) ? : count
;
1170 dev_nvram_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1172 if (cmd
!= NVRAM_MAGIC
)
1176 return nvram_commit();
1179 return nvram_commit();
1181 return nvram_xfr((char *)arg
);
1186 dev_nvram_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1188 unsigned long offset
= __pa(nvram_buf
) >> PAGE_SHIFT
;
1190 if (remap_pfn_range(vma
, vma
->vm_start
, offset
,
1191 vma
->vm_end
- vma
->vm_start
,
1199 dev_nvram_open(struct inode
*inode
, struct file
* file
)
1205 dev_nvram_release(struct inode
*inode
, struct file
* file
)
1210 static struct file_operations dev_nvram_fops
= {
1212 open
: dev_nvram_open
,
1213 release
: dev_nvram_release
,
1214 read
: dev_nvram_read
,
1215 write
: dev_nvram_write
,
1216 ioctl
: dev_nvram_ioctl
,
1217 mmap
: dev_nvram_mmap
1221 dev_nvram_exit(void)
1224 struct page
*page
, *end
;
1227 class_device_destroy(nvram_class
, MKDEV(nvram_major
, 0));
1228 class_destroy(nvram_class
);
1231 if (nvram_major
>= 0)
1232 unregister_chrdev(nvram_major
, "nvram");
1235 put_mtd_device(nvram_mtd
);
1237 while ((PAGE_SIZE
<< order
) < NVRAM_SPACE
)
1239 end
= virt_to_page(nvram_buf
+ (PAGE_SIZE
<< order
) - 1);
1240 for (page
= virt_to_page(nvram_buf
); page
<= end
; page
++)
1241 ClearPageReserved(page
);
1247 dev_nvram_init(void)
1249 int order
= 0, ret
= 0;
1250 struct page
*page
, *end
;
1254 /* Allocate and reserve memory to mmap() */
1255 while ((PAGE_SIZE
<< order
) < NVRAM_SPACE
)
1257 end
= virt_to_page(nvram_buf
+ (PAGE_SIZE
<< order
) - 1);
1258 for (page
= virt_to_page(nvram_buf
); page
<= end
; page
++) {
1259 SetPageReserved(page
);
1262 #if defined(CONFIG_MTD) || defined(CONFIG_MTD_MODULE)
1263 /* Find associated MTD device */
1264 for (i
= 0; i
< MAX_MTD_DEVICES
; i
++) {
1265 nvram_mtd
= get_mtd_device(NULL
, i
);
1266 if (!IS_ERR(nvram_mtd
)) {
1267 if (!strcmp(nvram_mtd
->name
, "nvram") &&
1268 nvram_mtd
->size
>= NVRAM_SPACE
) {
1271 put_mtd_device(nvram_mtd
);
1274 if (i
>= MAX_MTD_DEVICES
)
1278 #ifdef NVRAM_64K_SUPPORT
1283 DECLARE_WAITQUEUE(wait
, current
);
1284 wait_queue_head_t wait_q
;
1285 struct erase_info erase
;
1288 ret32
= nvram_mtd
->read(nvram_mtd
, offset_t
, 4, &log_len
, &log_buf
);
1289 if(log_buf
==0xffffffff) {
1290 /* Erase sector blocks */
1291 init_waitqueue_head(&wait_q
);
1293 erase
.mtd
= nvram_mtd
;
1295 erase
.len
= nvram_mtd
->erasesize
;
1296 erase
.callback
= erase_callback
;
1297 erase
.priv
= (u_long
) &wait_q
;
1298 set_current_state(TASK_INTERRUPTIBLE
);
1299 add_wait_queue(&wait_q
, &wait
);
1301 /* Unlock sector blocks */
1302 if (nvram_mtd
->unlock
)
1303 nvram_mtd
->unlock(nvram_mtd
, 0, nvram_mtd
->erasesize
);
1305 if ((ret
= nvram_mtd
->erase(nvram_mtd
, &erase
))) {
1306 set_current_state(TASK_RUNNING
);
1307 remove_wait_queue(&wait_q
, &wait
);
1308 printk("nvram mtd erase error\n");
1311 /* Wait for erase to finish */
1313 remove_wait_queue(&wait_q
, &wait
);
1317 /* Initialize hash table lock */
1318 spin_lock_init(&nvram_lock
);
1320 /* Initialize commit semaphore */
1321 init_MUTEX(&nvram_sem
);
1323 /* Register char device */
1324 if ((nvram_major
= register_chrdev(0, "nvram", &dev_nvram_fops
)) < 0) {
1329 if (si_osh(sih
) == NULL
) {
1330 osh
= osl_attach(NULL
, SI_BUS
, FALSE
);
1332 printk("Error allocating osh\n");
1333 unregister_chrdev(nvram_major
, "nvram");
1336 si_setosh(sih
, osh
);
1339 /* Initialize hash table */
1342 /* Create /dev/nvram handle */
1343 nvram_class
= class_create(THIS_MODULE
, "nvram");
1344 if (IS_ERR(nvram_class
)) {
1345 printk("Error creating nvram class\n");
1349 /* Add the device nvram0 */
1350 class_device_create(nvram_class
, NULL
, MKDEV(nvram_major
, 0), NULL
, "nvram");
1352 /* reserve commit read buffer */
1353 /* Backup sector blocks to be erased */
1354 if (!(nvram_commit_buf
= kmalloc(ROUNDUP(NVRAM_SPACE
, nvram_mtd
->erasesize
), GFP_KERNEL
))) {
1355 printk("dev_nvram_init: nvram_commit_buf out of memory\n");
1359 /* Set the SDRAM NCDL value into NVRAM if not already done */
1360 if (getintvar(NULL
, "sdram_ncdl") == 0) {
1362 char buf
[] = "0x00000000";
1364 if ((ncdl
= si_memc_get_ncdl(sih
))) {
1365 sprintf(buf
, "0x%08x", ncdl
);
1366 nvram_set("sdram_ncdl", buf
);
1379 int get_embedded_block(struct mtd_info
*mtd
, char *buf
, size_t erasesize
,
1380 u_int32_t
*offset
, struct nvram_header
**header
, u_int32_t
*emb_size
)
1383 struct nvram_header
*nvh
;
1385 #ifdef CONFIG_RTAN23 /*for AMCC RTAN23 */
1386 *offset
= mtd
->size
- erasesize
; /*/at the end of mtd */
1387 *emb_size
= 8*1024 - 16; /*/8K - 16 byte */
1388 printk("get_embedded_block: mtd->size(%08x) erasesize(%08x) offset(%08x) emb_size(%08x)\n", mtd
->size
, erasesize
, *offset
, *emb_size
);
1389 cfe_mtd
->read(mtd
, *offset
, erasesize
, &len
, buf
);
1390 if(len
!= erasesize
)
1393 /* find nvram header */
1394 nvh
= (struct nvram_header
*)(buf
+ erasesize
- 8*1024);
1395 if (nvh
->magic
== NVRAM_MAGIC
)
1401 #else /* for Broadcom WL500 serials */
1402 *offset
= 0; /* from the mtd start */
1403 *emb_size
= 4096; /* 1K byte */
1404 printk("get_embedded_block: mtd->size(%08x) erasesize(%08x) offset(%08x) emb_size(%08x)\n", mtd
->size
, erasesize
, *offset
, *emb_size
);
1405 cfe_mtd
->read(mtd
, *offset
, erasesize
, &len
, buf
);
1406 if(len
!= erasesize
)
1409 /* find nvram header */
1410 nvh
= (struct nvram_header
*)(buf
+ (4 * 1024));
1411 if (nvh
->magic
== NVRAM_MAGIC
)
1416 nvh
= (struct nvram_header
*)(buf
+ (1 * 1024));
1417 if (nvh
->magic
== NVRAM_MAGIC
)
1423 printk("get_embedded_block: no nvram magic found\n");
1426 static int cfe_init(void)
1432 /* Find associated MTD device */
1433 for (i
= 0; i
< MAX_MTD_DEVICES
; i
++) {
1434 cfe_mtd
= get_mtd_device(NULL
, i
);
1435 if (cfe_mtd
!= NULL
) {
1436 printk("cfe_init: CFE MTD %x %s %x\n", i
, cfe_mtd
->name
, cfe_mtd
->size
);
1437 if (!strcmp(cfe_mtd
->name
, "boot"))
1439 put_mtd_device(cfe_mtd
);
1442 if (i
>= MAX_MTD_DEVICES
)
1444 printk("cfe_init: No CFE MTD\n");
1449 if(cfe_mtd
== NULL
) goto fail
;
1451 /* sector blocks to be erased and backup */
1452 erasesize
= ROUNDUP(CFE_NVRAM_SPACE
, cfe_mtd
->erasesize
);
1454 //printk("cfe_init: block size %d\n", erasesize);
1455 cfe_buf
= kmalloc(erasesize
, GFP_KERNEL
);
1459 //printk("cfe_init: No CFE Memory\n");
1463 if((ret
= get_embedded_block(cfe_mtd
, cfe_buf
, erasesize
, &cfe_offset
, &cfe_nvram_header
, &cfe_embedded_size
)))
1466 printk("cfe_init: cfe_nvram_header(%08x)\n", (unsigned int) cfe_nvram_header
);
1467 bcm947xx_watchdog_disable();
1472 if (cfe_mtd
!= NULL
)
1474 put_mtd_device(cfe_mtd
);
1484 static int cfe_update(const char *keyword
, const char *value
)
1486 struct nvram_header
*header
;
1490 char *str
, *end
, *mv_target
= NULL
, *mv_start
= NULL
;
1492 if(keyword
== NULL
|| *keyword
== 0)
1495 if(cfe_buf
== NULL
||cfe_mtd
== NULL
)
1496 if((ret
= cfe_init()))
1499 header
= cfe_nvram_header
;
1501 //printk("cfe_update: before %x %x\n", header->len, cfe_nvram_header->crc_ver_init&0xff);
1502 str
= (char *) &header
[1];
1503 end
= (char *) header
+ cfe_embedded_size
- 2;
1504 end
[0] = end
[1] = '\0';
1505 for (; *str
; str
+= strlen(str
) + 1)
1509 if(strncmp(str
, keyword
, strlen(keyword
)) == 0 && str
[strlen(keyword
)] == '=')
1511 printk("cfe_update: !!!! found !!!!\n");
1513 if(value
!= NULL
&& strlen(str
) == strlen(keyword
) + 1 + strlen(value
))
1514 {//string length is the same
1515 strcpy(str
+strlen(keyword
)+1, value
);
1520 mv_start
= str
+ strlen(str
) + 1;
1525 /* str point to the end of all embedded nvram settings */
1527 if(mv_target
!= NULL
)
1528 { /* need to move string */
1529 int str_len
= strlen(mv_target
);
1530 printk("cfe_update: mv_target(%08x) mv_start(%08x) str(%08x) str_len(%d)\n", (unsigned int)mv_target
, (unsigned int)mv_start
, (unsigned int)str
, str_len
);
1531 if(value
!= NULL
&& (str
+ strlen(keyword
) + 1 + strlen(value
) + 1 - (str_len
+ 1)) > end
)
1533 memmove(mv_target
, mv_start
, str
- mv_start
);
1534 printk("cfe_update: memmove done\n");
1535 str
-= (str_len
+ 1); /* /set str to the end for placing incoming keyword and value there */
1540 printk("cfe_update: do unset\n");
1542 else if(!found
|| mv_target
!= NULL
) /*new or movement */
1543 { /* append the keyword and value here */
1544 printk("cfe_update: str(%08x)\n", (unsigned int) str
);
1545 if((str
+ strlen(keyword
) + 1 + strlen(value
) + 1) > end
)
1547 str
+= sprintf(str
, "%s=%s", keyword
, value
) + 1;
1548 printk("cfe_update: append string\n");
1551 memset(str
, 0, cfe_embedded_size
+(char *)header
- str
);
1553 header
->len
= ROUNDUP(str
- (char *) header
, 4);
1554 printk("cfe_update: header len: %x\n", header
->len
);
1556 crc
= nvram_calc_crc(header
);
1557 printk("cfe_update: nvram_calc_crc(header) = 0x%02x\n", crc
);
1558 header
->crc_ver_init
= (header
->crc_ver_init
& NVRAM_CRC_VER_MASK
)|crc
;
1559 /*/printk("cfe_update: after %x %x\n", header->crc_ver_init&0xFF, crc); */
1562 static int cfe_dump(void)
1568 if(cfe_buf
== NULL
||cfe_mtd
== NULL
)
1569 if((ret
= cfe_init()))
1572 printk("cfe_dump: cfe_buf(%08x), dump 1024 byte\n", (unsigned int)cfe_buf
);
1573 for(i
=0, ptr
=(unsigned char *)cfe_nvram_header
- 1024; ptr
< (unsigned char *)cfe_nvram_header
; i
++, ptr
++)
1575 if(i
%16==0) printk("%04x: %02x ", i
, *ptr
);
1576 else if(i
%16==15) printk("%02x\n", *ptr
);
1577 else if(i
%16==7) printk("%02x - ", *ptr
);
1578 else printk("%02x ", *ptr
);
1581 printk("\ncfe_dump: cfe_nvram_header(%08x)\n", (unsigned int)cfe_nvram_header
);
1582 printk("cfe_dump: cfe_nvram_header->len(0x%08x)\n", cfe_nvram_header
->len
);
1584 printk("\n####################\n");
1585 for(i
=0, ptr
=(unsigned char *)cfe_nvram_header
; i
< cfe_embedded_size
; i
++, ptr
++)
1587 if(i
%16==0) printk("%04x: %02x ", i
, *ptr
);
1588 else if(i
%16==15) printk("%02x\n", *ptr
);
1589 else if(i
%16==7) printk("%02x - ", *ptr
);
1590 else printk("%02x ", *ptr
);
1592 printk("\n####################\n");
1593 ptr
= (unsigned char *)&cfe_nvram_header
[1];
1596 printk("%s\n", ptr
);
1597 ptr
+= strlen(ptr
) + 1;
1599 printk("\n####################\n");
1600 for(i
=0, ptr
=((unsigned char *)cfe_nvram_header
) + cfe_embedded_size
; i
<16; i
++, ptr
++)
1602 if(i
%16==0) printk("%04x: %02x ", i
, *ptr
);
1603 else if(i
%16==15) printk("%02x\n", *ptr
);
1604 else if(i
%16==7) printk("%02x - ", *ptr
);
1605 else printk("%02x ", *ptr
);
1610 static int cfe_commit(void)
1612 DECLARE_WAITQUEUE(wait
, current
);
1613 wait_queue_head_t wait_q
;
1614 struct erase_info erase
;
1616 size_t erasesize
, len
=0;
1619 if(cfe_mtd
== NULL
||cfe_buf
== NULL
)
1621 printk("cfe_commit: do nothing\n");
1630 /* Backup sector blocks to be erased */
1631 erasesize
= ROUNDUP(CFE_NVRAM_SPACE
, cfe_mtd
->erasesize
);
1632 printk("cfe_commit: erasesize(%08x) cfe_offset(%08x)\n", erasesize
, cfe_offset
);
1634 /* Erase sector blocks */
1635 init_waitqueue_head(&wait_q
);
1636 for (offset
=cfe_offset
;offset
< cfe_offset
+erasesize
;offset
+= cfe_mtd
->erasesize
) {
1637 printk("cfe_commit: ERASE sector block offset(%08x) cfe_mtd->erasesize(%08x)\n", offset
, cfe_mtd
->erasesize
);
1638 erase
.mtd
= cfe_mtd
;
1639 erase
.addr
= offset
;
1640 erase
.len
= cfe_mtd
->erasesize
;
1641 erase
.callback
= erase_callback
;
1642 erase
.priv
= (u_long
) &wait_q
;
1644 set_current_state(TASK_INTERRUPTIBLE
);
1645 add_wait_queue(&wait_q
, &wait
);
1646 /* Unlock sector blocks */
1647 if (cfe_mtd
->unlock
)
1648 cfe_mtd
->unlock(cfe_mtd
, offset
, cfe_mtd
->erasesize
);
1650 if ((ret
= cfe_mtd
->erase(cfe_mtd
, &erase
))) {
1651 set_current_state(TASK_RUNNING
);
1652 remove_wait_queue(&wait_q
, &wait
);
1653 printk("cfe_commit: erase error\n");
1658 /* Wait for erase to finish */
1660 remove_wait_queue(&wait_q
, &wait
);
1663 ret
= cfe_mtd
->write(cfe_mtd
, cfe_offset
, erasesize
, &len
, cfe_buf
);
1664 printk("cfe_commit: MTD_WRITE cfe_offset(%08x) erasesize(%08x) len(%08x) ret(%08x)\n", cfe_offset
, erasesize
, len
, ret
);
1666 if (ret
|| len
!= erasesize
) {
1667 printk("cfe_commit: write error\n");
1672 if (cfe_mtd
!= NULL
)
1674 put_mtd_device(cfe_mtd
);
1682 //printk("commit: %d\n", ret);
1693 size_t erasesize
, len
;
1696 /* Find associated MTD device */
1697 for (i
= 0; i
< MAX_MTD_DEVICES
; i
++) {
1698 cfe_mtd
= get_mtd_device(NULL
, i
);
1700 printk("CFE MTD: %x %s %x\n", i
, cfe_mtd
->name
, cfe_mtd
->size
);
1701 if (!strcmp(cfe_mtd
->name
, "boot"))
1703 put_mtd_device(cfe_mtd
);
1706 if (i
>= MAX_MTD_DEVICES
)
1708 printk("No CFE MTD\n");
1712 if(!cfe_mtd
) goto fail
;
1714 /* sector blocks to be erased and backup */
1715 erasesize
= ROUNDUP(CFE_NVRAM_SPACE
, cfe_mtd
->erasesize
);
1717 /* printk("block size %d\n", erasesize); */
1719 cfe_buf
= kmalloc(erasesize
, GFP_KERNEL
);
1723 /* printk("No CFE Memory\n"); */
1726 cfe_mtd
->read(cfe_mtd
, CFE_NVRAM_START
, erasesize
, &len
, cfe_buf
);
1728 /* find nvram header */
1731 cfe_nvram_header
=(struct nvram_header
*)&cfe_buf
[i
];
1732 if (cfe_nvram_header
->magic
==NVRAM_MAGIC
) break;
1735 bcm947xx_watchdog_disable(); /*disable watchdog as well */
1738 printf("read from nvram %d %s\n", i
, cfe_buf
);
1739 for(i
=0;i
<CFE_SPACE
;i
++)
1741 if(i
%16) printk("\n");
1742 printk("%02x ", (unsigned char)cfe_buf
[i
]);
1749 put_mtd_device(cfe_mtd
);
1760 void cfe_update(const char *keyword
, const char *value
)
1762 unsigned long i
, offset
;
1763 struct nvram_header tmp
, *header
;
1768 if(!cfe_buf
||!cfe_mtd
)
1771 if (!cfe_buf
||!cfe_mtd
) return;
1773 header
= cfe_nvram_header
;
1775 printk("before: %x %x\n", header
->len
, cfe_nvram_header
->crc_ver_init
&0xff);
1777 for(i
=CFE_NVRAM_START
;i
<=CFE_NVRAM_END
;i
++)
1779 if(strncmp(&cfe_buf
[i
], keyword
, strlen(keyword
))==0)
1781 printk("before: %s\n", cfe_buf
+i
);
1782 offset
=strlen(keyword
);
1783 memcpy(cfe_buf
+i
+offset
+1, value
, strlen(value
));
1784 printk("after: %s\n", cfe_buf
+i
);
1791 char *tmp_buf
= (char *)cfe_nvram_header
;
1793 /* printk("header len: %x\n", header->len); */
1794 sprintf(tmp_buf
+header
->len
, "%s=%s", keyword
, value
);
1795 header
->len
= header
->len
+ strlen(keyword
) + strlen(value
) + 2;
1796 /* printk("header len: %x\n", header->len); */
1799 tmp
.crc_ver_init
= htol32(header
->crc_ver_init
);
1800 tmp
.config_refresh
= htol32(header
->config_refresh
);
1801 tmp
.config_ncdl
= htol32(header
->config_ncdl
);
1802 crc
= hndcrc8((char *) &tmp
+ 9, sizeof(struct nvram_header
) - 9, CRC8_INIT_VALUE
);
1804 /* Continue CRC8 over data bytes */
1805 crc
= hndcrc8((char *) &header
[1], header
->len
- sizeof(struct nvram_header
), crc
);
1806 header
->crc_ver_init
= (header
->crc_ver_init
&0xFFFFFF00)|crc
;
1807 printk("after: %x %x\n", header
->crc_ver_init
&0xFF, crc
);
1810 int cfe_commit(void)
1812 DECLARE_WAITQUEUE(wait
, current
);
1813 wait_queue_head_t wait_q
;
1814 struct erase_info erase
;
1817 size_t erasesize
, len
;
1821 if(!cfe_buf
||!cfe_mtd
) cfe_init();
1823 if(!cfe_mtd
||!cfe_buf
)
1829 /* Backup sector blocks to be erased */
1830 erasesize
= ROUNDUP(CFE_NVRAM_SPACE
, cfe_mtd
->erasesize
);
1834 /* Erase sector blocks */
1835 init_waitqueue_head(&wait_q
);
1838 for (offset
=CFE_NVRAM_START
;offset
<= CFE_NVRAM_END
;offset
+= cfe_mtd
->erasesize
) {
1839 erase
.mtd
= cfe_mtd
;
1840 erase
.addr
= offset
;
1841 erase
.len
= cfe_mtd
->erasesize
;
1842 erase
.callback
= erase_callback
;
1843 erase
.priv
= (u_long
) &wait_q
;
1845 set_current_state(TASK_INTERRUPTIBLE
);
1846 add_wait_queue(&wait_q
, &wait
);
1847 /* Unlock sector blocks */
1848 if (cfe_mtd
->unlock
)
1849 cfe_mtd
->unlock(cfe_mtd
, offset
, cfe_mtd
->erasesize
);
1851 if ((ret
= cfe_mtd
->erase(cfe_mtd
, &erase
))) {
1852 set_current_state(TASK_RUNNING
);
1853 remove_wait_queue(&wait_q
, &wait
);
1854 printk("cfe_commit: erase error\n");
1858 /* Wait for erase to finish */
1860 remove_wait_queue(&wait_q
, &wait
);
1863 ret
= cfe_mtd
->write(cfe_mtd
, CFE_NVRAM_START
, erasesize
, &len
, cfe_buf
);
1864 /* printk("Write offset: %x %x %x\n", ret, len, erasesize); */
1866 if (ret
|| len
!= erasesize
) {
1867 printk("cfe_commit: write error\n");
1875 put_mtd_device(cfe_mtd
);
1883 /* printk("commit: %d\n", ret); */
1890 module_init(dev_nvram_init
);
1891 module_exit(dev_nvram_exit
);