From dee901a3fde82083a630082f04c0139c73ba248f Mon Sep 17 00:00:00 2001 From: Guillaume Cottenceau Date: Tue, 20 Nov 2001 23:35:06 +0000 Subject: Initial revision --- mdk-stage1/pcmcia_/bulkmem.h | 195 ++++ mdk-stage1/pcmcia_/cardmgr.c | 1557 +++++++++++++++++++++++++++++ mdk-stage1/pcmcia_/cardmgr.h | 112 +++ mdk-stage1/pcmcia_/cirrus.h | 182 ++++ mdk-stage1/pcmcia_/cistpl.h | 604 +++++++++++ mdk-stage1/pcmcia_/cs.h | 465 +++++++++ mdk-stage1/pcmcia_/cs_types.h | 65 ++ mdk-stage1/pcmcia_/driver_ops.h | 82 ++ mdk-stage1/pcmcia_/ds.h | 163 +++ mdk-stage1/pcmcia_/i82365.h | 154 +++ mdk-stage1/pcmcia_/lex_config.c | 2052 ++++++++++++++++++++++++++++++++++++++ mdk-stage1/pcmcia_/probe.c | 463 +++++++++ mdk-stage1/pcmcia_/tcic.h | 266 +++++ mdk-stage1/pcmcia_/version.h | 4 + mdk-stage1/pcmcia_/vg468.h | 112 +++ mdk-stage1/pcmcia_/yacc_config.c | 1021 +++++++++++++++++++ mdk-stage1/pcmcia_/yacc_config.h | 37 + 17 files changed, 7534 insertions(+) create mode 100644 mdk-stage1/pcmcia_/bulkmem.h create mode 100644 mdk-stage1/pcmcia_/cardmgr.c create mode 100644 mdk-stage1/pcmcia_/cardmgr.h create mode 100644 mdk-stage1/pcmcia_/cirrus.h create mode 100644 mdk-stage1/pcmcia_/cistpl.h create mode 100644 mdk-stage1/pcmcia_/cs.h create mode 100644 mdk-stage1/pcmcia_/cs_types.h create mode 100644 mdk-stage1/pcmcia_/driver_ops.h create mode 100644 mdk-stage1/pcmcia_/ds.h create mode 100644 mdk-stage1/pcmcia_/i82365.h create mode 100644 mdk-stage1/pcmcia_/lex_config.c create mode 100644 mdk-stage1/pcmcia_/probe.c create mode 100644 mdk-stage1/pcmcia_/tcic.h create mode 100644 mdk-stage1/pcmcia_/version.h create mode 100644 mdk-stage1/pcmcia_/vg468.h create mode 100644 mdk-stage1/pcmcia_/yacc_config.c create mode 100644 mdk-stage1/pcmcia_/yacc_config.h diff --git a/mdk-stage1/pcmcia_/bulkmem.h b/mdk-stage1/pcmcia_/bulkmem.h new file mode 100644 index 000000000..7748d4432 --- /dev/null +++ b/mdk-stage1/pcmcia_/bulkmem.h @@ -0,0 +1,195 @@ +/* + * Definitions for bulk memory services + * + * bulkmem.h 1.13 2001/08/24 12:16:12 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + * bulkmem.h 1.3 1995/05/27 04:49:49 + */ + +#ifndef _LINUX_BULKMEM_H +#define _LINUX_BULKMEM_H + +/* For GetFirstRegion and GetNextRegion */ +typedef struct region_info_t { + u_int Attributes; + u_int CardOffset; + u_int RegionSize; + u_int AccessSpeed; + u_int BlockSize; + u_int PartMultiple; + u_char JedecMfr, JedecInfo; + memory_handle_t next; +} region_info_t; + +#define REGION_TYPE 0x0001 +#define REGION_TYPE_CM 0x0000 +#define REGION_TYPE_AM 0x0001 +#define REGION_PREFETCH 0x0008 +#define REGION_CACHEABLE 0x0010 +#define REGION_BAR_MASK 0xe000 +#define REGION_BAR_SHIFT 13 + +/* For OpenMemory */ +typedef struct open_mem_t { + u_int Attributes; + u_int Offset; +} open_mem_t; + +/* Attributes for OpenMemory */ +#define MEMORY_TYPE 0x0001 +#define MEMORY_TYPE_CM 0x0000 +#define MEMORY_TYPE_AM 0x0001 +#define MEMORY_EXCLUSIVE 0x0002 +#define MEMORY_PREFETCH 0x0008 +#define MEMORY_CACHEABLE 0x0010 +#define MEMORY_BAR_MASK 0xe000 +#define MEMORY_BAR_SHIFT 13 + +typedef struct eraseq_entry_t { + memory_handle_t Handle; + u_char State; + u_int Size; + u_int Offset; + void *Optional; +} eraseq_entry_t; + +typedef struct eraseq_hdr_t { + int QueueEntryCnt; + eraseq_entry_t *QueueEntryArray; +} eraseq_hdr_t; + +#define ERASE_QUEUED 0x00 +#define ERASE_IN_PROGRESS(n) (((n) > 0) && ((n) < 0x80)) +#define ERASE_IDLE 0xff +#define ERASE_PASSED 0xe0 +#define ERASE_FAILED 0xe1 + +#define ERASE_MISSING 0x80 +#define ERASE_MEDIA_WRPROT 0x84 +#define ERASE_NOT_ERASABLE 0x85 +#define ERASE_BAD_OFFSET 0xc1 +#define ERASE_BAD_TECH 0xc2 +#define ERASE_BAD_SOCKET 0xc3 +#define ERASE_BAD_VCC 0xc4 +#define ERASE_BAD_VPP 0xc5 +#define ERASE_BAD_SIZE 0xc6 + +/* For CopyMemory */ +typedef struct copy_op_t { + u_int Attributes; + u_int SourceOffset; + u_int DestOffset; + u_int Count; +} copy_op_t; + +/* For ReadMemory and WriteMemory */ +typedef struct mem_op_t { + u_int Attributes; + u_int Offset; + u_int Count; +} mem_op_t; + +#define MEM_OP_BUFFER 0x01 +#define MEM_OP_BUFFER_USER 0x00 +#define MEM_OP_BUFFER_KERNEL 0x01 +#define MEM_OP_DISABLE_ERASE 0x02 +#define MEM_OP_VERIFY 0x04 + +/* For RegisterMTD */ +typedef struct mtd_reg_t { + u_int Attributes; + u_int Offset; + u_long MediaID; +} mtd_reg_t; + +/* + * Definitions for MTD requests + */ + +typedef struct mtd_request_t { + u_int SrcCardOffset; + u_int DestCardOffset; + u_int TransferLength; + u_int Function; + u_long MediaID; + u_int Status; + u_int Timeout; +} mtd_request_t; + +/* Fields in MTD Function */ +#define MTD_REQ_ACTION 0x003 +#define MTD_REQ_ERASE 0x000 +#define MTD_REQ_READ 0x001 +#define MTD_REQ_WRITE 0x002 +#define MTD_REQ_COPY 0x003 +#define MTD_REQ_NOERASE 0x004 +#define MTD_REQ_VERIFY 0x008 +#define MTD_REQ_READY 0x010 +#define MTD_REQ_TIMEOUT 0x020 +#define MTD_REQ_LAST 0x040 +#define MTD_REQ_FIRST 0x080 +#define MTD_REQ_KERNEL 0x100 + +/* Status codes */ +#define MTD_WAITREQ 0x00 +#define MTD_WAITTIMER 0x01 +#define MTD_WAITRDY 0x02 +#define MTD_WAITPOWER 0x03 + +/* + * Definitions for MTD helper functions + */ + +/* For MTDModifyWindow */ +typedef struct mtd_mod_win_t { + u_int Attributes; + u_int AccessSpeed; + u_int CardOffset; +} mtd_mod_win_t; + +/* For MTDSetVpp */ +typedef struct mtd_vpp_req_t { + u_char Vpp1, Vpp2; +} mtd_vpp_req_t; + +/* For MTDRDYMask */ +typedef struct mtd_rdy_req_t { + u_int Mask; +} mtd_rdy_req_t; + +enum mtd_helper { + MTDRequestWindow, MTDModifyWindow, MTDReleaseWindow, + MTDSetVpp, MTDRDYMask +}; + +#ifdef IN_CARD_SERVICES +extern int MTDHelperEntry(int func, void *a1, void *a2); +#else +extern int MTDHelperEntry(int func, ...); +#endif + +#endif /* _LINUX_BULKMEM_H */ diff --git a/mdk-stage1/pcmcia_/cardmgr.c b/mdk-stage1/pcmcia_/cardmgr.c new file mode 100644 index 000000000..1d2df79f0 --- /dev/null +++ b/mdk-stage1/pcmcia_/cardmgr.c @@ -0,0 +1,1557 @@ +/*====================================================================== + + PCMCIA Card Manager daemon + + cardmgr.c 1.161 2001/08/24 12:19:19 + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The initial developer of the original code is David A. Hinds + . Portions created by David A. Hinds + are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + + Alternatively, the contents of this file may be used under the + terms of the GNU General Public License version 2 (the "GPL"), in + which case the provisions of the GPL are applicable instead of the + above. If you wish to allow the use of your version of this file + only under the terms of the GPL and not to allow others to use + your version of this file under the MPL, indicate your decision + by deleting the provisions above and replace them with the notice + and other provisions required by the GPL. If you do not delete + the provisions above, a recipient may use your version of this + file under either the MPL or the GPL. + +======================================================================*/ + +#ifndef __linux__ +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "cardmgr.h" + +/*====================================================================*/ + +typedef struct socket_info_t { + int fd; + int state; + card_info_t *card; + bind_info_t *bind[MAX_BINDINGS]; + mtd_ident_t *mtd[2*CISTPL_MAX_DEVICES]; +} socket_info_t; + +#define SOCKET_PRESENT 0x01 +#define SOCKET_READY 0x02 +#define SOCKET_HOTPLUG 0x04 + +/* Linked list of resource adjustments */ +struct adjust_list_t *root_adjust = NULL; + +/* Linked list of device definitions */ +struct device_info_t *root_device = NULL; + +/* Special pointer to "anonymous" card definition */ +struct card_info_t *blank_card = NULL; + +/* Linked list of card definitions */ +struct card_info_t *root_card = NULL; + +/* Linked list of function definitions */ +struct card_info_t *root_func = NULL; + +/* Linked list of MTD definitions */ +struct mtd_ident_t *root_mtd = NULL; + +/* Default MTD */ +struct mtd_ident_t *default_mtd = NULL; + +static int sockets; +static struct socket_info_t socket[MAX_SOCKS]; + +/* Default path for config file, device scripts */ +#ifdef ETC +static char *configpath = ETC; +#else +static char *configpath = "/etc/pcmcia"; +#endif + +/* Default path for pid file */ +static char *pidfile = "/var/run/cardmgr.pid"; + +#ifdef __linux__ +/* Default path for finding modules */ +static char *modpath = NULL; +#endif + +/* Default path for socket info table */ +static char *stabfile; + +/* If set, don't generate beeps when cards are inserted */ +static int be_quiet = 0; + +/* If set, use modprobe instead of insmod */ +static int do_modprobe = 0; + +/* If set, configure already inserted cards, then exit */ +static int one_pass = 0; + +/* Extra message logging? */ +static int verbose = 0; + +/*====================================================================*/ + +#ifdef __linux__ + +static int major = 0; + +static int lookup_dev(char *name) +{ + FILE *f; + int n; + char s[32], t[32]; + + f = fopen("/proc/devices", "r"); + if (f == NULL) + return -errno; + while (fgets(s, 32, f) != NULL) { + if (sscanf(s, "%d %s", &n, t) == 2) + if (strcmp(name, t) == 0) + break; + } + fclose(f); + if (strcmp(name, t) == 0) + return n; + else + return -ENODEV; +} + +int open_dev(dev_t dev, int mode) +{ + static char *paths[] = { + "/var/lib/pcmcia", "/var/run", "/dev", "/tmp", NULL + }; + char **p, fn[64]; + int fd; + + for (p = paths; *p; p++) { + sprintf(fn, "%s/cm-%d", *p, getpid()); + if (mknod(fn, mode, dev) == 0) + break; + } + if (!*p) + return -1; + fd = open(fn, (mode&S_IWRITE)?O_RDWR:O_RDONLY); + if (fd < 0) + fd = open(fn, O_NONBLOCK|((mode&S_IWRITE)?O_RDWR:O_RDONLY)); + unlink(fn); + return fd; +} + +#endif /* __linux__ */ + +int open_sock(int sock, int mode) +{ +#ifdef __linux__ + dev_t dev = (major<<8)+sock; + return open_dev(dev, mode); +#endif +#ifdef __BEOS__ + int fd; + char fn[B_OS_NAME_LENGTH]; + sprintf(fn, "/dev/pcmcia/sock%d", sock); + return open(fn, (mode & S_IWRITE) ? O_RDWR: O_RDONLY); +#endif +} + +/*====================================================================== + + xlate_scsi_name() is a sort-of-hack used to deduce the minor + device numbers of SCSI devices, from the information available to + the low-level driver. + +======================================================================*/ + +#ifdef __linux__ + +#include +#include +#define VERSION(v,p,s) (((v)<<16)+(p<<8)+s) +#if (LINUX_VERSION_CODE < VERSION(2,1,126)) +#define SCSI_DISK0_MAJOR SCSI_DISK_MAJOR +#endif + +static int xlate_scsi_name(bind_info_t *bind) +{ + int i, fd, mode, minor; + u_long arg[2], id1, id2; + + id1 = strtol(bind->name+3, NULL, 16); + if ((bind->major == SCSI_DISK0_MAJOR) || + (bind->major == SCSI_CDROM_MAJOR)) + mode = S_IREAD|S_IFBLK; + else + mode = S_IREAD|S_IFCHR; + + for (i = 0; i < 16; i++) { + minor = (bind->major == SCSI_DISK0_MAJOR) ? (i<<4) : i; + fd = open_dev((bind->major<<8)+minor, mode); + if (fd < 0) + continue; + if (ioctl(fd, SCSI_IOCTL_GET_IDLUN, arg) == 0) { + id2 = (arg[0]&0x0f) + ((arg[0]>>4)&0xf0) + + ((arg[0]>>8)&0xf00) + ((arg[0]>>12)&0xf000); + if (id1 == id2) { + close(fd); + switch (bind->major) { + case SCSI_DISK0_MAJOR: + case SCSI_GENERIC_MAJOR: + sprintf(bind->name+2, "%c", 'a'+i); break; + case SCSI_CDROM_MAJOR: + sprintf(bind->name, "scd%d", i); break; + case SCSI_TAPE_MAJOR: + sprintf(bind->name+2, "%d", i); break; + } + bind->minor = minor; + return 0; + } + } + close(fd); + } + return -1; +} +#endif + +/*====================================================================*/ + +#define BEEP_TIME 150 +#define BEEP_OK 1000 +#define BEEP_WARN 2000 +#define BEEP_ERR 4000 + +#ifdef __linux__ + +#include + +static void beep(unsigned int ms, unsigned int freq) +{ + int fd, arg; + + if (be_quiet) + return; + fd = open("/dev/console", O_RDWR); + if (fd < 0) + return; + arg = (ms << 16) | freq; + ioctl(fd, KDMKTONE, arg); + close(fd); + usleep(ms*1000); +} + +#endif /* __linux__ */ + +#ifdef __BEOS__ +static void beep(unsigned int ms, unsigned int freq) +{ + if (!be_quiet) system("/bin/beep"); +} +#endif + +/*====================================================================*/ + +static void write_pid(void) +{ + FILE *f; + f = fopen(pidfile, "w"); + if (f == NULL) + syslog(LOG_WARNING, "could not open %s: %m", pidfile); + else { + fprintf(f, "%d\n", getpid()); + fclose(f); + } +} + +static void write_stab(void) +{ + int i, j, k; + FILE *f; + socket_info_t *s; + bind_info_t *bind; + + f = fopen(stabfile, "w"); + if (f == NULL) { + syslog(LOG_WARNING, "fopen(stabfile) failed: %m"); + return; + } +#ifndef __BEOS__ + if (flock(fileno(f), LOCK_EX) != 0) { + syslog(LOG_ERR, "flock(stabfile) failed: %m"); + return; + } +#endif + for (i = 0; i < sockets; i++) { + s = &socket[i]; + fprintf(f, "Socket %d: ", i); + if (!(s->state & SOCKET_PRESENT)) { + fprintf(f, "empty\n"); + } else if (s->state & SOCKET_HOTPLUG) { + fprintf(f, "CardBus hotplug device\n"); + } else if (!s->card) { + fprintf(f, "unsupported card\n"); + } else { + fprintf(f, "%s\n", s->card->name); + for (j = 0; j < s->card->bindings; j++) + for (k = 0, bind = s->bind[j]; + bind != NULL; + k++, bind = bind->next) { + char *class = s->card->device[j]->class; + fprintf(f, "%d\t%s\t%s\t%d\t%s", + i, (class ? class : "none"), + bind->dev_info, k, bind->name); + if (bind->major) + fprintf(f, "\t%d\t%d\n", + bind->major, bind->minor); + else + fputc('\n', f); + } + } + } + fflush(f); +#ifndef __BEOS__ + flock(fileno(f), LOCK_UN); +#endif + fclose(f); +} + +/*====================================================================*/ + +static int get_tuple(int ns, cisdata_t code, ds_ioctl_arg_t *arg) +{ + socket_info_t *s = &socket[ns]; + + arg->tuple.DesiredTuple = code; + arg->tuple.Attributes = 0; + if (ioctl(s->fd, DS_GET_FIRST_TUPLE, arg) != 0) + return -1; + arg->tuple.TupleOffset = 0; + if (ioctl(s->fd, DS_GET_TUPLE_DATA, arg) != 0) { + syslog(LOG_INFO, "error reading CIS data on socket %d: %m", ns); + return -1; + } + if (ioctl(s->fd, DS_PARSE_TUPLE, arg) != 0) { + syslog(LOG_INFO, "error parsing CIS on socket %d: %m", ns); + return -1; + } + return 0; +} + +/*====================================================================== + + Code to fetch a 2.4 kernel's hot plug PCI driver list + + This is distasteful but is the best I could come up with. + +======================================================================*/ + +#ifdef __linux__ + +typedef struct pci_id { + u_short vendor, device; + struct pci_id *next; +} pci_id_t; + +static int get_pci_id(int ns, pci_id_t *id) +{ + socket_info_t *s = &socket[ns]; + config_info_t config; + + config.Function = config.ConfigBase = 0; + if ((ioctl(s->fd, DS_GET_CONFIGURATION_INFO, &config) != 0) || + (config.IntType != INT_CARDBUS) || !config.ConfigBase) + return 0; + id->vendor = config.ConfigBase & 0xffff; + id->device = config.ConfigBase >> 16; + return 1; +} + +#endif /* __linux__ */ + +/*====================================================================*/ + +static void log_card_info(cistpl_vers_1_t *vers, + cistpl_manfid_t *manfid, + cistpl_funcid_t *funcid, + pci_id_t *pci_id) +{ + char v[256] = ""; + int i; + static char *fn[] = { + "multi", "memory", "serial", "parallel", "fixed disk", + "video", "network", "AIMS", "SCSI" + }; + + if (vers) { + for (i = 0; i < vers->ns; i++) + sprintf(v+strlen(v), "%s\"%s\"", + (i>0) ? ", " : "", vers->str+vers->ofs[i]); + syslog(LOG_INFO, " product info: %s", v); + } else { + syslog(LOG_INFO, " no product info available"); + } + *v = '\0'; + if (manfid->manf != 0) + sprintf(v, " manfid: 0x%04x, 0x%04x", + manfid->manf, manfid->card); + if (funcid->func != 0xff) + sprintf(v+strlen(v), " function: %d (%s)", funcid->func, + fn[funcid->func]); + if (strlen(v) > 0) syslog(LOG_INFO, "%s", v); + if (pci_id->vendor != 0) + syslog(LOG_INFO, " PCI id: 0x%04x, 0x%04x", + pci_id->vendor, pci_id->device); +} + +static card_info_t *lookup_card(int ns) +{ + socket_info_t *s = &socket[ns]; + card_info_t *card = NULL; + ds_ioctl_arg_t arg; + cistpl_vers_1_t *vers = NULL; + cistpl_manfid_t manfid = { 0, 0 }; + pci_id_t pci_id = { 0, 0 }; + cistpl_funcid_t funcid = { 0xff, 0xff }; + cs_status_t status; + int i, ret, has_cis = 0; + + /* Do we have a CIS structure? */ + ret = ioctl(s->fd, DS_VALIDATE_CIS, &arg); + has_cis = ((ret == 0) && (arg.cisinfo.Chains > 0)); + + /* Try to read VERS_1, MANFID tuples */ + if (has_cis) { + /* rule of thumb: cards with no FUNCID, but with common memory + device geometry information, are probably memory cards */ + if (get_tuple(ns, CISTPL_FUNCID, &arg) == 0) + memcpy(&funcid, &arg.tuple_parse.parse.funcid, + sizeof(funcid)); + else if (get_tuple(ns, CISTPL_DEVICE_GEO, &arg) == 0) + funcid.func = CISTPL_FUNCID_MEMORY; + if (get_tuple(ns, CISTPL_MANFID, &arg) == 0) + memcpy(&manfid, &arg.tuple_parse.parse.manfid, + sizeof(manfid)); + if (get_tuple(ns, CISTPL_VERS_1, &arg) == 0) + vers = &arg.tuple_parse.parse.version_1; + + for (card = root_card; card; card = card->next) { + + if (card->ident_type & + ~(VERS_1_IDENT|MANFID_IDENT|TUPLE_IDENT)) + continue; + + if (card->ident_type & VERS_1_IDENT) { + if (vers == NULL) + continue; + for (i = 0; i < card->id.vers.ns; i++) { + if (strcmp(card->id.vers.pi[i], "*") == 0) + continue; + if (i >= vers->ns) + break; + if (strcmp(card->id.vers.pi[i], + vers->str+vers->ofs[i]) != 0) + break; + } + if (i < card->id.vers.ns) + continue; + } + + if (card->ident_type & MANFID_IDENT) { + if ((manfid.manf != card->manfid.manf) || + (manfid.card != card->manfid.card)) + continue; + } + + if (card->ident_type & TUPLE_IDENT) { + arg.tuple.DesiredTuple = card->id.tuple.code; + arg.tuple.Attributes = 0; + ret = ioctl(s->fd, DS_GET_FIRST_TUPLE, &arg); + if (ret != 0) continue; + arg.tuple.TupleOffset = card->id.tuple.ofs; + ret = ioctl(s->fd, DS_GET_TUPLE_DATA, &arg); + if (ret != 0) continue; + if (strncmp((char *)arg.tuple_parse.data, + card->id.tuple.info, + strlen(card->id.tuple.info)) != 0) + continue; + } + + break; /* we have a match */ + } + } + + /* Check PCI vendor/device info */ + status.Function = 0; + ioctl(s->fd, DS_GET_STATUS, &status); + if (status.CardState & CS_EVENT_CB_DETECT) { + if (get_pci_id(ns, &pci_id)) { + if (!card) { + for (card = root_card; card; card = card->next) + if ((card->ident_type == PCI_IDENT) && + (pci_id.vendor == card->manfid.manf) && + (pci_id.device == card->manfid.card)) + break; + } + } else { + /* this is a 2.4 kernel; hotplug handles these cards */ + s->state |= SOCKET_HOTPLUG; + syslog(LOG_INFO, "socket %d: CardBus hotplug device", ns); + //beep(BEEP_TIME, BEEP_OK); + return NULL; + } + } + + /* Try for a FUNCID match */ + if (!card && (funcid.func != 0xff)) { + for (card = root_func; card; card = card->next) + if (card->id.func.funcid == funcid.func) + break; + } + + if (card) { + syslog(LOG_INFO, "socket %d: %s", ns, card->name); + beep(BEEP_TIME, BEEP_OK); + if (verbose) log_card_info(vers, &manfid, &funcid, &pci_id); + return card; + } + + if (!blank_card || (status.CardState & CS_EVENT_CB_DETECT) || + manfid.manf || manfid.card || pci_id.vendor || vers) { + syslog(LOG_INFO, "unsupported card in socket %d", ns); + if (one_pass) return NULL; + beep(BEEP_TIME, BEEP_ERR); + log_card_info(vers, &manfid, &funcid, &pci_id); + return NULL; + } else { + card = blank_card; + syslog(LOG_INFO, "socket %d: %s", ns, card->name); + beep(BEEP_TIME, BEEP_WARN); + return card; + } +} + +/*====================================================================*/ + +static void load_config(void) +{ + if (chdir(configpath) != 0) { + syslog(LOG_ERR, "chdir to %s failed: %m", configpath); + exit(EXIT_FAILURE); + } + if (parse_configfile("config") != 0) + exit(EXIT_FAILURE); + if (root_device == NULL) + syslog(LOG_WARNING, "no device drivers defined"); + if ((root_card == NULL) && (root_func == NULL)) + syslog(LOG_WARNING, "no cards defined"); +} + +/*====================================================================*/ + +static void free_card(card_info_t *card) +{ + if (card && (--card->refs == 0)) { + int i; + free(card->name); + switch(card->ident_type) { + case VERS_1_IDENT: + for (i = 0; i < card->id.vers.ns; i++) + free(card->id.vers.pi[i]); + break; + case TUPLE_IDENT: + free(card->id.tuple.info); + break; + default: + break; + } + free(card); + } +} + +static void free_device(device_info_t *dev) +{ + if (dev && (--dev->refs == 0)) { + int i; + for (i = 0; i < dev->modules; i++) { + free(dev->module[i]); + if (dev->opts[i]) free(dev->opts[i]); + } + if (dev->class) free(dev->class); + free(dev); + } +} + +static void free_mtd(mtd_ident_t *mtd) +{ + if (mtd && (--mtd->refs == 0)) { + free(mtd->name); + free(mtd->module); + free(mtd); + } +} + +static void free_config(void) +{ + while (root_adjust != NULL) { + adjust_list_t *adj = root_adjust; + root_adjust = root_adjust->next; + free(adj); + } + + while (root_device != NULL) { + device_info_t *dev = root_device; + root_device = root_device->next; + free_device(dev); + } + + while (root_card != NULL) { + card_info_t *card = root_card; + root_card = root_card->next; + free_card(card); + } + + while (root_func != NULL) { + card_info_t *card = root_func; + root_func = root_func->next; + free_card(card); + } + blank_card = NULL; + + while (root_mtd != NULL) { + mtd_ident_t *mtd = root_mtd; + root_mtd = root_mtd->next; + free_mtd(mtd); + } + default_mtd = NULL; +} + +/*====================================================================*/ + +static int execute(char *msg, char *cmd) +{ + int ret; + FILE *f; + char line[256]; + + syslog(LOG_INFO, "executing: '%s'", cmd); + strcat(cmd, " 2>&1"); + f = popen(cmd, "r"); + while (fgets(line, 255, f)) { + line[strlen(line)-1] = '\0'; + syslog(LOG_INFO, "+ %s", line); + } + ret = pclose(f); + if (WIFEXITED(ret)) { + if (WEXITSTATUS(ret)) + syslog(LOG_INFO, "%s exited with status %d", + msg, WEXITSTATUS(ret)); + return WEXITSTATUS(ret); + } else + syslog(LOG_INFO, "%s exited on signal %d", + msg, WTERMSIG(ret)); + return -1; +} + +/*====================================================================*/ + +static int execute_on_dev(char *action, char *class, char *dev) +{ + /* Fixed length strings are ok here */ + char msg[128], cmd[128]; + + sprintf(msg, "%s cmd", action); + sprintf(cmd, "./%s %s %s", class, action, dev); + return execute(msg, cmd); +} + +static int execute_on_all(char *cmd, char *class, int sn, int fn) +{ + socket_info_t *s = &socket[sn]; + bind_info_t *bind; + int ret = 0; + for (bind = s->bind[fn]; bind != NULL; bind = bind->next) + if (bind->name[0] && (bind->name[2] != '#')) + ret |= execute_on_dev(cmd, class, bind->name); + return ret; +} + +/*====================================================================*/ + +#ifdef __linux__ + +typedef struct module_list_t { + char *mod; + int usage; + struct module_list_t *next; +} module_list_t; + +static module_list_t *module_list = NULL; + +static int try_insmod(char *mod, char *opts) +{ + char *cmd = malloc(strlen(mod) + strlen(modpath) + + (opts ? strlen(opts) : 0) + 30); + int ret; + + strcpy(cmd, "insmod "); + if (strchr(mod, '/') != NULL) + sprintf(cmd+7, "%s/%s.o", modpath, mod); + else + sprintf(cmd+7, "%s/pcmcia/%s.o", modpath, mod); + if (access(cmd+7, R_OK) != 0) { + syslog(LOG_INFO, "module %s not available", cmd+7); + free(cmd); + return -1; + } + if (opts) { + strcat(cmd, " "); + strcat(cmd, opts); + } + ret = execute("insmod", cmd); + free(cmd); + return ret; +} + +static int try_modprobe(char *mod, char *opts) +{ + char *cmd = malloc(strlen(mod) + (opts ? strlen(opts) : 0) + 20); + char *s = strrchr(mod, '/'); + int ret; + + sprintf(cmd, "modprobe %s", (s) ? s+1 : mod); + if (opts) { + strcat(cmd, " "); + strcat(cmd, opts); + } + ret = execute("modprobe", cmd); + free(cmd); + return ret; +} + +static void install_module(char *mod, char *opts) +{ + module_list_t *ml; + + for (ml = module_list; ml != NULL; ml = ml->next) + if (strcmp(mod, ml->mod) == 0) break; + if (ml == NULL) { + ml = (module_list_t *)malloc(sizeof(struct module_list_t)); + ml->mod = mod; + ml->usage = 0; + ml->next = module_list; + module_list = ml; + } + ml->usage++; + if (ml->usage != 1) + return; + +#ifdef __linux__ + if (access("/proc/bus/pccard/drivers", R_OK) == 0) { + FILE *f = fopen("/proc/bus/pccard/drivers", "r"); + if (f) { + char a[61], s[33]; + while (fgets(a, 60, f)) { + int is_kernel; + sscanf(a, "%s %d", s, &is_kernel); + if (strcmp(s, mod) != 0) continue; + /* If it isn't a module, we won't try to rmmod */ + ml->usage += is_kernel; + fclose(f); + return; + } + fclose(f); + } + } +#endif + + if (do_modprobe) { + if (try_modprobe(mod, opts) != 0) + try_insmod(mod, opts); + } else { + if (try_insmod(mod, opts) != 0) + try_modprobe(mod, opts); + } +} + +static void remove_module(char *mod) +{ + char *s, cmd[128]; + module_list_t *ml; + + for (ml = module_list; ml != NULL; ml = ml->next) + if (strcmp(mod, ml->mod) == 0) break; + if (ml != NULL) { + ml->usage--; + if (ml->usage == 0) { + /* Strip off leading path names */ + s = strrchr(mod, '/'); + s = (s) ? s+1 : mod; + sprintf(cmd, do_modprobe ? "modprobe -r %s" : "rmmod %s", s); + execute(do_modprobe ? "modprobe" : "rmmod", cmd); + } + } +} + +#endif /* __linux__ */ + +/*====================================================================*/ + +#ifdef __BEOS__ + +#define install_module(a,b) +#define remove_module(a) + +static void republish_driver(char *mod) +{ + int fd = open("/dev", O_RDWR); + write(fd, mod, strlen(mod)); + close(fd); +} + +#endif /* __BEOS__ */ + +/*====================================================================*/ + +static mtd_ident_t *lookup_mtd(region_info_t *region) +{ + mtd_ident_t *mtd; + int match = 0; + + for (mtd = root_mtd; mtd; mtd = mtd->next) { + switch (mtd->mtd_type) { + case JEDEC_MTD: + if ((mtd->jedec_mfr == region->JedecMfr) && + (mtd->jedec_info == region->JedecInfo)) { + match = 1; + break; + } + case DTYPE_MTD: + break; + default: + break; + } + if (match) break; + } + if (mtd) + return mtd; + else + return default_mtd; +} + +/*====================================================================*/ + +static void bind_mtd(int sn) +{ + socket_info_t *s = &socket[sn]; + region_info_t region; + bind_info_t bind; + mtd_info_t mtd_info; + mtd_ident_t *mtd; + int i, attr, ret, nr; + + nr = 0; + for (attr = 0; attr < 2; attr++) { + region.Attributes = attr; + ret = ioctl(s->fd, DS_GET_FIRST_REGION, ®ion); + while (ret == 0) { + mtd = lookup_mtd(®ion); + if (mtd) { + /* Have we seen this MTD before? */ + for (i = 0; i < nr; i++) + if (s->mtd[i] == mtd) break; + if (i == nr) { + install_module(mtd->module, mtd->opts); + s->mtd[nr] = mtd; + mtd->refs++; + nr++; + } + syslog(LOG_INFO, " %s memory region at 0x%x: %s", + attr ? "Attribute" : "Common", region.CardOffset, + mtd->name); + /* Bind MTD to this region */ + strcpy(mtd_info.dev_info, s->mtd[i]->module); + mtd_info.Attributes = region.Attributes; + mtd_info.CardOffset = region.CardOffset; + if (ioctl(s->fd, DS_BIND_MTD, &mtd_info) != 0) { + syslog(LOG_INFO, + "bind MTD '%s' to region at 0x%x failed: %m", + (char *)mtd_info.dev_info, region.CardOffset); + } + } + ret = ioctl(s->fd, DS_GET_NEXT_REGION, ®ion); + } + } + s->mtd[nr] = NULL; + + /* Now bind each unique MTD as a normal client of this socket */ + for (i = 0; i < nr; i++) { + strcpy(bind.dev_info, s->mtd[i]->module); + bind.function = 0; + if (ioctl(s->fd, DS_BIND_REQUEST, &bind) != 0) + syslog(LOG_INFO, "bind MTD '%s' to socket %d failed: %m", + (char *)bind.dev_info, sn); + } +} + +/*====================================================================*/ + +static void update_cis(socket_info_t *s) +{ + cisdump_t cis; + FILE *f = fopen(s->card->cis_file, "r"); + if (f == NULL) + syslog(LOG_ERR, "could not open '%s': %m", s->card->cis_file); + else { + cis.Length = fread(cis.Data, 1, CISTPL_MAX_CIS_SIZE, f); + fclose(f); + if (ioctl(s->fd, DS_REPLACE_CIS, &cis) != 0) + syslog(LOG_ERR, "could not replace CIS: %m"); + } +} + +/*====================================================================*/ + +static void do_insert(int sn) +{ + socket_info_t *s = &socket[sn]; + card_info_t *card; + device_info_t **dev; + bind_info_t *bind, **tail; + int i, j, ret; + + /* Already identified? */ + if ((s->card != NULL) && (s->card != blank_card)) + return; + + if (verbose) syslog(LOG_INFO, "initializing socket %d", sn); + card = lookup_card(sn); + if (s->state & SOCKET_HOTPLUG) { + write_stab(); + return; + } + /* Make sure we've learned something new before continuing */ + if (card == s->card) + return; + s->card = card; + card->refs++; + if (card->cis_file) update_cis(s); + + dev = card->device; + + /* Set up MTD's */ + for (i = 0; i < card->bindings; i++) + if (dev[i]->needs_mtd) + break; + if (i < card->bindings) + bind_mtd(sn); + +#ifdef __linux__ + /* Install kernel modules */ + for (i = 0; i < card->bindings; i++) { + dev[i]->refs++; + for (j = 0; j < dev[i]->modules; j++) + install_module(dev[i]->module[j], dev[i]->opts[j]); + } +#endif + + /* Bind drivers by their dev_info identifiers */ + for (i = 0; i < card->bindings; i++) { + bind = calloc(1, sizeof(bind_info_t)); + strcpy((char *)bind->dev_info, (char *)dev[i]->dev_info); + if (strcmp(bind->dev_info, "cb_enabler") == 0) + bind->function = BIND_FN_ALL; + else + bind->function = card->dev_fn[i]; + if (ioctl(s->fd, DS_BIND_REQUEST, bind) != 0) { + if (errno == EBUSY) { + syslog(LOG_INFO, "'%s' already bound to socket %d", + (char *)bind->dev_info, sn); + } else { + syslog(LOG_INFO, "bind '%s' to socket %d failed: %m", + (char *)bind->dev_info, sn); + beep(BEEP_TIME, BEEP_ERR); + write_stab(); + return; + } + } + +#ifdef __BEOS__ + republish_driver(dev[i]->module[0]); +#endif + + for (ret = j = 0; j < 10; j++) { + ret = ioctl(s->fd, DS_GET_DEVICE_INFO, bind); + if ((ret == 0) || (errno != EAGAIN)) + break; + usleep(100000); + } + if (ret != 0) { + syslog(LOG_INFO, "get dev info on socket %d failed: %m", + sn); + ioctl(s->fd, DS_UNBIND_REQUEST, bind); + beep(BEEP_TIME, BEEP_ERR); + write_stab(); + return; + } + tail = &s->bind[i]; + while (ret == 0) { + bind_info_t *old; +#ifdef __linux__ + if ((strlen(bind->name) > 3) && (bind->name[2] == '#')) + xlate_scsi_name(bind); +#endif + old = *tail = bind; tail = (bind_info_t **)&bind->next; + bind = (bind_info_t *)malloc(sizeof(bind_info_t)); + memcpy(bind, old, sizeof(bind_info_t)); + ret = ioctl(s->fd, DS_GET_NEXT_DEVICE, bind); + } + *tail = NULL; free(bind); + write_stab(); + } + + /* Run "start" commands */ + for (i = ret = 0; i < card->bindings; i++) + if (dev[i]->class) + ret |= execute_on_all("start", dev[i]->class, sn, i); + beep(BEEP_TIME, (ret) ? BEEP_ERR : BEEP_OK); + +} + +/*====================================================================*/ + +static int do_check(int sn) +{ + socket_info_t *s = &socket[sn]; + card_info_t *card; + device_info_t **dev; + int i, ret; + + card = s->card; + if (card == NULL) + return 0; + + /* Run "check" commands */ + dev = card->device; + for (i = 0; i < card->bindings; i++) { + if (dev[i]->class) { + ret = execute_on_all("check", dev[i]->class, sn, i); + if (ret != 0) + return CS_IN_USE; + } + } + return 0; +} + +/*====================================================================*/ + +static void do_remove(int sn) +{ + socket_info_t *s = &socket[sn]; + card_info_t *card; + device_info_t **dev; + bind_info_t *bind; + int i, j; + + if (verbose) syslog(LOG_INFO, "shutting down socket %d", sn); + + card = s->card; + if (card == NULL) + goto done; + + /* Run "stop" commands */ + dev = card->device; + for (i = 0; i < card->bindings; i++) { + if (dev[i]->class) { + execute_on_all("stop", dev[i]->class, sn, i); + } + } + + /* unbind driver instances */ + for (i = 0; i < card->bindings; i++) { + if (s->bind[i]) { + if (ioctl(s->fd, DS_UNBIND_REQUEST, s->bind[i]) != 0) + syslog(LOG_INFO, "unbind '%s' from socket %d failed: %m", + (char *)s->bind[i]->dev_info, sn); + while (s->bind[i]) { + bind = s->bind[i]; + s->bind[i] = bind->next; + free(bind); + } + } + } + for (i = 0; (s->mtd[i] != NULL); i++) { + bind_info_t b; + strcpy(b.dev_info, s->mtd[i]->module); + b.function = 0; + if (ioctl(s->fd, DS_UNBIND_REQUEST, &b) != 0) + syslog(LOG_INFO, "unbind MTD '%s' from socket %d failed: %m", + s->mtd[i]->module, sn); + } + + /* remove kernel modules in inverse order */ + for (i = 0; i < card->bindings; i++) { + for (j = dev[i]->modules-1; j >= 0; j--) + remove_module(dev[i]->module[j]); + free_device(dev[i]); + } + /* Remove any MTD's bound to this socket */ + for (i = 0; (s->mtd[i] != NULL); i++) { + remove_module(s->mtd[i]->module); + free_mtd(s->mtd[i]); + s->mtd[i] = NULL; + } + +done: + beep(BEEP_TIME, BEEP_OK); + free_card(card); + s->card = NULL; + write_stab(); +} + +/*====================================================================*/ + +static void do_suspend(int sn) +{ + socket_info_t *s = &socket[sn]; + card_info_t *card; + device_info_t **dev; + int i, ret; + + card = s->card; + if (card == NULL) + return; + dev = card->device; + for (i = 0; i < card->bindings; i++) { + if (dev[i]->class) { + ret = execute_on_all("suspend", dev[i]->class, sn, i); + if (ret != 0) + beep(BEEP_TIME, BEEP_ERR); + } + } +} + +/*====================================================================*/ + +static void do_resume(int sn) +{ + socket_info_t *s = &socket[sn]; + card_info_t *card; + device_info_t **dev; + int i, ret; + + card = s->card; + if (card == NULL) + return; + dev = card->device; + for (i = 0; i < card->bindings; i++) { + if (dev[i]->class) { + ret = execute_on_all("resume", dev[i]->class, sn, i); + if (ret != 0) + beep(BEEP_TIME, BEEP_ERR); + } + } +} + +/*====================================================================*/ + +static void wait_for_pending(void) +{ + cs_status_t status; + int i; + status.Function = 0; + for (;;) { + usleep(100000); + for (i = 0; i < sockets; i++) + if ((ioctl(socket[i].fd, DS_GET_STATUS, &status) == 0) && + (status.CardState & CS_EVENT_CARD_INSERTION)) + break; + if (i == sockets) break; + } +} + +/*====================================================================*/ + +static void free_resources(void) +{ + adjust_list_t *al; + int fd = socket[0].fd; + + for (al = root_adjust; al; al = al->next) { + if (al->adj.Action == ADD_MANAGED_RESOURCE) { + al->adj.Action = REMOVE_MANAGED_RESOURCE; + ioctl(fd, DS_ADJUST_RESOURCE_INFO, &al->adj); + } else if ((al->adj.Action == REMOVE_MANAGED_RESOURCE) && + (al->adj.Resource == RES_IRQ)) { + al->adj.Action = ADD_MANAGED_RESOURCE; + ioctl(fd, DS_ADJUST_RESOURCE_INFO, &al->adj); + } + } + +} + +/*====================================================================*/ + +static void adjust_resources(void) +{ + adjust_list_t *al; + int ret; + char tmp[64]; + int fd = socket[0].fd; + + for (al = root_adjust; al; al = al->next) { + ret = ioctl(fd, DS_ADJUST_RESOURCE_INFO, &al->adj); + if (ret != 0) { + switch (al->adj.Resource) { + case RES_MEMORY_RANGE: + sprintf(tmp, "memory %#lx-%#lx", + al->adj.resource.memory.Base, + al->adj.resource.memory.Base + + al->adj.resource.memory.Size - 1); + break; + case RES_IO_RANGE: + sprintf(tmp, "IO ports %#x-%#x", + al->adj.resource.io.BasePort, + al->adj.resource.io.BasePort + + al->adj.resource.io.NumPorts - 1); + break; + case RES_IRQ: + sprintf(tmp, "irq %u", al->adj.resource.irq.IRQ); + break; + } + syslog(LOG_INFO, "could not adjust resource: %s: %m", tmp); + } + } +} + +/*====================================================================*/ + +static int cleanup_files = 0; + +static void fork_now(void) +{ + int ret; + if ((ret = fork()) > 0) { + cleanup_files = 0; + exit(0); + } + if (ret == -1) + syslog(LOG_ERR, "forking: %m"); + if (setsid() < 0) + syslog(LOG_ERR, "detaching from tty: %m"); +} + +static void done(void) +{ + syslog(LOG_INFO, "exiting"); + if (cleanup_files) { + unlink(pidfile); + unlink(stabfile); + } +} + +/*====================================================================*/ + +/* most recent signal */ +static int caught_signal = 0; + +static void catch_signal(int sig) +{ + caught_signal = sig; + if (signal(sig, catch_signal) == SIG_ERR) + syslog(LOG_INFO, "signal(%d): %m", sig); +} + +static void handle_signal(void) +{ + int i; + switch (caught_signal) { + case SIGTERM: + case SIGINT: + for (i = 0; i < sockets; i++) + if ((socket[i].state & SOCKET_PRESENT) && + (do_check(i) == 0)) do_remove(i); + free_resources(); + exit(0); + break; + case SIGHUP: + free_resources(); + free_config(); + syslog(LOG_INFO, "re-loading config file"); + load_config(); + adjust_resources(); + break; +#ifdef SIGPWR + case SIGPWR: + break; +#endif + } +} + +/*====================================================================*/ + +static int init_sockets(void) +{ + int fd, i; + servinfo_t serv; + +#ifdef __linux__ + major = lookup_dev("pcmcia"); + if (major < 0) { + if (major == -ENODEV) + syslog(LOG_ERR, "no pcmcia driver in /proc/devices"); + else + syslog(LOG_ERR, "could not open /proc/devices: %m"); + exit(EXIT_FAILURE); + } +#endif + for (fd = -1, i = 0; i < MAX_SOCKS; i++) { + fd = open_sock(i, S_IFCHR|S_IREAD|S_IWRITE); + if (fd < 0) break; + socket[i].fd = fd; + socket[i].state = 0; + } + if ((fd < 0) && (errno != ENODEV) && (errno != ENOENT)) + syslog(LOG_ERR, "open_sock(socket %d) failed: %m", i); + sockets = i; + if (sockets == 0) { + syslog(LOG_ERR, "no sockets found!"); + return -1; + } else + syslog(LOG_INFO, "watching %d sockets", sockets); + + if (ioctl(socket[0].fd, DS_GET_CARD_SERVICES_INFO, &serv) == 0) { + if (serv.Revision != CS_RELEASE_CODE) + syslog(LOG_INFO, "Card Services release does not match"); + } else { + syslog(LOG_ERR, "could not get CS revision info!"); + return -1; + } + adjust_resources(); + return 0; +} + +/*====================================================================*/ + +int main(int argc, char *argv[]) +{ + int optch, errflg; + int i, max_fd, ret, event, pass; + int delay_fork = 0; + struct timeval tv; + fd_set fds; + + if (access("/var/lib/pcmcia", R_OK) == 0) { + stabfile = "/var/lib/pcmcia/stab"; + } else { + stabfile = "/var/run/stab"; + } + + errflg = 0; + while ((optch = getopt(argc, argv, "Vqdvofc:m:p:s:")) != -1) { + switch (optch) { + case 'V': + fprintf(stderr, "cardmgr version " CS_RELEASE "\n"); + return 0; + break; + case 'q': + be_quiet = 1; break; + case 'v': + verbose = 1; break; + case 'o': + one_pass = 1; break; + case 'f': + delay_fork = 1; break; + case 'c': + configpath = strdup(optarg); break; +#ifdef __linux__ + case 'd': + do_modprobe = 1; break; + case 'm': + modpath = strdup(optarg); break; +#endif + case 'p': + pidfile = strdup(optarg); break; + case 's': + stabfile = strdup(optarg); break; + default: + errflg = 1; break; + } + } + if (errflg || (optind < argc)) { + fprintf(stderr, "usage: %s [-V] [-q] [-v] [-d] [-o] [-f] " + "[-c configpath] [-m modpath]\n " + "[-p pidfile] [-s stabfile]\n", argv[0]); + exit(EXIT_FAILURE); + } + +#ifdef DEBUG + openlog("cardmgr", LOG_PID|LOG_PERROR, LOG_DAEMON); +#else + openlog("cardmgr", LOG_PID|LOG_CONS, LOG_DAEMON); + close(0); close(1); close(2); + if (!delay_fork && !one_pass) + fork_now(); +#endif + + syslog(LOG_INFO, "starting, version is " CS_RELEASE); + atexit(&done); + putenv("PATH=/bin:/sbin:/usr/bin:/usr/sbin"); + if (verbose) + putenv("VERBOSE=1"); + +#ifdef __linux__ + if (modpath == NULL) { + if (access("/lib/modules/preferred", X_OK) == 0) + modpath = "/lib/modules/preferred"; + else { + struct utsname utsname; + if (uname(&utsname) != 0) { + syslog(LOG_ERR, "uname(): %m"); + exit(EXIT_FAILURE); + } + modpath = (char *)malloc(strlen(utsname.release)+14); + sprintf(modpath, "/lib/modules/%s", utsname.release); + } + } + if (access(modpath, X_OK) != 0) + syslog(LOG_INFO, "cannot access %s: %m", modpath); + /* We default to using modprobe if it is available */ + do_modprobe |= (access("/sbin/modprobe", X_OK) == 0); +#endif /* __linux__ */ + + load_config(); + + if (init_sockets() != 0) + exit(EXIT_FAILURE); + + /* If we've gotten this far, then clean up pid and stab at exit */ + write_pid(); + write_stab(); + cleanup_files = 1; + + if (signal(SIGHUP, catch_signal) == SIG_ERR) + syslog(LOG_ERR, "signal(SIGHUP): %m"); + if (signal(SIGTERM, catch_signal) == SIG_ERR) + syslog(LOG_ERR, "signal(SIGTERM): %m"); + if (signal(SIGINT, catch_signal) == SIG_ERR) + syslog(LOG_ERR, "signal(SIGINT): %m"); +#ifdef SIGPWR + if (signal(SIGPWR, catch_signal) == SIG_ERR) + syslog(LOG_ERR, "signal(SIGPWR): %m"); +#endif + + for (i = max_fd = 0; i < sockets; i++) + max_fd = (socket[i].fd > max_fd) ? socket[i].fd : max_fd; + + /* First select() call: poll, don't wait */ + tv.tv_sec = tv.tv_usec = 0; + + /* Wait for sockets in setup-pending state to settle */ + if (one_pass || delay_fork) + wait_for_pending(); + + for (pass = 0; ; pass++) { + FD_ZERO(&fds); + for (i = 0; i < sockets; i++) + FD_SET(socket[i].fd, &fds); + + while ((ret = select(max_fd+1, &fds, NULL, NULL, + ((pass == 0) ? &tv : NULL))) < 0) { + if (errno == EINTR) { + handle_signal(); + } else { + syslog(LOG_ERR, "select(): %m"); + exit(EXIT_FAILURE); + } + } + + for (i = 0; i < sockets; i++) { + if (!FD_ISSET(socket[i].fd, &fds)) + continue; + ret = read(socket[i].fd, &event, 4); + if ((ret == -1) && (errno != EAGAIN)) + syslog(LOG_INFO, "read(%d): %m\n", i); + if (ret != 4) + continue; + + switch (event) { + case CS_EVENT_CARD_REMOVAL: + socket[i].state = 0; + do_remove(i); + break; + case CS_EVENT_EJECTION_REQUEST: + ret = do_check(i); + if (ret == 0) { + socket[i].state = 0; + do_remove(i); + } + write(socket[i].fd, &ret, 4); + break; + case CS_EVENT_CARD_INSERTION: + case CS_EVENT_INSERTION_REQUEST: + socket[i].state |= SOCKET_PRESENT; + case CS_EVENT_CARD_RESET: + socket[i].state |= SOCKET_READY; + do_insert(i); + break; + case CS_EVENT_RESET_PHYSICAL: + socket[i].state &= ~SOCKET_READY; + break; + case CS_EVENT_PM_SUSPEND: + do_suspend(i); + break; + case CS_EVENT_PM_RESUME: + do_resume(i); + break; + } + + } + + if (one_pass) + exit(EXIT_SUCCESS); + if (delay_fork) { + fork_now(); + write_pid(); + } + + } /* repeat */ + return 0; +} diff --git a/mdk-stage1/pcmcia_/cardmgr.h b/mdk-stage1/pcmcia_/cardmgr.h new file mode 100644 index 000000000..1d002e972 --- /dev/null +++ b/mdk-stage1/pcmcia_/cardmgr.h @@ -0,0 +1,112 @@ +/* + * cardmgr.h 1.37 2001/08/24 12:19:20 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#define MAX_SOCKS 8 +#define MAX_BINDINGS 4 +#define MAX_MODULES 4 + +typedef struct adjust_list_t { + adjust_t adj; + struct adjust_list_t *next; +} adjust_list_t; + +typedef struct func_ident_t { + u_char funcid; +} func_ident_t; + +typedef struct manfid_ident_t { + u_short manf; + u_short card; +} manfid_ident_t; + +typedef struct vers_ident_t { + int ns; + char *pi[4]; +} vers_ident_t; + +typedef struct tuple_ident_t { + cisdata_t code; + long ofs; + char *info; +} tuple_ident_t; + +typedef struct device_info_t { + dev_info_t dev_info; + int needs_mtd; + int modules; + char *module[MAX_MODULES]; + char *opts[MAX_MODULES]; + char *class; + int refs; + struct device_info_t *next; +} device_info_t; + +#define VERS_1_IDENT 0x0001 +#define MANFID_IDENT 0x0002 +#define TUPLE_IDENT 0x0010 +#define FUNC_IDENT 0x0020 +#define BLANK_IDENT 0x0040 +#define PCI_IDENT 0x0080 +#define EXCL_IDENT 0x00f0 + +typedef struct card_info_t { + char *name; + int ident_type; + union { + vers_ident_t vers; + tuple_ident_t tuple; + func_ident_t func; + } id; + manfid_ident_t manfid; + int bindings; + device_info_t *device[MAX_BINDINGS]; + int dev_fn[MAX_BINDINGS]; + char *cis_file; + int refs; + struct card_info_t *next; +} card_info_t; + +typedef struct mtd_ident_t { + char *name; + enum { + JEDEC_MTD=1, DTYPE_MTD, DEFAULT_MTD + } mtd_type; + int dtype, jedec_mfr, jedec_info; + char *module, *opts; + int refs; + struct mtd_ident_t *next; +} mtd_ident_t; + +extern adjust_list_t *root_adjust; +extern device_info_t *root_device; +extern card_info_t *blank_card; +extern card_info_t *root_card, *root_func; +extern mtd_ident_t *root_mtd, *default_mtd; + +int parse_configfile(char *fn); diff --git a/mdk-stage1/pcmcia_/cirrus.h b/mdk-stage1/pcmcia_/cirrus.h new file mode 100644 index 000000000..49d7fa2de --- /dev/null +++ b/mdk-stage1/pcmcia_/cirrus.h @@ -0,0 +1,182 @@ +/* + * cirrus.h 1.10 2001/08/24 12:15:33 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_CIRRUS_H +#define _LINUX_CIRRUS_H + +#ifndef PCI_VENDOR_ID_CIRRUS +#define PCI_VENDOR_ID_CIRRUS 0x1013 +#endif +#ifndef PCI_DEVICE_ID_CIRRUS_6729 +#define PCI_DEVICE_ID_CIRRUS_6729 0x1100 +#endif +#ifndef PCI_DEVICE_ID_CIRRUS_6832 +#define PCI_DEVICE_ID_CIRRUS_6832 0x1110 +#endif + +#define PD67_MISC_CTL_1 0x16 /* Misc control 1 */ +#define PD67_FIFO_CTL 0x17 /* FIFO control */ +#define PD67_MISC_CTL_2 0x1E /* Misc control 2 */ +#define PD67_CHIP_INFO 0x1f /* Chip information */ +#define PD67_ATA_CTL 0x026 /* 6730: ATA control */ +#define PD67_EXT_INDEX 0x2e /* Extension index */ +#define PD67_EXT_DATA 0x2f /* Extension data */ + +#define pd67_ext_get(s, r) \ + (i365_set(s, PD67_EXT_INDEX, r), i365_get(s, PD67_EXT_DATA)) +#define pd67_ext_set(s, r, v) \ + (i365_set(s, PD67_EXT_INDEX, r), i365_set(s, PD67_EXT_DATA, v)) + +/* PD6722 extension registers -- indexed in PD67_EXT_INDEX */ +#define PD67_DATA_MASK0 0x01 /* Data mask 0 */ +#define PD67_DATA_MASK1 0x02 /* Data mask 1 */ +#define PD67_DMA_CTL 0x03 /* DMA control */ + +/* PD6730 extension registers -- indexed in PD67_EXT_INDEX */ +#define PD67_EXT_CTL_1 0x03 /* Extension control 1 */ +#define PD67_MEM_PAGE(n) ((n)+5) /* PCI window bits 31:24 */ +#define PD67_EXTERN_DATA 0x0a +#define PD67_MISC_CTL_3 0x25 +#define PD67_SMB_PWR_CTL 0x26 + +/* I/O window address offset */ +#define PD67_IO_OFF(w) (0x36+((w)<<1)) + +/* Timing register sets */ +#define PD67_TIME_SETUP(n) (0x3a + 3*(n)) +#define PD67_TIME_CMD(n) (0x3b + 3*(n)) +#define PD67_TIME_RECOV(n) (0x3c + 3*(n)) + +/* Flags for PD67_MISC_CTL_1 */ +#define PD67_MC1_5V_DET 0x01 /* 5v detect */ +#define PD67_MC1_MEDIA_ENA 0x01 /* 6730: Multimedia enable */ +#define PD67_MC1_VCC_3V 0x02 /* 3.3v Vcc */ +#define PD67_MC1_PULSE_MGMT 0x04 +#define PD67_MC1_PULSE_IRQ 0x08 +#define PD67_MC1_SPKR_ENA 0x10 +#define PD67_MC1_INPACK_ENA 0x80 + +/* Flags for PD67_FIFO_CTL */ +#define PD67_FIFO_EMPTY 0x80 + +/* Flags for PD67_MISC_CTL_2 */ +#define PD67_MC2_FREQ_BYPASS 0x01 +#define PD67_MC2_DYNAMIC_MODE 0x02 +#define PD67_MC2_SUSPEND 0x04 +#define PD67_MC2_5V_CORE 0x08 +#define PD67_MC2_LED_ENA 0x10 /* IRQ 12 is LED enable */ +#define PD67_MC2_FAST_PCI 0x10 /* 6729: PCI bus > 25 MHz */ +#define PD67_MC2_3STATE_BIT7 0x20 /* Floppy change bit */ +#define PD67_MC2_DMA_MODE 0x40 +#define PD67_MC2_IRQ15_RI 0x80 /* IRQ 15 is ring enable */ + +/* Flags for PD67_CHIP_INFO */ +#define PD67_INFO_SLOTS 0x20 /* 0 = 1 slot, 1 = 2 slots */ +#define PD67_INFO_CHIP_ID 0xc0 +#define PD67_INFO_REV 0x1c + +/* Fields in PD67_TIME_* registers */ +#define PD67_TIME_SCALE 0xc0 +#define PD67_TIME_SCALE_1 0x00 +#define PD67_TIME_SCALE_16 0x40 +#define PD67_TIME_SCALE_256 0x80 +#define PD67_TIME_SCALE_4096 0xc0 +#define PD67_TIME_MULT 0x3f + +/* Fields in PD67_DMA_CTL */ +#define PD67_DMA_MODE 0xc0 +#define PD67_DMA_OFF 0x00 +#define PD67_DMA_DREQ_INPACK 0x40 +#define PD67_DMA_DREQ_WP 0x80 +#define PD67_DMA_DREQ_BVD2 0xc0 +#define PD67_DMA_PULLUP 0x20 /* Disable socket pullups? */ + +/* Fields in PD67_EXT_CTL_1 */ +#define PD67_EC1_VCC_PWR_LOCK 0x01 +#define PD67_EC1_AUTO_PWR_CLEAR 0x02 +#define PD67_EC1_LED_ENA 0x04 +#define PD67_EC1_INV_CARD_IRQ 0x08 +#define PD67_EC1_INV_MGMT_IRQ 0x10 +#define PD67_EC1_PULLUP_CTL 0x20 + +/* Fields in PD67_EXTERN_DATA */ +#define PD67_EXD_VS1(s) (0x01 << ((s)<<1)) +#define PD67_EXD_VS2(s) (0x02 << ((s)<<1)) + +/* Fields in PD67_MISC_CTL_3 */ +#define PD67_MC3_IRQ_MASK 0x03 +#define PD67_MC3_IRQ_PCPCI 0x00 +#define PD67_MC3_IRQ_EXTERN 0x01 +#define PD67_MC3_IRQ_PCIWAY 0x02 +#define PD67_MC3_IRQ_PCI 0x03 +#define PD67_MC3_PWR_MASK 0x0c +#define PD67_MC3_PWR_SERIAL 0x00 +#define PD67_MC3_PWR_TI2202 0x08 +#define PD67_MC3_PWR_SMB 0x0c + +/* Register definitions for Cirrus PD6832 PCI-to-CardBus bridge */ + +/* PD6832 extension registers -- indexed in PD67_EXT_INDEX */ +#define PD68_EXT_CTL_2 0x0b +#define PD68_PCI_SPACE 0x22 +#define PD68_PCCARD_SPACE 0x23 +#define PD68_WINDOW_TYPE 0x24 +#define PD68_EXT_CSC 0x2e +#define PD68_MISC_CTL_4 0x2f +#define PD68_MISC_CTL_5 0x30 +#define PD68_MISC_CTL_6 0x31 + +/* Extra flags in PD67_MISC_CTL_3 */ +#define PD68_MC3_HW_SUSP 0x10 +#define PD68_MC3_MM_EXPAND 0x40 +#define PD68_MC3_MM_ARM 0x80 + +/* Bridge Control Register */ +#define PD6832_BCR_MGMT_IRQ_ENA 0x0800 + +/* Socket Number Register */ +#define PD6832_SOCKET_NUMBER 0x004c /* 8 bit */ + +/* Data structure for tracking vendor-specific state */ +typedef struct cirrus_state_t { + u_char misc1; /* PD67_MISC_CTL_1 */ + u_char misc2; /* PD67_MISC_CTL_2 */ + u_char ectl1; /* PD67_EXT_CTL_1 */ + u_char timer[6]; /* PD67_TIME_* */ +} cirrus_state_t; + +#define CIRRUS_PCIC_ID \ + IS_PD6729, IS_PD6730, IS_PD6832 + +#define CIRRUS_PCIC_INFO \ + { "Cirrus PD6729", IS_CIRRUS|IS_PCI, ID(CIRRUS, 6729) }, \ + { "Cirrus PD6730", IS_CIRRUS|IS_PCI, PCI_VENDOR_ID_CIRRUS, -1 }, \ + { "Cirrus PD6832", IS_CIRRUS|IS_CARDBUS, ID(CIRRUS, 6832) } + +#endif /* _LINUX_CIRRUS_H */ diff --git a/mdk-stage1/pcmcia_/cistpl.h b/mdk-stage1/pcmcia_/cistpl.h new file mode 100644 index 000000000..1d4cac20e --- /dev/null +++ b/mdk-stage1/pcmcia_/cistpl.h @@ -0,0 +1,604 @@ +/* + * cistpl.h 1.35 2001/08/24 12:16:12 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_CISTPL_H +#define _LINUX_CISTPL_H + +#define CISTPL_NULL 0x00 +#define CISTPL_DEVICE 0x01 +#define CISTPL_LONGLINK_CB 0x02 +#define CISTPL_INDIRECT 0x03 +#define CISTPL_CONFIG_CB 0x04 +#define CISTPL_CFTABLE_ENTRY_CB 0x05 +#define CISTPL_LONGLINK_MFC 0x06 +#define CISTPL_BAR 0x07 +#define CISTPL_PWR_MGMNT 0x08 +#define CISTPL_EXTDEVICE 0x09 +#define CISTPL_CHECKSUM 0x10 +#define CISTPL_LONGLINK_A 0x11 +#define CISTPL_LONGLINK_C 0x12 +#define CISTPL_LINKTARGET 0x13 +#define CISTPL_NO_LINK 0x14 +#define CISTPL_VERS_1 0x15 +#define CISTPL_ALTSTR 0x16 +#define CISTPL_DEVICE_A 0x17 +#define CISTPL_JEDEC_C 0x18 +#define CISTPL_JEDEC_A 0x19 +#define CISTPL_CONFIG 0x1a +#define CISTPL_CFTABLE_ENTRY 0x1b +#define CISTPL_DEVICE_OC 0x1c +#define CISTPL_DEVICE_OA 0x1d +#define CISTPL_DEVICE_GEO 0x1e +#define CISTPL_DEVICE_GEO_A 0x1f +#define CISTPL_MANFID 0x20 +#define CISTPL_FUNCID 0x21 +#define CISTPL_FUNCE 0x22 +#define CISTPL_SWIL 0x23 +#define CISTPL_END 0xff +/* Layer 2 tuples */ +#define CISTPL_VERS_2 0x40 +#define CISTPL_FORMAT 0x41 +#define CISTPL_GEOMETRY 0x42 +#define CISTPL_BYTEORDER 0x43 +#define CISTPL_DATE 0x44 +#define CISTPL_BATTERY 0x45 +#define CISTPL_FORMAT_A 0x47 +/* Layer 3 tuples */ +#define CISTPL_ORG 0x46 +#define CISTPL_SPCL 0x90 + +typedef struct cistpl_longlink_t { + u_int addr; +} cistpl_longlink_t; + +typedef struct cistpl_checksum_t { + u_short addr; + u_short len; + u_char sum; +} cistpl_checksum_t; + +#define CISTPL_MAX_FUNCTIONS 8 +#define CISTPL_MFC_ATTR 0x00 +#define CISTPL_MFC_COMMON 0x01 + +typedef struct cistpl_longlink_mfc_t { + u_char nfn; + struct { + u_char space; + u_int addr; + } fn[CISTPL_MAX_FUNCTIONS]; +} cistpl_longlink_mfc_t; + +#define CISTPL_MAX_ALTSTR_STRINGS 4 + +typedef struct cistpl_altstr_t { + u_char ns; + u_char ofs[CISTPL_MAX_ALTSTR_STRINGS]; + char str[254]; +} cistpl_altstr_t; + +#define CISTPL_DTYPE_NULL 0x00 +#define CISTPL_DTYPE_ROM 0x01 +#define CISTPL_DTYPE_OTPROM 0x02 +#define CISTPL_DTYPE_EPROM 0x03 +#define CISTPL_DTYPE_EEPROM 0x04 +#define CISTPL_DTYPE_FLASH 0x05 +#define CISTPL_DTYPE_SRAM 0x06 +#define CISTPL_DTYPE_DRAM 0x07 +#define CISTPL_DTYPE_FUNCSPEC 0x0d +#define CISTPL_DTYPE_EXTEND 0x0e + +#define CISTPL_MAX_DEVICES 4 + +typedef struct cistpl_device_t { + u_char ndev; + struct { + u_char type; + u_char wp; + u_int speed; + u_int size; + } dev[CISTPL_MAX_DEVICES]; +} cistpl_device_t; + +#define CISTPL_DEVICE_MWAIT 0x01 +#define CISTPL_DEVICE_3VCC 0x02 + +typedef struct cistpl_device_o_t { + u_char flags; + cistpl_device_t device; +} cistpl_device_o_t; + +#define CISTPL_VERS_1_MAX_PROD_STRINGS 4 + +typedef struct cistpl_vers_1_t { + u_char major; + u_char minor; + u_char ns; + u_char ofs[CISTPL_VERS_1_MAX_PROD_STRINGS]; + char str[254]; +} cistpl_vers_1_t; + +typedef struct cistpl_jedec_t { + u_char nid; + struct { + u_char mfr; + u_char info; + } id[CISTPL_MAX_DEVICES]; +} cistpl_jedec_t; + +typedef struct cistpl_manfid_t { + u_short manf; + u_short card; +} cistpl_manfid_t; + +#define CISTPL_FUNCID_MULTI 0x00 +#define CISTPL_FUNCID_MEMORY 0x01 +#define CISTPL_FUNCID_SERIAL 0x02 +#define CISTPL_FUNCID_PARALLEL 0x03 +#define CISTPL_FUNCID_FIXED 0x04 +#define CISTPL_FUNCID_VIDEO 0x05 +#define CISTPL_FUNCID_NETWORK 0x06 +#define CISTPL_FUNCID_AIMS 0x07 +#define CISTPL_FUNCID_SCSI 0x08 + +#define CISTPL_SYSINIT_POST 0x01 +#define CISTPL_SYSINIT_ROM 0x02 + +typedef struct cistpl_funcid_t { + u_char func; + u_char sysinit; +} cistpl_funcid_t; + +typedef struct cistpl_funce_t { + u_char type; + u_char data[0]; +} cistpl_funce_t; + +/*====================================================================== + + Modem Function Extension Tuples + +======================================================================*/ + +#define CISTPL_FUNCE_SERIAL_IF 0x00 +#define CISTPL_FUNCE_SERIAL_CAP 0x01 +#define CISTPL_FUNCE_SERIAL_SERV_DATA 0x02 +#define CISTPL_FUNCE_SERIAL_SERV_FAX 0x03 +#define CISTPL_FUNCE_SERIAL_SERV_VOICE 0x04 +#define CISTPL_FUNCE_SERIAL_CAP_DATA 0x05 +#define CISTPL_FUNCE_SERIAL_CAP_FAX 0x06 +#define CISTPL_FUNCE_SERIAL_CAP_VOICE 0x07 +#define CISTPL_FUNCE_SERIAL_IF_DATA 0x08 +#define CISTPL_FUNCE_SERIAL_IF_FAX 0x09 +#define CISTPL_FUNCE_SERIAL_IF_VOICE 0x0a + +/* UART identification */ +#define CISTPL_SERIAL_UART_8250 0x00 +#define CISTPL_SERIAL_UART_16450 0x01 +#define CISTPL_SERIAL_UART_16550 0x02 +#define CISTPL_SERIAL_UART_8251 0x03 +#define CISTPL_SERIAL_UART_8530 0x04 +#define CISTPL_SERIAL_UART_85230 0x05 + +/* UART capabilities */ +#define CISTPL_SERIAL_UART_SPACE 0x01 +#define CISTPL_SERIAL_UART_MARK 0x02 +#define CISTPL_SERIAL_UART_ODD 0x04 +#define CISTPL_SERIAL_UART_EVEN 0x08 +#define CISTPL_SERIAL_UART_5BIT 0x01 +#define CISTPL_SERIAL_UART_6BIT 0x02 +#define CISTPL_SERIAL_UART_7BIT 0x04 +#define CISTPL_SERIAL_UART_8BIT 0x08 +#define CISTPL_SERIAL_UART_1STOP 0x10 +#define CISTPL_SERIAL_UART_MSTOP 0x20 +#define CISTPL_SERIAL_UART_2STOP 0x40 + +typedef struct cistpl_serial_t { + u_char uart_type; + u_char uart_cap_0; + u_char uart_cap_1; +} cistpl_serial_t; + +typedef struct cistpl_modem_cap_t { + u_char flow; + u_char cmd_buf; + u_char rcv_buf_0, rcv_buf_1, rcv_buf_2; + u_char xmit_buf_0, xmit_buf_1, xmit_buf_2; +} cistpl_modem_cap_t; + +#define CISTPL_SERIAL_MOD_103 0x01 +#define CISTPL_SERIAL_MOD_V21 0x02 +#define CISTPL_SERIAL_MOD_V23 0x04 +#define CISTPL_SERIAL_MOD_V22 0x08 +#define CISTPL_SERIAL_MOD_212A 0x10 +#define CISTPL_SERIAL_MOD_V22BIS 0x20 +#define CISTPL_SERIAL_MOD_V26 0x40 +#define CISTPL_SERIAL_MOD_V26BIS 0x80 +#define CISTPL_SERIAL_MOD_V27BIS 0x01 +#define CISTPL_SERIAL_MOD_V29 0x02 +#define CISTPL_SERIAL_MOD_V32 0x04 +#define CISTPL_SERIAL_MOD_V32BIS 0x08 +#define CISTPL_SERIAL_MOD_V34 0x10 + +#define CISTPL_SERIAL_ERR_MNP2_4 0x01 +#define CISTPL_SERIAL_ERR_V42_LAPM 0x02 + +#define CISTPL_SERIAL_CMPR_V42BIS 0x01 +#define CISTPL_SERIAL_CMPR_MNP5 0x02 + +#define CISTPL_SERIAL_CMD_AT1 0x01 +#define CISTPL_SERIAL_CMD_AT2 0x02 +#define CISTPL_SERIAL_CMD_AT3 0x04 +#define CISTPL_SERIAL_CMD_MNP_AT 0x08 +#define CISTPL_SERIAL_CMD_V25BIS 0x10 +#define CISTPL_SERIAL_CMD_V25A 0x20 +#define CISTPL_SERIAL_CMD_DMCL 0x40 + +typedef struct cistpl_data_serv_t { + u_char max_data_0; + u_char max_data_1; + u_char modulation_0; + u_char modulation_1; + u_char error_control; + u_char compression; + u_char cmd_protocol; + u_char escape; + u_char encrypt; + u_char misc_features; + u_char ccitt_code[0]; +} cistpl_data_serv_t; + +typedef struct cistpl_fax_serv_t { + u_char max_data_0; + u_char max_data_1; + u_char modulation; + u_char encrypt; + u_char features_0; + u_char features_1; + u_char ccitt_code[0]; +} cistpl_fax_serv_t; + +typedef struct cistpl_voice_serv_t { + u_char max_data_0; + u_char max_data_1; +} cistpl_voice_serv_t; + +/*====================================================================== + + LAN Function Extension Tuples + +======================================================================*/ + +#define CISTPL_FUNCE_LAN_TECH 0x01 +#define CISTPL_FUNCE_LAN_SPEED 0x02 +#define CISTPL_FUNCE_LAN_MEDIA 0x03 +#define CISTPL_FUNCE_LAN_NODE_ID 0x04 +#define CISTPL_FUNCE_LAN_CONNECTOR 0x05 + +/* LAN technologies */ +#define CISTPL_LAN_TECH_ARCNET 0x01 +#define CISTPL_LAN_TECH_ETHERNET 0x02 +#define CISTPL_LAN_TECH_TOKENRING 0x03 +#define CISTPL_LAN_TECH_LOCALTALK 0x04 +#define CISTPL_LAN_TECH_FDDI 0x05 +#define CISTPL_LAN_TECH_ATM 0x06 +#define CISTPL_LAN_TECH_WIRELESS 0x07 + +typedef struct cistpl_lan_tech_t { + u_char tech; +} cistpl_lan_tech_t; + +typedef struct cistpl_lan_speed_t { + u_int speed; +} cistpl_lan_speed_t; + +/* LAN media definitions */ +#define CISTPL_LAN_MEDIA_UTP 0x01 +#define CISTPL_LAN_MEDIA_STP 0x02 +#define CISTPL_LAN_MEDIA_THIN_COAX 0x03 +#define CISTPL_LAN_MEDIA_THICK_COAX 0x04 +#define CISTPL_LAN_MEDIA_FIBER 0x05 +#define CISTPL_LAN_MEDIA_900MHZ 0x06 +#define CISTPL_LAN_MEDIA_2GHZ 0x07 +#define CISTPL_LAN_MEDIA_5GHZ 0x08 +#define CISTPL_LAN_MEDIA_DIFF_IR 0x09 +#define CISTPL_LAN_MEDIA_PTP_IR 0x0a + +typedef struct cistpl_lan_media_t { + u_char media; +} cistpl_lan_media_t; + +typedef struct cistpl_lan_node_id_t { + u_char nb; + u_char id[16]; +} cistpl_lan_node_id_t; + +typedef struct cistpl_lan_connector_t { + u_char code; +} cistpl_lan_connector_t; + +/*====================================================================== + + IDE Function Extension Tuples + +======================================================================*/ + +#define CISTPL_IDE_INTERFACE 0x01 + +typedef struct cistpl_ide_interface_t { + u_char interface; +} cistpl_ide_interface_t; + +/* First feature byte */ +#define CISTPL_IDE_SILICON 0x04 +#define CISTPL_IDE_UNIQUE 0x08 +#define CISTPL_IDE_DUAL 0x10 + +/* Second feature byte */ +#define CISTPL_IDE_HAS_SLEEP 0x01 +#define CISTPL_IDE_HAS_STANDBY 0x02 +#define CISTPL_IDE_HAS_IDLE 0x04 +#define CISTPL_IDE_LOW_POWER 0x08 +#define CISTPL_IDE_REG_INHIBIT 0x10 +#define CISTPL_IDE_HAS_INDEX 0x20 +#define CISTPL_IDE_IOIS16 0x40 + +typedef struct cistpl_ide_feature_t { + u_char feature1; + u_char feature2; +} cistpl_ide_feature_t; + +#define CISTPL_FUNCE_IDE_IFACE 0x01 +#define CISTPL_FUNCE_IDE_MASTER 0x02 +#define CISTPL_FUNCE_IDE_SLAVE 0x03 + +/*====================================================================== + + Configuration Table Entries + +======================================================================*/ + +#define CISTPL_BAR_SPACE 0x07 +#define CISTPL_BAR_SPACE_IO 0x10 +#define CISTPL_BAR_PREFETCH 0x20 +#define CISTPL_BAR_CACHEABLE 0x40 +#define CISTPL_BAR_1MEG_MAP 0x80 + +typedef struct cistpl_bar_t { + u_char attr; + u_int size; +} cistpl_bar_t; + +typedef struct cistpl_config_t { + u_char last_idx; + u_int base; + u_int rmask[4]; + u_char subtuples; +} cistpl_config_t; + +/* These are bits in the 'present' field, and indices in 'param' */ +#define CISTPL_POWER_VNOM 0 +#define CISTPL_POWER_VMIN 1 +#define CISTPL_POWER_VMAX 2 +#define CISTPL_POWER_ISTATIC 3 +#define CISTPL_POWER_IAVG 4 +#define CISTPL_POWER_IPEAK 5 +#define CISTPL_POWER_IDOWN 6 + +#define CISTPL_POWER_HIGHZ_OK 0x01 +#define CISTPL_POWER_HIGHZ_REQ 0x02 + +typedef struct cistpl_power_t { + u_char present; + u_char flags; + u_int param[7]; +} cistpl_power_t; + +typedef struct cistpl_timing_t { + u_int wait, waitscale; + u_int ready, rdyscale; + u_int reserved, rsvscale; +} cistpl_timing_t; + +#define CISTPL_IO_LINES_MASK 0x1f +#define CISTPL_IO_8BIT 0x20 +#define CISTPL_IO_16BIT 0x40 +#define CISTPL_IO_RANGE 0x80 + +#define CISTPL_IO_MAX_WIN 16 + +typedef struct cistpl_io_t { + u_char flags; + u_char nwin; + struct { + u_int base; + u_int len; + } win[CISTPL_IO_MAX_WIN]; +} cistpl_io_t; + +typedef struct cistpl_irq_t { + u_int IRQInfo1; + u_int IRQInfo2; +} cistpl_irq_t; + +#define CISTPL_MEM_MAX_WIN 8 + +typedef struct cistpl_mem_t { + u_char flags; + u_char nwin; + struct { + u_int len; + u_int card_addr; + u_int host_addr; + } win[CISTPL_MEM_MAX_WIN]; +} cistpl_mem_t; + +#define CISTPL_CFTABLE_DEFAULT 0x0001 +#define CISTPL_CFTABLE_BVDS 0x0002 +#define CISTPL_CFTABLE_WP 0x0004 +#define CISTPL_CFTABLE_RDYBSY 0x0008 +#define CISTPL_CFTABLE_MWAIT 0x0010 +#define CISTPL_CFTABLE_AUDIO 0x0800 +#define CISTPL_CFTABLE_READONLY 0x1000 +#define CISTPL_CFTABLE_PWRDOWN 0x2000 + +typedef struct cistpl_cftable_entry_t { + u_char index; + u_short flags; + u_char interface; + cistpl_power_t vcc, vpp1, vpp2; + cistpl_timing_t timing; + cistpl_io_t io; + cistpl_irq_t irq; + cistpl_mem_t mem; + u_char subtuples; +} cistpl_cftable_entry_t; + +#define CISTPL_CFTABLE_MASTER 0x000100 +#define CISTPL_CFTABLE_INVALIDATE 0x000200 +#define CISTPL_CFTABLE_VGA_PALETTE 0x000400 +#define CISTPL_CFTABLE_PARITY 0x000800 +#define CISTPL_CFTABLE_WAIT 0x001000 +#define CISTPL_CFTABLE_SERR 0x002000 +#define CISTPL_CFTABLE_FAST_BACK 0x004000 +#define CISTPL_CFTABLE_BINARY_AUDIO 0x010000 +#define CISTPL_CFTABLE_PWM_AUDIO 0x020000 + +typedef struct cistpl_cftable_entry_cb_t { + u_char index; + u_int flags; + cistpl_power_t vcc, vpp1, vpp2; + u_char io; + cistpl_irq_t irq; + u_char mem; + u_char subtuples; +} cistpl_cftable_entry_cb_t; + +typedef struct cistpl_device_geo_t { + u_char ngeo; + struct { + u_char buswidth; + u_int erase_block; + u_int read_block; + u_int write_block; + u_int partition; + u_int interleave; + } geo[CISTPL_MAX_DEVICES]; +} cistpl_device_geo_t; + +typedef struct cistpl_vers_2_t { + u_char vers; + u_char comply; + u_short dindex; + u_char vspec8, vspec9; + u_char nhdr; + u_char vendor, info; + char str[244]; +} cistpl_vers_2_t; + +typedef struct cistpl_org_t { + u_char data_org; + char desc[30]; +} cistpl_org_t; + +#define CISTPL_ORG_FS 0x00 +#define CISTPL_ORG_APPSPEC 0x01 +#define CISTPL_ORG_XIP 0x02 + +typedef struct cistpl_format_t { + u_char type; + u_char edc; + u_int offset; + u_int length; +} cistpl_format_t; + +#define CISTPL_FORMAT_DISK 0x00 +#define CISTPL_FORMAT_MEM 0x01 + +#define CISTPL_EDC_NONE 0x00 +#define CISTPL_EDC_CKSUM 0x01 +#define CISTPL_EDC_CRC 0x02 +#define CISTPL_EDC_PCC 0x03 + +typedef union cisparse_t { + cistpl_device_t device; + cistpl_checksum_t checksum; + cistpl_longlink_t longlink; + cistpl_longlink_mfc_t longlink_mfc; + cistpl_vers_1_t version_1; + cistpl_altstr_t altstr; + cistpl_jedec_t jedec; + cistpl_manfid_t manfid; + cistpl_funcid_t funcid; + cistpl_funce_t funce; + cistpl_bar_t bar; + cistpl_config_t config; + cistpl_cftable_entry_t cftable_entry; + cistpl_cftable_entry_cb_t cftable_entry_cb; + cistpl_device_geo_t device_geo; + cistpl_vers_2_t vers_2; + cistpl_org_t org; + cistpl_format_t format; +} cisparse_t; + +typedef struct tuple_t { + u_int Attributes; + cisdata_t DesiredTuple; + u_int Flags; /* internal use */ + u_int LinkOffset; /* internal use */ + u_int CISOffset; /* internal use */ + cisdata_t TupleCode; + cisdata_t TupleLink; + cisdata_t TupleOffset; + cisdata_t TupleDataMax; + cisdata_t TupleDataLen; + cisdata_t *TupleData; +} tuple_t; + +/* Special cisdata_t value */ +#define RETURN_FIRST_TUPLE 0xff + +/* Attributes for tuple calls */ +#define TUPLE_RETURN_LINK 0x01 +#define TUPLE_RETURN_COMMON 0x02 + +/* For ValidateCIS */ +typedef struct cisinfo_t { + u_int Chains; +} cisinfo_t; + +#define CISTPL_MAX_CIS_SIZE 0x200 + +/* For ReplaceCIS */ +typedef struct cisdump_t { + u_int Length; + cisdata_t Data[CISTPL_MAX_CIS_SIZE]; +} cisdump_t; + +#endif /* LINUX_CISTPL_H */ diff --git a/mdk-stage1/pcmcia_/cs.h b/mdk-stage1/pcmcia_/cs.h new file mode 100644 index 000000000..dea6937eb --- /dev/null +++ b/mdk-stage1/pcmcia_/cs.h @@ -0,0 +1,465 @@ +/* + * cs.h 1.73 2001/08/24 12:16:12 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_CS_H +#define _LINUX_CS_H + +/* For AccessConfigurationRegister */ +typedef struct conf_reg_t { + u_char Function; + u_int Action; + off_t Offset; + u_int Value; +} conf_reg_t; + +/* Actions */ +#define CS_READ 1 +#define CS_WRITE 2 + +/* for AdjustResourceInfo */ +typedef struct adjust_t { + u_int Action; + u_int Resource; + u_int Attributes; + union { + struct memory { + u_long Base; + u_long Size; + } memory; + struct io { + ioaddr_t BasePort; + ioaddr_t NumPorts; + u_int IOAddrLines; + } io; + struct irq { + u_int IRQ; + } irq; + } resource; +} adjust_t; + +/* Action field */ +#define REMOVE_MANAGED_RESOURCE 1 +#define ADD_MANAGED_RESOURCE 2 +#define GET_FIRST_MANAGED_RESOURCE 3 +#define GET_NEXT_MANAGED_RESOURCE 4 +/* Resource field */ +#define RES_MEMORY_RANGE 1 +#define RES_IO_RANGE 2 +#define RES_IRQ 3 +/* Attribute field */ +#define RES_IRQ_TYPE 0x03 +#define RES_IRQ_TYPE_EXCLUSIVE 0 +#define RES_IRQ_TYPE_TIME 1 +#define RES_IRQ_TYPE_DYNAMIC 2 +#define RES_IRQ_CSC 0x04 +#define RES_SHARED 0x08 +#define RES_RESERVED 0x10 +#define RES_ALLOCATED 0x20 +#define RES_REMOVED 0x40 + +typedef struct servinfo_t { + char Signature[2]; + u_int Count; + u_int Revision; + u_int CSLevel; + char *VendorString; +} servinfo_t; + +typedef struct event_callback_args_t { + client_handle_t client_handle; + void *info; + void *mtdrequest; + void *buffer; + void *misc; + void *client_data; + struct bus_operations *bus; +} event_callback_args_t; + +/* for GetConfigurationInfo */ +typedef struct config_info_t { + u_char Function; + u_int Attributes; + u_int Vcc, Vpp1, Vpp2; + u_int IntType; + u_int ConfigBase; + u_char Status, Pin, Copy, Option, ExtStatus; + u_int Present; + u_int CardValues; + u_int AssignedIRQ; + u_int IRQAttributes; + ioaddr_t BasePort1; + ioaddr_t NumPorts1; + u_int Attributes1; + ioaddr_t BasePort2; + ioaddr_t NumPorts2; + u_int Attributes2; + u_int IOAddrLines; +} config_info_t; + +/* For CardValues field */ +#define CV_OPTION_VALUE 0x01 +#define CV_STATUS_VALUE 0x02 +#define CV_PIN_REPLACEMENT 0x04 +#define CV_COPY_VALUE 0x08 +#define CV_EXT_STATUS 0x10 + +/* For GetFirst/NextClient */ +typedef struct client_req_t { + socket_t Socket; + u_int Attributes; +} client_req_t; + +#define CLIENT_THIS_SOCKET 0x01 + +/* For RegisterClient */ +typedef struct client_reg_t { + dev_info_t *dev_info; + u_int Attributes; + u_int EventMask; + int (*event_handler)(event_t event, int priority, + event_callback_args_t *); + event_callback_args_t event_callback_args; + u_int Version; +} client_reg_t; + +/* ModifyConfiguration */ +typedef struct modconf_t { + u_int Attributes; + u_int Vcc, Vpp1, Vpp2; +} modconf_t; + +/* Attributes for ModifyConfiguration */ +#define CONF_IRQ_CHANGE_VALID 0x100 +#define CONF_VCC_CHANGE_VALID 0x200 +#define CONF_VPP1_CHANGE_VALID 0x400 +#define CONF_VPP2_CHANGE_VALID 0x800 + +/* For RequestConfiguration */ +typedef struct config_req_t { + u_int Attributes; + u_int Vcc, Vpp1, Vpp2; + u_int IntType; + u_int ConfigBase; + u_char Status, Pin, Copy, ExtStatus; + u_char ConfigIndex; + u_int Present; +} config_req_t; + +/* Attributes for RequestConfiguration */ +#define CONF_ENABLE_IRQ 0x01 +#define CONF_ENABLE_DMA 0x02 +#define CONF_ENABLE_SPKR 0x04 +#define CONF_VALID_CLIENT 0x100 + +/* IntType field */ +#define INT_MEMORY 0x01 +#define INT_MEMORY_AND_IO 0x02 +#define INT_CARDBUS 0x04 +#define INT_ZOOMED_VIDEO 0x08 + +/* For RequestIO and ReleaseIO */ +typedef struct io_req_t { + ioaddr_t BasePort1; + ioaddr_t NumPorts1; + u_int Attributes1; + ioaddr_t BasePort2; + ioaddr_t NumPorts2; + u_int Attributes2; + u_int IOAddrLines; +} io_req_t; + +/* Attributes for RequestIO and ReleaseIO */ +#define IO_SHARED 0x01 +#define IO_FIRST_SHARED 0x02 +#define IO_FORCE_ALIAS_ACCESS 0x04 +#define IO_DATA_PATH_WIDTH 0x18 +#define IO_DATA_PATH_WIDTH_8 0x00 +#define IO_DATA_PATH_WIDTH_16 0x08 +#define IO_DATA_PATH_WIDTH_AUTO 0x10 + +/* For RequestIRQ and ReleaseIRQ */ +typedef struct irq_req_t { + u_int Attributes; + u_int AssignedIRQ; + u_int IRQInfo1, IRQInfo2; + void *Handler; + void *Instance; +} irq_req_t; + +/* Attributes for RequestIRQ and ReleaseIRQ */ +#define IRQ_TYPE 0x03 +#define IRQ_TYPE_EXCLUSIVE 0x00 +#define IRQ_TYPE_TIME 0x01 +#define IRQ_TYPE_DYNAMIC_SHARING 0x02 +#define IRQ_FORCED_PULSE 0x04 +#define IRQ_FIRST_SHARED 0x08 +#define IRQ_HANDLE_PRESENT 0x10 +#define IRQ_PULSE_ALLOCATED 0x100 + +/* Bits in IRQInfo1 field */ +#define IRQ_MASK 0x0f +#define IRQ_NMI_ID 0x01 +#define IRQ_IOCK_ID 0x02 +#define IRQ_BERR_ID 0x04 +#define IRQ_VEND_ID 0x08 +#define IRQ_INFO2_VALID 0x10 +#define IRQ_LEVEL_ID 0x20 +#define IRQ_PULSE_ID 0x40 +#define IRQ_SHARE_ID 0x80 + +typedef struct eventmask_t { + u_int Attributes; + u_int EventMask; +} eventmask_t; + +#define CONF_EVENT_MASK_VALID 0x01 + +/* Configuration registers present */ +#define PRESENT_OPTION 0x001 +#define PRESENT_STATUS 0x002 +#define PRESENT_PIN_REPLACE 0x004 +#define PRESENT_COPY 0x008 +#define PRESENT_EXT_STATUS 0x010 +#define PRESENT_IOBASE_0 0x020 +#define PRESENT_IOBASE_1 0x040 +#define PRESENT_IOBASE_2 0x080 +#define PRESENT_IOBASE_3 0x100 +#define PRESENT_IOSIZE 0x200 + +/* For GetMemPage, MapMemPage */ +typedef struct memreq_t { + u_int CardOffset; + page_t Page; +} memreq_t; + +/* For ModifyWindow */ +typedef struct modwin_t { + u_int Attributes; + u_int AccessSpeed; +} modwin_t; + +/* For RequestWindow */ +typedef struct win_req_t { + u_int Attributes; + u_long Base; + u_int Size; + u_int AccessSpeed; +} win_req_t; + +/* Attributes for RequestWindow */ +#define WIN_ADDR_SPACE 0x0001 +#define WIN_ADDR_SPACE_MEM 0x0000 +#define WIN_ADDR_SPACE_IO 0x0001 +#define WIN_MEMORY_TYPE 0x0002 +#define WIN_MEMORY_TYPE_CM 0x0000 +#define WIN_MEMORY_TYPE_AM 0x0002 +#define WIN_ENABLE 0x0004 +#define WIN_DATA_WIDTH 0x0018 +#define WIN_DATA_WIDTH_8 0x0000 +#define WIN_DATA_WIDTH_16 0x0008 +#define WIN_DATA_WIDTH_32 0x0010 +#define WIN_PAGED 0x0020 +#define WIN_SHARED 0x0040 +#define WIN_FIRST_SHARED 0x0080 +#define WIN_USE_WAIT 0x0100 +#define WIN_STRICT_ALIGN 0x0200 +#define WIN_MAP_BELOW_1MB 0x0400 +#define WIN_PREFETCH 0x0800 +#define WIN_CACHEABLE 0x1000 +#define WIN_BAR_MASK 0xe000 +#define WIN_BAR_SHIFT 13 + +/* Attributes for RegisterClient */ +#define INFO_MASTER_CLIENT 0x01 +#define INFO_IO_CLIENT 0x02 +#define INFO_MTD_CLIENT 0x04 +#define INFO_MEM_CLIENT 0x08 +#define MAX_NUM_CLIENTS 3 + +#define INFO_CARD_SHARE 0x10 +#define INFO_CARD_EXCL 0x20 + +typedef struct cs_status_t { + u_char Function; + event_t CardState; + event_t SocketState; +} cs_status_t; + +typedef struct error_info_t { + int func; + int retcode; +} error_info_t; + +/* Special stuff for binding drivers to sockets */ +typedef struct bind_req_t { + socket_t Socket; + u_char Function; + dev_info_t *dev_info; +} bind_req_t; + +/* Flag to bind to all functions */ +#define BIND_FN_ALL 0xff + +typedef struct mtd_bind_t { + socket_t Socket; + u_int Attributes; + u_int CardOffset; + dev_info_t *dev_info; +} mtd_bind_t; + +/* Events */ +#define CS_EVENT_PRI_LOW 0 +#define CS_EVENT_PRI_HIGH 1 + +#define CS_EVENT_WRITE_PROTECT 0x000001 +#define CS_EVENT_CARD_LOCK 0x000002 +#define CS_EVENT_CARD_INSERTION 0x000004 +#define CS_EVENT_CARD_REMOVAL 0x000008 +#define CS_EVENT_BATTERY_DEAD 0x000010 +#define CS_EVENT_BATTERY_LOW 0x000020 +#define CS_EVENT_READY_CHANGE 0x000040 +#define CS_EVENT_CARD_DETECT 0x000080 +#define CS_EVENT_RESET_REQUEST 0x000100 +#define CS_EVENT_RESET_PHYSICAL 0x000200 +#define CS_EVENT_CARD_RESET 0x000400 +#define CS_EVENT_REGISTRATION_COMPLETE 0x000800 +#define CS_EVENT_RESET_COMPLETE 0x001000 +#define CS_EVENT_PM_SUSPEND 0x002000 +#define CS_EVENT_PM_RESUME 0x004000 +#define CS_EVENT_INSERTION_REQUEST 0x008000 +#define CS_EVENT_EJECTION_REQUEST 0x010000 +#define CS_EVENT_MTD_REQUEST 0x020000 +#define CS_EVENT_ERASE_COMPLETE 0x040000 +#define CS_EVENT_REQUEST_ATTENTION 0x080000 +#define CS_EVENT_CB_DETECT 0x100000 +#define CS_EVENT_3VCARD 0x200000 +#define CS_EVENT_XVCARD 0x400000 + +/* Return codes */ +#define CS_SUCCESS 0x00 +#define CS_BAD_ADAPTER 0x01 +#define CS_BAD_ATTRIBUTE 0x02 +#define CS_BAD_BASE 0x03 +#define CS_BAD_EDC 0x04 +#define CS_BAD_IRQ 0x06 +#define CS_BAD_OFFSET 0x07 +#define CS_BAD_PAGE 0x08 +#define CS_READ_FAILURE 0x09 +#define CS_BAD_SIZE 0x0a +#define CS_BAD_SOCKET 0x0b +#define CS_BAD_TYPE 0x0d +#define CS_BAD_VCC 0x0e +#define CS_BAD_VPP 0x0f +#define CS_BAD_WINDOW 0x11 +#define CS_WRITE_FAILURE 0x12 +#define CS_NO_CARD 0x14 +#define CS_UNSUPPORTED_FUNCTION 0x15 +#define CS_UNSUPPORTED_MODE 0x16 +#define CS_BAD_SPEED 0x17 +#define CS_BUSY 0x18 +#define CS_GENERAL_FAILURE 0x19 +#define CS_WRITE_PROTECTED 0x1a +#define CS_BAD_ARG_LENGTH 0x1b +#define CS_BAD_ARGS 0x1c +#define CS_CONFIGURATION_LOCKED 0x1d +#define CS_IN_USE 0x1e +#define CS_NO_MORE_ITEMS 0x1f +#define CS_OUT_OF_RESOURCE 0x20 +#define CS_BAD_HANDLE 0x21 + +#define CS_BAD_TUPLE 0x40 + +#ifdef __KERNEL__ + +/* + * Calls to set up low-level "Socket Services" drivers + */ + +typedef int (*ss_entry_t)(u_int sock, u_int cmd, void *arg); +extern int register_ss_entry(int nsock, ss_entry_t entry); +extern void unregister_ss_entry(ss_entry_t entry); + +/* + * The main Card Services entry point + */ + +enum service { + AccessConfigurationRegister, AddSocketServices, + AdjustResourceInfo, CheckEraseQueue, CloseMemory, CopyMemory, + DeregisterClient, DeregisterEraseQueue, GetCardServicesInfo, + GetClientInfo, GetConfigurationInfo, GetEventMask, + GetFirstClient, GetFirstPartion, GetFirstRegion, GetFirstTuple, + GetNextClient, GetNextPartition, GetNextRegion, GetNextTuple, + GetStatus, GetTupleData, MapLogSocket, MapLogWindow, MapMemPage, + MapPhySocket, MapPhyWindow, ModifyConfiguration, ModifyWindow, + OpenMemory, ParseTuple, ReadMemory, RegisterClient, + RegisterEraseQueue, RegisterMTD, RegisterTimer, + ReleaseConfiguration, ReleaseExclusive, ReleaseIO, ReleaseIRQ, + ReleaseSocketMask, ReleaseWindow, ReplaceSocketServices, + RequestConfiguration, RequestExclusive, RequestIO, RequestIRQ, + RequestSocketMask, RequestWindow, ResetCard, ReturnSSEntry, + SetEventMask, SetRegion, ValidateCIS, VendorSpecific, + WriteMemory, BindDevice, BindMTD, ReportError, + SuspendCard, ResumeCard, EjectCard, InsertCard, ReplaceCIS, + GetFirstWindow, GetNextWindow, GetMemPage +}; + +#ifdef IN_CARD_SERVICES +extern int CardServices(int func, void *a1, void *a2, void *a3); +#else +extern int CardServices(int func, ...); +#endif + +#ifdef __BEOS__ +#define SS_MODULE_NAME(s) ("busses/pcmcia/" s "/v1") +#define MTD_MODULE_NAME(s) ("busses/pcmcia/" s "/v1") +#define CS_CLIENT_MODULE_NAME "bus_managers/pcmcia_cs/client/v1" +typedef struct cs_client_module_info { + bus_manager_info binfo; + int (*_CardServices)(int, ...); + int (*_MTDHelperEntry)(int, ...); + void (*_add_timer)(struct timer_list *); + void (*_del_timer)(struct timer_list *); +} cs_client_module_info; +#define CS_SOCKET_MODULE_NAME "bus_managers/pcmcia_cs/socket/v1" +typedef struct cs_socket_module_info { + bus_manager_info binfo; + int (*_register_ss_entry)(int, ss_entry_t); + void (*_unregister_ss_entry)(ss_entry_t); + void (*_add_timer)(struct timer_list *); + void (*_del_timer)(struct timer_list *); + int (*register_resource)(int, u_long, u_long); + int (*release_resource)(int, u_long, u_long); + int (*check_resource)(int, u_long, u_long); +} cs_socket_module_info; +#endif + +#endif /* __KERNEL__ */ + +#endif /* _LINUX_CS_H */ diff --git a/mdk-stage1/pcmcia_/cs_types.h b/mdk-stage1/pcmcia_/cs_types.h new file mode 100644 index 000000000..a6b56b6bf --- /dev/null +++ b/mdk-stage1/pcmcia_/cs_types.h @@ -0,0 +1,65 @@ +/* + * cs_types.h 1.19 2001/08/24 12:16:12 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_CS_TYPES_H +#define _LINUX_CS_TYPES_H + +#ifdef __linux__ +#ifdef __KERNEL__ +#include +#else +#include +#endif +#endif + +typedef u_short socket_t; +typedef u_short ioaddr_t; +typedef u_int event_t; +typedef u_char cisdata_t; +typedef u_short page_t; + +struct client_t; +typedef struct client_t *client_handle_t; + +struct window_t; +typedef struct window_t *window_handle_t; + +struct region_t; +typedef struct region_t *memory_handle_t; + +struct eraseq_t; +typedef struct eraseq_t *eraseq_handle_t; + +#ifndef DEV_NAME_LEN +#define DEV_NAME_LEN 32 +#endif + +typedef char dev_info_t[DEV_NAME_LEN]; + +#endif /* _LINUX_CS_TYPES_H */ diff --git a/mdk-stage1/pcmcia_/driver_ops.h b/mdk-stage1/pcmcia_/driver_ops.h new file mode 100644 index 000000000..a7223e2c6 --- /dev/null +++ b/mdk-stage1/pcmcia_/driver_ops.h @@ -0,0 +1,82 @@ +/* + * driver_ops.h 1.16 2001/08/24 12:16:13 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_DRIVER_OPS_H +#define _LINUX_DRIVER_OPS_H + +#ifndef DEV_NAME_LEN +#define DEV_NAME_LEN 32 +#endif + +#ifdef __KERNEL__ + +typedef struct dev_node_t { + char dev_name[DEV_NAME_LEN]; + u_short major, minor; + struct dev_node_t *next; +} dev_node_t; + +typedef struct dev_locator_t { + enum { LOC_ISA, LOC_PCI } bus; + union { + struct { + u_short io_base_1, io_base_2; + u_long mem_base; + u_char irq, dma; + } isa; + struct { + u_char bus; + u_char devfn; + } pci; + } b; +} dev_locator_t; + +typedef struct driver_operations { + char *name; + dev_node_t *(*attach) (dev_locator_t *loc); + void (*suspend) (dev_node_t *dev); + void (*resume) (dev_node_t *dev); + void (*detach) (dev_node_t *dev); +} driver_operations; + +int register_driver(struct driver_operations *ops); +void unregister_driver(struct driver_operations *ops); + +#ifdef __BEOS__ +#define CB_ENABLER_MODULE_NAME "bus_managers/cb_enabler/v1" +typedef struct cb_enabler_module_info { + bus_manager_info binfo; + int (*register_driver)(struct driver_operations *ops); + void (*unregister_driver)(struct driver_operations *ops); +} cb_enabler_module_info; +#endif /* __BEOS__ */ + +#endif /* __KERNEL__ */ + +#endif /* _LINUX_DRIVER_OPS_H */ diff --git a/mdk-stage1/pcmcia_/ds.h b/mdk-stage1/pcmcia_/ds.h new file mode 100644 index 000000000..cc89d4912 --- /dev/null +++ b/mdk-stage1/pcmcia_/ds.h @@ -0,0 +1,163 @@ +/* + * ds.h 1.57 2001/08/24 12:16:13 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_DS_H +#define _LINUX_DS_H + +#include +#include + +typedef struct tuple_parse_t { + tuple_t tuple; + cisdata_t data[255]; + cisparse_t parse; +} tuple_parse_t; + +typedef struct win_info_t { + window_handle_t handle; + win_req_t window; + memreq_t map; +} win_info_t; + +typedef struct bind_info_t { + dev_info_t dev_info; + u_char function; + struct dev_link_t *instance; + char name[DEV_NAME_LEN]; + u_short major, minor; + void *next; +} bind_info_t; + +typedef struct mtd_info_t { + dev_info_t dev_info; + u_int Attributes; + u_int CardOffset; +} mtd_info_t; + +typedef union ds_ioctl_arg_t { + servinfo_t servinfo; + adjust_t adjust; + config_info_t config; + tuple_t tuple; + tuple_parse_t tuple_parse; + client_req_t client_req; + cs_status_t status; + conf_reg_t conf_reg; + cisinfo_t cisinfo; + region_info_t region; + bind_info_t bind_info; + mtd_info_t mtd_info; + win_info_t win_info; + cisdump_t cisdump; +} ds_ioctl_arg_t; + +#define DS_GET_CARD_SERVICES_INFO _IOR ('d', 1, servinfo_t) +#define DS_ADJUST_RESOURCE_INFO _IOWR('d', 2, adjust_t) +#define DS_GET_CONFIGURATION_INFO _IOWR('d', 3, config_info_t) +#define DS_GET_FIRST_TUPLE _IOWR('d', 4, tuple_t) +#define DS_GET_NEXT_TUPLE _IOWR('d', 5, tuple_t) +#define DS_GET_TUPLE_DATA _IOWR('d', 6, tuple_parse_t) +#define DS_PARSE_TUPLE _IOWR('d', 7, tuple_parse_t) +#define DS_RESET_CARD _IO ('d', 8) +#define DS_GET_STATUS _IOWR('d', 9, cs_status_t) +#define DS_ACCESS_CONFIGURATION_REGISTER _IOWR('d', 10, conf_reg_t) +#define DS_VALIDATE_CIS _IOR ('d', 11, cisinfo_t) +#define DS_SUSPEND_CARD _IO ('d', 12) +#define DS_RESUME_CARD _IO ('d', 13) +#define DS_EJECT_CARD _IO ('d', 14) +#define DS_INSERT_CARD _IO ('d', 15) +#define DS_GET_FIRST_REGION _IOWR('d', 16, region_info_t) +#define DS_GET_NEXT_REGION _IOWR('d', 17, region_info_t) +#define DS_REPLACE_CIS _IOWR('d', 18, cisdump_t) +#define DS_GET_FIRST_WINDOW _IOR ('d', 19, win_info_t) +#define DS_GET_NEXT_WINDOW _IOWR('d', 20, win_info_t) +#define DS_GET_MEM_PAGE _IOWR('d', 21, win_info_t) + +#define DS_BIND_REQUEST _IOWR('d', 60, bind_info_t) +#define DS_GET_DEVICE_INFO _IOWR('d', 61, bind_info_t) +#define DS_GET_NEXT_DEVICE _IOWR('d', 62, bind_info_t) +#define DS_UNBIND_REQUEST _IOW ('d', 63, bind_info_t) +#define DS_BIND_MTD _IOWR('d', 64, mtd_info_t) + +#ifdef __KERNEL__ + +typedef struct dev_link_t { + dev_node_t *dev; + u_int state, open; + wait_queue_head_t pending; + struct timer_list release; + client_handle_t handle; + io_req_t io; + irq_req_t irq; + config_req_t conf; + window_handle_t win; + void *priv; + struct dev_link_t *next; +} dev_link_t; + +/* Flags for device state */ +#define DEV_PRESENT 0x01 +#define DEV_CONFIG 0x02 +#define DEV_STALE_CONFIG 0x04 /* release on close */ +#define DEV_STALE_LINK 0x08 /* detach on release */ +#define DEV_CONFIG_PENDING 0x10 +#define DEV_RELEASE_PENDING 0x20 +#define DEV_SUSPEND 0x40 +#define DEV_BUSY 0x80 + +#define DEV_OK(l) \ + ((l) && ((l->state & ~DEV_BUSY) == (DEV_CONFIG|DEV_PRESENT))) + +int register_pccard_driver(dev_info_t *dev_info, + dev_link_t *(*attach)(void), + void (*detach)(dev_link_t *)); + +int unregister_pccard_driver(dev_info_t *dev_info); + +#define register_pcmcia_driver register_pccard_driver +#define unregister_pcmcia_driver unregister_pccard_driver + +#ifdef __BEOS__ +#define DS_MODULE_NAME "bus_managers/pcmcia_ds/v1" +typedef struct ds_module_info { + bus_manager_info binfo; + int (*_register_pccard_driver)(dev_info_t *, + dev_link_t *(*)(void), + void (*)(dev_link_t *)); + int (*_unregister_pccard_driver)(dev_info_t *); + struct driver_info_t **root_driver; + int *sockets; + struct socket_info_t **socket_table; + sem_id *list_sem; +} ds_module_info; +#endif /* __BEOS__ */ + +#endif /* __KERNEL__ */ + +#endif /* _LINUX_DS_H */ diff --git a/mdk-stage1/pcmcia_/i82365.h b/mdk-stage1/pcmcia_/i82365.h new file mode 100644 index 000000000..27ee5837c --- /dev/null +++ b/mdk-stage1/pcmcia_/i82365.h @@ -0,0 +1,154 @@ +/* + * i82365.h 1.21 2001/08/24 12:15:33 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_I82365_H +#define _LINUX_I82365_H + +/* register definitions for the Intel 82365SL PCMCIA controller */ + +/* Offsets for PCIC registers */ +#define I365_IDENT 0x00 /* Identification and revision */ +#define I365_STATUS 0x01 /* Interface status */ +#define I365_POWER 0x02 /* Power and RESETDRV control */ +#define I365_INTCTL 0x03 /* Interrupt and general control */ +#define I365_CSC 0x04 /* Card status change */ +#define I365_CSCINT 0x05 /* Card status change interrupt control */ +#define I365_ADDRWIN 0x06 /* Address window enable */ +#define I365_IOCTL 0x07 /* I/O control */ +#define I365_GENCTL 0x16 /* Card detect and general control */ +#define I365_GBLCTL 0x1E /* Global control register */ + +/* Offsets for I/O and memory window registers */ +#define I365_IO(map) (0x08+((map)<<2)) +#define I365_MEM(map) (0x10+((map)<<3)) +#define I365_W_START 0 +#define I365_W_STOP 2 +#define I365_W_OFF 4 + +/* Flags for I365_STATUS */ +#define I365_CS_BVD1 0x01 +#define I365_CS_STSCHG 0x01 +#define I365_CS_BVD2 0x02 +#define I365_CS_SPKR 0x02 +#define I365_CS_DETECT 0x0C +#define I365_CS_WRPROT 0x10 +#define I365_CS_READY 0x20 /* Inverted */ +#define I365_CS_POWERON 0x40 +#define I365_CS_GPI 0x80 + +/* Flags for I365_POWER */ +#define I365_PWR_OFF 0x00 /* Turn off the socket */ +#define I365_PWR_OUT 0x80 /* Output enable */ +#define I365_PWR_NORESET 0x40 /* Disable RESETDRV on resume */ +#define I365_PWR_AUTO 0x20 /* Auto pwr switch enable */ +#define I365_VCC_MASK 0x18 /* Mask for turning off Vcc */ +/* There are different layouts for B-step and DF-step chips: the B + step has independent Vpp1/Vpp2 control, and the DF step has only + Vpp1 control, plus 3V control */ +#define I365_VCC_5V 0x10 /* Vcc = 5.0v */ +#define I365_VCC_3V 0x18 /* Vcc = 3.3v */ +#define I365_VPP2_MASK 0x0c /* Mask for turning off Vpp2 */ +#define I365_VPP2_5V 0x04 /* Vpp2 = 5.0v */ +#define I365_VPP2_12V 0x08 /* Vpp2 = 12.0v */ +#define I365_VPP1_MASK 0x03 /* Mask for turning off Vpp1 */ +#define I365_VPP1_5V 0x01 /* Vpp2 = 5.0v */ +#define I365_VPP1_12V 0x02 /* Vpp2 = 12.0v */ + +/* Flags for I365_INTCTL */ +#define I365_RING_ENA 0x80 +#define I365_PC_RESET 0x40 +#define I365_PC_IOCARD 0x20 +#define I365_INTR_ENA 0x10 +#define I365_IRQ_MASK 0x0F + +/* Flags for I365_CSC and I365_CSCINT*/ +#define I365_CSC_BVD1 0x01 +#define I365_CSC_STSCHG 0x01 +#define I365_CSC_BVD2 0x02 +#define I365_CSC_READY 0x04 +#define I365_CSC_DETECT 0x08 +#define I365_CSC_ANY 0x0F +#define I365_CSC_GPI 0x10 + +/* Flags for I365_ADDRWIN */ +#define I365_ADDR_MEMCS16 0x20 +#define I365_ENA_IO(map) (0x40 << (map)) +#define I365_ENA_MEM(map) (0x01 << (map)) + +/* Flags for I365_IOCTL */ +#define I365_IOCTL_MASK(map) (0x0F << (map<<2)) +#define I365_IOCTL_WAIT(map) (0x08 << (map<<2)) +#define I365_IOCTL_0WS(map) (0x04 << (map<<2)) +#define I365_IOCTL_IOCS16(map) (0x02 << (map<<2)) +#define I365_IOCTL_16BIT(map) (0x01 << (map<<2)) + +/* Flags for I365_GENCTL */ +#define I365_CTL_16DELAY 0x01 +#define I365_CTL_RESET 0x02 +#define I365_CTL_GPI_ENA 0x04 +#define I365_CTL_GPI_CTL 0x08 +#define I365_CTL_RESUME 0x10 +#define I365_CTL_SW_IRQ 0x20 + +/* Flags for I365_GBLCTL */ +#define I365_GBL_PWRDOWN 0x01 +#define I365_GBL_CSC_LEV 0x02 +#define I365_GBL_WRBACK 0x04 +#define I365_GBL_IRQ_0_LEV 0x08 +#define I365_GBL_IRQ_1_LEV 0x10 + +/* Flags for memory window registers */ +#define I365_MEM_16BIT 0x8000 /* In memory start high byte */ +#define I365_MEM_0WS 0x4000 +#define I365_MEM_WS1 0x8000 /* In memory stop high byte */ +#define I365_MEM_WS0 0x4000 +#define I365_MEM_WRPROT 0x8000 /* In offset high byte */ +#define I365_MEM_REG 0x4000 + +#define I365_REG(slot, reg) (((slot) << 6) | (reg)) + +/* Default ISA interrupt mask */ +#define I365_ISA_IRQ_MASK 0xdeb8 /* irq's 3-5,7,9-12,14,15 */ + +/* Device ID's for PCI-to-PCMCIA bridges */ + +#ifndef PCI_VENDOR_ID_INTEL +#define PCI_VENDOR_ID_INTEL 0x8086 +#endif +#ifndef PCI_DEVICE_ID_INTEL_82092AA_0 +#define PCI_DEVICE_ID_INTEL_82092AA_0 0x1221 +#endif +#ifndef PCI_VENDOR_ID_OMEGA +#define PCI_VENDOR_ID_OMEGA 0x119b +#endif +#ifndef PCI_DEVICE_ID_OMEGA_82C092G +#define PCI_DEVICE_ID_OMEGA_82C092G 0x1221 +#endif + +#endif /* _LINUX_I82365_H */ diff --git a/mdk-stage1/pcmcia_/lex_config.c b/mdk-stage1/pcmcia_/lex_config.c new file mode 100644 index 000000000..52d7310da --- /dev/null +++ b/mdk-stage1/pcmcia_/lex_config.c @@ -0,0 +1,2052 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 45 +#define YY_END_OF_BUFFER 46 +static yyconst short int yy_accept[247] = + { 0, + 5, 5, 2, 2, 46, 44, 5, 4, 5, 44, + 6, 41, 41, 44, 44, 44, 44, 44, 44, 44, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 3, + 2, 45, 5, 5, 6, 0, 43, 0, 6, 41, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, + 0, 0, 3, 2, 0, 43, 0, 42, 0, 0, + 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, + 0, 18, 0, 0, 0, 0, 23, 0, 0, 0, + + 0, 26, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 8, 10, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, + 0, 27, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 0, 0, 14, 0, 0, 0, 0, + 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 31, 0, 0, 0, 0, 0, 13, 0, + 0, 0, 0, 20, 21, 22, 0, 0, 0, 28, + 0, 0, 0, 1, 0, 0, 0, 0, 12, 15, + 0, 0, 17, 0, 0, 0, 0, 29, 0, 0, + + 32, 0, 0, 0, 0, 16, 0, 0, 0, 0, + 0, 0, 0, 39, 7, 0, 0, 24, 0, 0, + 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 34, 0, 0, 0, 40, 0, + 0, 35, 37, 0, 38, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 1, 5, 6, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 7, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 1, 6, 1, + 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 10, 1, 1, 11, 1, 12, 13, 14, 15, + + 16, 17, 18, 1, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[36] = + { 0, + 1, 2, 3, 2, 1, 1, 4, 4, 4, 1, + 1, 4, 4, 4, 4, 4, 4, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst short int yy_base[253] = + { 0, + 0, 0, 34, 37, 293, 294, 40, 294, 41, 41, + 0, 41, 45, 31, 273, 42, 40, 257, 38, 34, + 274, 47, 273, 262, 53, 271, 57, 35, 60, 0, + 79, 294, 82, 83, 0, 83, 294, 87, 0, 87, + 0, 263, 260, 260, 255, 253, 269, 74, 245, 265, + 244, 253, 262, 248, 259, 249, 249, 256, 255, 80, + 239, 240, 248, 238, 80, 236, 236, 232, 294, 236, + 233, 245, 0, 97, 95, 97, 108, 0, 230, 234, + 242, 241, 294, 226, 242, 234, 226, 229, 234, 235, + 226, 294, 231, 229, 220, 213, 294, 228, 209, 212, + + 228, 294, 209, 219, 221, 217, 216, 206, 211, 203, + 215, 219, 194, 294, 294, 199, 196, 212, 209, 193, + 208, 192, 190, 206, 200, 190, 195, 187, 190, 294, + 192, 294, 188, 184, 200, 198, 195, 192, 188, 181, + 191, 181, 294, 181, 186, 294, 186, 189, 180, 183, + 294, 182, 161, 179, 183, 165, 170, 167, 158, 177, + 166, 171, 294, 161, 174, 172, 158, 152, 294, 165, + 165, 154, 162, 294, 166, 294, 153, 154, 158, 294, + 157, 157, 160, 294, 146, 157, 140, 136, 294, 294, + 147, 141, 294, 150, 133, 151, 139, 294, 148, 133, + + 294, 143, 142, 127, 126, 294, 142, 138, 140, 140, + 124, 124, 136, 294, 294, 126, 118, 294, 130, 118, + 113, 114, 115, 294, 125, 127, 108, 116, 99, 87, + 294, 90, 87, 86, 294, 96, 78, 74, 294, 75, + 64, 294, 294, 46, 294, 294, 118, 122, 126, 130, + 134, 64 + } ; + +static yyconst short int yy_def[253] = + { 0, + 246, 1, 247, 247, 246, 246, 246, 246, 246, 248, + 249, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 250, + 246, 246, 246, 246, 249, 248, 246, 251, 249, 246, + 252, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 250, 246, 248, 248, 251, 252, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 0, 246, 246, 246, 246, + 246, 246 + } ; + +static yyconst short int yy_nxt[330] = + { 0, + 6, 7, 8, 9, 10, 11, 12, 13, 6, 6, + 6, 14, 15, 16, 17, 18, 19, 6, 20, 21, + 6, 6, 22, 23, 24, 25, 6, 26, 27, 28, + 6, 29, 6, 6, 6, 31, 32, 31, 31, 32, + 31, 33, 33, 33, 34, 37, 35, 40, 40, 42, + 38, 40, 40, 45, 43, 48, 51, 53, 56, 69, + 46, 54, 57, 47, 62, 70, 63, 78, 52, 49, + 66, 58, 67, 245, 41, 71, 59, 64, 72, 244, + 74, 68, 74, 33, 33, 33, 34, 37, 35, 36, + 85, 76, 38, 40, 40, 98, 77, 104, 74, 37, + + 74, 37, 243, 242, 38, 86, 38, 241, 105, 99, + 36, 240, 76, 239, 238, 237, 236, 77, 30, 30, + 30, 30, 36, 36, 36, 36, 39, 39, 235, 39, + 73, 234, 233, 73, 75, 75, 75, 75, 232, 231, + 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, + 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, + 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, + 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, + 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, + 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, + + 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, + 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, + 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, + 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, + 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, + 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, + 110, 109, 108, 107, 106, 103, 102, 101, 100, 97, + 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, + 84, 83, 82, 81, 80, 79, 65, 61, 60, 55, + 50, 44, 246, 5, 246, 246, 246, 246, 246, 246, + + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246 + } ; + +static yyconst short int yy_chk[330] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 3, 3, 4, 4, + 4, 7, 9, 7, 9, 10, 9, 12, 12, 14, + 10, 13, 13, 16, 14, 17, 19, 20, 22, 28, + 16, 20, 22, 16, 25, 28, 25, 252, 19, 17, + 27, 22, 27, 244, 12, 29, 22, 25, 29, 241, + 31, 27, 31, 33, 34, 33, 34, 36, 34, 38, + 48, 38, 36, 40, 40, 60, 38, 65, 74, 75, + + 74, 76, 240, 238, 75, 48, 76, 237, 65, 60, + 77, 236, 77, 234, 233, 232, 230, 77, 247, 247, + 247, 247, 248, 248, 248, 248, 249, 249, 229, 249, + 250, 228, 227, 250, 251, 251, 251, 251, 226, 225, + 223, 222, 221, 220, 219, 217, 216, 213, 212, 211, + 210, 209, 208, 207, 205, 204, 203, 202, 200, 199, + 197, 196, 195, 194, 192, 191, 188, 187, 186, 185, + 183, 182, 181, 179, 178, 177, 175, 173, 172, 171, + 170, 168, 167, 166, 165, 164, 162, 161, 160, 159, + 158, 157, 156, 155, 154, 153, 152, 150, 149, 148, + + 147, 145, 144, 142, 141, 140, 139, 138, 137, 136, + 135, 134, 133, 131, 129, 128, 127, 126, 125, 124, + 123, 122, 121, 120, 119, 118, 117, 116, 113, 112, + 111, 110, 109, 108, 107, 106, 105, 104, 103, 101, + 100, 99, 98, 96, 95, 94, 93, 91, 90, 89, + 88, 87, 86, 85, 84, 82, 81, 80, 79, 72, + 71, 70, 68, 67, 66, 64, 63, 62, 61, 59, + 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, + 47, 46, 45, 44, 43, 42, 26, 24, 23, 21, + 18, 15, 5, 246, 246, 246, 246, 246, 246, 246, + + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246, 246, + 246, 246, 246, 246, 246, 246, 246, 246, 246 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "lex_config.l" +#define INITIAL 0 +/* Special state for handling include files */ +#define src 1 + +#line 5 "lex_config.l" +/* + * lex_config.l 1.40 2001/08/24 12:21:25 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#undef src +#include +#include +#include +#include +#include +#include +#define src 1 + +#include +#include + +#include "yacc_config.h" + +/* For assembling nice error messages */ +char *current_file; +int current_lineno; + +static int lex_number(char *s); +static int lex_string(char *s); +static void do_source(char *fn); +static int do_eof(void); + + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 63 "lex_config.l" + + + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 247 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 294 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 65 "lex_config.l" +BEGIN(src); + YY_BREAK +case 2: +YY_RULE_SETUP +#line 66 "lex_config.l" +/* skip */ ; + YY_BREAK +case 3: +YY_RULE_SETUP +#line 67 "lex_config.l" +do_source(yytext); BEGIN(INITIAL); + YY_BREAK +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(src): +#line 68 "lex_config.l" +if (do_eof()) yyterminate(); + YY_BREAK +case 4: +YY_RULE_SETUP +#line 70 "lex_config.l" +current_lineno++; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 71 "lex_config.l" +/* skip */ ; + YY_BREAK +case 6: +YY_RULE_SETUP +#line 72 "lex_config.l" +/* skip */ ; + YY_BREAK +case 7: +YY_RULE_SETUP +#line 74 "lex_config.l" +return ANONYMOUS; + YY_BREAK +case 8: +YY_RULE_SETUP +#line 75 "lex_config.l" +return BIND; + YY_BREAK +case 9: +YY_RULE_SETUP +#line 76 "lex_config.l" +return CIS; + YY_BREAK +case 10: +YY_RULE_SETUP +#line 77 "lex_config.l" +return CARD; + YY_BREAK +case 11: +YY_RULE_SETUP +#line 78 "lex_config.l" +return CLASS; + YY_BREAK +case 12: +YY_RULE_SETUP +#line 79 "lex_config.l" +return DEFAULT; + YY_BREAK +case 13: +YY_RULE_SETUP +#line 80 "lex_config.l" +return DEVICE; + YY_BREAK +case 14: +YY_RULE_SETUP +#line 81 "lex_config.l" +return DTYPE; + YY_BREAK +case 15: +YY_RULE_SETUP +#line 82 "lex_config.l" +return EXCLUDE; + YY_BREAK +case 16: +YY_RULE_SETUP +#line 83 "lex_config.l" +return FUNCTION; + YY_BREAK +case 17: +YY_RULE_SETUP +#line 84 "lex_config.l" +return INCLUDE; + YY_BREAK +case 18: +YY_RULE_SETUP +#line 85 "lex_config.l" +return IRQ_NO; + YY_BREAK +case 19: +YY_RULE_SETUP +#line 86 "lex_config.l" +return JEDEC; + YY_BREAK +case 20: +YY_RULE_SETUP +#line 87 "lex_config.l" +return MANFID; + YY_BREAK +case 21: +YY_RULE_SETUP +#line 88 "lex_config.l" +return MEMORY; + YY_BREAK +case 22: +YY_RULE_SETUP +#line 89 "lex_config.l" +return MODULE; + YY_BREAK +case 23: +YY_RULE_SETUP +#line 90 "lex_config.l" +return MTD; + YY_BREAK +case 24: +YY_RULE_SETUP +#line 91 "lex_config.l" +return NEEDS_MTD; + YY_BREAK +case 25: +YY_RULE_SETUP +#line 92 "lex_config.l" +return OPTS; + YY_BREAK +case 26: +YY_RULE_SETUP +#line 93 "lex_config.l" +return PCI; + YY_BREAK +case 27: +YY_RULE_SETUP +#line 94 "lex_config.l" +return PORT; + YY_BREAK +case 28: +YY_RULE_SETUP +#line 95 "lex_config.l" +return REGION; + YY_BREAK +case 29: +YY_RULE_SETUP +#line 96 "lex_config.l" +return RESERVE; + YY_BREAK +case 30: +YY_RULE_SETUP +#line 97 "lex_config.l" +return TO; + YY_BREAK +case 31: +YY_RULE_SETUP +#line 98 "lex_config.l" +return TUPLE; + YY_BREAK +case 32: +YY_RULE_SETUP +#line 99 "lex_config.l" +return VERSION; + YY_BREAK +case 33: +YY_RULE_SETUP +#line 101 "lex_config.l" +return lex_number("1"); + YY_BREAK +case 34: +YY_RULE_SETUP +#line 102 "lex_config.l" +return lex_number("2"); + YY_BREAK +case 35: +YY_RULE_SETUP +#line 103 "lex_config.l" +return lex_number("3"); + YY_BREAK +case 36: +YY_RULE_SETUP +#line 104 "lex_config.l" +return lex_number("4"); + YY_BREAK +case 37: +YY_RULE_SETUP +#line 105 "lex_config.l" +return lex_number("5"); + YY_BREAK +case 38: +YY_RULE_SETUP +#line 106 "lex_config.l" +return lex_number("6"); + YY_BREAK +case 39: +YY_RULE_SETUP +#line 107 "lex_config.l" +return lex_number("7"); + YY_BREAK +case 40: +YY_RULE_SETUP +#line 108 "lex_config.l" +return lex_number("8"); + YY_BREAK +case 41: +YY_RULE_SETUP +#line 110 "lex_config.l" +return lex_number(yytext); + YY_BREAK +case 42: +YY_RULE_SETUP +#line 112 "lex_config.l" +return lex_number(yytext); + YY_BREAK +case 43: +YY_RULE_SETUP +#line 114 "lex_config.l" +return lex_string(yytext); + YY_BREAK +case 44: +YY_RULE_SETUP +#line 116 "lex_config.l" +return yytext[0]; + YY_BREAK +case 45: +YY_RULE_SETUP +#line 118 "lex_config.l" +ECHO; + YY_BREAK + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 247 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 247 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 246); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 118 "lex_config.l" + + +#ifndef yywrap +int yywrap() { return 1; } +#endif + +/*====================================================================== + + Stuff to parse basic data types + +======================================================================*/ + +static int lex_number(char *s) +{ + yylval.num = strtoul(s, NULL, 0); + return NUMBER; +} + +static int lex_string(char *s) +{ + int n = strlen(s); + yylval.str = malloc(n-1); + strncpy(yylval.str, s+1, n-2); + yylval.str[n-2] = '\0'; + return STRING; +} + +/*====================================================================== + + Code to support nesting of configuration files + +======================================================================*/ + +#define MAX_SOURCE_DEPTH 4 +struct source_stack { + YY_BUFFER_STATE buffer; + char *filename; + int lineno, fileno; + FILE *file; + glob_t glob; +} source_stack[MAX_SOURCE_DEPTH]; +static int source_stack_ptr = 0; +static int parse_env = 0; + +static int get_glob(void) +{ + struct source_stack *s = &source_stack[source_stack_ptr]; + while (s->fileno < s->glob.gl_pathc) { + char *fn = s->glob.gl_pathv[s->fileno]; + s->file = fopen(fn, "r"); + if (s->file == NULL) { + if (strpbrk(fn, "?*[") == NULL) + syslog(LOG_INFO, "could not open '%s': %m", fn); + s->fileno++; + } else { + current_lineno = 1; + current_file = strdup(fn); + yy_switch_to_buffer(yy_create_buffer(s->file, YY_BUF_SIZE)); + source_stack_ptr++; + s->fileno++; + return 0; + } + } + return -1; +} + +static void do_source(char *fn) +{ + struct source_stack *s = &source_stack[source_stack_ptr]; + + if (source_stack_ptr >= MAX_SOURCE_DEPTH) { + syslog(LOG_INFO, "source depth limit exceeded"); + return; + } + glob(fn, GLOB_NOCHECK, NULL, &s->glob); + s->fileno = 0; + s->buffer = YY_CURRENT_BUFFER; + s->lineno = current_lineno; + s->filename = current_file; + get_glob(); +} + +static int do_eof(void) +{ + struct source_stack *s = &source_stack[--source_stack_ptr]; + if (source_stack_ptr < 0) { + if (parse_env == 0) { + char *t = getenv("PCMCIA_OPTS"); + if (t == NULL) return -1; + parse_env = 1; + source_stack_ptr = 0; + current_file = "PCMCIA_OPTS"; + current_lineno = 1; + yy_scan_string(t); + return 0; + } else + return -1; + } + fclose(s->file); + free(current_file); + yy_delete_buffer(YY_CURRENT_BUFFER); + if (get_glob() != 0) { + yy_switch_to_buffer(s->buffer); + current_lineno = s->lineno; + current_file = s->filename; + } + return 0; +} + +/*====================================================================== + + The main entry point... returns -1 if the file can't be accessed. + +======================================================================*/ + +int parse_configfile(char *fn) +{ + FILE *f; + + f = fopen(fn, "r"); + if (!f) { + syslog(LOG_INFO, "could not open '%s': %m", fn); + return -1; + } + current_lineno = 1; + current_file = fn; + source_stack_ptr = 0; + yyrestart(f); + yyparse(); + fclose(f); + return 0; +} + diff --git a/mdk-stage1/pcmcia_/probe.c b/mdk-stage1/pcmcia_/probe.c new file mode 100644 index 000000000..6fcb9fb52 --- /dev/null +++ b/mdk-stage1/pcmcia_/probe.c @@ -0,0 +1,463 @@ +/*====================================================================== + + PCMCIA controller probe + + probe.c 1.55 2001/08/24 12:19:20 + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The initial developer of the original code is David A. Hinds + . Portions created by David A. Hinds + are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + + Alternatively, the contents of this file may be used under the + terms of the GNU General Public License version 2 (the "GPL"), in + which case the provisions of the GPL are applicable instead of the + above. If you wish to allow the use of your version of this file + only under the terms of the GPL and not to allow others to use + your version of this file under the MPL, indicate your decision + by deleting the provisions above and replace them with the notice + and other provisions required by the GPL. If you do not delete + the provisions above, a recipient may use your version of this + file under either the MPL or the GPL. + +======================================================================*/ + +#include +#include +#include +#include +#include +#include +#include + +#include + +/*====================================================================*/ + +#ifdef CONFIG_PCI + +typedef struct { + u_short vendor, device; + char *tag; + char *name; +} pci_id_t; + +pci_id_t pci_id[] = { + { 0x1013, 0x1100, "Cirrus Logic CL 6729", "Cirrus PD6729" }, + { 0x1013, 0x1110, "Cirrus Logic PD 6832", "Cirrus PD6832" }, + { 0x10b3, 0xb106, "SMC 34C90", "SMC 34C90" }, + { 0x1180, 0x0465, "Ricoh RL5C465", "Ricoh RL5C465" }, + { 0x1180, 0x0466, "Ricoh RL5C466", "Ricoh RL5C466" }, + { 0x1180, 0x0475, "Ricoh RL5C475", "Ricoh RL5C475" }, + { 0x1180, 0x0476, "Ricoh RL5C476", "Ricoh RL5C476" }, + { 0x1180, 0x0478, "Ricoh RL5C478", "Ricoh RL5C478" }, + { 0x104c, 0xac12, "Texas Instruments PCI1130", "TI 1130" }, + { 0x104c, 0xac13, "Texas Instruments PCI1031", "TI 1031" }, + { 0x104c, 0xac15, "Texas Instruments PCI1131", "TI 1131" }, + { 0x104c, 0xac1a, "Texas Instruments PCI1210", "TI 1210" }, + { 0x104c, 0xac1e, "Texas Instruments PCI1211", "TI 1211" }, + { 0x104c, 0xac17, "Texas Instruments PCI1220", "TI 1220" }, + { 0x104c, 0xac19, "Texas Instruments PCI1221", "TI 1221" }, + { 0x104c, 0xac1c, "Texas Instruments PCI1225", "TI 1225" }, + { 0x104c, 0xac16, "Texas Instruments PCI1250", "TI 1250A" }, + { 0x104c, 0xac1d, "Texas Instruments PCI1251A", "TI 1251A" }, + { 0x104c, 0xac1f, "Texas Instruments PCI1251B", "TI 1251B" }, + { 0x104c, 0xac50, "Texas Instruments PCI1410", "TI 1410" }, + { 0x104c, 0xac51, "Texas Instruments PCI1420", "TI 1420" }, + { 0x104c, 0xac1b, "Texas Instruments PCI1450", "TI 1450" }, + { 0x104c, 0xac52, "Texas Instruments PCI1451", "TI 1451" }, + { 0x104c, 0xac41, "Texas Instruments PCI4410", "TI 4410" }, + { 0x104c, 0xac40, "Texas Instruments PCI4450", "TI 4450" }, + { 0x104c, 0xac42, "Texas Instruments PCI4451", "TI 4451" }, + { 0x1217, 0x6729, "O2 Micro 6729", "O2Micro OZ6729" }, + { 0x1217, 0x673a, "O2 Micro 6730", "O2Micro OZ6730" }, + { 0x1217, 0x6832, "O2 Micro 6832/6833", "O2Micro OZ6832/OZ6833" }, + { 0x1217, 0x6836, "O2 Micro 6836/6860", "O2Micro OZ6836/OZ6860" }, + { 0x1217, 0x6872, "O2 Micro 6812", "O2Micro OZ6812" }, + { 0x1179, 0x0603, "Toshiba ToPIC95-A", "Toshiba ToPIC95-A" }, + { 0x1179, 0x060a, "Toshiba ToPIC95-B", "Toshiba ToPIC95-B" }, + { 0x1179, 0x060f, "Toshiba ToPIC97", "Toshiba ToPIC97" }, + { 0x1179, 0x0617, "Toshiba ToPIC100", "Toshiba ToPIC100" }, + { 0x119b, 0x1221, "Omega Micro 82C092G", "Omega Micro 82C092G" }, + { 0x8086, 0x1221, "Intel 82092AA", "Intel 82092AA" } +}; +#define PCI_COUNT (sizeof(pci_id)/sizeof(pci_id_t)) + +static int pci_probe(int verbose, int module) +{ + char s[256], *t, *name = NULL; + u_int device, vendor, i; + FILE *f; + + if (!module) + printf("PCI bridge probe: "); + + if ((f = fopen("/proc/bus/pci/devices", "r")) != NULL) { + while (fgets(s, 256, f) != NULL) { + u_int n = strtoul(s+5, NULL, 16); + vendor = (n >> 16); device = (n & 0xffff); + for (i = 0; i < PCI_COUNT; i++) + if ((vendor == pci_id[i].vendor) && + (device == pci_id[i].device)) break; + if (i < PCI_COUNT) { + name = pci_id[i].name; + break; + } + } + } else if ((f = fopen("/proc/pci", "r")) != NULL) { + while (fgets(s, 256, f) != NULL) { + t = strstr(s, "Device id="); + if (t) { + device = strtoul(t+10, NULL, 16); + t = strstr(s, "Vendor id="); + vendor = strtoul(t+10, NULL, 16); + for (i = 0; i < PCI_COUNT; i++) + if ((vendor == pci_id[i].vendor) && + (device == pci_id[i].device)) break; + } else + for (i = 0; i < PCI_COUNT; i++) + if (strstr(s, pci_id[i].tag) != NULL) break; + if (i != PCI_COUNT) { + name = pci_id[i].name; + break; + } else { + t = strstr(s, "CardBus bridge"); + if (t != NULL) { + name = t + 16; + t = strchr(s, '('); + t[-1] = '\0'; + break; + } + } + } + } + + if (name) { + if (module) + printf("i82365\n"); + else + printf("%s found, 2 sockets.\n", name); + return 0; + } else { + if (!module) + printf("not found.\n"); + return -ENODEV; + } +} +#endif + +/*====================================================================*/ + +#ifdef CONFIG_ISA + +#ifdef __GLIBC__ +#include +#else +#include +#endif +typedef u_short ioaddr_t; + +#include "i82365.h" +#include "cirrus.h" +#include "vg468.h" + +static ioaddr_t i365_base = 0x03e0; + +static u_char i365_get(u_short sock, u_short reg) +{ + u_char val = I365_REG(sock, reg); + outb(val, i365_base); val = inb(i365_base+1); + return val; +} + +static void i365_set(u_short sock, u_short reg, u_char data) +{ + u_char val = I365_REG(sock, reg); + outb(val, i365_base); outb(data, i365_base+1); +} + +static void i365_bset(u_short sock, u_short reg, u_char mask) +{ + u_char d = i365_get(sock, reg); + d |= mask; + i365_set(sock, reg, d); +} + +static void i365_bclr(u_short sock, u_short reg, u_char mask) +{ + u_char d = i365_get(sock, reg); + d &= ~mask; + i365_set(sock, reg, d); +} + +int i365_probe(int verbose, int module) +{ + int val, sock, done; + char *name = "i82365sl"; + + if (!module) + printf("Intel PCIC probe: "); + if (verbose) printf("\n"); + + sock = done = 0; + ioperm(i365_base, 4, 1); + ioperm(0x80, 1, 1); + for (; sock < 2; sock++) { + val = i365_get(sock, I365_IDENT); + if (verbose) + printf(" ident(%d)=%#2.2x", sock, val); + switch (val) { + case 0x82: + name = "i82365sl A step"; + break; + case 0x83: + name = "i82365sl B step"; + break; + case 0x84: + name = "VLSI 82C146"; + break; + case 0x88: case 0x89: case 0x8a: + name = "IBM Clone"; + break; + case 0x8b: case 0x8c: + break; + default: + done = 1; + } + if (done) break; + } + + if (verbose) printf("\n "); + if (sock == 0) { + if (!module) + printf("not found.\n"); + return -ENODEV; + } + + if ((sock == 2) && (strcmp(name, "VLSI 82C146") == 0)) + name = "i82365sl DF"; + + /* Check for Vadem chips */ + outb(0x0e, i365_base); + outb(0x37, i365_base); + i365_bset(0, VG468_MISC, VG468_MISC_VADEMREV); + val = i365_get(0, I365_IDENT); + if (val & I365_IDENT_VADEM) { + if ((val & 7) < 4) + name = "Vadem VG-468"; + else + name = "Vadem VG-469"; + i365_bclr(0, VG468_MISC, VG468_MISC_VADEMREV); + } + + /* Check for Cirrus CL-PD67xx chips */ + i365_set(0, PD67_CHIP_INFO, 0); + val = i365_get(0, PD67_CHIP_INFO); + if ((val & PD67_INFO_CHIP_ID) == PD67_INFO_CHIP_ID) { + val = i365_get(0, PD67_CHIP_INFO); + if ((val & PD67_INFO_CHIP_ID) == 0) { + if (val & PD67_INFO_SLOTS) + name = "Cirrus CL-PD672x"; + else { + name = "Cirrus CL-PD6710"; + sock = 1; + } + i365_set(0, PD67_EXT_INDEX, 0xe5); + if (i365_get(0, PD67_EXT_INDEX) != 0xe5) + name = "VIA VT83C469"; + } + } + + if (module) + printf("i82365\n"); + else + printf("%s found, %d sockets.\n", name, sock); + return 0; + +} /* i365_probe */ + +#endif /* CONFIG_ISA */ + +/*====================================================================*/ + +#ifdef CONFIG_ISA + +#include "tcic.h" + +static ioaddr_t tcic_base = TCIC_BASE; + +static u_char tcic_getb(ioaddr_t base, u_char reg) +{ + u_char val = inb(base+reg); + return val; +} + +static void tcic_setb(ioaddr_t base, u_char reg, u_char data) +{ + outb(data, base+reg); +} + +static u_short tcic_getw(ioaddr_t base, u_char reg) +{ + u_short val = inw(base+reg); + return val; +} + +static void tcic_setw(ioaddr_t base, u_char reg, u_short data) +{ + outw(data, base+reg); +} + +static u_short tcic_aux_getw(ioaddr_t base, u_short reg) +{ + u_char mode = (tcic_getb(base, TCIC_MODE) & TCIC_MODE_PGMMASK) | reg; + tcic_setb(base, TCIC_MODE, mode); + return tcic_getw(base, TCIC_AUX); +} + +static void tcic_aux_setw(ioaddr_t base, u_short reg, u_short data) +{ + u_char mode = (tcic_getb(base, TCIC_MODE) & TCIC_MODE_PGMMASK) | reg; + tcic_setb(base, TCIC_MODE, mode); + tcic_setw(base, TCIC_AUX, data); +} + +static int get_tcic_id(ioaddr_t base) +{ + u_short id; + tcic_aux_setw(base, TCIC_AUX_TEST, TCIC_TEST_DIAG); + id = tcic_aux_getw(base, TCIC_AUX_ILOCK); + id = (id & TCIC_ILOCKTEST_ID_MASK) >> TCIC_ILOCKTEST_ID_SH; + tcic_aux_setw(base, TCIC_AUX_TEST, 0); + return id; +} + +int tcic_probe_at(ioaddr_t base, int module) +{ + int i; + u_short old; + + /* Anything there?? */ + for (i = 0; i < 0x10; i += 2) + if (tcic_getw(base, i) == 0xffff) + return -1; + + if (!module) + printf(" at %#3.3x: ", base); fflush(stdout); + + /* Try to reset the chip */ + tcic_setw(base, TCIC_SCTRL, TCIC_SCTRL_RESET); + tcic_setw(base, TCIC_SCTRL, 0); + + /* Can we set the addr register? */ + old = tcic_getw(base, TCIC_ADDR); + tcic_setw(base, TCIC_ADDR, 0); + if (tcic_getw(base, TCIC_ADDR) != 0) { + tcic_setw(base, TCIC_ADDR, old); + return -2; + } + + tcic_setw(base, TCIC_ADDR, 0xc3a5); + if (tcic_getw(base, TCIC_ADDR) != 0xc3a5) + return -3; + + return 2; +} + +int tcic_probe(int verbose, int module, ioaddr_t base) +{ + int sock, id; + + if (!module) + printf("Databook TCIC-2 probe: "); fflush(stdout); + + ioperm(base, 16, 1); + ioperm(0x80, 1, 1); + sock = tcic_probe_at(base, module); + + if (sock <= 0) { + if (!module) + printf("not found.\n"); + return -ENODEV; + } + + if (module) + printf("tcic\n"); + else { + id = get_tcic_id(base); + switch (id) { + case TCIC_ID_DB86082: + printf("DB86082"); break; + case TCIC_ID_DB86082A: + printf("DB86082A"); break; + case TCIC_ID_DB86084: + printf("DB86084"); break; + case TCIC_ID_DB86084A: + printf("DB86084A"); break; + case TCIC_ID_DB86072: + printf("DB86072"); break; + case TCIC_ID_DB86184: + printf("DB86184"); break; + case TCIC_ID_DB86082B: + printf("DB86082B"); break; + default: + printf("Unknown TCIC-2 ID 0x%02x", id); + } + printf(" found at %#6x, %d sockets.\n", base, sock); + } + return 0; + +} /* tcic_probe */ + +#endif /* CONFIG_ISA */ + +/*====================================================================*/ + +int main(int argc, char *argv[]) +{ + int optch, errflg; + extern char *optarg; + int verbose = 0, module = 0; + + errflg = 0; + while ((optch = getopt(argc, argv, "t:vxm")) != -1) { + switch (optch) { +#ifdef CONFIG_ISA + case 't': + tcic_base = strtoul(optarg, NULL, 0); break; +#endif + case 'v': + verbose = 1; break; + case 'm': + module = 1; break; + default: + errflg = 1; break; + } + } + if (errflg || (optind < argc)) { + fprintf(stderr, "usage: %s [-t tcic_base] [-v] [-m]\n", argv[0]); + exit(EXIT_FAILURE); + } + +#ifdef CONFIG_PCI + if (pci_probe(verbose, module) == 0) + exit(EXIT_SUCCESS); +#endif +#ifdef CONFIG_ISA + if (i365_probe(verbose, module) == 0) + exit(EXIT_SUCCESS); + else if (tcic_probe(verbose, module, tcic_base) == 0) + exit(EXIT_SUCCESS); +#endif + exit(EXIT_FAILURE); + return 0; +} diff --git a/mdk-stage1/pcmcia_/tcic.h b/mdk-stage1/pcmcia_/tcic.h new file mode 100644 index 000000000..cad193885 --- /dev/null +++ b/mdk-stage1/pcmcia_/tcic.h @@ -0,0 +1,266 @@ +/* + * tcic.h 1.15 2001/08/24 12:15:34 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_TCIC_H +#define _LINUX_TCIC_H + +#define TCIC_BASE 0x240 + +/* offsets of registers from TCIC_BASE */ +#define TCIC_DATA 0x00 +#define TCIC_ADDR 0x02 +#define TCIC_SCTRL 0x06 +#define TCIC_SSTAT 0x07 +#define TCIC_MODE 0x08 +#define TCIC_PWR 0x09 +#define TCIC_EDC 0x0A +#define TCIC_ICSR 0x0C +#define TCIC_IENA 0x0D +#define TCIC_AUX 0x0E + +#define TCIC_SS_SHFT 12 +#define TCIC_SS_MASK 0x7000 + +/* Flags for TCIC_ADDR */ +#define TCIC_ADR2_REG 0x8000 +#define TCIC_ADR2_INDREG 0x0800 + +#define TCIC_ADDR_REG 0x80000000 +#define TCIC_ADDR_SS_SHFT (TCIC_SS_SHFT+16) +#define TCIC_ADDR_SS_MASK (TCIC_SS_MASK<<16) +#define TCIC_ADDR_INDREG 0x08000000 +#define TCIC_ADDR_IO 0x04000000 +#define TCIC_ADDR_MASK 0x03ffffff + +/* Flags for TCIC_SCTRL */ +#define TCIC_SCTRL_ENA 0x01 +#define TCIC_SCTRL_INCMODE 0x18 +#define TCIC_SCTRL_INCMODE_HOLD 0x00 +#define TCIC_SCTRL_INCMODE_WORD 0x08 +#define TCIC_SCTRL_INCMODE_REG 0x10 +#define TCIC_SCTRL_INCMODE_AUTO 0x18 +#define TCIC_SCTRL_EDCSUM 0x20 +#define TCIC_SCTRL_RESET 0x80 + +/* Flags for TCIC_SSTAT */ +#define TCIC_SSTAT_6US 0x01 +#define TCIC_SSTAT_10US 0x02 +#define TCIC_SSTAT_PROGTIME 0x04 +#define TCIC_SSTAT_LBAT1 0x08 +#define TCIC_SSTAT_LBAT2 0x10 +#define TCIC_SSTAT_RDY 0x20 /* Inverted */ +#define TCIC_SSTAT_WP 0x40 +#define TCIC_SSTAT_CD 0x80 /* Card detect */ + +/* Flags for TCIC_MODE */ +#define TCIC_MODE_PGMMASK 0x1f +#define TCIC_MODE_NORMAL 0x00 +#define TCIC_MODE_PGMWR 0x01 +#define TCIC_MODE_PGMRD 0x02 +#define TCIC_MODE_PGMCE 0x04 +#define TCIC_MODE_PGMDBW 0x08 +#define TCIC_MODE_PGMWORD 0x10 +#define TCIC_MODE_AUXSEL_MASK 0xe0 + +/* Registers accessed through TCIC_AUX, by setting TCIC_MODE */ +#define TCIC_AUX_TCTL (0<<5) +#define TCIC_AUX_PCTL (1<<5) +#define TCIC_AUX_WCTL (2<<5) +#define TCIC_AUX_EXTERN (3<<5) +#define TCIC_AUX_PDATA (4<<5) +#define TCIC_AUX_SYSCFG (5<<5) +#define TCIC_AUX_ILOCK (6<<5) +#define TCIC_AUX_TEST (7<<5) + +/* Flags for TCIC_PWR */ +#define TCIC_PWR_VCC(sock) (0x01<<(sock)) +#define TCIC_PWR_VCC_MASK 0x03 +#define TCIC_PWR_VPP(sock) (0x08<<(sock)) +#define TCIC_PWR_VPP_MASK 0x18 +#define TCIC_PWR_CLIMENA 0x40 +#define TCIC_PWR_CLIMSTAT 0x80 + +/* Flags for TCIC_ICSR */ +#define TCIC_ICSR_CLEAR 0x01 +#define TCIC_ICSR_SET 0x02 +#define TCIC_ICSR_JAM (TCIC_ICSR_CLEAR|TCIC_ICSR_SET) +#define TCIC_ICSR_STOPCPU 0x04 +#define TCIC_ICSR_ILOCK 0x08 +#define TCIC_ICSR_PROGTIME 0x10 +#define TCIC_ICSR_ERR 0x20 +#define TCIC_ICSR_CDCHG 0x40 +#define TCIC_ICSR_IOCHK 0x80 + +/* Flags for TCIC_IENA */ +#define TCIC_IENA_CFG_MASK 0x03 +#define TCIC_IENA_CFG_OFF 0x00 /* disabled */ +#define TCIC_IENA_CFG_OD 0x01 /* active low, open drain */ +#define TCIC_IENA_CFG_LOW 0x02 /* active low, totem pole */ +#define TCIC_IENA_CFG_HIGH 0x03 /* active high, totem pole */ +#define TCIC_IENA_ILOCK 0x08 +#define TCIC_IENA_PROGTIME 0x10 +#define TCIC_IENA_ERR 0x20 /* overcurrent or iochk */ +#define TCIC_IENA_CDCHG 0x40 + +/* Flags for TCIC_AUX_WCTL */ +#define TCIC_WAIT_COUNT_MASK 0x001f +#define TCIC_WAIT_ASYNC 0x0020 +#define TCIC_WAIT_SENSE 0x0040 +#define TCIC_WAIT_SRC 0x0080 +#define TCIC_WCTL_WR 0x0100 +#define TCIC_WCTL_RD 0x0200 +#define TCIC_WCTL_CE 0x0400 +#define TCIC_WCTL_LLBAT1 0x0800 +#define TCIC_WCTL_LLBAT2 0x1000 +#define TCIC_WCTL_LRDY 0x2000 +#define TCIC_WCTL_LWP 0x4000 +#define TCIC_WCTL_LCD 0x8000 + +/* Flags for TCIC_AUX_SYSCFG */ +#define TCIC_SYSCFG_IRQ_MASK 0x000f +#define TCIC_SYSCFG_MCSFULL 0x0010 +#define TCIC_SYSCFG_IO1723 0x0020 +#define TCIC_SYSCFG_MCSXB 0x0040 +#define TCIC_SYSCFG_ICSXB 0x0080 +#define TCIC_SYSCFG_NOPDN 0x0100 +#define TCIC_SYSCFG_MPSEL_SHFT 9 +#define TCIC_SYSCFG_MPSEL_MASK 0x0e00 +#define TCIC_SYSCFG_MPSENSE 0x2000 +#define TCIC_SYSCFG_AUTOBUSY 0x4000 +#define TCIC_SYSCFG_ACC 0x8000 + +#define TCIC_ILOCK_OUT 0x01 +#define TCIC_ILOCK_SENSE 0x02 +#define TCIC_ILOCK_CRESET 0x04 +#define TCIC_ILOCK_CRESENA 0x08 +#define TCIC_ILOCK_CWAIT 0x10 +#define TCIC_ILOCK_CWAITSNS 0x20 +#define TCIC_ILOCK_HOLD_MASK 0xc0 +#define TCIC_ILOCK_HOLD_CCLK 0xc0 + +#define TCIC_ILOCKTEST_ID_SH 8 +#define TCIC_ILOCKTEST_ID_MASK 0x7f00 +#define TCIC_ILOCKTEST_MCIC_1 0x8000 + +#define TCIC_ID_DB86082 0x02 +#define TCIC_ID_DB86082A 0x03 +#define TCIC_ID_DB86084 0x04 +#define TCIC_ID_DB86084A 0x08 +#define TCIC_ID_DB86072 0x15 +#define TCIC_ID_DB86184 0x14 +#define TCIC_ID_DB86082B 0x17 + +#define TCIC_TEST_DIAG 0x8000 + +/* + * Indirectly addressed registers + */ + +#define TCIC_SCF1(sock) ((sock)<<3) +#define TCIC_SCF2(sock) (((sock)<<3)+2) + +/* Flags for SCF1 */ +#define TCIC_SCF1_IRQ_MASK 0x000f +#define TCIC_SCF1_IRQ_OFF 0x0000 +#define TCIC_SCF1_IRQOC 0x0010 +#define TCIC_SCF1_PCVT 0x0020 +#define TCIC_SCF1_IRDY 0x0040 +#define TCIC_SCF1_ATA 0x0080 +#define TCIC_SCF1_DMA_SHIFT 8 +#define TCIC_SCF1_DMA_MASK 0x0700 +#define TCIC_SCF1_DMA_OFF 0 +#define TCIC_SCF1_DREQ2 2 +#define TCIC_SCF1_IOSTS 0x0800 +#define TCIC_SCF1_SPKR 0x1000 +#define TCIC_SCF1_FINPACK 0x2000 +#define TCIC_SCF1_DELWR 0x4000 +#define TCIC_SCF1_HD7IDE 0x8000 + +/* Flags for SCF2 */ +#define TCIC_SCF2_RI 0x0001 +#define TCIC_SCF2_IDBR 0x0002 +#define TCIC_SCF2_MDBR 0x0004 +#define TCIC_SCF2_MLBAT1 0x0008 +#define TCIC_SCF2_MLBAT2 0x0010 +#define TCIC_SCF2_MRDY 0x0020 +#define TCIC_SCF2_MWP 0x0040 +#define TCIC_SCF2_MCD 0x0080 +#define TCIC_SCF2_MALL 0x00f8 + +/* Indirect addresses for memory window registers */ +#define TCIC_MWIN(sock,map) (0x100+(((map)+((sock)<<2))<<3)) +#define TCIC_MBASE_X 2 +#define TCIC_MMAP_X 4 +#define TCIC_MCTL_X 6 + +#define TCIC_MBASE_4K_BIT 0x4000 +#define TCIC_MBASE_HA_SHFT 12 +#define TCIC_MBASE_HA_MASK 0x0fff + +#define TCIC_MMAP_REG 0x8000 +#define TCIC_MMAP_CA_SHFT 12 +#define TCIC_MMAP_CA_MASK 0x3fff + +#define TCIC_MCTL_WSCNT_MASK 0x001f +#define TCIC_MCTL_WCLK 0x0020 +#define TCIC_MCTL_WCLK_CCLK 0x0000 +#define TCIC_MCTL_WCLK_BCLK 0x0020 +#define TCIC_MCTL_QUIET 0x0040 +#define TCIC_MCTL_WP 0x0080 +#define TCIC_MCTL_ACC 0x0100 +#define TCIC_MCTL_KE 0x0200 +#define TCIC_MCTL_EDC 0x0400 +#define TCIC_MCTL_B8 0x0800 +#define TCIC_MCTL_SS_SHFT TCIC_SS_SHFT +#define TCIC_MCTL_SS_MASK TCIC_SS_MASK +#define TCIC_MCTL_ENA 0x8000 + +/* Indirect addresses for I/O window registers */ +#define TCIC_IWIN(sock,map) (0x200+(((map)+((sock)<<1))<<2)) +#define TCIC_IBASE_X 0 +#define TCIC_ICTL_X 2 + +#define TCIC_ICTL_WSCNT_MASK TCIC_MCTL_WSCNT_MASK +#define TCIC_ICTL_QUIET TCIC_MCTL_QUIET +#define TCIC_ICTL_1K 0x0080 +#define TCIC_ICTL_PASS16 0x0100 +#define TCIC_ICTL_ACC TCIC_MCTL_ACC +#define TCIC_ICTL_TINY 0x0200 +#define TCIC_ICTL_B16 0x0400 +#define TCIC_ICTL_B8 TCIC_MCTL_B8 +#define TCIC_ICTL_BW_MASK (TCIC_ICTL_B16|TCIC_ICTL_B8) +#define TCIC_ICTL_BW_DYN 0 +#define TCIC_ICTL_BW_8 TCIC_ICTL_B8 +#define TCIC_ICTL_BW_16 TCIC_ICTL_B16 +#define TCIC_ICTL_BW_ATA (TCIC_ICTL_B16|TCIC_ICTL_B8) +#define TCIC_ICTL_SS_SHFT TCIC_SS_SHFT +#define TCIC_ICTL_SS_MASK TCIC_SS_MASK +#define TCIC_ICTL_ENA TCIC_MCTL_ENA + +#endif /* _LINUX_TCIC_H */ diff --git a/mdk-stage1/pcmcia_/version.h b/mdk-stage1/pcmcia_/version.h new file mode 100644 index 000000000..3be8f28bc --- /dev/null +++ b/mdk-stage1/pcmcia_/version.h @@ -0,0 +1,4 @@ +/* version.h 1.101 2001/08/09 12:29:14 (David Hinds) */ + +#define CS_RELEASE "3.1.29" +#define CS_RELEASE_CODE 0x311d diff --git a/mdk-stage1/pcmcia_/vg468.h b/mdk-stage1/pcmcia_/vg468.h new file mode 100644 index 000000000..93dc00b37 --- /dev/null +++ b/mdk-stage1/pcmcia_/vg468.h @@ -0,0 +1,112 @@ +/* + * vg468.h 1.14 2001/08/24 12:15:34 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#ifndef _LINUX_VG468_H +#define _LINUX_VG468_H + +/* Special bit in I365_IDENT used for Vadem chip detection */ +#define I365_IDENT_VADEM 0x08 + +/* Special definitions in I365_POWER */ +#define VG468_VPP2_MASK 0x0c +#define VG468_VPP2_5V 0x04 +#define VG468_VPP2_12V 0x08 + +/* Unique Vadem registers */ +#define VG469_VSENSE 0x1f /* Card voltage sense */ +#define VG469_VSELECT 0x2f /* Card voltage select */ +#define VG468_CTL 0x38 /* Control register */ +#define VG468_TIMER 0x39 /* Timer control */ +#define VG468_MISC 0x3a /* Miscellaneous */ +#define VG468_GPIO_CFG 0x3b /* GPIO configuration */ +#define VG469_EXT_MODE 0x3c /* Extended mode register */ +#define VG468_SELECT 0x3d /* Programmable chip select */ +#define VG468_SELECT_CFG 0x3e /* Chip select configuration */ +#define VG468_ATA 0x3f /* ATA control */ + +/* Flags for VG469_VSENSE */ +#define VG469_VSENSE_A_VS1 0x01 +#define VG469_VSENSE_A_VS2 0x02 +#define VG469_VSENSE_B_VS1 0x04 +#define VG469_VSENSE_B_VS2 0x08 + +/* Flags for VG469_VSELECT */ +#define VG469_VSEL_VCC 0x03 +#define VG469_VSEL_5V 0x00 +#define VG469_VSEL_3V 0x03 +#define VG469_VSEL_MAX 0x0c +#define VG469_VSEL_EXT_STAT 0x10 +#define VG469_VSEL_EXT_BUS 0x20 +#define VG469_VSEL_MIXED 0x40 +#define VG469_VSEL_ISA 0x80 + +/* Flags for VG468_CTL */ +#define VG468_CTL_SLOW 0x01 /* 600ns memory timing */ +#define VG468_CTL_ASYNC 0x02 /* Asynchronous bus clocking */ +#define VG468_CTL_TSSI 0x08 /* Tri-state some outputs */ +#define VG468_CTL_DELAY 0x10 /* Card detect debounce */ +#define VG468_CTL_INPACK 0x20 /* Obey INPACK signal? */ +#define VG468_CTL_POLARITY 0x40 /* VCCEN polarity */ +#define VG468_CTL_COMPAT 0x80 /* Compatibility stuff */ + +#define VG469_CTL_WS_COMPAT 0x04 /* Wait state compatibility */ +#define VG469_CTL_STRETCH 0x10 /* LED stretch */ + +/* Flags for VG468_TIMER */ +#define VG468_TIMER_ZEROPWR 0x10 /* Zero power control */ +#define VG468_TIMER_SIGEN 0x20 /* Power up */ +#define VG468_TIMER_STATUS 0x40 /* Activity timer status */ +#define VG468_TIMER_RES 0x80 /* Timer resolution */ +#define VG468_TIMER_MASK 0x0f /* Activity timer timeout */ + +/* Flags for VG468_MISC */ +#define VG468_MISC_GPIO 0x04 /* General-purpose IO */ +#define VG468_MISC_DMAWSB 0x08 /* DMA wait state control */ +#define VG469_MISC_LEDENA 0x10 /* LED enable */ +#define VG468_MISC_VADEMREV 0x40 /* Vadem revision control */ +#define VG468_MISC_UNLOCK 0x80 /* Unique register lock */ + +/* Flags for VG469_EXT_MODE_A */ +#define VG469_MODE_VPPST 0x03 /* Vpp steering control */ +#define VG469_MODE_INT_SENSE 0x04 /* Internal voltage sense */ +#define VG469_MODE_CABLE 0x08 +#define VG469_MODE_COMPAT 0x10 /* i82365sl B or DF step */ +#define VG469_MODE_TEST 0x20 +#define VG469_MODE_RIO 0x40 /* Steer RIO to INTR? */ + +/* Flags for VG469_EXT_MODE_B */ +#define VG469_MODE_B_3V 0x01 /* 3.3v for socket B */ + +/* Data structure for tracking vendor-specific state */ +typedef struct vg46x_state_t { + u_char ctl; /* VG468_CTL */ + u_char ema; /* VG468_EXT_MODE_A */ +} vg46x_state_t; + +#endif /* _LINUX_VG468_H */ diff --git a/mdk-stage1/pcmcia_/yacc_config.c b/mdk-stage1/pcmcia_/yacc_config.c new file mode 100644 index 000000000..4f63fe4cb --- /dev/null +++ b/mdk-stage1/pcmcia_/yacc_config.c @@ -0,0 +1,1021 @@ +#ifndef lint +static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; +#endif +#define YYBYACC 1 +#define YYMAJOR 1 +#define YYMINOR 9 +#define yyclearin (yychar=(-1)) +#define yyerrok (yyerrflag=0) +#define YYRECOVERING (yyerrflag!=0) +#define YYPREFIX "yy" +#line 2 "yacc_config.y" +/* + * yacc_config.y 1.53 2001/08/24 12:21:34 + * + * The contents of this file are subject to the Mozilla Public License + * Version 1.1 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License + * at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" + * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See + * the License for the specific language governing rights and + * limitations under the License. + * + * The initial developer of the original code is David A. Hinds + * . Portions created by David A. Hinds + * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. + * + * Alternatively, the contents of this file may be used under the + * terms of the GNU General Public License version 2 (the "GPL"), in + * which case the provisions of the GPL are applicable instead of the + * above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use + * your version of this file under the MPL, indicate your decision by + * deleting the provisions above and replace them with the notice and + * other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file + * under either the MPL or the GPL. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "cardmgr.h" + +/* If bison: generate nicer error messages */ +#define YYERROR_VERBOSE 1 + +/* from lex_config, for nice error messages */ +extern char *current_file; +extern int current_lineno; + +void yyerror(char *msg, ...); + +static int add_binding(card_info_t *card, char *name, int fn); +static int add_module(device_info_t *card, char *name); + +#line 65 "yacc_config.y" +typedef union { + char *str; + u_long num; + struct device_info_t *device; + struct card_info_t *card; + struct mtd_ident_t *mtd; + struct adjust_list_t *adjust; +} YYSTYPE; +#line 77 "y.tab.c" +#define DEVICE 257 +#define CARD 258 +#define ANONYMOUS 259 +#define TUPLE 260 +#define MANFID 261 +#define VERSION 262 +#define FUNCTION 263 +#define PCI 264 +#define BIND 265 +#define CIS 266 +#define TO 267 +#define NEEDS_MTD 268 +#define MODULE 269 +#define OPTS 270 +#define CLASS 271 +#define REGION 272 +#define JEDEC 273 +#define DTYPE 274 +#define DEFAULT 275 +#define MTD 276 +#define INCLUDE 277 +#define EXCLUDE 278 +#define RESERVE 279 +#define IRQ_NO 280 +#define PORT 281 +#define MEMORY 282 +#define STRING 283 +#define NUMBER 284 +#define YYERRCODE 256 +short yylhs[] = { -1, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, + 1, 1, 2, 2, 2, 3, 3, 3, 3, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 8, 9, + 10, 11, 12, 12, 13, 15, 14, 14, 14, 14, + 4, 21, 5, 5, 5, 6, 16, 16, 16, 16, + 18, 17, 19, 20, 20, 22, +}; +short yylen[] = { 2, + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 3, 2, 4, 4, 2, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 7, + 5, 5, 3, 3, 3, 3, 3, 5, 3, 5, + 2, 4, 3, 3, 3, 3, 2, 1, 1, 1, + 3, 4, 2, 3, 3, 4, +}; +short yydefred[] = { 1, + 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 17, 0, 19, 0, 21, 22, 23, 24, + 0, 26, 0, 28, 0, 49, 48, 50, 0, 6, + 7, 16, 20, 0, 47, 0, 0, 0, 0, 9, + 10, 11, 0, 41, 0, 0, 0, 0, 29, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 0, 13, 0, 0, 12, 43, + 46, 44, 45, 0, 0, 33, 35, 0, 0, 36, + 34, 0, 0, 51, 54, 55, 42, 56, 0, 0, + 0, 0, 0, 0, 0, 52, 14, 15, 0, 31, + 32, 38, 40, 0, 30, +}; +short yydgoto[] = { 1, + 11, 40, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, +}; +short yysindex[] = { 0, + -250, 0, -279, -278, -274, -265, -259, -242, -242, -242, + -10, -248, 0, -44, 0, -249, 0, 0, 0, 0, + -9, 0, -3, 0, -243, 0, 0, 0, -233, 0, + 0, 0, 0, -228, 0, -227, -240, -238, -237, 0, + 0, 0, -242, 0, -235, -232, -231, -230, 0, -234, + -229, -226, -225, -224, -222, -221, -220, -219, -218, -217, + 0, -215, -213, -212, -211, 0, 9, 11, 0, 0, + 0, 0, 0, 14, 21, 0, 0, 30, -192, 0, + 0, -191, -207, 0, 0, 0, 0, 0, -206, -205, + -204, -203, -202, -201, -200, 0, 0, 0, 41, 0, + 0, 0, 0, -197, 0, +}; +short yyrindex[] = { 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 107, 149, 0, 90, 0, 124, 0, 0, 0, 0, + 49, 0, 73, 0, 0, 0, 0, 0, 141, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, +}; +short yygindex[] = { 0, + 0, -7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, +}; +#define YYTABLESIZE 428 +short yytable[] = { 48, + 37, 41, 42, 32, 33, 2, 3, 4, 34, 49, + 50, 51, 52, 53, 54, 55, 56, 35, 5, 44, + 45, 6, 46, 36, 39, 7, 8, 9, 10, 59, + 60, 61, 62, 43, 57, 69, 63, 37, 38, 39, + 58, 64, 65, 66, 37, 67, 68, 70, 25, 74, + 71, 72, 73, 89, 75, 90, 76, 91, 77, 78, + 79, 80, 81, 82, 92, 83, 84, 85, 39, 86, + 87, 88, 27, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 0, 0, 0, 18, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 47, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 37, 37, 37, 37, + 37, 37, 37, 37, 37, 37, 37, 0, 0, 37, + 0, 0, 37, 0, 0, 0, 37, 37, 37, 37, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 0, 0, 39, 0, 0, 39, 0, 0, 0, + 39, 39, 39, 39, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 0, 0, 25, 0, 0, + 25, 0, 0, 0, 25, 25, 25, 25, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 0, + 0, 27, 0, 0, 27, 18, 18, 18, 27, 27, + 27, 27, 0, 0, 0, 0, 0, 18, 18, 0, + 18, 18, 2, 2, 2, 18, 18, 18, 18, 0, + 0, 0, 0, 0, 0, 2, 0, 0, 2, 5, + 5, 5, 2, 2, 2, 2, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 5, 4, 4, 4, 5, + 5, 5, 5, 0, 3, 3, 3, 0, 0, 4, + 0, 0, 4, 0, 0, 0, 4, 4, 4, 4, + 3, 0, 0, 0, 3, 3, 3, 3, +}; +short yycheck[] = { 44, + 0, 9, 10, 283, 283, 256, 257, 258, 283, 259, + 260, 261, 262, 263, 264, 265, 266, 283, 269, 268, + 269, 272, 271, 283, 0, 276, 277, 278, 279, 273, + 274, 275, 276, 44, 44, 43, 270, 280, 281, 282, + 44, 270, 270, 284, 44, 284, 284, 283, 0, 284, + 283, 283, 283, 45, 284, 45, 283, 44, 284, 284, + 283, 283, 283, 283, 44, 284, 284, 283, 44, 283, + 283, 283, 0, 44, 267, 267, 284, 284, 284, 284, + 284, 284, 284, 284, 44, 283, -1, -1, -1, 0, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, -1, -1, -1, -1, -1, -1, -1, 0, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 270, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, -1, -1, 269, + -1, -1, 272, -1, -1, -1, 276, 277, 278, 279, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, -1, -1, 269, -1, -1, 272, -1, -1, -1, + 276, 277, 278, 279, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, -1, -1, 269, -1, -1, + 272, -1, -1, -1, 276, 277, 278, 279, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, -1, + -1, 269, -1, -1, 272, 256, 257, 258, 276, 277, + 278, 279, -1, -1, -1, -1, -1, 268, 269, -1, + 271, 272, 256, 257, 258, 276, 277, 278, 279, -1, + -1, -1, -1, -1, -1, 269, -1, -1, 272, 256, + 257, 258, 276, 277, 278, 279, -1, -1, -1, -1, + -1, -1, 269, -1, -1, 272, 256, 257, 258, 276, + 277, 278, 279, -1, 256, 257, 258, -1, -1, 269, + -1, -1, 272, -1, -1, -1, 276, 277, 278, 279, + 272, -1, -1, -1, 276, 277, 278, 279, +}; +#define YYFINAL 1 +#ifndef YYDEBUG +#define YYDEBUG 0 +#endif +#define YYMAXTOKEN 284 +#if YYDEBUG +char *yyname[] = { +"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,"','","'-'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"DEVICE","CARD", +"ANONYMOUS","TUPLE","MANFID","VERSION","FUNCTION","PCI","BIND","CIS","TO", +"NEEDS_MTD","MODULE","OPTS","CLASS","REGION","JEDEC","DTYPE","DEFAULT","MTD", +"INCLUDE","EXCLUDE","RESERVE","IRQ_NO","PORT","MEMORY","STRING","NUMBER", +}; +char *yyrule[] = { +"$accept : list", +"list :", +"list : list adjust", +"list : list device", +"list : list mtd", +"list : list card", +"list : list opts", +"list : list mtd_opts", +"list : list error", +"adjust : INCLUDE resource", +"adjust : EXCLUDE resource", +"adjust : RESERVE resource", +"adjust : adjust ',' resource", +"resource : IRQ_NO NUMBER", +"resource : PORT NUMBER '-' NUMBER", +"resource : MEMORY NUMBER '-' NUMBER", +"device : DEVICE STRING", +"device : needs_mtd", +"device : module", +"device : class", +"card : CARD STRING", +"card : anonymous", +"card : tuple", +"card : manfid", +"card : pci", +"card : version", +"card : function", +"card : bind", +"card : cis", +"anonymous : card ANONYMOUS", +"tuple : card TUPLE NUMBER ',' NUMBER ',' STRING", +"manfid : card MANFID NUMBER ',' NUMBER", +"pci : card PCI NUMBER ',' NUMBER", +"version : card VERSION STRING", +"version : version ',' STRING", +"function : card FUNCTION NUMBER", +"cis : card CIS STRING", +"bind : card BIND STRING", +"bind : card BIND STRING TO NUMBER", +"bind : bind ',' STRING", +"bind : bind ',' STRING TO NUMBER", +"needs_mtd : device NEEDS_MTD", +"opts : MODULE STRING OPTS STRING", +"module : device MODULE STRING", +"module : module OPTS STRING", +"module : module ',' STRING", +"class : device CLASS STRING", +"region : REGION STRING", +"region : dtype", +"region : jedec", +"region : default", +"dtype : region DTYPE NUMBER", +"jedec : region JEDEC NUMBER NUMBER", +"default : region DEFAULT", +"mtd : region MTD STRING", +"mtd : mtd OPTS STRING", +"mtd_opts : MTD STRING OPTS STRING", +}; +#endif +#ifdef YYSTACKSIZE +#undef YYMAXDEPTH +#define YYMAXDEPTH YYSTACKSIZE +#else +#ifdef YYMAXDEPTH +#define YYSTACKSIZE YYMAXDEPTH +#else +#define YYSTACKSIZE 500 +#define YYMAXDEPTH 500 +#endif +#endif +int yydebug; +int yynerrs; +int yyerrflag; +int yychar; +short *yyssp; +YYSTYPE *yyvsp; +YYSTYPE yyval; +YYSTYPE yylval; +short yyss[YYSTACKSIZE]; +YYSTYPE yyvs[YYSTACKSIZE]; +#define yystacksize YYSTACKSIZE +#line 468 "yacc_config.y" +void yyerror(char *msg, ...) +{ + va_list ap; + char str[256]; + + va_start(ap, msg); + sprintf(str, "config error, file '%s' line %d: ", + current_file, current_lineno); + vsprintf(str+strlen(str), msg, ap); +#if YYDEBUG + fprintf(stderr, "%s\n", str); +#else + syslog(LOG_ERR, "%s", str); +#endif + va_end(ap); +} + +static int add_binding(card_info_t *card, char *name, int fn) +{ + device_info_t *dev = root_device; + if (card->bindings == MAX_BINDINGS) { + yyerror("too many bindings\n"); + return -1; + } + for (; dev; dev = dev->next) + if (strcmp((char *)dev->dev_info, name) == 0) break; + if (dev == NULL) { + yyerror("unknown device: %s", name); + return -1; + } + card->device[card->bindings] = dev; + card->dev_fn[card->bindings] = fn; + card->bindings++; + free(name); + return 0; +} + +static int add_module(device_info_t *dev, char *name) +{ + if (dev->modules == MAX_MODULES) { + yyerror("too many modules"); + return -1; + } + dev->module[dev->modules] = name; + dev->opts[dev->modules] = NULL; + dev->modules++; + return 0; +} + +#if YYDEBUG +adjust_list_t *root_adjust = NULL; +device_info_t *root_device = NULL; +card_info_t *root_card = NULL, *blank_card = NULL, *root_func = NULL; +mtd_ident_t *root_mtd = NULL, *default_mtd = NULL; + +void main(int argc, char *argv[]) +{ + yydebug = 1; + if (argc > 1) + parse_configfile(argv[1]); +} +#endif +#line 426 "y.tab.c" +#define YYABORT goto yyabort +#define YYREJECT goto yyabort +#define YYACCEPT goto yyaccept +#define YYERROR goto yyerrlab +int +yyparse() +{ + register int yym, yyn, yystate; +#if YYDEBUG + register char *yys; + extern char *getenv(); + + if (yys = getenv("YYDEBUG")) + { + yyn = *yys; + if (yyn >= '0' && yyn <= '9') + yydebug = yyn - '0'; + } +#endif + + yynerrs = 0; + yyerrflag = 0; + yychar = (-1); + + yyssp = yyss; + yyvsp = yyvs; + *yyssp = yystate = 0; + +yyloop: + if (yyn = yydefred[yystate]) goto yyreduce; + if (yychar < 0) + { + if ((yychar = yylex()) < 0) yychar = 0; +#if YYDEBUG + if (yydebug) + { + yys = 0; + if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; + if (!yys) yys = "illegal-symbol"; + printf("%sdebug: state %d, reading %d (%s)\n", + YYPREFIX, yystate, yychar, yys); + } +#endif + } + if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == yychar) + { +#if YYDEBUG + if (yydebug) + printf("%sdebug: state %d, shifting to state %d\n", + YYPREFIX, yystate, yytable[yyn]); +#endif + if (yyssp >= yyss + yystacksize - 1) + { + goto yyoverflow; + } + *++yyssp = yystate = yytable[yyn]; + *++yyvsp = yylval; + yychar = (-1); + if (yyerrflag > 0) --yyerrflag; + goto yyloop; + } + if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == yychar) + { + yyn = yytable[yyn]; + goto yyreduce; + } + if (yyerrflag) goto yyinrecovery; +#ifdef lint + goto yynewerror; +#endif +yynewerror: + yyerror("syntax error"); +#ifdef lint + goto yyerrlab; +#endif +yyerrlab: + ++yynerrs; +yyinrecovery: + if (yyerrflag < 3) + { + yyerrflag = 3; + for (;;) + { + if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) + { +#if YYDEBUG + if (yydebug) + printf("%sdebug: state %d, error recovery shifting\ + to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); +#endif + if (yyssp >= yyss + yystacksize - 1) + { + goto yyoverflow; + } + *++yyssp = yystate = yytable[yyn]; + *++yyvsp = yylval; + goto yyloop; + } + else + { +#if YYDEBUG + if (yydebug) + printf("%sdebug: error recovery discarding state %d\n", + YYPREFIX, *yyssp); +#endif + if (yyssp <= yyss) goto yyabort; + --yyssp; + --yyvsp; + } + } + } + else + { + if (yychar == 0) goto yyabort; +#if YYDEBUG + if (yydebug) + { + yys = 0; + if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; + if (!yys) yys = "illegal-symbol"; + printf("%sdebug: state %d, error recovery discards token %d (%s)\n", + YYPREFIX, yystate, yychar, yys); + } +#endif + yychar = (-1); + goto yyloop; + } +yyreduce: +#if YYDEBUG + if (yydebug) + printf("%sdebug: state %d, reducing by rule %d (%s)\n", + YYPREFIX, yystate, yyn, yyrule[yyn]); +#endif + yym = yylen[yyn]; + yyval = yyvsp[1-yym]; + switch (yyn) + { +case 2: +#line 84 "yacc_config.y" +{ + adjust_list_t **tail = &root_adjust; + while (*tail != NULL) tail = &(*tail)->next; + *tail = yyvsp[0].adjust; + } +break; +case 3: +#line 90 "yacc_config.y" +{ + yyvsp[0].device->next = root_device; + root_device = yyvsp[0].device; + } +break; +case 4: +#line 95 "yacc_config.y" +{ + if (yyvsp[0].mtd->mtd_type == 0) { + yyerror("no ID method for this card"); + YYERROR; + } + if (yyvsp[0].mtd->module == NULL) { + yyerror("no MTD module specified"); + YYERROR; + } + yyvsp[0].mtd->next = root_mtd; + root_mtd = yyvsp[0].mtd; + } +break; +case 5: +#line 108 "yacc_config.y" +{ + if (yyvsp[0].card->ident_type == 0) { + yyerror("no ID method for this card"); + YYERROR; + } + if (yyvsp[0].card->bindings == 0) { + yyerror("no function bindings"); + YYERROR; + } + if (yyvsp[0].card->ident_type == FUNC_IDENT) { + yyvsp[0].card->next = root_func; + root_func = yyvsp[0].card; + } else { + yyvsp[0].card->next = root_card; + root_card = yyvsp[0].card; + } + } +break; +case 9: +#line 131 "yacc_config.y" +{ + yyvsp[0].adjust->adj.Action = ADD_MANAGED_RESOURCE; + yyval.adjust = yyvsp[0].adjust; + } +break; +case 10: +#line 136 "yacc_config.y" +{ + yyvsp[0].adjust->adj.Action = REMOVE_MANAGED_RESOURCE; + yyval.adjust = yyvsp[0].adjust; + } +break; +case 11: +#line 141 "yacc_config.y" +{ + yyvsp[0].adjust->adj.Action = ADD_MANAGED_RESOURCE; + yyvsp[0].adjust->adj.Attributes |= RES_RESERVED; + yyval.adjust = yyvsp[0].adjust; + } +break; +case 12: +#line 147 "yacc_config.y" +{ + yyvsp[0].adjust->adj.Action = yyvsp[-2].adjust->adj.Action; + yyvsp[0].adjust->adj.Attributes = yyvsp[-2].adjust->adj.Attributes; + yyvsp[0].adjust->next = yyvsp[-2].adjust; + yyval.adjust = yyvsp[0].adjust; + } +break; +case 13: +#line 156 "yacc_config.y" +{ + yyval.adjust = calloc(sizeof(adjust_list_t), 1); + yyval.adjust->adj.Resource = RES_IRQ; + yyval.adjust->adj.resource.irq.IRQ = yyvsp[0].num; + } +break; +case 14: +#line 162 "yacc_config.y" +{ + if ((yyvsp[0].num < yyvsp[-2].num) || (yyvsp[0].num > 0xffff)) { + yyerror("invalid port range"); + YYERROR; + } + yyval.adjust = calloc(sizeof(adjust_list_t), 1); + yyval.adjust->adj.Resource = RES_IO_RANGE; + yyval.adjust->adj.resource.io.BasePort = yyvsp[-2].num; + yyval.adjust->adj.resource.io.NumPorts = yyvsp[0].num - yyvsp[-2].num + 1; + } +break; +case 15: +#line 173 "yacc_config.y" +{ + if (yyvsp[0].num < yyvsp[-2].num) { + yyerror("invalid address range"); + YYERROR; + } + yyval.adjust = calloc(sizeof(adjust_list_t), 1); + yyval.adjust->adj.Resource = RES_MEMORY_RANGE; + yyval.adjust->adj.resource.memory.Base = yyvsp[-2].num; + yyval.adjust->adj.resource.memory.Size = yyvsp[0].num - yyvsp[-2].num + 1; + } +break; +case 16: +#line 186 "yacc_config.y" +{ + yyval.device = calloc(sizeof(device_info_t), 1); + yyval.device->refs = 1; + strcpy(yyval.device->dev_info, yyvsp[0].str); + free(yyvsp[0].str); + } +break; +case 20: +#line 198 "yacc_config.y" +{ + yyval.card = calloc(sizeof(card_info_t), 1); + yyval.card->refs = 1; + yyval.card->name = yyvsp[0].str; + } +break; +case 29: +#line 214 "yacc_config.y" +{ + if (yyvsp[-1].card->ident_type != 0) { + yyerror("ID method already defined"); + YYERROR; + } + if (blank_card) { + yyerror("Anonymous card already defined"); + YYERROR; + } + yyvsp[-1].card->ident_type = BLANK_IDENT; + blank_card = yyvsp[-1].card; + } +break; +case 30: +#line 229 "yacc_config.y" +{ + if (yyvsp[-6].card->ident_type != 0) { + yyerror("ID method already defined"); + YYERROR; + } + yyvsp[-6].card->ident_type = TUPLE_IDENT; + yyvsp[-6].card->id.tuple.code = yyvsp[-4].num; + yyvsp[-6].card->id.tuple.ofs = yyvsp[-2].num; + yyvsp[-6].card->id.tuple.info = yyvsp[0].str; + } +break; +case 31: +#line 242 "yacc_config.y" +{ + if (yyvsp[-4].card->ident_type & EXCL_IDENT) { + yyerror("ID method already defined"); + YYERROR; + } + yyvsp[-4].card->ident_type = MANFID_IDENT; + yyvsp[-4].card->manfid.manf = yyvsp[-2].num; + yyvsp[-4].card->manfid.card = yyvsp[0].num; + } +break; +case 32: +#line 253 "yacc_config.y" +{ + if (yyvsp[-4].card->ident_type != 0) { + yyerror("ID method already defined"); + YYERROR; + } + yyvsp[-4].card->ident_type = PCI_IDENT; + yyvsp[-4].card->manfid.manf = yyvsp[-2].num; + yyvsp[-4].card->manfid.card = yyvsp[0].num; + } +break; +case 33: +#line 264 "yacc_config.y" +{ + if (yyvsp[-2].card->ident_type & EXCL_IDENT) { + yyerror("ID method already defined\n"); + YYERROR; + } + yyvsp[-2].card->ident_type = VERS_1_IDENT; + yyvsp[-2].card->id.vers.ns = 1; + yyvsp[-2].card->id.vers.pi[0] = yyvsp[0].str; + } +break; +case 34: +#line 274 "yacc_config.y" +{ + if (yyvsp[-2].card->id.vers.ns == 4) { + yyerror("too many version strings"); + YYERROR; + } + yyvsp[-2].card->id.vers.pi[yyvsp[-2].card->id.vers.ns] = yyvsp[0].str; + yyvsp[-2].card->id.vers.ns++; + } +break; +case 35: +#line 285 "yacc_config.y" +{ + if (yyvsp[-2].card->ident_type != 0) { + yyerror("ID method already defined\n"); + YYERROR; + } + yyvsp[-2].card->ident_type = FUNC_IDENT; + yyvsp[-2].card->id.func.funcid = yyvsp[0].num; + } +break; +case 36: +#line 296 "yacc_config.y" +{ yyvsp[-2].card->cis_file = strdup(yyvsp[0].str); } +break; +case 37: +#line 300 "yacc_config.y" +{ + if (add_binding(yyvsp[-2].card, yyvsp[0].str, 0) != 0) + YYERROR; + } +break; +case 38: +#line 305 "yacc_config.y" +{ + if (add_binding(yyvsp[-4].card, yyvsp[-2].str, yyvsp[0].num) != 0) + YYERROR; + } +break; +case 39: +#line 310 "yacc_config.y" +{ + if (add_binding(yyvsp[-2].card, yyvsp[0].str, 0) != 0) + YYERROR; + } +break; +case 40: +#line 315 "yacc_config.y" +{ + if (add_binding(yyvsp[-4].card, yyvsp[-2].str, yyvsp[0].num) != 0) + YYERROR; + } +break; +case 41: +#line 322 "yacc_config.y" +{ + yyvsp[-1].device->needs_mtd = 1; + } +break; +case 42: +#line 328 "yacc_config.y" +{ + device_info_t *d; + int i, found = 0; + for (d = root_device; d; d = d->next) { + for (i = 0; i < d->modules; i++) + if (strcmp(yyvsp[-2].str, d->module[i]) == 0) break; + if (i < d->modules) { + if (d->opts[i]) + free(d->opts[i]); + d->opts[i] = strdup(yyvsp[0].str); + found = 1; + } + } + free(yyvsp[-2].str); free(yyvsp[0].str); + if (!found) { + yyerror("module name not found!"); + YYERROR; + } + } +break; +case 43: +#line 350 "yacc_config.y" +{ + if (add_module(yyvsp[-2].device, yyvsp[0].str) != 0) + YYERROR; + } +break; +case 44: +#line 355 "yacc_config.y" +{ + if (yyvsp[-2].device->opts[yyvsp[-2].device->modules-1] == NULL) { + yyvsp[-2].device->opts[yyvsp[-2].device->modules-1] = yyvsp[0].str; + } else { + yyerror("too many options"); + YYERROR; + } + } +break; +case 45: +#line 364 "yacc_config.y" +{ + if (add_module(yyvsp[-2].device, yyvsp[0].str) != 0) + YYERROR; + } +break; +case 46: +#line 371 "yacc_config.y" +{ + if (yyvsp[-2].device->class != NULL) { + yyerror("extra class string"); + YYERROR; + } + yyvsp[-2].device->class = yyvsp[0].str; + } +break; +case 47: +#line 381 "yacc_config.y" +{ + yyval.mtd = calloc(sizeof(mtd_ident_t), 1); + yyval.mtd->refs = 1; + yyval.mtd->name = yyvsp[0].str; + } +break; +case 51: +#line 392 "yacc_config.y" +{ + if (yyvsp[-2].mtd->mtd_type != 0) { + yyerror("ID method already defined"); + YYERROR; + } + yyvsp[-2].mtd->mtd_type = DTYPE_MTD; + yyvsp[-2].mtd->dtype = yyvsp[0].num; + } +break; +case 52: +#line 403 "yacc_config.y" +{ + if (yyvsp[-3].mtd->mtd_type != 0) { + yyerror("ID method already defined"); + YYERROR; + } + yyvsp[-3].mtd->mtd_type = JEDEC_MTD; + yyvsp[-3].mtd->jedec_mfr = yyvsp[-1].num; + yyvsp[-3].mtd->jedec_info = yyvsp[0].num; + } +break; +case 53: +#line 415 "yacc_config.y" +{ + if (yyvsp[-1].mtd->mtd_type != 0) { + yyerror("ID method already defined"); + YYERROR; + } + if (default_mtd) { + yyerror("Default MTD already defined"); + YYERROR; + } + yyvsp[-1].mtd->mtd_type = DEFAULT_MTD; + default_mtd = yyvsp[-1].mtd; + } +break; +case 54: +#line 430 "yacc_config.y" +{ + if (yyvsp[-2].mtd->module != NULL) { + yyerror("extra MTD entry"); + YYERROR; + } + yyvsp[-2].mtd->module = yyvsp[0].str; + } +break; +case 55: +#line 438 "yacc_config.y" +{ + if (yyvsp[-2].mtd->opts == NULL) { + yyvsp[-2].mtd->opts = yyvsp[0].str; + } else { + yyerror("too many options"); + YYERROR; + } + } +break; +case 56: +#line 449 "yacc_config.y" +{ + mtd_ident_t *m; + int found = 0; + for (m = root_mtd; m; m = m->next) + if (strcmp(yyvsp[-2].str, m->module) == 0) break; + if (m) { + if (m->opts) free(m->opts); + m->opts = strdup(yyvsp[0].str); + found = 1; + } + free(yyvsp[-2].str); free(yyvsp[0].str); + if (!found) { + yyerror("MTD name not found!"); + YYERROR; + } + } +break; +#line 966 "y.tab.c" + } + yyssp -= yym; + yystate = *yyssp; + yyvsp -= yym; + yym = yylhs[yyn]; + if (yystate == 0 && yym == 0) + { +#if YYDEBUG + if (yydebug) + printf("%sdebug: after reduction, shifting from state 0 to\ + state %d\n", YYPREFIX, YYFINAL); +#endif + yystate = YYFINAL; + *++yyssp = YYFINAL; + *++yyvsp = yyval; + if (yychar < 0) + { + if ((yychar = yylex()) < 0) yychar = 0; +#if YYDEBUG + if (yydebug) + { + yys = 0; + if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; + if (!yys) yys = "illegal-symbol"; + printf("%sdebug: state %d, reading %d (%s)\n", + YYPREFIX, YYFINAL, yychar, yys); + } +#endif + } + if (yychar == 0) goto yyaccept; + goto yyloop; + } + if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && + yyn <= YYTABLESIZE && yycheck[yyn] == yystate) + yystate = yytable[yyn]; + else + yystate = yydgoto[yym]; +#if YYDEBUG + if (yydebug) + printf("%sdebug: after reduction, shifting from state %d \ +to state %d\n", YYPREFIX, *yyssp, yystate); +#endif + if (yyssp >= yyss + yystacksize - 1) + { + goto yyoverflow; + } + *++yyssp = yystate; + *++yyvsp = yyval; + goto yyloop; +yyoverflow: + yyerror("yacc stack overflow"); +yyabort: + return (1); +yyaccept: + return (0); +} diff --git a/mdk-stage1/pcmcia_/yacc_config.h b/mdk-stage1/pcmcia_/yacc_config.h new file mode 100644 index 000000000..b4902c8e6 --- /dev/null +++ b/mdk-stage1/pcmcia_/yacc_config.h @@ -0,0 +1,37 @@ +#define DEVICE 257 +#define CARD 258 +#define ANONYMOUS 259 +#define TUPLE 260 +#define MANFID 261 +#define VERSION 262 +#define FUNCTION 263 +#define PCI 264 +#define BIND 265 +#define CIS 266 +#define TO 267 +#define NEEDS_MTD 268 +#define MODULE 269 +#define OPTS 270 +#define CLASS 271 +#define REGION 272 +#define JEDEC 273 +#define DTYPE 274 +#define DEFAULT 275 +#define MTD 276 +#define INCLUDE 277 +#define EXCLUDE 278 +#define RESERVE 279 +#define IRQ_NO 280 +#define PORT 281 +#define MEMORY 282 +#define STRING 283 +#define NUMBER 284 +typedef union { + char *str; + u_long num; + struct device_info_t *device; + struct card_info_t *card; + struct mtd_ident_t *mtd; + struct adjust_list_t *adjust; +} YYSTYPE; +extern YYSTYPE yylval; -- cgit v1.2.1