392 lines
8 KiB
C
392 lines
8 KiB
C
/**************************************************************************
|
|
*
|
|
* BRIEF MODULE DESCRIPTION
|
|
* nvram interface routines.
|
|
*
|
|
* Copyright 2004 IDT Inc. (rischelp@idt.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
* NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*
|
|
**************************************************************************
|
|
* May 2004 rkt, neb
|
|
*
|
|
* Initial Release
|
|
*
|
|
*
|
|
*
|
|
**************************************************************************
|
|
*/
|
|
|
|
#include <linux/ctype.h>
|
|
#include <linux/string.h>
|
|
|
|
//#include <asm/ds1553rtc.h>
|
|
#include "nvram434.h"
|
|
#define NVRAM_BASE 0xbfff8000
|
|
|
|
extern void setenv (char *e, char *v, int rewrite);
|
|
extern void unsetenv (char *e);
|
|
extern void mapenv (int (*func)(char *, char *));
|
|
extern char *getenv (char *s);
|
|
extern void purgeenv(void);
|
|
|
|
static void nvram_initenv(void);
|
|
|
|
static unsigned char
|
|
nvram_getbyte(int offs)
|
|
{
|
|
return(*((unsigned char*)(NVRAM_BASE + offs)));
|
|
}
|
|
|
|
static void
|
|
nvram_setbyte(int offs, unsigned char val)
|
|
{
|
|
unsigned char* nvramDataPointer = (unsigned char*)(NVRAM_BASE + offs);
|
|
|
|
*nvramDataPointer = val;
|
|
}
|
|
|
|
/*
|
|
* BigEndian!
|
|
*/
|
|
static unsigned short
|
|
nvram_getshort(int offs)
|
|
{
|
|
return((nvram_getbyte(offs) << 8) | nvram_getbyte(offs + 1));
|
|
}
|
|
|
|
static void
|
|
nvram_setshort(int offs, unsigned short val)
|
|
{
|
|
nvram_setbyte(offs, (unsigned char)((val >> 8) & 0xff));
|
|
nvram_setbyte(offs + 1, (unsigned char)(val & 0xff));
|
|
}
|
|
#if 0
|
|
static unsigned int
|
|
nvram_getint(int offs)
|
|
{
|
|
unsigned int val;
|
|
val = nvram_getbyte(offs) << 24;
|
|
val |= nvram_getbyte(offs + 1) << 16;
|
|
val |= nvram_getbyte(offs + 2) << 8;
|
|
val |= nvram_getbyte(offs + 3);
|
|
return(val);
|
|
}
|
|
|
|
static void
|
|
nvram_setint(int offs, unsigned int val)
|
|
{
|
|
nvram_setbyte(offs, val >> 24);
|
|
nvram_setbyte(offs + 1, val >> 16);
|
|
nvram_setbyte(offs + 2, val >> 8);
|
|
nvram_setbyte(offs + 3, val);
|
|
}
|
|
#endif
|
|
/*
|
|
* calculate NVRAM checksum
|
|
*/
|
|
static unsigned short
|
|
nvram_calcsum(void)
|
|
{
|
|
unsigned short sum = NV_MAGIC;
|
|
int i;
|
|
|
|
for (i = ENV_BASE; i < ENV_TOP; i += 2)
|
|
sum += nvram_getshort(i);
|
|
return(sum);
|
|
}
|
|
|
|
/*
|
|
* update the nvram checksum
|
|
*/
|
|
static void
|
|
nvram_updatesum (void)
|
|
{
|
|
nvram_setshort(NVOFF_CSUM, nvram_calcsum());
|
|
}
|
|
|
|
/*
|
|
* test validity of nvram by checksumming it
|
|
*/
|
|
static int
|
|
nvram_isvalid(void)
|
|
{
|
|
static int is_valid;
|
|
|
|
if (is_valid)
|
|
return(1);
|
|
|
|
if (nvram_getshort(NVOFF_MAGIC) != NV_MAGIC) {
|
|
printk("nvram_isvalid FAILED\n");
|
|
//nvram_initenv();
|
|
}
|
|
is_valid = 1;
|
|
return(1);
|
|
}
|
|
|
|
/* return nvram address of environment string */
|
|
static int
|
|
nvram_matchenv(char *s)
|
|
{
|
|
int envsize, envp, n, i, varsize;
|
|
char *var;
|
|
|
|
envsize = nvram_getshort(NVOFF_ENVSIZE);
|
|
|
|
if (envsize > ENV_AVAIL)
|
|
return(0); /* sanity */
|
|
|
|
envp = ENV_BASE;
|
|
|
|
if ((n = strlen (s)) > 255)
|
|
return(0);
|
|
|
|
while (envsize > 0) {
|
|
varsize = nvram_getbyte(envp);
|
|
if (varsize == 0 || (envp + varsize) > ENV_TOP)
|
|
return(0); /* sanity */
|
|
for (i = envp + 1, var = s; i <= envp + n; i++, var++) {
|
|
char c1 = nvram_getbyte(i);
|
|
char c2 = *var;
|
|
if (islower(c1))
|
|
c1 = toupper(c1);
|
|
if (islower(c2))
|
|
c2 = toupper(c2);
|
|
if (c1 != c2)
|
|
break;
|
|
}
|
|
if (i > envp + n) { /* match so far */
|
|
if (n == varsize - 1) /* match on boolean */
|
|
return(envp);
|
|
if (nvram_getbyte(i) == '=') /* exact match on variable */
|
|
return(envp);
|
|
}
|
|
envsize -= varsize;
|
|
envp += varsize;
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
static void nvram_initenv(void)
|
|
{
|
|
nvram_setshort(NVOFF_MAGIC, NV_MAGIC);
|
|
nvram_setshort(NVOFF_ENVSIZE, 0);
|
|
|
|
nvram_updatesum();
|
|
}
|
|
|
|
static void
|
|
nvram_delenv(char *s)
|
|
{
|
|
int nenvp, envp, envsize, nbytes;
|
|
|
|
envp = nvram_matchenv(s);
|
|
if (envp == 0)
|
|
return;
|
|
|
|
nenvp = envp + nvram_getbyte(envp);
|
|
envsize = nvram_getshort(NVOFF_ENVSIZE);
|
|
nbytes = envsize - (nenvp - ENV_BASE);
|
|
nvram_setshort(NVOFF_ENVSIZE, envsize - (nenvp - envp));
|
|
while (nbytes--) {
|
|
nvram_setbyte(envp, nvram_getbyte(nenvp));
|
|
envp++;
|
|
nenvp++;
|
|
}
|
|
nvram_updatesum();
|
|
}
|
|
|
|
static int
|
|
nvram_setenv(char *s, char *v)
|
|
{
|
|
int ns, nv, total;
|
|
int envp;
|
|
|
|
if (!nvram_isvalid())
|
|
return(-1);
|
|
|
|
nvram_delenv(s);
|
|
ns = strlen(s);
|
|
if (ns == 0)
|
|
return (-1);
|
|
if (v && *v) {
|
|
nv = strlen(v);
|
|
total = ns + nv + 2;
|
|
}
|
|
else {
|
|
nv = 0;
|
|
total = ns + 1;
|
|
}
|
|
if (total > 255 || total > ENV_AVAIL - nvram_getshort(NVOFF_ENVSIZE))
|
|
return(-1);
|
|
|
|
envp = ENV_BASE + nvram_getshort(NVOFF_ENVSIZE);
|
|
|
|
nvram_setbyte(envp, (unsigned char) total);
|
|
envp++;
|
|
|
|
while (ns--) {
|
|
nvram_setbyte(envp, *s);
|
|
envp++;
|
|
s++;
|
|
}
|
|
|
|
if (nv) {
|
|
nvram_setbyte(envp, '=');
|
|
envp++;
|
|
while (nv--) {
|
|
nvram_setbyte(envp, *v);
|
|
envp++;
|
|
v++;
|
|
}
|
|
}
|
|
nvram_setshort(NVOFF_ENVSIZE, envp-ENV_BASE);
|
|
nvram_updatesum();
|
|
return 0;
|
|
}
|
|
|
|
static char *
|
|
nvram_getenv(char *s)
|
|
{
|
|
static char buf[256]; /* FIXME: this cannot be static */
|
|
int envp, ns, nbytes, i;
|
|
|
|
if (!nvram_isvalid())
|
|
return "INVALID NVRAM"; //((char *)0);
|
|
|
|
envp = nvram_matchenv(s);
|
|
if (envp == 0)
|
|
return "NOT FOUND"; //((char *)0);
|
|
ns = strlen(s);
|
|
if (nvram_getbyte(envp) == ns + 1) /* boolean */
|
|
buf[0] = '\0';
|
|
else {
|
|
nbytes = nvram_getbyte(envp) - (ns + 2);
|
|
envp += ns + 2;
|
|
for (i = 0; i < nbytes; i++)
|
|
buf[i] = nvram_getbyte(envp++);
|
|
buf[i] = '\0';
|
|
}
|
|
return(buf);
|
|
}
|
|
|
|
static void
|
|
nvram_unsetenv(char *s)
|
|
{
|
|
if (!nvram_isvalid())
|
|
return;
|
|
|
|
nvram_delenv(s);
|
|
}
|
|
|
|
/*
|
|
* apply func to each string in environment
|
|
*/
|
|
static void
|
|
nvram_mapenv(int (*func)(char *, char *))
|
|
{
|
|
int envsize, envp, n, i, seeneql;
|
|
char name[256], value[256];
|
|
char c, *s;
|
|
|
|
if (!nvram_isvalid())
|
|
return;
|
|
|
|
envsize = nvram_getshort(NVOFF_ENVSIZE);
|
|
envp = ENV_BASE;
|
|
|
|
while (envsize > 0) {
|
|
value[0] = '\0';
|
|
seeneql = 0;
|
|
s = name;
|
|
n = nvram_getbyte(envp);
|
|
for (i = envp + 1; i < envp + n; i++) {
|
|
c = nvram_getbyte(i);
|
|
if ((c == '=') && !seeneql) {
|
|
*s = '\0';
|
|
s = value;
|
|
seeneql = 1;
|
|
continue;
|
|
}
|
|
*s++ = c;
|
|
}
|
|
*s = '\0';
|
|
(*func)(name, value);
|
|
envsize -= n;
|
|
envp += n;
|
|
}
|
|
}
|
|
#if 0
|
|
static unsigned int
|
|
digit(char c)
|
|
{
|
|
if ('0' <= c && c <= '9')
|
|
return (c - '0');
|
|
if ('A' <= c && c <= 'Z')
|
|
return (10 + c - 'A');
|
|
if ('a' <= c && c <= 'z')
|
|
return (10 + c - 'a');
|
|
return (~0);
|
|
}
|
|
#endif
|
|
/*
|
|
* Wrappers to allow 'special' environment variables to get processed
|
|
*/
|
|
void
|
|
setenv(char *e, char *v, int rewrite)
|
|
{
|
|
if (nvram_getenv(e) && !rewrite)
|
|
return;
|
|
|
|
nvram_setenv(e, v);
|
|
}
|
|
|
|
char *
|
|
getenv(char *e)
|
|
{
|
|
return(nvram_getenv(e));
|
|
}
|
|
|
|
void
|
|
unsetenv(char *e)
|
|
{
|
|
nvram_unsetenv(e);
|
|
}
|
|
|
|
void
|
|
purgeenv()
|
|
{
|
|
int i;
|
|
unsigned char* nvramDataPointer = (unsigned char*)(NVRAM_BASE);
|
|
|
|
for (i = ENV_BASE; i < ENV_TOP; i++)
|
|
*nvramDataPointer++ = 0;
|
|
nvram_setshort(NVOFF_MAGIC, NV_MAGIC);
|
|
nvram_setshort(NVOFF_ENVSIZE, 0);
|
|
nvram_setshort(NVOFF_CSUM, NV_MAGIC);
|
|
}
|
|
|
|
void
|
|
mapenv(int (*func)(char *, char *))
|
|
{
|
|
nvram_mapenv(func);
|
|
}
|