878 lines
13 KiB
C
878 lines
13 KiB
C
/*
|
|
* Decode pcmciad file.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include "cardd.h"
|
|
|
|
static FILE *in;
|
|
static int pushc, pusht;
|
|
static int lineno;
|
|
static char *filename;
|
|
|
|
static char *keys[] =
|
|
{
|
|
"io", /* 1 */
|
|
"irq", /* 2 */
|
|
"memory", /* 3 */
|
|
"card", /* 4 */
|
|
"device", /* 5 */
|
|
"config", /* 6 */
|
|
"__EOF__", /* 7 */
|
|
"reset", /* 8 */
|
|
"ether", /* 9 */
|
|
"insert", /* 10 */
|
|
"remove", /* 11 */
|
|
"iosize", /* 12 */
|
|
"memsize", /* 13 */
|
|
0
|
|
};
|
|
|
|
struct flags
|
|
{
|
|
char *name;
|
|
int mask;
|
|
};
|
|
|
|
void parsefile();
|
|
char *token();
|
|
char *getline();
|
|
char *next_tok();
|
|
int num_tok();
|
|
void error(char *);
|
|
int keyword(char *);
|
|
struct allocblk *ioblk_tok(int);
|
|
struct allocblk *memblk_tok(int);
|
|
int irq_tok(int);
|
|
void setflags(struct flags *, int *);
|
|
struct driver *new_driver(char *);
|
|
|
|
void addcmd(struct cmd **cp);
|
|
void parse_card();
|
|
|
|
/*
|
|
* Read a file and parse the pcmcia configuration data.
|
|
* After parsing, verify the links.
|
|
*/
|
|
void
|
|
readfile(char *name)
|
|
{
|
|
struct card *cp;
|
|
|
|
in = fopen(name, "r");
|
|
if (in == 0)
|
|
{
|
|
perror(name);
|
|
exit(1);
|
|
}
|
|
parsefile();
|
|
for (cp = cards; cp; cp = cp->next)
|
|
{
|
|
if (cp->config == 0)
|
|
fprintf(stderr, "warning: card %s(%s) has no valid configuration\n",
|
|
cp->manuf, cp->version);
|
|
}
|
|
}
|
|
void
|
|
parsefile()
|
|
{
|
|
int i;
|
|
struct allocblk *bp;
|
|
|
|
pushc = 0;
|
|
lineno = 1;
|
|
for(;;)
|
|
switch(keyword(next_tok()))
|
|
{
|
|
default:
|
|
error("Syntax error");
|
|
pusht = 0;
|
|
break;
|
|
case 7:
|
|
return;
|
|
/*
|
|
* reserved I/O blocks
|
|
*/
|
|
case 1:
|
|
while ((bp = ioblk_tok(0)) != 0)
|
|
{
|
|
if (bp->size == 0 || bp->addr == 0)
|
|
{
|
|
free(bp);
|
|
continue;
|
|
}
|
|
bit_nset(io_avail, bp->addr, bp->addr+bp->size-1);
|
|
bp->next = pool_ioblks;
|
|
pool_ioblks = bp;
|
|
}
|
|
pusht = 1;
|
|
break;
|
|
/*
|
|
* reserved irqs
|
|
*/
|
|
case 2:
|
|
while ((i = irq_tok(0)) > 0)
|
|
pool_irq[i] = 1;
|
|
pusht = 1;
|
|
break;
|
|
/*
|
|
* reserved memory blocks.
|
|
*/
|
|
case 3:
|
|
while ((bp = memblk_tok(0)) != 0)
|
|
{
|
|
if (bp->size == 0 || bp->addr == 0)
|
|
{
|
|
free(bp);
|
|
continue;
|
|
}
|
|
bit_nset(mem_avail, MEM2BIT(bp->addr),
|
|
MEM2BIT(bp->addr+bp->size)-1);
|
|
bp->next = pool_mem;
|
|
pool_mem = bp;
|
|
}
|
|
pusht = 1;
|
|
break;
|
|
/*
|
|
* Card definition.
|
|
*/
|
|
case 4:
|
|
parse_card();
|
|
break;
|
|
/*
|
|
* Device description
|
|
*/
|
|
#if 0
|
|
case 5:
|
|
parse_device();
|
|
break;
|
|
#endif
|
|
}
|
|
}
|
|
/*
|
|
* Parse a card definition.
|
|
*/
|
|
void
|
|
parse_card()
|
|
{
|
|
char *man, *vers;
|
|
struct card *cp;
|
|
int i;
|
|
struct card_config *confp, *lastp;
|
|
|
|
man = newstr(next_tok());
|
|
vers = newstr(next_tok());
|
|
cp = xmalloc(sizeof(*cp));
|
|
cp->manuf = man;
|
|
cp->version = vers;
|
|
cp->reset_time = 50;
|
|
cp->next = cards;
|
|
cards = cp;
|
|
for (;;)
|
|
{
|
|
switch(keyword(next_tok()))
|
|
{
|
|
default:
|
|
pusht = 1;
|
|
return;
|
|
case 8:
|
|
i = num_tok();
|
|
if (i == -1)
|
|
{
|
|
error("Illegal card reset time");
|
|
break;
|
|
}
|
|
cp->reset_time = i;
|
|
break;
|
|
case 6:
|
|
i = num_tok();
|
|
if (i == -1)
|
|
{
|
|
error("Illegal card config index");
|
|
break;
|
|
}
|
|
confp = xmalloc(sizeof(*confp));
|
|
man = next_tok();
|
|
confp->driver = new_driver(man);
|
|
confp->irq = num_tok();
|
|
confp->flags = num_tok();
|
|
if (confp->flags == -1)
|
|
{
|
|
pusht = 1;
|
|
confp->flags = 0;
|
|
}
|
|
if (confp->irq < 0 || confp->irq > 15)
|
|
{
|
|
error("Illegal card IRQ value");
|
|
break;
|
|
}
|
|
confp->index = i & 0x3F;
|
|
/*
|
|
* If no valid driver for this config, then do not save
|
|
* this configuration entry.
|
|
*/
|
|
if (confp->driver)
|
|
{
|
|
if (cp->config == 0)
|
|
cp->config = confp;
|
|
else
|
|
{
|
|
for (lastp = cp->config; lastp->next;
|
|
lastp = lastp->next)
|
|
;
|
|
lastp->next = confp;
|
|
}
|
|
}
|
|
else
|
|
free(confp);
|
|
break;
|
|
case 9:
|
|
cp->ether = num_tok();
|
|
if (cp->ether == -1)
|
|
{
|
|
error("Illegal ether address offset");
|
|
cp->ether = 0;
|
|
}
|
|
break;
|
|
case 10:
|
|
addcmd(&cp->insert);
|
|
break;
|
|
case 11:
|
|
addcmd(&cp->remove);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
* Generate a new driver structure. If one exists, use
|
|
* that one after confirming the correct class.
|
|
*/
|
|
struct driver *
|
|
new_driver(char *name)
|
|
{
|
|
struct driver *drvp;
|
|
char *p;
|
|
|
|
for (drvp = drivers; drvp; drvp = drvp->next)
|
|
if (strcmp(drvp->name, name)==0)
|
|
return(drvp);
|
|
drvp = xmalloc(sizeof(*drvp));
|
|
drvp->next = drivers;
|
|
drivers = drvp;
|
|
drvp->name = newstr(name);
|
|
drvp->kernel = newstr(name);
|
|
p = drvp->kernel;
|
|
while (*p++)
|
|
if (*p >= '0' && *p <= '9')
|
|
{
|
|
drvp->unit = atoi(p);
|
|
*p = 0;
|
|
break;
|
|
}
|
|
#ifdef DEBUG
|
|
if (verbose)
|
|
printf("Drv %s%d created\n", drvp->kernel, drvp->unit);
|
|
#endif
|
|
return(drvp);
|
|
}
|
|
#if 0
|
|
/*
|
|
* Parse the device description.
|
|
*/
|
|
parse_device()
|
|
{
|
|
enum drvclass type = drvclass_tok();
|
|
struct device *dp;
|
|
static struct device *lastp;
|
|
|
|
if (type == drv_none)
|
|
{
|
|
error("Unknown driver class");
|
|
return;
|
|
}
|
|
dp = xmalloc(sizeof(*dp));
|
|
dp->type = type;
|
|
if (devlist == 0)
|
|
devlist = dp;
|
|
else
|
|
lastp->next = dp;
|
|
lastp = dp;
|
|
for (;;)
|
|
switch(keyword(next_tok()))
|
|
{
|
|
default:
|
|
pusht = 1;
|
|
return;
|
|
case 10:
|
|
addcmd(&dp->insert);
|
|
break;
|
|
case 11:
|
|
addcmd(&dp->remove);
|
|
break;
|
|
}
|
|
}
|
|
/*
|
|
* Parse the driver description.
|
|
*/
|
|
parse_driver()
|
|
{
|
|
char *name, *dev, *p;
|
|
struct driver *dp;
|
|
static struct driver *lastp;
|
|
int i;
|
|
struct allocblk *bp;
|
|
static struct flags io_flags[] =
|
|
{
|
|
{ "ws", 0x01 },
|
|
{ "16bit", 0x02 },
|
|
{ "cs16", 0x04 },
|
|
{ "zerows", 0x08 },
|
|
{ 0, 0 }
|
|
};
|
|
static struct flags mem_flags[] =
|
|
{
|
|
{ "16bit", 0x01 },
|
|
{ "zerows", 0x02 },
|
|
{ "ws0", 0x04 },
|
|
{ "ws1", 0x08 },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
name = newstr(next_tok());
|
|
dev = newstr(next_tok());
|
|
type = drvclass_tok();
|
|
if (type == drv_none)
|
|
{
|
|
error("Unknown driver class");
|
|
return;
|
|
}
|
|
dp = xmalloc(sizeof(*dp));
|
|
dp->name = name;
|
|
dp->kernel = dev;
|
|
dp->type = type;
|
|
dp->unit = -1;
|
|
dp->irq = -1;
|
|
/*
|
|
* Check for unit number in driver name.
|
|
*/
|
|
p = dev;
|
|
while (*p++)
|
|
if (*p >= '0' && *p <= '9')
|
|
{
|
|
dp->unit = atoi(p);
|
|
*p = 0;
|
|
break;
|
|
}
|
|
if (dp->unit < 0)
|
|
error("Illegal kernel driver unit");
|
|
/*
|
|
* Place at end of list.
|
|
*/
|
|
if (lastp == 0)
|
|
drivers = dp;
|
|
else
|
|
lastp->next = dp;
|
|
lastp = dp;
|
|
for (;;)
|
|
switch(keyword(next_tok()))
|
|
{
|
|
default:
|
|
pusht = 1;
|
|
return;
|
|
case 1:
|
|
bp = ioblk_tok(1);
|
|
if (bp)
|
|
{
|
|
setflags(io_flags, &bp->flags);
|
|
if (dp->io)
|
|
{
|
|
error("Duplicate I/O spec");
|
|
free(bp);
|
|
}
|
|
else
|
|
{
|
|
bit_nclear(io_avail, bp->addr,
|
|
bp->addr+bp->size-1);
|
|
dp->io = bp;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
dp->irq = irq_tok(1);
|
|
if (dp->irq > 0)
|
|
pool_irq[i] = 0;
|
|
break;
|
|
case 3:
|
|
bp = memblk_tok(1);
|
|
if (bp)
|
|
{
|
|
setflags(mem_flags, &bp->flags);
|
|
if (dp->mem)
|
|
{
|
|
error("Duplicate memory spec");
|
|
free(bp);
|
|
}
|
|
else
|
|
{
|
|
bit_nclear(mem_avail,
|
|
MEM2BIT(bp->addr),
|
|
MEM2BIT(bp->addr+bp->size)-1);
|
|
dp->mem = bp;
|
|
}
|
|
}
|
|
break;
|
|
case 10:
|
|
addcmd(&dp->insert);
|
|
break;
|
|
case 11:
|
|
addcmd(&dp->remove);
|
|
break;
|
|
/*
|
|
* iosize - Don't allocate an I/O port, but specify
|
|
* a size for the range of ports. The actual port number
|
|
* will be allocated dynamically.
|
|
*/
|
|
case 12:
|
|
i = num_tok();
|
|
if (i <= 0 || i > 128)
|
|
error("Illegal iosize");
|
|
else
|
|
{
|
|
int flags = 0;
|
|
setflags(io_flags, &flags);
|
|
if (dp->io)
|
|
error("Duplicate I/O spec");
|
|
else
|
|
{
|
|
dp->io = xmalloc(sizeof(*dp->io));
|
|
dp->io->flags = flags;
|
|
dp->io->size = i;
|
|
}
|
|
}
|
|
break;
|
|
case 13:
|
|
i = num_tok();
|
|
if (i <= 0 || i > 256*1024)
|
|
error("Illegal memsize");
|
|
else
|
|
{
|
|
int flags = 0;
|
|
setflags(mem_flags, &flags);
|
|
if (dp->mem)
|
|
error("Duplicate memory spec");
|
|
else
|
|
{
|
|
dp->mem = xmalloc(sizeof(*dp->mem));
|
|
dp->mem->flags = flags;
|
|
dp->mem->size = i;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
/*
|
|
* drvclass_tok - next token is expected to
|
|
* be a driver class.
|
|
*/
|
|
enum drvclass
|
|
drvclass_tok()
|
|
{
|
|
char *s = next_tok();
|
|
|
|
if (strcmp(s, "tty")==0)
|
|
return(drv_tty);
|
|
else if (strcmp(s, "net")==0)
|
|
return(drv_net);
|
|
else if (strcmp(s, "bio")==0)
|
|
return(drv_bio);
|
|
else if (strcmp(s, "null")==0)
|
|
return(drv_null);
|
|
return(drv_none);
|
|
}
|
|
#endif /* 0 */
|
|
/*
|
|
* Parse one I/O block.
|
|
*/
|
|
struct allocblk *
|
|
ioblk_tok(int force)
|
|
{
|
|
struct allocblk *io;
|
|
int i, j;
|
|
|
|
if ((i = num_tok()) >= 0)
|
|
{
|
|
if (strcmp("-", next_tok()) || (j = num_tok()) < 0 || j < i)
|
|
{
|
|
error("I/O block format error");
|
|
return(0);
|
|
}
|
|
io = xmalloc(sizeof(*io));
|
|
io->addr = i;
|
|
io->size = j - i + 1;
|
|
if (j > IOPORTS)
|
|
{
|
|
error("I/O port out of range");
|
|
if (force)
|
|
{
|
|
free(io);
|
|
io = 0;
|
|
}
|
|
else
|
|
io->addr = io->size = 0;
|
|
}
|
|
return(io);
|
|
}
|
|
if (force)
|
|
error("Illegal or missing I/O block spec");
|
|
return(0);
|
|
}
|
|
/*
|
|
* Parse a memory block.
|
|
*/
|
|
struct allocblk *
|
|
memblk_tok(int force)
|
|
{
|
|
struct allocblk *mem;
|
|
int i, j;
|
|
|
|
if ((i = num_tok()) >= 0)
|
|
if ((j = num_tok()) < 0)
|
|
error("Illegal memory block");
|
|
else
|
|
{
|
|
mem = xmalloc(sizeof(*mem));
|
|
mem->addr = i & ~(MEMUNIT-1);
|
|
mem->size = (j + MEMUNIT - 1) & ~(MEMUNIT-1);
|
|
if (i < MEMSTART || (i + j) > MEMEND)
|
|
{
|
|
error("Memory address out of range");
|
|
if (force)
|
|
{
|
|
free(mem);
|
|
mem = 0;
|
|
}
|
|
else
|
|
mem->addr = mem->size = 0;
|
|
}
|
|
return(mem);
|
|
}
|
|
if (force)
|
|
error("Illegal or missing memory block spec");
|
|
return(0);
|
|
}
|
|
/*
|
|
* IRQ token. Must be number > 0 && < 16.
|
|
* If force is set, IRQ must exist, and can also be '?'.
|
|
*/
|
|
int
|
|
irq_tok(int force)
|
|
{
|
|
int i;
|
|
|
|
if (strcmp("?", next_tok())==0 && force)
|
|
return(0);
|
|
pusht = 1;
|
|
i = num_tok();
|
|
if (i > 0 && i < 16)
|
|
return(i);
|
|
if (force)
|
|
error("Illegal IRQ value");
|
|
return(-1);
|
|
}
|
|
/*
|
|
* search the table for a match.
|
|
*/
|
|
int
|
|
keyword(char *str)
|
|
{
|
|
char **s;
|
|
int i = 1;
|
|
|
|
for (s = keys; *s; s++, i++)
|
|
if (strcmp(*s, str)==0)
|
|
return(i);
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* Set/clear flags
|
|
*/
|
|
void
|
|
setflags(struct flags *flags, int *value)
|
|
{
|
|
char *s;
|
|
struct flags *fp;
|
|
int set = 1;
|
|
|
|
do {
|
|
s = next_tok();
|
|
if (*s == '!')
|
|
{
|
|
s++;
|
|
set = 0;
|
|
}
|
|
for (fp = flags; fp->name; fp++)
|
|
if (strcmp(s, fp->name)==0)
|
|
{
|
|
if (set)
|
|
*value |= fp->mask;
|
|
else
|
|
*value &= ~fp->mask;
|
|
break;
|
|
}
|
|
} while (fp->name);
|
|
pusht = 1;
|
|
}
|
|
/*
|
|
* addcmd - Append the command line to the list of
|
|
* commands.
|
|
*/
|
|
void
|
|
addcmd(struct cmd **cp)
|
|
{
|
|
char *s = getline();
|
|
struct cmd *ncp;
|
|
|
|
if (*s)
|
|
{
|
|
ncp = xmalloc(sizeof(*ncp));
|
|
ncp->line = s;
|
|
while (*cp)
|
|
cp = &(*cp)->next;
|
|
*cp = ncp;
|
|
}
|
|
}
|
|
void
|
|
error(char *msg)
|
|
{
|
|
pusht = 1;
|
|
fprintf(stderr, "%s: %s at line %d, near %s\n",
|
|
filename, msg, lineno, next_tok());
|
|
pusht = 1;
|
|
}
|
|
int last_char;
|
|
|
|
int
|
|
get()
|
|
{
|
|
int c;
|
|
|
|
if (pushc)
|
|
c = pushc;
|
|
else
|
|
c = getc(in);
|
|
pushc = 0;
|
|
while (c == '\\')
|
|
{
|
|
c = getc(in);
|
|
switch(c)
|
|
{
|
|
case '#':
|
|
return(last_char = c);
|
|
case '\n':
|
|
lineno++;
|
|
c = getc(in);
|
|
continue;
|
|
}
|
|
pushc = c;
|
|
return('\\');
|
|
}
|
|
if (c == '\n')
|
|
lineno++;
|
|
if (c == '#')
|
|
{
|
|
while (get() != '\n')
|
|
;
|
|
return(last_char = '\n');
|
|
}
|
|
return(last_char = c);
|
|
}
|
|
/*
|
|
* num_tok - expecting a number token. If not a number,
|
|
* return -1.
|
|
* Handles octal (who uses octal anymore?)
|
|
* hex
|
|
* decimal
|
|
* Looks for a 'k' at the end of decimal numbers
|
|
* and multiplies by 1024.
|
|
*/
|
|
int
|
|
num_tok()
|
|
{
|
|
char *s = next_tok(), c;
|
|
int val=0, base;
|
|
|
|
base = 10;
|
|
c = *s++;
|
|
if (c == '0')
|
|
{
|
|
base = 8;
|
|
c = *s++;
|
|
if (c == 'x' || c == 'X')
|
|
{
|
|
c = *s++;
|
|
base = 16;
|
|
}
|
|
}
|
|
do {
|
|
switch(c)
|
|
{
|
|
case 'k':
|
|
case 'K':
|
|
if (val && base == 10 && *s == 0)
|
|
return(val * 1024);
|
|
return(-1);
|
|
default:
|
|
return(-1);
|
|
case '0': case '1':
|
|
case '2': case '3':
|
|
case '4': case '5':
|
|
case '6': case '7':
|
|
val = val * base + c - '0';
|
|
break;
|
|
|
|
case '8': case '9':
|
|
if (base == 8)
|
|
return(-1);
|
|
else
|
|
val = val * base + c - '0';
|
|
break;
|
|
case 'a': case 'b':
|
|
case 'c': case 'd':
|
|
case 'e': case 'f':
|
|
if (base == 16)
|
|
val = val * base + c - 'a' + 10;
|
|
else
|
|
return(-1);
|
|
break;
|
|
case 'A': case 'B':
|
|
case 'C': case 'D':
|
|
case 'E': case 'F':
|
|
if (base == 16)
|
|
val = val * base + c - 'A' + 10;
|
|
else
|
|
return(-1);
|
|
break;
|
|
}
|
|
} while ((c = *s++) != 0);
|
|
return(val);
|
|
}
|
|
char *_next_tok();
|
|
char *
|
|
next_tok()
|
|
{
|
|
char *s = _next_tok();
|
|
#if 0
|
|
printf("Tok = %s\n", s);
|
|
#endif
|
|
return(s);
|
|
}
|
|
/*
|
|
* get one token. Handles string quoting etc.
|
|
*/
|
|
char *
|
|
_next_tok()
|
|
{
|
|
static char buf[1024];
|
|
char *p = buf, instr = 0;
|
|
int c;
|
|
|
|
if (pusht)
|
|
{
|
|
pusht = 0;
|
|
return(buf);
|
|
}
|
|
for(;;)
|
|
{
|
|
c = get();
|
|
switch(c)
|
|
{
|
|
default:
|
|
*p++ = c;
|
|
break;
|
|
case '"':
|
|
if (instr)
|
|
{
|
|
*p++ = 0;
|
|
return(buf);
|
|
}
|
|
instr = 1;
|
|
break;
|
|
case '\n':
|
|
if (instr)
|
|
{
|
|
error("Unterminated string");
|
|
break;
|
|
}
|
|
/*
|
|
* Eat whitespace unless in a string.
|
|
*/
|
|
case ' ':
|
|
case '\t':
|
|
if (!instr)
|
|
{
|
|
if (p!=buf)
|
|
{
|
|
*p++ = 0;
|
|
return(buf);
|
|
}
|
|
}
|
|
else
|
|
*p++ = c;
|
|
break;
|
|
/*
|
|
* Special characters that must be tokens on their own.
|
|
*/
|
|
case '-':
|
|
case '?':
|
|
case '*':
|
|
if (instr)
|
|
*p++ = c;
|
|
else
|
|
{
|
|
if (p != buf)
|
|
pushc = c;
|
|
else
|
|
*p++ = c;
|
|
*p++ = 0;
|
|
return(buf);
|
|
}
|
|
break;
|
|
case EOF:
|
|
if (p != buf)
|
|
{
|
|
*p++ = 0;
|
|
return(buf);
|
|
}
|
|
strcpy(buf, "__EOF__");
|
|
return(buf);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* get the rest of the line. If the
|
|
* last character scanned was a newline, then
|
|
* return an empty line. If this isn't checked, then
|
|
* a getline may incorrectly return the next line.
|
|
*/
|
|
char *
|
|
getline()
|
|
{
|
|
char buf[1024], *p = buf;
|
|
int c, i = 0;
|
|
|
|
if (last_char == '\n')
|
|
return(newstr(""));
|
|
do {
|
|
c = get();
|
|
} while (c == ' ' || c == '\t');
|
|
for (;c != '\n' && c != EOF; c = get())
|
|
if (i++ < sizeof(buf)-10)
|
|
*p++ = c;
|
|
*p = 0;
|
|
return(newstr(buf));
|
|
}
|