Google Git
Sign in
linux / linux / kernel / git / viro / vfs / 9255a42119bac1ae0ff8a97af20496b37e71ea9b / . / drivers / staging / dgap / dgap_parse.c
blob: ff9d19449b43c1dc41d8b0a8ba0e9bdc3c2a0116 [file] [log] [blame]
/*
* Copyright 2003 Digi International (www.digi.com)
* Scott H Kilau <Scott_Kilau at digi dot 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, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* 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.
*
*
* NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE!
*
* This is shared code between Digi's CVS archive and the
* Linux Kernel sources.
* Changing the source just for reformatting needlessly breaks
* our CVS diff history.
*
* Send any bug fixes/changes to: Eng.Linux at digi dot com.
* Thank you.
*
*
*****************************************************************************
*
* dgap_parse.c - Parses the configuration information from the input file.
*
* $Id: dgap_parse.c,v 1.1 2009/10/23 14:01:57 markh Exp $
*
*/
#include <linux/kernel.h>
#include <linux/ctype.h>
#include <linux/slab.h>
#include "dgap_types.h"
#include "dgap_fep5.h"
#include "dgap_driver.h"
#include "dgap_conf.h"
/*
* Function prototypes.
*/
static int dgap_gettok(char **in, struct cnode *p);
static char *dgap_getword(char **in);
static char *dgap_savestring(char *s);
static struct cnode *dgap_newnode(int t);
static int dgap_checknode(struct cnode *p);
static void dgap_err(char *s);
/*
* Our needed internal static variables...
*/
static struct cnode dgap_head;
#define MAXCWORD 200
static char dgap_cword[MAXCWORD];
struct toklist {
int token;
char *string;
};
static struct toklist dgap_tlist[] = {
{ BEGIN, "config_begin" },
{ END, "config_end" },
{ BOARD, "board" },
{ PCX, "Digi_AccelePort_C/X_PCI" }, /* C/X_PCI */
{ PEPC, "Digi_AccelePort_EPC/X_PCI" }, /* EPC/X_PCI */
{ PPCM, "Digi_AccelePort_Xem_PCI" }, /* PCI/Xem */
{ APORT2_920P, "Digi_AccelePort_2r_920_PCI" },
{ APORT4_920P, "Digi_AccelePort_4r_920_PCI" },
{ APORT8_920P, "Digi_AccelePort_8r_920_PCI" },
{ PAPORT4, "Digi_AccelePort_4r_PCI(EIA-232/RS-422)" },
{ PAPORT8, "Digi_AccelePort_8r_PCI(EIA-232/RS-422)" },
{ IO, "io" },
{ PCIINFO, "pciinfo" },
{ LINE, "line" },
{ CONC, "conc" },
{ CONC, "concentrator" },
{ CX, "cx" },
{ CX, "ccon" },
{ EPC, "epccon" },
{ EPC, "epc" },
{ MOD, "module" },
{ ID, "id" },
{ STARTO, "start" },
{ SPEED, "speed" },
{ CABLE, "cable" },
{ CONNECT, "connect" },
{ METHOD, "method" },
{ STATUS, "status" },
{ CUSTOM, "Custom" },
{ BASIC, "Basic" },
{ MEM, "mem" },
{ MEM, "memory" },
{ PORTS, "ports" },
{ MODEM, "modem" },
{ NPORTS, "nports" },
{ TTYN, "ttyname" },
{ CU, "cuname" },
{ PRINT, "prname" },
{ CMAJOR, "major" },
{ ALTPIN, "altpin" },
{ USEINTR, "useintr" },
{ TTSIZ, "ttysize" },
{ CHSIZ, "chsize" },
{ BSSIZ, "boardsize" },
{ UNTSIZ, "schedsize" },
{ F2SIZ, "f2200size" },
{ VPSIZ, "vpixsize" },
{ 0, NULL }
};
/*
* Parse a configuration file read into memory as a string.
*/
int dgap_parsefile(char **in, int Remove)
{
struct cnode *p, *brd, *line, *conc;
int rc;
char *s = NULL, *s2 = NULL;
int linecnt = 0;
p = &dgap_head;
brd = line = conc = NULL;
/* perhaps we are adding to an existing list? */
while (p->next != NULL) {
p = p->next;
}
/* file must start with a BEGIN */
while ( (rc = dgap_gettok(in,p)) != BEGIN ) {
if (rc == 0) {
dgap_err("unexpected EOF");
return(-1);
}
}
for (; ; ) {
rc = dgap_gettok(in,p);
if (rc == 0) {
dgap_err("unexpected EOF");
return(-1);
}
switch (rc) {
case 0:
dgap_err("unexpected end of file");
return(-1);
case BEGIN: /* should only be 1 begin */
dgap_err("unexpected config_begin\n");
return(-1);
case END:
return(0);
case BOARD: /* board info */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(BNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
p->u.board.status = dgap_savestring("No");
line = conc = NULL;
brd = p;
linecnt = -1;
break;
case APORT2_920P: /* AccelePort_4 */
if (p->type != BNODE) {
dgap_err("unexpected Digi_2r_920 string");
return(-1);
}
p->u.board.type = APORT2_920P;
p->u.board.v_type = 1;
DPR_INIT(("Adding Digi_2r_920 PCI to config...\n"));
break;
case APORT4_920P: /* AccelePort_4 */
if (p->type != BNODE) {
dgap_err("unexpected Digi_4r_920 string");
return(-1);
}
p->u.board.type = APORT4_920P;
p->u.board.v_type = 1;
DPR_INIT(("Adding Digi_4r_920 PCI to config...\n"));
break;
case APORT8_920P: /* AccelePort_8 */
if (p->type != BNODE) {
dgap_err("unexpected Digi_8r_920 string");
return(-1);
}
p->u.board.type = APORT8_920P;
p->u.board.v_type = 1;
DPR_INIT(("Adding Digi_8r_920 PCI to config...\n"));
break;
case PAPORT4: /* AccelePort_4 PCI */
if (p->type != BNODE) {
dgap_err("unexpected Digi_4r(PCI) string");
return(-1);
}
p->u.board.type = PAPORT4;
p->u.board.v_type = 1;
DPR_INIT(("Adding Digi_4r PCI to config...\n"));
break;
case PAPORT8: /* AccelePort_8 PCI */
if (p->type != BNODE) {
dgap_err("unexpected Digi_8r string");
return(-1);
}
p->u.board.type = PAPORT8;
p->u.board.v_type = 1;
DPR_INIT(("Adding Digi_8r PCI to config...\n"));
break;
case PCX: /* PCI C/X */
if (p->type != BNODE) {
dgap_err("unexpected Digi_C/X_(PCI) string");
return(-1);
}
p->u.board.type = PCX;
p->u.board.v_type = 1;
p->u.board.conc1 = 0;
p->u.board.conc2 = 0;
p->u.board.module1 = 0;
p->u.board.module2 = 0;
DPR_INIT(("Adding PCI C/X to config...\n"));
break;
case PEPC: /* PCI EPC/X */
if (p->type != BNODE) {
dgap_err("unexpected \"Digi_EPC/X_(PCI)\" string");
return(-1);
}
p->u.board.type = PEPC;
p->u.board.v_type = 1;
p->u.board.conc1 = 0;
p->u.board.conc2 = 0;
p->u.board.module1 = 0;
p->u.board.module2 = 0;
DPR_INIT(("Adding PCI EPC/X to config...\n"));
break;
case PPCM: /* PCI/Xem */
if (p->type != BNODE) {
dgap_err("unexpected PCI/Xem string");
return(-1);
}
p->u.board.type = PPCM;
p->u.board.v_type = 1;
p->u.board.conc1 = 0;
p->u.board.conc2 = 0;
DPR_INIT(("Adding PCI XEM to config...\n"));
break;
case IO: /* i/o port */
if (p->type != BNODE) {
dgap_err("IO port only vaild for boards");
return(-1);
}
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.portstr = dgap_savestring(s);
p->u.board.port = (short)simple_strtol(s, &s2, 0);
if ((short)strlen(s) > (short)(s2 - s)) {
dgap_err("bad number for IO port");
return(-1);
}
p->u.board.v_port = 1;
DPR_INIT(("Adding IO (%s) to config...\n", s));
break;
case MEM: /* memory address */
if (p->type != BNODE) {
dgap_err("memory address only vaild for boards");
return(-1);
}
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.addrstr = dgap_savestring(s);
p->u.board.addr = simple_strtoul(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for memory address");
return(-1);
}
p->u.board.v_addr = 1;
DPR_INIT(("Adding MEM (%s) to config...\n", s));
break;
case PCIINFO: /* pci information */
if (p->type != BNODE) {
dgap_err("memory address only vaild for boards");
return(-1);
}
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.pcibusstr = dgap_savestring(s);
p->u.board.pcibus = simple_strtoul(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for pci bus");
return(-1);
}
p->u.board.v_pcibus = 1;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.pcislotstr = dgap_savestring(s);
p->u.board.pcislot = simple_strtoul(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for pci slot");
return(-1);
}
p->u.board.v_pcislot = 1;
DPR_INIT(("Adding PCIINFO (%s %s) to config...\n", p->u.board.pcibusstr,
p->u.board.pcislotstr));
break;
case METHOD:
if (p->type != BNODE) {
dgap_err("install method only vaild for boards");
return(-1);
}
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.method = dgap_savestring(s);
p->u.board.v_method = 1;
DPR_INIT(("Adding METHOD (%s) to config...\n", s));
break;
case STATUS:
if (p->type != BNODE) {
dgap_err("config status only vaild for boards");
return(-1);
}
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.status = dgap_savestring(s);
DPR_INIT(("Adding STATUS (%s) to config...\n", s));
break;
case NPORTS: /* number of ports */
if (p->type == BNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.nport = (char)simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for number of ports");
return(-1);
}
p->u.board.v_nport = 1;
} else if (p->type == CNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.conc.nport = (char)simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for number of ports");
return(-1);
}
p->u.conc.v_nport = 1;
} else if (p->type == MNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.module.nport = (char)simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for number of ports");
return(-1);
}
p->u.module.v_nport = 1;
} else {
dgap_err("nports only valid for concentrators or modules");
return(-1);
}
DPR_INIT(("Adding NPORTS (%s) to config...\n", s));
break;
case ID: /* letter ID used in tty name */
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.status = dgap_savestring(s);
if (p->type == CNODE) {
p->u.conc.id = dgap_savestring(s);
p->u.conc.v_id = 1;
} else if (p->type == MNODE) {
p->u.module.id = dgap_savestring(s);
p->u.module.v_id = 1;
} else {
dgap_err("id only valid for concentrators or modules");
return(-1);
}
DPR_INIT(("Adding ID (%s) to config...\n", s));
break;
case STARTO: /* start offset of ID */
if (p->type == BNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.board.start = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for start of tty count");
return(-1);
}
p->u.board.v_start = 1;
} else if (p->type == CNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.conc.start = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for start of tty count");
return(-1);
}
p->u.conc.v_start = 1;
} else if (p->type == MNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.module.start = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for start of tty count");
return(-1);
}
p->u.module.v_start = 1;
} else {
dgap_err("start only valid for concentrators or modules");
return(-1);
}
DPR_INIT(("Adding START (%s) to config...\n", s));
break;
case TTYN: /* tty name prefix */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(TNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
if ( (s = dgap_getword(in)) == NULL ) {
dgap_err("unexpeced end of file");
return(-1);
}
if ( (p->u.ttyname = dgap_savestring(s)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
DPR_INIT(("Adding TTY (%s) to config...\n", s));
break;
case CU: /* cu name prefix */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(CUNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
if ( (s = dgap_getword(in)) == NULL ) {
dgap_err("unexpeced end of file");
return(-1);
}
if ( (p->u.cuname = dgap_savestring(s)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
DPR_INIT(("Adding CU (%s) to config...\n", s));
break;
case LINE: /* line information */
if (dgap_checknode(p))
return(-1);
if (brd == NULL) {
dgap_err("must specify board before line info");
return(-1);
}
switch (brd->u.board.type) {
case PPCM:
dgap_err("line not vaild for PC/em");
return(-1);
}
if ( (p->next = dgap_newnode(LNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
conc = NULL;
line = p;
linecnt++;
DPR_INIT(("Adding LINE to config...\n"));
break;
case CONC: /* concentrator information */
if (dgap_checknode(p))
return(-1);
if (line == NULL) {
dgap_err("must specify line info before concentrator");
return(-1);
}
if ( (p->next = dgap_newnode(CNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
conc = p;
if (linecnt)
brd->u.board.conc2++;
else
brd->u.board.conc1++;
DPR_INIT(("Adding CONC to config...\n"));
break;
case CX: /* c/x type concentrator */
if (p->type != CNODE) {
dgap_err("cx only valid for concentrators");
return(-1);
}
p->u.conc.type = CX;
p->u.conc.v_type = 1;
DPR_INIT(("Adding CX to config...\n"));
break;
case EPC: /* epc type concentrator */
if (p->type != CNODE) {
dgap_err("cx only valid for concentrators");
return(-1);
}
p->u.conc.type = EPC;
p->u.conc.v_type = 1;
DPR_INIT(("Adding EPC to config...\n"));
break;
case MOD: /* EBI module */
if (dgap_checknode(p))
return(-1);
if (brd == NULL) {
dgap_err("must specify board info before EBI modules");
return(-1);
}
switch (brd->u.board.type) {
case PPCM:
linecnt = 0;
break;
default:
if (conc == NULL) {
dgap_err("must specify concentrator info before EBI module");
return(-1);
}
}
if ( (p->next = dgap_newnode(MNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
if (linecnt)
brd->u.board.module2++;
else
brd->u.board.module1++;
DPR_INIT(("Adding MOD to config...\n"));
break;
case PORTS: /* ports type EBI module */
if (p->type != MNODE) {
dgap_err("ports only valid for EBI modules");
return(-1);
}
p->u.module.type = PORTS;
p->u.module.v_type = 1;
DPR_INIT(("Adding PORTS to config...\n"));
break;
case MODEM: /* ports type EBI module */
if (p->type != MNODE) {
dgap_err("modem only valid for modem modules");
return(-1);
}
p->u.module.type = MODEM;
p->u.module.v_type = 1;
DPR_INIT(("Adding MODEM to config...\n"));
break;
case CABLE:
if (p->type == LNODE) {
if ((s = dgap_getword(in)) == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.line.cable = dgap_savestring(s);
p->u.line.v_cable = 1;
}
DPR_INIT(("Adding CABLE (%s) to config...\n", s));
break;
case SPEED: /* sync line speed indication */
if (p->type == LNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.line.speed = (char)simple_strtol(s, &s2, 0);
if ((short)strlen(s) > (short)(s2 - s)) {
dgap_err("bad number for line speed");
return(-1);
}
p->u.line.v_speed = 1;
} else if (p->type == CNODE) {
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.conc.speed = (char)simple_strtol(s, &s2, 0);
if ((short)strlen(s) > (short)(s2 - s)) {
dgap_err("bad number for line speed");
return(-1);
}
p->u.conc.v_speed = 1;
} else {
dgap_err("speed valid only for lines or concentrators.");
return(-1);
}
DPR_INIT(("Adding SPEED (%s) to config...\n", s));
break;
case CONNECT:
if (p->type == CNODE) {
if ((s = dgap_getword(in)) == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.conc.connect = dgap_savestring(s);
p->u.conc.v_connect = 1;
}
DPR_INIT(("Adding CONNECT (%s) to config...\n", s));
break;
case PRINT: /* transparent print name prefix */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(PNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
if ( (s = dgap_getword(in)) == NULL ) {
dgap_err("unexpeced end of file");
return(-1);
}
if ( (p->u.printname = dgap_savestring(s)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
DPR_INIT(("Adding PRINT (%s) to config...\n", s));
break;
case CMAJOR: /* major number */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(JNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.majornumber = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for major number");
return(-1);
}
DPR_INIT(("Adding CMAJOR (%s) to config...\n", s));
break;
case ALTPIN: /* altpin setting */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(ANODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.altpin = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for altpin");
return(-1);
}
DPR_INIT(("Adding ALTPIN (%s) to config...\n", s));
break;
case USEINTR: /* enable interrupt setting */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(INTRNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.useintr = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for useintr");
return(-1);
}
DPR_INIT(("Adding USEINTR (%s) to config...\n", s));
break;
case TTSIZ: /* size of tty structure */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(TSNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.ttysize = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for ttysize");
return(-1);
}
DPR_INIT(("Adding TTSIZ (%s) to config...\n", s));
break;
case CHSIZ: /* channel structure size */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(CSNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.chsize = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for chsize");
return(-1);
}
DPR_INIT(("Adding CHSIZE (%s) to config...\n", s));
break;
case BSSIZ: /* board structure size */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(BSNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.bssize = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for bssize");
return(-1);
}
DPR_INIT(("Adding BSSIZ (%s) to config...\n", s));
break;
case UNTSIZ: /* sched structure size */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(USNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.unsize = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for schedsize");
return(-1);
}
DPR_INIT(("Adding UNTSIZ (%s) to config...\n", s));
break;
case F2SIZ: /* f2200 structure size */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(FSNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.f2size = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for f2200size");
return(-1);
}
DPR_INIT(("Adding F2SIZ (%s) to config...\n", s));
break;
case VPSIZ: /* vpix structure size */
if (dgap_checknode(p))
return(-1);
if ( (p->next = dgap_newnode(VSNODE)) == NULL ) {
dgap_err("out of memory");
return(-1);
}
p = p->next;
s = dgap_getword(in);
if (s == NULL) {
dgap_err("unexpected end of file");
return(-1);
}
p->u.vpixsize = simple_strtol(s, &s2, 0);
if ((int)strlen(s) > (int)(s2 - s)) {
dgap_err("bad number for vpixsize");
return(-1);
}
DPR_INIT(("Adding VPSIZ (%s) to config...\n", s));
break;
}
}
}
/*
* dgap_sindex: much like index(), but it looks for a match of any character in
* the group, and returns that position. If the first character is a ^, then
* this will match the first occurrence not in that group.
*/
static char *dgap_sindex (char *string, char *group)
{
char *ptr;
if (!string || !group)
return (char *) NULL;
if (*group == '^') {
group++;
for (; *string; string++) {
for (ptr = group; *ptr; ptr++) {
if (*ptr == *string)
break;
}
if (*ptr == '\0')
return string;
}
}
else {
for (; *string; string++) {
for (ptr = group; *ptr; ptr++) {
if (*ptr == *string)
return string;
}
}
}
return (char *) NULL;
}
/*
* Get a token from the input file; return 0 if end of file is reached
*/
static int dgap_gettok(char **in, struct cnode *p)
{
char *w;
struct toklist *t;
if (strstr(dgap_cword, "boar")) {
w = dgap_getword(in);
snprintf(dgap_cword, MAXCWORD, "%s", w);
for (t = dgap_tlist; t->token != 0; t++) {
if ( !strcmp(w, t->string)) {
return(t->token);
}
}
dgap_err("board !!type not specified");
return(1);
}
else {
while ( (w = dgap_getword(in)) != NULL ) {
snprintf(dgap_cword, MAXCWORD, "%s", w);
for (t = dgap_tlist; t->token != 0; t++) {
if ( !strcmp(w, t->string) )
return(t->token);
}
}
return(0);
}
}
/*
* get a word from the input stream, also keep track of current line number.
* words are separated by whitespace.
*/
static char *dgap_getword(char **in)
{
char *ret_ptr = *in;
char *ptr = dgap_sindex(*in, " \t\n");
/* If no word found, return null */
if (!ptr)
return NULL;
/* Mark new location for our buffer */
*ptr = '\0';
*in = ptr + 1;
/* Eat any extra spaces/tabs/newlines that might be present */
while (*in && **in && ((**in == ' ') || (**in == '\t') || (**in == '\n'))) {
**in = '\0';
*in = *in + 1;
}
return ret_ptr;
}
/*
* print an error message, giving the line number in the file where
* the error occurred.
*/
static void dgap_err(char *s)
{
printk("DGAP: parse: %s\n", s);
}
/*
* allocate a new configuration node of type t
*/
static struct cnode *dgap_newnode(int t)
{
struct cnode *n;
n = kmalloc(sizeof(struct cnode), GFP_ATOMIC);
if (n != NULL) {
memset((char *)n, 0, sizeof(struct cnode));
n->type = t;
}
return(n);
}
/*
* dgap_checknode: see if all the necessary info has been supplied for a node
* before creating the next node.
*/
static int dgap_checknode(struct cnode *p)
{
switch (p->type) {
case BNODE:
if (p->u.board.v_type == 0) {
dgap_err("board type !not specified");
return(1);
}
return(0);
case LNODE:
if (p->u.line.v_speed == 0) {
dgap_err("line speed not specified");
return(1);
}
return(0);
case CNODE:
if (p->u.conc.v_type == 0) {
dgap_err("concentrator type not specified");
return(1);
}
if (p->u.conc.v_speed == 0) {
dgap_err("concentrator line speed not specified");
return(1);
}
if (p->u.conc.v_nport == 0) {
dgap_err("number of ports on concentrator not specified");
return(1);
}
if (p->u.conc.v_id == 0) {
dgap_err("concentrator id letter not specified");
return(1);
}
return(0);
case MNODE:
if (p->u.module.v_type == 0) {
dgap_err("EBI module type not specified");
return(1);
}
if (p->u.module.v_nport == 0) {
dgap_err("number of ports on EBI module not specified");
return(1);
}
if (p->u.module.v_id == 0) {
dgap_err("EBI module id letter not specified");
return(1);
}
return(0);
}
return(0);
}
/*
* save a string somewhere
*/
static char *dgap_savestring(char *s)
{
char *p;
if ( (p = kmalloc(strlen(s) + 1, GFP_ATOMIC) ) != NULL) {
strcpy(p, s);
}
return(p);
}
/*
* Given a board pointer, returns whether we should use interrupts or not.
*/
uint dgap_config_get_useintr(struct board_t *bd)
{
struct cnode *p = NULL;
if (!bd)
return(0);
for (p = bd->bd_config; p; p = p->next) {
switch (p->type) {
case INTRNODE:
/*
* check for pcxr types.
*/
return p->u.useintr;
default:
break;
}
}
/* If not found, then don't turn on interrupts. */
return 0;
}
/*
* Given a board pointer, returns whether we turn on altpin or not.
*/
uint dgap_config_get_altpin(struct board_t *bd)
{
struct cnode *p = NULL;
if (!bd)
return(0);
for (p = bd->bd_config; p; p = p->next) {
switch (p->type) {
case ANODE:
/*
* check for pcxr types.
*/
return p->u.altpin;
default:
break;
}
}
/* If not found, then don't turn on interrupts. */
return 0;
}
/*
* Given a specific type of board, if found, detached link and
* returns the first occurrence in the list.
*/
struct cnode *dgap_find_config(int type, int bus, int slot)
{
struct cnode *p, *prev = NULL, *prev2 = NULL, *found = NULL;
p = &dgap_head;
while (p->next != NULL) {
prev = p;
p = p->next;
if (p->type == BNODE) {
if (p->u.board.type == type) {
if (p->u.board.v_pcibus && p->u.board.pcibus != bus) {
DPR(("Found matching board, but wrong bus position. System says bus %d, we want bus %ld\n",
bus, p->u.board.pcibus));
continue;
}
if (p->u.board.v_pcislot && p->u.board.pcislot != slot) {
DPR_INIT(("Found matching board, but wrong slot position. System says slot %d, we want slot %ld\n",
slot, p->u.board.pcislot));
continue;
}
DPR_INIT(("Matched type in config file\n"));
found = p;
/*
* Keep walking thru the list till we find the next board.
*/
while (p->next != NULL) {
prev2 = p;
p = p->next;
if (p->type == BNODE) {
/*
* Mark the end of our 1 board chain of configs.
*/
prev2->next = NULL;
/*
* Link the "next" board to the previous board,
* effectively "unlinking" our board from the main config.
*/
prev->next = p;
return found;
}
}
/*
* It must be the last board in the list.
*/
prev->next = NULL;
return found;
}
}
}
return NULL;
}
/*
* Given a board pointer, walks the config link, counting up
* all ports user specified should be on the board.
* (This does NOT mean they are all actually present right now tho)
*/
uint dgap_config_get_number_of_ports(struct board_t *bd)
{
int count = 0;
struct cnode *p = NULL;
if (!bd)
return(0);
for (p = bd->bd_config; p; p = p->next) {
switch (p->type) {
case BNODE:
/*
* check for pcxr types.
*/
if (p->u.board.type > EPCFE)
count += p->u.board.nport;
break;
case CNODE:
count += p->u.conc.nport;
break;
case MNODE:
count += p->u.module.nport;
break;
}
}
return (count);
}
char *dgap_create_config_string(struct board_t *bd, char *string)
{
char *ptr = string;
struct cnode *p = NULL;
struct cnode *q = NULL;
int speed;
if (!bd) {
*ptr = 0xff;
return string;
}
for (p = bd->bd_config; p; p = p->next) {
switch (p->type) {
case LNODE:
*ptr = '\0';
ptr++;
*ptr = p->u.line.speed;
ptr++;
break;
case CNODE:
/*
* Because the EPC/con concentrators can have EM modules
* hanging off of them, we have to walk ahead in the list
* and keep adding the number of ports on each EM to the config.
* UGH!
*/
speed = p->u.conc.speed;
q = p->next;
if ((q != NULL) && (q->type == MNODE) ) {
*ptr = (p->u.conc.nport + 0x80);
ptr++;
p = q;
while ((q->next != NULL) && (q->next->type) == MNODE) {
*ptr = (q->u.module.nport + 0x80);
ptr++;
p = q;
q = q->next;
}
*ptr = q->u.module.nport;
ptr++;
} else {
*ptr = p->u.conc.nport;
ptr++;
}
*ptr = speed;
ptr++;
break;
}
}
*ptr = 0xff;
return string;
}
char *dgap_get_config_letters(struct board_t *bd, char *string)
{
int found = FALSE;
char *ptr = string;
struct cnode *cptr = NULL;
int len = 0;
int left = MAXTTYNAMELEN;
if (!bd) {
return "<NULL>";
}
for (cptr = bd->bd_config; cptr; cptr = cptr->next) {
if ((cptr->type == BNODE) &&
((cptr->u.board.type == APORT2_920P) || (cptr->u.board.type == APORT4_920P) ||
(cptr->u.board.type == APORT8_920P) || (cptr->u.board.type == PAPORT4) ||
(cptr->u.board.type == PAPORT8))) {
found = TRUE;
}
if (cptr->type == TNODE && found == TRUE) {
char *ptr1;
if (strstr(cptr->u.ttyname, "tty")) {
ptr1 = cptr->u.ttyname;
ptr1 += 3;
}
else {
ptr1 = cptr->u.ttyname;
}
if (ptr1) {
len = snprintf(ptr, left, "%s", ptr1);
left -= len;
ptr += len;
if (left <= 0)
break;
}
}
if (cptr->type == CNODE) {
if (cptr->u.conc.id) {
len = snprintf(ptr, left, "%s", cptr->u.conc.id);
left -= len;
ptr += len;
if (left <= 0)
break;
}
}
if (cptr->type == MNODE) {
if (cptr->u.module.id) {
len = snprintf(ptr, left, "%s", cptr->u.module.id);
left -= len;
ptr += len;
if (left <= 0)
break;
}
}
}
return string;
}