Changeset 15440


Ignore:
Timestamp:
2009-04-27T16:51:26+02:00 (9 years ago)
Author:
nbd
Message:

brcm-2.4: rip out all /dev/nvram and nvram setting/committing code from the kernel

Location:
trunk/target/linux/brcm-2.4/files/arch/mips/bcm947xx
Files:
1 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm-2.4/files/arch/mips/bcm947xx/Makefile

    r10137 r15440  
    1010export-objs     := export.o 
    1111obj-y           := prom.o setup.o time.o sbmips.o gpio.o 
    12 obj-y           += nvram.o nvram_linux.o cfe_env.o hndpmu.o 
     12obj-y           += nvram.o cfe_env.o hndpmu.o 
    1313obj-y           += sbutils.o utils.o bcmsrom.o hndchipc.o 
    1414obj-$(CONFIG_PCI) += sbpci.o pcibios.o 
  • trunk/target/linux/brcm-2.4/files/arch/mips/bcm947xx/export.c

    r10137 r15440  
    7070_export(nvram_get) 
    7171_export(nvram_getall) 
    72 _export(nvram_set) 
    73 _export(nvram_unset) 
    74 _export(nvram_commit) 
    7572 
    7673_export(srom_read) 
  • trunk/target/linux/brcm-2.4/files/arch/mips/bcm947xx/nvram.c

    r10137 r15440  
    11/* 
    2  * NVRAM variable manipulation (common) 
     2 * NVRAM variable manipulation (Linux kernel half) 
    33 * 
    4  * Copyright 2004, Broadcom Corporation 
     4 * Copyright 2006, Broadcom Corporation 
    55 * All Rights Reserved. 
    66 *  
     
    1212 */ 
    1313 
     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> 
     24#include <linux/fs.h> 
     25#include <linux/miscdevice.h> 
     26#include <linux/mtd/mtd.h> 
     27#include <asm/addrspace.h> 
     28#include <asm/io.h> 
     29#include <asm/uaccess.h> 
     30 
    1431#include <typedefs.h> 
    1532#include <osl.h> 
    1633#include <bcmendian.h> 
    1734#include <bcmnvram.h> 
    18 #include <sbsdram.h> 
    19  
    20 extern struct nvram_tuple * BCMINIT(_nvram_realloc)(struct nvram_tuple *t, const char *name, const char *value); 
    21 extern void BCMINIT(_nvram_free)(struct nvram_tuple *t); 
    22 extern int BCMINIT(_nvram_read)(void *buf); 
    23  
    24 char * BCMINIT(_nvram_get)(const char *name); 
    25 int BCMINIT(_nvram_set)(const char *name, const char *value); 
    26 int BCMINIT(_nvram_unset)(const char *name); 
    27 int BCMINIT(_nvram_getall)(char *buf, int count); 
    28 int BCMINIT(_nvram_commit)(struct nvram_header *header); 
    29 int BCMINIT(_nvram_init)(void); 
    30 void BCMINIT(_nvram_exit)(void); 
    31  
    32 static struct nvram_tuple * BCMINITDATA(nvram_hash)[257]; 
    33 static struct nvram_tuple * nvram_dead; 
    34  
    35 /* Free all tuples. Should be locked. */ 
    36 static void   
    37 BCMINITFN(nvram_free)(void) 
    38 { 
    39         uint i; 
    40         struct nvram_tuple *t, *next; 
    41  
    42         /* Free hash table */ 
    43         for (i = 0; i < ARRAYSIZE(BCMINIT(nvram_hash)); i++) { 
    44                 for (t = BCMINIT(nvram_hash)[i]; t; t = next) { 
    45                         next = t->next; 
    46                         BCMINIT(_nvram_free)(t); 
     35#include <sbconfig.h> 
     36#include <sbchipc.h> 
     37#include <sbutils.h> 
     38#include <hndmips.h> 
     39#include <sflash.h> 
     40 
     41/* In BSS to minimize text size and page aligned so it can be mmap()-ed */ 
     42static char nvram_buf[NVRAM_SPACE] __attribute__((aligned(PAGE_SIZE))); 
     43 
     44/* Global SB handle */ 
     45extern void *bcm947xx_sbh; 
     46extern spinlock_t bcm947xx_sbh_lock; 
     47 
     48static int cfe_env; 
     49extern char *cfe_env_get(char *nv_buf, const char *name); 
     50 
     51/* Convenience */ 
     52#define sbh bcm947xx_sbh 
     53#define sbh_lock bcm947xx_sbh_lock 
     54 
     55/* Probe for NVRAM header */ 
     56static void __init 
     57early_nvram_init(void) 
     58{ 
     59        struct nvram_header *header; 
     60        chipcregs_t *cc; 
     61        struct sflash *info = NULL; 
     62        int i; 
     63        uint32 base, off, lim; 
     64        u32 *src, *dst; 
     65 
     66        if ((cc = sb_setcore(sbh, SB_CC, 0)) != NULL) { 
     67                base = KSEG1ADDR(SB_FLASH2); 
     68                switch (readl(&cc->capabilities) & CC_CAP_FLASH_MASK) { 
     69                case PFLASH: 
     70                        lim = SB_FLASH2_SZ; 
     71                        break; 
     72 
     73                case SFLASH_ST: 
     74                case SFLASH_AT: 
     75                        if ((info = sflash_init(sbh,cc)) == NULL) 
     76                                return; 
     77                        lim = info->size; 
     78                        break; 
     79 
     80                case FLASH_NONE: 
     81                default: 
     82                        return; 
    4783                } 
    48                 BCMINIT(nvram_hash)[i] = NULL; 
    49         } 
    50  
    51         /* Free dead table */ 
    52         for (t = nvram_dead; t; t = next) { 
    53                 next = t->next; 
    54                 BCMINIT(_nvram_free)(t); 
    55         } 
    56         nvram_dead = NULL; 
    57  
    58         /* Indicate to per-port code that all tuples have been freed */ 
    59         BCMINIT(_nvram_free)(NULL); 
    60 } 
    61  
    62 /* String hash */ 
    63 static INLINE uint 
    64 hash(const char *s) 
    65 { 
    66         uint hash = 0; 
    67  
    68         while (*s) 
    69                 hash = 31 * hash + *s++; 
    70  
    71         return hash; 
    72 } 
    73  
    74 /* (Re)initialize the hash table. Should be locked. */ 
    75 static int  
    76 BCMINITFN(nvram_rehash)(struct nvram_header *header) 
    77 { 
    78         char buf[] = "0xXXXXXXXX", *name, *value, *end, *eq; 
    79  
    80         /* (Re)initialize hash table */ 
    81         BCMINIT(nvram_free)(); 
    82  
    83         /* Parse and set "name=value\0 ... \0\0" */ 
    84         name = (char *) &header[1]; 
    85         end = (char *) header + NVRAM_SPACE - 2; 
    86         end[0] = end[1] = '\0'; 
    87         for (; *name; name = value + strlen(value) + 1) { 
    88                 if (!(eq = strchr(name, '='))) 
    89                         break; 
    90                 *eq = '\0'; 
    91                 value = eq + 1; 
    92                 BCMINIT(_nvram_set)(name, value); 
    93                 *eq = '='; 
    94         } 
    95  
    96         /* Set special SDRAM parameters */ 
    97         if (!BCMINIT(_nvram_get)("sdram_init")) { 
    98                 sprintf(buf, "0x%04X", (uint16)(header->crc_ver_init >> 16)); 
    99                 BCMINIT(_nvram_set)("sdram_init", buf); 
    100         } 
    101         if (!BCMINIT(_nvram_get)("sdram_config")) { 
    102                 sprintf(buf, "0x%04X", (uint16)(header->config_refresh & 0xffff)); 
    103                 BCMINIT(_nvram_set)("sdram_config", buf); 
    104         } 
    105         if (!BCMINIT(_nvram_get)("sdram_refresh")) { 
    106                 sprintf(buf, "0x%04X", (uint16)((header->config_refresh >> 16) & 0xffff)); 
    107                 BCMINIT(_nvram_set)("sdram_refresh", buf); 
    108         } 
    109         if (!BCMINIT(_nvram_get)("sdram_ncdl")) { 
    110                 sprintf(buf, "0x%08X", header->config_ncdl); 
    111                 BCMINIT(_nvram_set)("sdram_ncdl", buf); 
    112         } 
    113  
    114         return 0; 
    115 } 
    116  
    117 /* Get the value of an NVRAM variable. Should be locked. */ 
    118 char *  
    119 BCMINITFN(_nvram_get)(const char *name) 
    120 { 
    121         uint i; 
    122         struct nvram_tuple *t; 
    123         char *value; 
     84        } else { 
     85                /* extif assumed, Stop at 4 MB */ 
     86                base = KSEG1ADDR(SB_FLASH1); 
     87                lim = SB_FLASH1_SZ; 
     88        } 
     89 
     90        /* XXX: hack for supporting the CFE environment stuff on WGT634U */ 
     91        src = (u32 *) KSEG1ADDR(base + 8 * 1024 * 1024 - 0x2000); 
     92        dst = (u32 *) nvram_buf; 
     93        if ((lim == 0x02000000) && ((*src & 0xff00ff) == 0x000001)) { 
     94                printk("early_nvram_init: WGT634U NVRAM found.\n"); 
     95 
     96                for (i = 0; i < 0x1ff0; i++) { 
     97                        if (*src == 0xFFFFFFFF) 
     98                                break; 
     99                        *dst++ = *src++; 
     100                } 
     101                cfe_env = 1; 
     102                return; 
     103        } 
     104 
     105        off = FLASH_MIN; 
     106        while (off <= lim) { 
     107                /* Windowed flash access */ 
     108                header = (struct nvram_header *) KSEG1ADDR(base + off - NVRAM_SPACE); 
     109                if (header->magic == NVRAM_MAGIC) 
     110                        goto found; 
     111                off <<= 1; 
     112        } 
     113 
     114        /* Try embedded NVRAM at 4 KB and 1 KB as last resorts */ 
     115        header = (struct nvram_header *) KSEG1ADDR(base + 4 * 1024); 
     116        if (header->magic == NVRAM_MAGIC) 
     117                goto found; 
     118         
     119        header = (struct nvram_header *) KSEG1ADDR(base + 1 * 1024); 
     120        if (header->magic == NVRAM_MAGIC) 
     121                goto found; 
     122         
     123        printk("early_nvram_init: NVRAM not found\n"); 
     124        return; 
     125 
     126found: 
     127        src = (u32 *) header; 
     128        dst = (u32 *) nvram_buf; 
     129        for (i = 0; i < sizeof(struct nvram_header); i += 4) 
     130                *dst++ = *src++; 
     131        for (; i < header->len && i < NVRAM_SPACE; i += 4) 
     132                *dst++ = ltoh32(*src++); 
     133} 
     134 
     135/* Early (before mm or mtd) read-only access to NVRAM */ 
     136static char * __init 
     137early_nvram_get(const char *name) 
     138{ 
     139        char *var, *value, *end, *eq; 
    124140 
    125141        if (!name) 
    126142                return NULL; 
    127143 
    128         /* Hash the name */ 
    129         i = hash(name) % ARRAYSIZE(BCMINIT(nvram_hash)); 
    130  
    131         /* Find the associated tuple in the hash table */ 
    132         for (t = BCMINIT(nvram_hash)[i]; t && strcmp(t->name, name); t = t->next); 
    133  
    134         value = t ? t->value : NULL; 
    135  
    136         return value; 
    137 } 
    138  
    139 /* Get the value of an NVRAM variable. Should be locked. */ 
    140 int  
    141 BCMINITFN(_nvram_set)(const char *name, const char *value) 
    142 { 
    143         uint i; 
    144         struct nvram_tuple *t, *u, **prev; 
    145  
    146         /* Hash the name */ 
    147         i = hash(name) % ARRAYSIZE(BCMINIT(nvram_hash)); 
    148  
    149         /* Find the associated tuple in the hash table */ 
    150         for (prev = &BCMINIT(nvram_hash)[i], t = *prev; t && strcmp(t->name, name); prev = &t->next, t = *prev); 
    151  
    152         /* (Re)allocate tuple */ 
    153         if (!(u = BCMINIT(_nvram_realloc)(t, name, value))) 
    154                 return -12; /* -ENOMEM */ 
    155  
    156         /* Value reallocated */ 
    157         if (t && t == u) 
    158                 return 0; 
    159  
    160         /* Move old tuple to the dead table */ 
    161         if (t) { 
    162                 *prev = t->next; 
    163                 t->next = nvram_dead; 
    164                 nvram_dead = t; 
    165         } 
    166  
    167         /* Add new tuple to the hash table */ 
    168         u->next = BCMINIT(nvram_hash)[i]; 
    169         BCMINIT(nvram_hash)[i] = u; 
     144        /* Too early? */ 
     145        if (sbh == NULL) 
     146                return NULL; 
     147 
     148        if (!nvram_buf[0]) 
     149                early_nvram_init(); 
     150 
     151        if (cfe_env) 
     152                return cfe_env_get(nvram_buf, name); 
     153 
     154        /* Look for name=value and return value */ 
     155        var = &nvram_buf[sizeof(struct nvram_header)]; 
     156        end = nvram_buf + sizeof(nvram_buf) - 2; 
     157        end[0] = end[1] = '\0'; 
     158        for (; *var; var = value + strlen(value) + 1) { 
     159                if (!(eq = strchr(var, '='))) 
     160                        break; 
     161                value = eq + 1; 
     162                if ((eq - var) == strlen(name) && strncmp(var, name, (eq - var)) == 0) 
     163                        return value; 
     164        } 
     165 
     166        return NULL; 
     167} 
     168 
     169static int __init 
     170early_nvram_getall(char *buf, int count) 
     171{ 
     172        char *var, *end; 
     173        int len = 0; 
     174         
     175        /* Too early? */ 
     176        if (sbh == NULL) 
     177                return -1; 
     178 
     179        if (!nvram_buf[0]) 
     180                early_nvram_init(); 
     181 
     182        bzero(buf, count); 
     183 
     184        /* Write name=value\0 ... \0\0 */ 
     185        var = &nvram_buf[sizeof(struct nvram_header)]; 
     186        end = nvram_buf + sizeof(nvram_buf) - 2; 
     187        end[0] = end[1] = '\0'; 
     188        for (; *var; var += strlen(var) + 1) { 
     189                if ((count - len) <= (strlen(var) + 1)) 
     190                        break; 
     191                len += sprintf(buf + len, "%s", var) + 1; 
     192        } 
    170193 
    171194        return 0; 
    172195} 
    173196 
    174 /* Unset the value of an NVRAM variable. Should be locked. */ 
    175 int  
    176 BCMINITFN(_nvram_unset)(const char *name) 
    177 { 
    178         uint i; 
    179         struct nvram_tuple *t, **prev; 
    180  
    181         if (!name) 
    182                 return 0; 
    183  
    184         /* Hash the name */ 
    185         i = hash(name) % ARRAYSIZE(BCMINIT(nvram_hash)); 
    186  
    187         /* Find the associated tuple in the hash table */ 
    188         for (prev = &BCMINIT(nvram_hash)[i], t = *prev; t && strcmp(t->name, name); prev = &t->next, t = *prev); 
    189  
    190         /* Move it to the dead table */ 
    191         if (t) { 
    192                 *prev = t->next; 
    193                 t->next = nvram_dead; 
    194                 nvram_dead = t; 
    195         } 
    196  
    197         return 0; 
    198 } 
    199  
    200 /* Get all NVRAM variables. Should be locked. */ 
    201 int  
    202 BCMINITFN(_nvram_getall)(char *buf, int count) 
    203 { 
    204         uint i; 
    205         struct nvram_tuple *t; 
    206         int len = 0; 
    207  
    208         bzero(buf, count); 
    209  
    210         /* Write name=value\0 ... \0\0 */ 
    211         for (i = 0; i < ARRAYSIZE(BCMINIT(nvram_hash)); i++) { 
    212                 for (t = BCMINIT(nvram_hash)[i]; t; t = t->next) { 
    213                         if ((count - len) > (strlen(t->name) + 1 + strlen(t->value) + 1)) 
    214                                 len += sprintf(buf + len, "%s=%s", t->name, t->value) + 1; 
    215                         else 
    216                                 break; 
    217                 } 
    218         } 
    219  
    220         return 0; 
    221 } 
    222  
    223 /* Regenerate NVRAM. Should be locked. */ 
     197 
     198char * 
     199nvram_get(const char *name) 
     200{ 
     201        return early_nvram_get(name); 
     202} 
     203 
    224204int 
    225 BCMINITFN(_nvram_commit)(struct nvram_header *header) 
    226 { 
    227         char *init, *config, *refresh, *ncdl; 
    228         char *ptr, *end; 
    229         int i; 
    230         struct nvram_tuple *t; 
    231         struct nvram_header tmp; 
    232         uint8 crc; 
    233  
    234         /* Regenerate header */ 
    235         header->magic = NVRAM_MAGIC; 
    236         header->crc_ver_init = (NVRAM_VERSION << 8); 
    237         if (!(init = BCMINIT(_nvram_get)("sdram_init")) || 
    238             !(config = BCMINIT(_nvram_get)("sdram_config")) || 
    239             !(refresh = BCMINIT(_nvram_get)("sdram_refresh")) || 
    240             !(ncdl = BCMINIT(_nvram_get)("sdram_ncdl"))) { 
    241                 header->crc_ver_init |= SDRAM_INIT << 16; 
    242                 header->config_refresh = SDRAM_CONFIG; 
    243                 header->config_refresh |= SDRAM_REFRESH << 16; 
    244                 header->config_ncdl = 0; 
    245         } else { 
    246                 header->crc_ver_init |= (simple_strtoul(init, NULL, 0) & 0xffff) << 16; 
    247                 header->config_refresh = simple_strtoul(config, NULL, 0) & 0xffff; 
    248                 header->config_refresh |= (simple_strtoul(refresh, NULL, 0) & 0xffff) << 16; 
    249                 header->config_ncdl = simple_strtoul(ncdl, NULL, 0); 
    250         } 
    251  
    252         /* Clear data area */ 
    253         ptr = (char *) header + sizeof(struct nvram_header); 
    254         bzero(ptr, NVRAM_SPACE - sizeof(struct nvram_header)); 
    255  
    256         /* Leave space for a double NUL at the end */ 
    257         end = (char *) header + NVRAM_SPACE - 2; 
    258  
    259         /* Write out all tuples */ 
    260         for (i = 0; i < ARRAYSIZE(BCMINIT(nvram_hash)); i++) { 
    261                 for (t = BCMINIT(nvram_hash)[i]; t; t = t->next) { 
    262                         if ((ptr + strlen(t->name) + 1 + strlen(t->value) + 1) > end) 
    263                                 break; 
    264                         ptr += sprintf(ptr, "%s=%s", t->name, t->value) + 1; 
    265                 } 
    266         } 
    267  
    268         /* End with a double NUL */ 
    269         ptr += 2; 
    270  
    271         /* Set new length */ 
    272         header->len = ROUNDUP(ptr - (char *) header, 4); 
    273  
    274         /* Little-endian CRC8 over the last 11 bytes of the header */ 
    275         tmp.crc_ver_init = htol32(header->crc_ver_init); 
    276         tmp.config_refresh = htol32(header->config_refresh); 
    277         tmp.config_ncdl = htol32(header->config_ncdl); 
    278         crc = hndcrc8((char *) &tmp + 9, sizeof(struct nvram_header) - 9, 0xff); 
    279  
    280         /* Continue CRC8 over data bytes */ 
    281         crc = hndcrc8((char *) &header[1], header->len - sizeof(struct nvram_header), crc); 
    282  
    283         /* Set new CRC8 */ 
    284         header->crc_ver_init |= crc; 
    285  
    286         /* Reinitialize hash table */ 
    287         return BCMINIT(nvram_rehash)(header); 
    288 } 
    289  
    290 /* Initialize hash table. Should be locked. */ 
    291 int  
    292 BCMINITFN(_nvram_init)(void) 
    293 { 
    294         struct nvram_header *header; 
     205nvram_getall(char *buf, int count) 
     206{ 
     207        unsigned long flags; 
    295208        int ret; 
    296209 
    297         if (!(header = (struct nvram_header *) kmalloc(NVRAM_SPACE, GFP_ATOMIC))) { 
    298                 return -12; /* -ENOMEM */ 
    299         } 
    300  
    301         if ((ret = BCMINIT(_nvram_read)(header)) == 0 && 
    302             header->magic == NVRAM_MAGIC) 
    303                 BCMINIT(nvram_rehash)(header); 
    304  
    305         kfree(header); 
    306         return ret; 
    307 } 
    308  
    309 /* Free hash table. Should be locked. */ 
    310 void  
    311 BCMINITFN(_nvram_exit)(void) 
    312 { 
    313         BCMINIT(nvram_free)(); 
     210        return early_nvram_getall(buf, count); 
    314211} 
    315212 
     
    332229                        return (&s[len+1]); 
    333230 
    334                 while (*s++) 
    335                         ; 
     231                while (*s++); 
    336232        } 
    337233 
     
    355251} 
    356252 
    357  
Note: See TracChangeset for help on using the changeset viewer.