--- /dev/null
+/*
+ * Copyright (c) 1994 Stefan Grefen. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by Charles Hannum.
+ * This product includes software developed by Stefan Grefen.
+ * 4. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id: pcmcia.c,v 1.1 1996/01/15 00:05:03 hvozda Exp $
+ */
+
+/* derived from scsiconf.c writte by Julian Elischer et al */
+/* TODO add modload support and loadable lists of devices */
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/device.h>
+#include <sys/ioctl.h>
+#include <sys/fcntl.h>
+
+#include <dev/pcmcia/pcmcia.h>
+#include <dev/pcmcia/pcmciabus.h>
+#include <dev/pcmcia/pcmcia_ioctl.h>
+
+#ifdef IBM_WD
+#define PCMCIA_DEBUG
+#endif
+#ifdef PCMCIA_DEBUG
+# define PPRINTF(a) printf a
+#else
+# define PPRINTF(a)
+#endif
+
+static void pcmciadumpcf __P((struct pcmcia_conf *));
+static int pcmcia_strcmp __P((char *, char *, int, char *));
+
+void pcmcia_shuthook __P((void *));
+
+static struct pcmcia_adapter pcmcia_drivers[4];
+static int pcmcia_cntrl = 0;
+static int probed = 0;
+static struct device **deldevs = NULL;
+static int ndeldevs = 0;
+
+/* I've decided to re-ifdef these. It makes making a kernel easier
+ until I either get config(8) modified to deal somehow
+ or figure out a better to way declare the prototypes and
+ build up the knowndevs struct. Stefan may have ideas...
+*/
+
+#ifdef PCMCIA_ED
+extern struct pcmciadevs pcmcia_ed_devs[];
+#endif
+#ifdef PCMCIA_COM
+extern struct pcmciadevs pcmcia_com_devs[];
+#endif
+#ifdef PCMCIA_EP
+extern struct pcmciadevs pcmcia_ep_devs[];
+#endif
+
+static struct pcmciadevs *knowndevs[] = {
+#ifdef PCMCIA_ED
+ pcmcia_ed_devs,
+#endif
+#ifdef PCMCIA_COM
+ pcmcia_com_devs,
+#endif
+#ifdef PCMCIA_EP
+ pcmcia_ep_devs,
+#endif
+ NULL
+};
+
+#ifdef notyet
+static struct pcmciadevs *knowndevs[10] = { NULL };
+#define KNOWNSIZE (sizeof(knowndevs) / sizeof(knowndevs[0]))
+#endif
+
+#define PCMCIA_SERVICE(a,b,c,d,e) ((a)->chip_link->pcmcia_service(b,c,\
+ (void *) d,e))
+#define PCMCIA_MAP_IO(a,b,c,d,e) ((a)->chip_link->pcmcia_map_io(b,c,d,e))
+#define PCMCIA_MAP_INTR(a,b,c,d) ((a)->chip_link->pcmcia_map_intr(b,c,d))
+#define PCMCIA_MAP_MEM(a,b,c,d,e,f) ((a)->chip_link->pcmcia_map_mem(b,c,d,e,f))
+
+#define PCMCIA_BUS_INIT(a,b,c,d,e,f)((a)->bus_link->bus_init((b),(c),(d),(e)\
+ ,(f)))
+#define PCMCIA_BUS_SEARCH(a,b,c,d) ((a)->bus_link->bus_search((b),(c),(d)))
+#define PCMCIA_BUS_PROBE(a,b,c,d,e) ((a)->bus_link->bus_probe((b),(c),(d),(e)))
+#define PCMCIA_BUS_CONFIG(a,b,c,d,e)((a)->bus_link->bus_config((b),(c),(d),(e)))
+#define PCMCIA_BUS_UNCONFIG(a,b) ((a)->bus_link->bus_unconfig((b)))
+
+#define SCRATCH_MEM(a) ((a)->scratch_mem)
+#define SCRATCH_SIZE(a) ((a)->scratch_memsiz)
+#define SCRATCH_INUSE(a)((a)->scratch_inuse)
+
+/*
+ * Declarations
+ */
+struct pcmciadevs *pcmcia_probedev __P((struct pcmcia_link *));
+struct pcmciadevs *pcmcia_selectdev __P((char *, char *, char *, char *));
+int pcmcia_probe_bus __P((struct pcmcia_link *, int, int,
+ struct pcmcia_conf *));
+int pcmciabusmatch __P((struct device *, void *, void *));
+void pcmciabusattach __P((struct device *, struct device *, void *));
+
+struct cfdriver pcmciabuscd = {
+ NULL, "pcmcia", pcmciabusmatch, pcmciabusattach, DV_DULL,
+ sizeof(struct pcmciabus_softc), 1
+};
+
+#ifdef notyet
+int
+pcmcia_add_device(devs)
+ struct pcmciadevs *devs;
+{
+ int i;
+
+ if (devs == NULL)
+ return 0;
+
+ for (i = 0; i < KNOWNSIZE; i++)
+ if (knowndevs[i] == NULL)
+ break;
+
+ if (i == KNOWNSIZE)
+ panic("Too many pcmcia devices");
+
+ knowndevs[i] = devs;
+ for (; devs->devname != NULL; devs++)
+ printf("added %s\n", devs->devname);
+ return i;
+}
+#endif
+
+int
+pcmcia_register(adapter_softc, bus_link, chip_link, slot)
+ void *adapter_softc;
+ struct pcmciabus_link *bus_link;
+ struct pcmcia_funcs *chip_link;
+ int slot;
+{
+ PPRINTF(("- pcmcia_register\n"));
+ if (pcmcia_cntrl == 0)
+ bzero(pcmcia_drivers, sizeof(pcmcia_drivers));
+
+ if (pcmcia_cntrl < 4) {
+ pcmcia_drivers[slot].adapter_softc = adapter_softc;
+ pcmcia_drivers[slot].chip_link = chip_link;
+ pcmcia_drivers[slot].bus_link = bus_link;
+ pcmcia_cntrl++;
+ return 1;
+ }
+ return 0;
+}
+
+int
+pcmciabusmatch(parent, self, aux)
+ struct device *parent;
+ void *self;
+ void *aux;
+{
+ struct pcmciabus_softc *sc = (void *)self;
+ struct cfdata *cf = sc->sc_dev.dv_cfdata;
+ int i, found = 0;
+
+ PPRINTF(("- pcmciabusmatch\n"));
+ if (pcmcia_cntrl <= 0)
+ return 0;
+
+ for (i = 0; i < 4; i++)
+ if (pcmcia_drivers[i].bus_link) {
+ if (PCMCIA_BUS_INIT(&pcmcia_drivers[i], parent, cf,
+ aux, &pcmcia_drivers[i], 0))
+ found++;
+ }
+ return found != 0;
+}
+
+/*
+ * The routine called by the adapter boards to get all their
+ * devices configured in.
+ */
+void
+pcmciabusattach(parent, self, aux)
+ struct device *parent;
+ struct device *self;
+ void *aux;
+{
+ struct pcmciabus_softc *sc = (struct pcmciabus_softc *) self;
+ struct cfdata *cf = self->dv_cfdata;
+ int i, found = 0;
+
+ PPRINTF(("- pcmciabusattach\n"));
+ for (i = 0; i < 4; i++)
+ if (pcmcia_drivers[i].bus_link) {
+ if (PCMCIA_BUS_INIT(&pcmcia_drivers[i], parent, cf,
+ aux, &pcmcia_drivers[i], 1))
+ found++;
+ }
+
+ printf("\n");
+
+ pcmcia_probe_bus(NULL, sc->sc_dev.dv_unit, -1, NULL);
+}
+
+/*
+ * Probe the requested pcmcia bus. It must be already set up.
+ * -1 requests all set up pcmcia busses.
+ */
+int
+pcmcia_probe_busses(bus, slot)
+ int bus, slot;
+{
+ PPRINTF(("- pcmcia_probe_busses\n"));
+ if (bus == -1) {
+ for (bus = 0; bus < pcmciabuscd.cd_ndevs; bus++)
+ if (pcmciabuscd.cd_devs[bus])
+ pcmcia_probe_bus(NULL, bus, slot, NULL);
+ return 0;
+ } else {
+ return pcmcia_probe_bus(NULL, bus, slot, NULL);
+ }
+}
+
+/*
+ * Probe the requested pcmcia bus. It must be already set up.
+ */
+int
+pcmcia_probe_bus(link, bus, slot, cf)
+ struct pcmcia_link *link;
+ int bus, slot;
+ struct pcmcia_conf *cf;
+{
+ struct pcmciabus_softc *pcmcia;
+ int maxslot, minslot, maxlun, minlun;
+ struct pcmciadevs *bestmatch = NULL;
+ int spec_probe = (link != NULL);
+
+ PPRINTF(("- pcmcia_probe_bus\n"));
+ if (bus < 0 || bus >= pcmciabuscd.cd_ndevs)
+ return ENXIO;
+ pcmcia = pcmciabuscd.cd_devs[bus];
+ if (!pcmcia)
+ return ENXIO;
+
+ if (slot == -1) {
+ maxslot = 7;
+ minslot = 0;
+ } else {
+ if (slot < 0 || slot > 7)
+ return EINVAL;
+ maxslot = minslot = slot;
+ }
+
+ for (slot = minslot; slot <= maxslot; slot++) {
+ if (link = pcmcia->sc_link[slot]) {
+ if (link->devp)
+ continue;
+ }
+ if (pcmcia_drivers[slot >> 1].adapter_softc == NULL)
+ continue;
+
+ /*
+ * If we presently don't have a link block
+ * then allocate one
+ */
+ if (!link) {
+ pcmcia->sc_link[slot] = link =
+ malloc(sizeof(*link), M_TEMP, M_NOWAIT);
+ if (link == NULL)
+ return ENOMEM;
+ bzero(link, sizeof(*link));
+ link->opennings = 1;
+ link->adapter = &pcmcia_drivers[slot >> 1];
+ link->slot = slot;
+ }
+ bestmatch = pcmcia_probedev(link);
+ /*
+ * We already know what the device is. We use a
+ * special matching routine which insists that the
+ * cfdata is of the right type rather than putting
+ * more intelligence in individual match routines for
+ * each high-level driver.
+ * We must have the final probe do all of the comparisons,
+ * or we could get stuck in an infinite loop trying the same
+ * device repeatedly. We use the `fordriver' field of
+ * the pcmcia_link for now, rather than inventing a new
+ * structure just for the config_search().
+ */
+ if (link->fordriver == NULL) {
+ if (bestmatch)
+ link->fordriver = bestmatch->devname;
+ else {
+ if (!spec_probe) {
+ link->device = NULL;
+ link->devp = NULL;
+ PCMCIA_SERVICE(link->adapter,
+ link, PCMCIA_OP_POWER,
+ 0, 0);
+ }
+ }
+ }
+
+ if (spec_probe) {
+ if (cf && pcmcia_mapcard(link, -1, cf) != 0)
+ link->fordriver = NULL;
+ }
+
+ if (link->fordriver != NULL) {
+ int i;
+ struct device **delp = deldevs;
+ int found = 0;
+ link->device = bestmatch;
+ link->flags = (link->flags &
+ ~(PCMCIA_ATTACH_TYPE)) |
+ PCMCIA_REATTACH;
+ for (i = 0; i < ndeldevs; i++, delp++) {
+ if (*delp &&
+ pcmcia_configure((*delp)->dv_parent, *delp,
+ link)) {
+ link->flags = (link->flags &
+ ~PCMCIA_ATTACH_TYPE)
+ | PCMCIA_SLOT_INUSE;
+ found = 1;
+ *delp = NULL;
+ break;
+ }
+ }
+ if (!found) {
+ link->flags = (link->flags &
+ ~PCMCIA_ATTACH_TYPE) | PCMCIA_ATTACH;
+ if (PCMCIA_BUS_SEARCH(link->adapter,
+ &pcmcia->sc_dev,
+ link, NULL)) {
+ link->flags = (link->flags &
+ ~PCMCIA_ATTACH_TYPE)
+ | PCMCIA_SLOT_INUSE;
+ } else {
+ link->flags &= ~(PCMCIA_ATTACH_TYPE |
+ PCMCIA_SLOT_INUSE);
+ link->device = NULL;
+ printf(
+ "No matching config entry %s.\n",
+ link->fordriver ?
+ link->fordriver : "(NULL)");
+ if (!spec_probe)
+ PCMCIA_SERVICE(link->adapter,
+ link,
+ PCMCIA_OP_POWER,
+ 0, 0);
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+/*
+ * given a target ask the device what
+ * it is, and find the correct driver table
+ * entry.
+ */
+struct pcmciadevs *
+pcmcia_probedev(link)
+ struct pcmcia_link *link;
+{
+ struct pcmcia_adapter *pca = link->adapter;
+ u_char scratch[CIS_MAXSIZE];
+ char manu[MAX_CIS_NAMELEN];
+ char model[MAX_CIS_NAMELEN];
+ char add_inf1[MAX_CIS_NAMELEN];
+ char add_inf2[MAX_CIS_NAMELEN];
+ int card_stat;
+ int err;
+ int pow = 0;
+ int slot = link->slot;
+
+ PPRINTF(("- pcmcia_probe_dev\n"));
+
+ printf("%s slot %d:",
+ ((struct device *) link->adapter->adapter_softc)->dv_xname,
+ slot & 1);
+
+ if ((err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_STATUS,
+ &card_stat, 0)) != 0) {
+ printf("failed to get status %d\n", err);
+ return NULL;
+ }
+
+ if ((card_stat & PCMCIA_CARD_PRESENT) == 0) {
+ printf(" <slot empty>\n");
+ return NULL;
+ }
+
+ if (!(card_stat & PCMCIA_POWER)) {
+ pow = 1;
+ if ((err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_POWER, 10000,
+ PCMCIA_POWER_ON|
+ PCMCIA_POWER_5V)) != 0) {
+ printf("failed to turn on power %d\n", err);
+ return NULL;
+ }
+ }
+
+ if (!(link->flags & (PCMCIA_SLOT_INUSE | CARD_IS_MAPPED))) {
+ if ((err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_RESET,
+ 500000, 0)) != 0) {
+ printf("failed to reset %d\n", err);
+ PCMCIA_SERVICE(pca, link, PCMCIA_OP_POWER, 0, 0);
+ return NULL;
+ }
+ }
+
+ /*
+ * Ask the device what it is
+ */
+ if ((err = pcmcia_read_cis(link, scratch, 0, sizeof(scratch))) != 0) {
+ printf("failed to read cis info %d\n", err);
+ goto bad;
+ }
+
+ if ((err = pcmcia_get_cisver1(link, scratch, sizeof(scratch),
+ manu, model, add_inf1,
+ add_inf2)) != 0) {
+ printf("failed to get cis info %d\n", err);
+ goto bad;
+ }
+
+ printf(" <%s, %s", manu, model);
+ if (add_inf1[0])
+ printf(", %s", add_inf1);
+ if (add_inf2[0])
+ printf(", %s", add_inf2);
+ printf(">\n");
+
+
+ /*
+ * Try make as good a match as possible with
+ * available sub drivers
+ */
+ return pcmcia_selectdev(manu, model, add_inf1, add_inf2);
+bad:
+ if (!pow)
+ PCMCIA_SERVICE(pca, link, PCMCIA_OP_POWER, 0, 0);
+ return NULL;
+}
+
+/*
+ * Try make as good a match as possible with
+ * available sub drivers
+ */
+struct pcmciadevs *
+pcmcia_selectdev(manu, model, add_inf1, add_inf2)
+ char *manu, *model, *add_inf1, *add_inf2;
+{
+ u_int bestmatches = 0;
+ struct pcmciadevs *bestmatch = (struct pcmciadevs *) 0;
+ struct pcmciadevs **dlist, *dentry;
+
+ PPRINTF(("- pcmcia_selectdev\n"));
+ for (dlist = knowndevs; *dlist; dlist++)
+ for (dentry = *dlist; dentry &&
+ dentry->devname != NULL; dentry++) {
+ int match = 0;
+
+#ifdef PCMCIA_DEBUG
+ dentry->flags |= PC_SHOWME;
+#endif
+ match|=pcmcia_strcmp(dentry->manufacturer,
+ manu,dentry->flags,"manufacturer")<<6;
+ match|=pcmcia_strcmp(dentry->model,
+ model,dentry->flags,"model")<<4;
+ match|=pcmcia_strcmp(dentry->add_inf1,
+ add_inf1,dentry->flags,"info1")<<2;
+ match|=pcmcia_strcmp(dentry->add_inf2,
+ add_inf2,dentry->flags,"info2");
+/* the following was replaced by the wildcard function called above */
+#if 0
+ if (dentry->flags & PC_SHOWME)
+ printf("manufacturer = `%s'-`%s'\n",
+ dentry->manufacturer ?
+ dentry->manufacturer :
+ "X",
+ manu);
+ if (dentry->manufacturer) {
+ if (strcmp(dentry->manufacturer, manu) == 0) {
+ match |= 8;
+ } else {
+ continue;
+ }
+ }
+
+ if (dentry->flags & PC_SHOWME)
+ printf("model = `%s'-`%s'\n",
+ dentry->model ? dentry->model :
+ "X",
+ model);
+ if (dentry->model) {
+ if (strcmp(dentry->model, model) == 0) {
+ match |= 4;
+ } else {
+ continue;
+ }
+ }
+
+
+ if (dentry->flags & PC_SHOWME)
+ printf("info1 = `%s'-`%s'\n",
+ dentry->add_inf1 ? dentry->add_inf1 :
+ "X",
+ add_inf1);
+ if (dentry->add_inf1) {
+ if (strcmp(dentry->add_inf1, add_inf1) == 0) {
+ match |= 2;
+ } else {
+ continue;
+ }
+ }
+
+ if (dentry->flags & PC_SHOWME)
+ printf("info2 = `%s'-`%s'\n",
+ dentry->add_inf2 ? dentry->add_inf2 :
+ "X",
+ add_inf2);
+ if (dentry->add_inf2) {
+ if (strcmp(dentry->add_inf2, add_inf2) == 0) {
+ match |= 1;
+ } else {
+ continue;
+ }
+ }
+#endif
+#ifdef PCMCIA_DEBUG
+ printf("match == %d [%d]\n",match,bestmatches);
+#endif
+
+ if(match > bestmatches) {
+ bestmatches = match;
+ bestmatch = dentry;
+ }
+ }
+
+ return bestmatch;
+}
+
+int
+pcmcia_configure(parent, self, aux)
+ struct device *parent;
+ void *self;
+ void *aux;
+{
+ struct device *dev = self;
+ struct pcmcia_link *link = aux;
+ struct cfdata *cf = dev->dv_cfdata;
+ struct cfdriver *cd = cf->cf_driver;
+ char *devname = (char *) link->fordriver;
+ struct pcmciadevs *pcs = link->device;
+ struct pcmcia_device *pcd;
+ struct pcmcia_adapter *pca = link->adapter;
+ struct pcmcia_conf pc_cf;
+ u_char scratch[CIS_MAXSIZE];
+ int mymap = 0;
+
+ PPRINTF(("- pcmcia_configure\n"));
+
+ if (strcmp(devname, cd->cd_name) || !pca)
+ return 0;
+
+ if (pcs == NULL)
+ pcd = NULL;
+ else
+ pcd = pcs->dev;
+
+ PPRINTF(("pcmcia_configure: %x\n", pcd));
+ if (!(link->flags & CARD_IS_MAPPED)) {
+ /* read 'suggested' configuration */
+ PPRINTF(("pcmcia_configure: calling read cis\n"));
+ if (pcmcia_read_cis(link, scratch, 0, sizeof(scratch)) != 0)
+ return 0;
+
+ bzero(&pc_cf, sizeof(pc_cf));
+
+ PPRINTF(("pcmcia_configure: calling get cf\n"));
+ if (pcmcia_get_cf(link, scratch, sizeof(scratch), -1,
+ &pc_cf) != 0)
+ return 0;
+#ifdef PCMCIA_DEBUG
+ pcmciadumpcf(&pc_cf);
+#endif
+ /* and modify it (device specific) */
+ if (pcd && pcd->pcmcia_config) {
+ PPRINTF(("pcmcia_configure: calling config\n"));
+ if (pcd->pcmcia_config(link, dev, &pc_cf, cf))
+ return 0;
+
+ if ((pc_cf.cfgtype & CFGENTRYMASK) == CFGENTRYID) {
+ PPRINTF(("pcmcia_configure: calling cf2\n"));
+ if (pcmcia_get_cf(link, scratch,
+ sizeof(scratch), -2,
+ &pc_cf) != 0)
+ return 0;
+
+ PPRINTF(("pcmcia_configure: calling conf2\n"));
+ if (pcd->pcmcia_config(link, dev, &pc_cf, cf))
+ return 0;
+ /* give it a try */
+ if(pc_cf.cfgid==0)
+ pc_cf.cfgid=1;
+ }
+ } else {
+ PPRINTF(("pcmcia_configure: calling bus config\n"));
+ if (PCMCIA_BUS_CONFIG(pca, link, dev, &pc_cf, cf))
+ return 0;
+ }
+#ifdef PCMCIA_DEBUG
+ pcmciadumpcf(&pc_cf);
+#endif
+
+ if (pcmcia_mapcard(link, -1, &pc_cf) != 0)
+ return 0;
+
+ mymap = 1;
+ }
+ link->devp = dev;
+
+ PPRINTF(("pcmcia_configure: calling bus probe\n"));
+ if (!(PCMCIA_BUS_PROBE(pca, parent, dev, cf, link))) {
+ PPRINTF(("pcmcia_configure: bus probe failed\n"));
+ goto bad;
+ }
+
+ if (pcd && pcd->pcmcia_insert && pcd->pcmcia_insert(link, dev, cf)) {
+ PPRINTF(("pcmcia_configure: pcmcia_insert failed\n"));
+ goto bad;
+ }
+
+ link->shuthook = shutdownhook_establish(pcmcia_shuthook,
+ (void *)link);
+ return 1;
+
+bad:
+ link->devp = NULL;
+ if (mymap)
+ pcmcia_unmapcard(link);
+ printf("pcmcia_configure: configuration error\n");
+ return 0;
+}
+
+void
+pcmcia_shuthook(arg)
+void *arg;
+{
+ struct pcmcia_link *link = (struct pcmcia_link *)arg;
+ if (pcmcia_unconfigure(link) == 0) {
+ /*
+ * turn off power too.
+ */
+ PCMCIA_SERVICE(link->adapter, link, PCMCIA_OP_RESET, 500000, 0);
+ PCMCIA_SERVICE(link->adapter, link, PCMCIA_OP_POWER, 0, 0);
+ }
+}
+
+int
+pcmcia_unconfigure(link)
+ struct pcmcia_link *link;
+{
+ int status;
+ int i, err;
+ struct device **delp;
+ struct device *dev;
+ struct pcmcia_adapter *pca = link->adapter;
+ struct pcmcia_device *pcd;
+
+ PPRINTF(("- pcmcia_unconfigure\n"));
+ if (link->devp == NULL)
+ return ENODEV;
+
+ if (link->device)
+ pcd = link->device->dev;
+ else
+ pcd = NULL;
+
+ if (link->flags & CARD_IS_MAPPED) {
+ if (pcd && pcd->pcmcia_remove) {
+ if (pcd->pcmcia_remove(link, link->devp))
+ return EBUSY;
+ }
+ else {
+ if (PCMCIA_BUS_UNCONFIG(pca, link))
+ return EBUSY;
+ }
+ if (pcmcia_unmapcard(link) != 0)
+ return EBUSY;
+ }
+ delp = deldevs;
+ for (i = 0; delp && *delp && i < ndeldevs; i++, delp++)
+ continue;
+ if (i >= ndeldevs) {
+ int sz = ndeldevs ? (ndeldevs * 2) :
+ (MINALLOCSIZE / sizeof(void *));
+ struct device **ndel = malloc(sz * sizeof(void *),
+ M_DEVBUF, M_NOWAIT);
+ if (!ndel) {
+ PPRINTF(("pcmcia_delete: creating dev array"));
+ return ENOMEM;
+ }
+ bzero(ndel, sz * sizeof(void *));
+ if (ndeldevs) {
+ bcopy(deldevs, ndel, ndeldevs * sizeof(void *));
+ free(deldevs, M_DEVBUF);
+ }
+ ndeldevs = sz - 1;
+ deldevs = ndel;
+ delp = deldevs + i;
+ }
+ dev = *delp = link->devp;
+ link->devp = NULL;
+ printf("device %s in pcmcia slot %d detached\n", dev->dv_xname,
+ link->slot);
+ shutdownhook_disestablish(link->shuthook);
+ link->shuthook = 0;
+ return 0;
+}
+
+int
+pcmcia_mapcard(link, unit, pc_cf)
+ struct pcmcia_link *link;
+ struct pcmcia_conf *pc_cf;
+{
+ struct pcmcia_adapter *pca = link->adapter;
+ int s, i, err;
+ PPRINTF(("- pcmcia_mapcard\n"));
+
+ if (pca == NULL)
+ return ENXIO;
+ s = splbio();
+
+ while (SCRATCH_INUSE(pca))
+ sleep((caddr_t) & SCRATCH_INUSE(pca), PZERO - 1);
+
+ SCRATCH_INUSE(pca) = 1;
+ splx(s);
+ for (i = 0; i < pc_cf->memwin; i++) {
+ if ((err = PCMCIA_MAP_MEM(pca, link,
+ (caddr_t) pc_cf->mem[i].start,
+ pc_cf->mem[i].caddr,
+ pc_cf->mem[i].len,
+ (pc_cf->mem[i].flags &
+ (PCMCIA_MAP_16 | PCMCIA_MAP_ATTR)) |
+ i | PCMCIA_PHYSICAL_ADDR)) != 0) {
+ PPRINTF(("pcmcia_mapcard: mapmem %d err%d\n", i, err));
+ goto error;
+ }
+ }
+ for (i = 0; i < pc_cf->iowin; i++) {
+ if ((err = PCMCIA_MAP_IO(pca, link, pc_cf->io[i].start,
+ pc_cf->io[i].len,
+ (pc_cf->io[i].flags & (PCMCIA_MAP_16 |
+ PCMCIA_MAP_8)) | i)) != 0) {
+ PPRINTF(("pcmcia_mapcard: mapio %d err %d\n", i, err));
+ goto error;
+ }
+ }
+
+ if ((pc_cf->irq_num & 0xf) > 0) {
+ if ((err = PCMCIA_MAP_INTR(pca, link, pc_cf->irq_num & 0xf,
+ 0)) != 0) {
+ PPRINTF(("pcmcia_mapcard: map_intr %d err %d\n",
+ pc_cf->irq_num & 0xf, err));
+ goto error;
+ }
+ }
+ /* Now we've mapped everything enable it */
+ if ((err = PCMCIA_MAP_MEM(pca, link, SCRATCH_MEM(pca),
+ pc_cf->cfg_off & (~(SCRATCH_SIZE(pca) - 1)), SCRATCH_SIZE(pca),
+ PCMCIA_MAP_ATTR | PCMCIA_LAST_WIN)) != 0) {
+ PPRINTF(("pcmcia_mapcard: enable err %d\n", err));
+ goto error;
+ }
+
+ if ((err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_RESET, -500000,
+ pc_cf->iocard)) != 0) {
+ PPRINTF(("failed to reset %d\n", err));
+ goto error;
+ }
+
+#define GETMEM(x) SCRATCH_MEM(pca)[(pc_cf->cfg_off & \
+ (SCRATCH_SIZE(pca) - 1)) + x]
+ if ((pc_cf->cfgtype & DOSRESET)) {
+ GETMEM(0) = PCMCIA_SRESET;
+ delay(50000);
+ }
+
+
+ PPRINTF(("CMDR %x\n",((pc_cf->cfgtype & CFGENTRYID) ?
+ pc_cf->cfgid |CFGENTRYID:
+ (pc_cf->cfgtype & CFGENTRYMASK)|1)|
+ (pc_cf->irq_level ? PCMCIA_LVLREQ : 0)
+ ));
+
+ GETMEM(0) = ((pc_cf->cfgtype & CFGENTRYID) ?
+ pc_cf->cfgid |CFGENTRYID:
+ (pc_cf->cfgtype & CFGENTRYMASK)|1)|
+ (pc_cf->irq_level ? PCMCIA_LVLREQ : 0);
+ delay(50000);
+
+ if (pc_cf->cfg_regmask & (1 << (PCMCIA_SCR / 2)))
+ GETMEM(PCMCIA_SCR) = (link->slot & 1) | 0x10;
+
+#if 0
+ DPRINTF(("CCSR %x\n", GETMEM(PCMCIA_CCSR]));
+ if (GETMEM(PCMCIA_CCSR] & PCMCIA_POWER_DOWN) {
+ GETMEM(PCMCIA_CCSR] &= ~PCMCIA_POWER_DOWN;
+ DPRINTF(("CCSR now %x\n", GETMEM(PCMCIA_CCSR]));
+ }
+#endif
+
+ if ((err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_WAIT,
+ 500000, 0)) != 0)
+ PPRINTF(("failed to initialize %d\n", err));
+error:
+ PCMCIA_MAP_MEM(pca, link, 0, 0, 0, PCMCIA_LAST_WIN | PCMCIA_UNMAP);
+ if (err != 0) {
+ for (i = 0; i < pc_cf->memwin; i++) {
+ PCMCIA_MAP_MEM(pca, link,
+ (caddr_t) pc_cf->mem[i].start,
+ pc_cf->mem[i].caddr,
+ pc_cf->mem[i].len,
+ (pc_cf->mem[i].flags & (PCMCIA_MAP_16 |
+ PCMCIA_MAP_ATTR)) | i |
+ PCMCIA_PHYSICAL_ADDR | PCMCIA_UNMAP);
+ }
+ for (i = 0; i < pc_cf->iowin; i++) {
+ PCMCIA_MAP_IO(pca, link, pc_cf->io[i].start,
+ pc_cf->io[i].len,
+ (pc_cf->io[i].flags & (PCMCIA_MAP_16 |
+ PCMCIA_MAP_8)) | i | PCMCIA_UNMAP);
+ }
+ PCMCIA_MAP_INTR(pca, link, pc_cf->irq_num, PCMCIA_UNMAP);
+ link->flags &= ~CARD_IS_MAPPED;
+ link->iowin = 0;
+ link->memwin = 0;
+ link->intr = 0;
+ } else {
+ link->flags |= CARD_IS_MAPPED;
+ link->iowin = pc_cf->iowin;
+ link->memwin = pc_cf->memwin;
+ link->intr = pc_cf->irq_num;
+ }
+ s = splbio();
+ SCRATCH_INUSE(pca) = 0;
+ wakeup((caddr_t) & SCRATCH_INUSE(pca));
+ splx(s);
+ return err;
+}
+
+int
+pcmcia_unmapcard(link)
+ struct pcmcia_link *link;
+{
+ int i;
+ struct pcmcia_adapter *pca = link->adapter;
+ PPRINTF(("- pcmcia_unmapcard\n"));
+ if (!pca)
+ return ENODEV;
+
+ for (i = 0; i < link->memwin; i++)
+ PCMCIA_MAP_MEM(pca, link, 0, 0, 0, (i | PCMCIA_UNMAP));
+
+ for (i = 0; i < link->iowin; i++)
+ PCMCIA_MAP_IO(pca, link, 0, 0, (i | PCMCIA_UNMAP));
+
+ PCMCIA_MAP_INTR(pca, link, link->intr, PCMCIA_UNMAP);
+ PCMCIA_SERVICE(pca, link, PCMCIA_OP_RESET, 0, 0);
+ link->flags &= ~(CARD_IS_MAPPED | PCMCIA_SLOT_INUSE);
+ link->iowin = 0;
+ link->memwin = 0;
+ link->intr = 0;
+ return 0;
+}
+
+
+static int
+pcmcia_mapcard_and_configure(link, unit, pc_cf)
+ struct pcmcia_link *link;
+ struct pcmcia_conf *pc_cf;
+ int unit;
+{
+ int err;
+ int mymap = 0;
+
+ PPRINTF(("- pcmcia_mapcard_and_configure\n"));
+ if (pc_cf->driver_name[0][0]) {
+#if 0
+ if ((err = pcmcia_mapcard(link, unit, pc_cf)) != 0) {
+ return err;
+ }
+ mymap=1;
+#endif
+ link->fordriver = pc_cf->driver_name[0];
+ } else {
+ link->fordriver = NULL;
+ pc_cf = NULL;
+ }
+ pcmcia_probe_bus(link, 0, link->slot, pc_cf);
+ if ((link->flags & PCMCIA_SLOT_INUSE) == 0) {
+ if (mymap)
+ pcmcia_unmapcard(link);
+ return ENODEV;
+ }
+ return 0;
+}
+
+
+int
+pcmcia_read_cis(link, scratch, offs, len)
+ struct pcmcia_link *link;
+ u_char *scratch;
+ int offs, len;
+{
+ struct pcmcia_adapter *pca = link->adapter;
+ int s;
+ int err = 0;
+ int j = 0;
+ u_char *p = SCRATCH_MEM(pca);
+ int size = SCRATCH_SIZE(pca);
+ volatile int *inuse = &SCRATCH_INUSE(pca);
+
+ PPRINTF(("- pcmcia_read_cis\n"));
+ if (pca == NULL)
+ return ENXIO;
+
+ s = splbio();
+ while (*inuse)
+ sleep((caddr_t) inuse, PZERO - 1);
+ *inuse = 1;
+ splx(s);
+
+ while (len > 0) {
+ int pgoff = offs / size;
+ int toff = offs - (pgoff * size);
+ int tlen = min(len + toff, size / 2) - toff;
+ int i;
+
+ if ((err = PCMCIA_MAP_MEM(pca, link, p, pgoff, size,
+ PCMCIA_MAP_ATTR |
+ PCMCIA_LAST_WIN)) != 0)
+ goto error;
+
+ for (i = 0; i < tlen; j++, i++)
+ scratch[j] = p[toff + i * 2];
+
+ PCMCIA_MAP_MEM(pca, link, p, 0, size,
+ PCMCIA_LAST_WIN | PCMCIA_UNMAP);
+ len -= tlen;
+ }
+error:
+ s = splbio();
+ *inuse = 0;
+ wakeup((caddr_t) inuse);
+ splx(s);
+
+ return err;
+}
+
+/* here we start our pseudodev for controlling the slots */
+#define PCMCIABUS_UNIT(a) (minor(a))
+#define PCMCIABUS_SLOT(a) (a&0x7)
+#define PCMCIABUS_CHIPIID(a) (a&0x3)
+#define PCMCIABUS_CHIP 0x10
+#define PCMCIABUS_BUS 0x20
+#define PCMCIABUS_DEVTYPE(a) ((a)&(PCMCIABUS_CHIP|PCMCIABUS_BUS))
+static int busopen = 0;
+static int chipopen[4] = {0, 0, 0, 0};
+
+int
+pcmciabusopen(dev, flag, mode, p)
+ dev_t dev;
+ int flag, mode;
+ struct proc *p;
+{
+ int unit = PCMCIABUS_UNIT(dev);
+ int chipid, slot;
+ struct pcmcia_link *link;
+ struct pcmciabus_softc *pcmcia;
+
+ PPRINTF(("- pcmciabusopen\n"));
+ if (pcmcia_cntrl == 0)
+ return ENXIO;
+ switch (PCMCIABUS_DEVTYPE(unit)) {
+ case PCMCIABUS_BUS:
+ if (unit != PCMCIABUS_BUS)
+ return ENXIO;
+ if (busopen)
+ return EBUSY;
+ busopen = 1;
+ break;
+
+ case PCMCIABUS_CHIP:
+ chipid = PCMCIABUS_CHIPIID(unit);
+ if (chipid > 3)
+ return ENXIO;
+ if (pcmcia_drivers[chipid].adapter_softc == NULL)
+ return ENXIO;
+
+ if (chipopen[chipid])
+ return EBUSY;
+
+ chipopen[chipid] = 1;
+ break;
+
+ case 0:
+ slot = PCMCIABUS_SLOT(unit);
+ chipid = slot >> 1;
+
+ if (chipid > 7)
+ return ENXIO;
+
+ if (pcmcia_drivers[chipid].adapter_softc == NULL)
+ return ENXIO;
+ pcmcia = pcmciabuscd.cd_devs[0];
+ link = pcmcia->sc_link[slot];
+
+ if (link->flags & PCMCIA_SLOT_OPEN)
+ return EBUSY;
+
+ link->flags |= PCMCIA_SLOT_OPEN;
+ break;
+
+ default:
+ return ENXIO;
+
+ }
+ return 0;
+}
+
+
+int
+pcmciabusclose(dev)
+{
+ int unit = PCMCIABUS_UNIT(dev);
+ int chipid, slot;
+ struct pcmcia_link *link;
+ struct pcmciabus_softc *pcmcia;
+ int s;
+
+ PPRINTF(("- pcmciabusclose\n"));
+ if (pcmcia_cntrl == 0)
+ return ENXIO;
+ switch (PCMCIABUS_DEVTYPE(unit)) {
+ case PCMCIABUS_BUS:
+ busopen = 0;
+ break;
+
+ case PCMCIABUS_CHIP:
+ chipid = PCMCIABUS_CHIPIID(unit);
+ chipopen[chipid] = 0;
+ break;
+
+ case 0:
+ slot = PCMCIABUS_SLOT(unit);
+ pcmcia = pcmciabuscd.cd_devs[0];
+ link = pcmcia->sc_link[slot];
+
+ s = splclock();
+ link->flags &= ~(PCMCIA_SLOT_OPEN|PCMCIA_SLOT_EVENT);
+ splx(s);
+ break;
+
+ default:
+ return ENXIO;
+ }
+ return 0;
+}
+
+int
+pcmciachip_ioctl(chipid, cmd, data)
+ int chipid, cmd;
+ caddr_t data;
+{
+ int err = 0;
+ struct pcmcia_adapter *pca = &pcmcia_drivers[chipid];
+ struct pcmcia_link link;
+ struct pcmcia_regs *pi = (void *) data;
+
+ PPRINTF(("- pcmciachip_ioctl\n"));
+ if (pca->chip_link == NULL || pca->adapter_softc == NULL)
+ return ENXIO;
+
+ switch (cmd) {
+ case PCMCIAIO_READ_REGS:
+ pi->chip = chipid;
+ link.adapter = pca;
+ link.slot = chipid << 1;
+ return PCMCIA_SERVICE(pca, &link, PCMCIA_OP_GETREGS,
+ pi->chip_data, 0);
+ }
+ return ENOTTY;
+}
+
+int
+pcmciaslot_ioctl(link, slotid, cmd, data)
+ struct pcmcia_link *link;
+ int slotid, cmd;
+ caddr_t data;
+{
+ int err = 0;
+ struct pcmcia_adapter *pca = &pcmcia_drivers[slotid >> 1];
+
+ PPRINTF(("- pcmciaslot_ioctl\n"));
+ if (link == NULL || pca->chip_link == NULL ||
+ pca->adapter_softc == NULL)
+ return ENXIO;
+
+ switch (cmd) {
+ case PCMCIAIO_GET_STATUS:
+ {
+ struct pcmcia_status *pi = (void *) data;
+ pi->slot = slotid;
+ pi->status = 0;
+ err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_STATUS,
+ &pi->status, 0);
+ if (!err) {
+ pi->status |= ((link->flags & CARD_IS_MAPPED) ?
+ PCMCIA_CARD_IS_MAPPED : 0) |
+ ((link->flags & PCMCIA_SLOT_INUSE) ?
+ PCMCIA_CARD_INUSE : 0);
+ }
+ return err;
+ }
+
+ case PCMCIAIO_GET_INFO:
+ {
+ struct pcmcia_info *pi = (void *) data;
+ int status;
+
+ if ((err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_STATUS,
+ &status, 0)) != 0)
+ return err;
+ if ((status & PCMCIA_CARD_PRESENT) == 0)
+ return ENODEV;
+ pi->slot = slotid;
+ return pcmcia_read_cis(link, pi->cis_data, 0,
+ CIS_MAXSIZE);
+ }
+
+ case PCMCIAIO_CONFIGURE:
+ {
+ struct pcmcia_conf *pc_cf = (void *) data;
+ return pcmcia_mapcard_and_configure(link, -1, pc_cf);
+ }
+
+ case PCMCIAIO_UNCONFIGURE:
+ return pcmcia_unconfigure(link);
+
+ case PCMCIAIO_UNMAP:
+ return pcmcia_unmapcard(link);
+
+ case PCMCIAIO_SET_POWER:
+ {
+ int pi = *(int *) data;
+ pi &= 0x3;
+ switch (pi) {
+ case PCMCIASIO_POWER_OFF:
+ return PCMCIA_SERVICE(pca, link,
+ PCMCIA_OP_POWER, 0, 0);
+
+ case PCMCIASIO_POWER_5V:
+ case PCMCIASIO_POWER_3V:
+ case PCMCIASIO_POWER_AUTO:
+ err = PCMCIA_SERVICE(pca, link,
+ PCMCIA_OP_POWER,
+ 10000, pi);
+ if (err)
+ return err;
+
+ err = PCMCIA_SERVICE(pca, link,
+ PCMCIA_OP_RESET,
+ 500000, 0);
+ if (err) {
+ PPRINTF(("failed to reset %d\n", err));
+ PCMCIA_SERVICE(pca, link,
+ PCMCIA_OP_POWER, 0, 0);
+ return err;
+ }
+ return 0;
+
+ default:
+ return EINVAL;
+ }
+ }
+
+ case PCMCIAIO_READ_COR:
+ {
+ struct pcmcia_info *pi = (void *)data;
+ struct pcmcia_conf pc_cf;
+ int status,s;
+
+ err = PCMCIA_SERVICE(pca, link, PCMCIA_OP_STATUS,
+ &status, 0);
+ if (err)
+ return err;
+ if ((status & PCMCIA_CARD_PRESENT) == 0)
+ return ENODEV;
+
+ if (status = pcmcia_read_cis(link, pi->cis_data, 0,
+ CIS_MAXSIZE))
+ return status;
+
+ bzero(&pc_cf, sizeof(pc_cf));
+ if (pcmcia_get_cf(link, pi->cis_data,
+ sizeof(pi->cis_data), -1,
+ &pc_cf) != 0 )
+ return EIO;
+
+ s=splbio();
+
+ while(SCRATCH_INUSE(pca))
+ sleep((caddr_t)&SCRATCH_INUSE(pca), PZERO - 1);
+
+ SCRATCH_INUSE(pca) = 1;
+ splx(s);
+ if ((err = PCMCIA_MAP_MEM(pca, link, SCRATCH_MEM(pca),
+ pc_cf.cfg_off &
+ ~(SCRATCH_SIZE(pca)-1),
+ SCRATCH_SIZE(pca),
+ PCMCIA_MAP_ATTR|
+ PCMCIA_LAST_WIN)) == 0) {
+ int m, i;
+ u_char *d = pi->cis_data,*p;
+ p = SCRATCH_MEM(pca)+
+ (pc_cf.cfg_off & (SCRATCH_SIZE(pca)-1));
+ for (i = 0, m = 1; i < 32; i++, m <<= 1) {
+ if (pc_cf.cfg_regmask & m) {
+ *d++ = i;
+ *d++ = p[i*2];
+ }
+ }
+ *d++ = 0xff;
+ *d++ = 0xff;
+ PCMCIA_MAP_MEM(pca, link, SCRATCH_MEM(pca),
+ 0,SCRATCH_SIZE(pca),
+ PCMCIA_LAST_WIN|PCMCIA_UNMAP);
+ }
+ s = splbio();
+ SCRATCH_INUSE(pca)=0;
+ wakeup((caddr_t)&SCRATCH_INUSE(pca));
+ splx(s);
+ return err;
+ }
+ default:
+ return ENOTTY;
+ }
+ return ENOTTY;
+}
+
+int
+pcmciabusioctl(dev, cmd, data, flag, p)
+ dev_t dev;
+ int cmd;
+ caddr_t data;
+ int flag;
+ struct proc *p;
+{
+ int unit = PCMCIABUS_UNIT(dev);
+ struct pcmciabus_softc *pcmcia;
+ struct pcmcia_link *link;
+
+ PPRINTF(("- pcmciabus_ioctl\n"));
+ pcmcia = pcmciabuscd.cd_devs[0];
+ if (pcmcia_cntrl == 0 || pcmcia == NULL)
+ return ENXIO;
+ switch (PCMCIABUS_DEVTYPE(unit)) {
+#if 0
+ case PCMCIABUS_BUS:
+ return pcmciabus_ioctl(0, cmd, data);
+#endif
+ case PCMCIABUS_CHIP:
+ return pcmciachip_ioctl(PCMCIABUS_CHIPIID(unit), cmd, data);
+ case 0:
+ link = pcmcia->sc_link[PCMCIABUS_SLOT(unit)];
+ return pcmciaslot_ioctl(link, PCMCIABUS_SLOT(unit), cmd, data);
+ default:
+ return ENXIO;
+ }
+}
+
+int
+pcmciabusselect(device, rw, p)
+ dev_t device;
+ int rw;
+ struct proc *p;
+{
+ int s;
+ int unit = PCMCIABUS_UNIT(device);
+ struct pcmciabus_softc *pcmcia;
+ struct pcmcia_link *link;
+
+ PPRINTF(("- pcmciabus_ioctl\n"));
+ pcmcia = pcmciabuscd.cd_devs[0];
+
+ switch (PCMCIABUS_DEVTYPE(unit)) {
+ case 0:
+ link = pcmcia->sc_link[PCMCIABUS_SLOT(unit)];
+ break;
+ case PCMCIABUS_BUS:
+ case PCMCIABUS_CHIP:
+ default:
+ return 0;
+ }
+
+ s = splclock(); /* XXX something higher than all devices that can plug in.... */
+ switch (rw) {
+ case FREAD:
+ case FWRITE:
+ break;
+ case 0:
+ if (link->flags & PCMCIA_SLOT_EVENT) {
+ link->flags &= ~PCMCIA_SLOT_EVENT;
+ splx(s);
+ return 1;
+ }
+ selrecord(p, &link->pcmcialink_sel);
+ break;
+ }
+ splx(s);
+ return 0;
+}
+
+int
+pcmciabusmmap()
+{
+ return ENXIO;
+}
+
+/* pcmcia template string match. A '*' matches any number of characters.
+ A NULL template matches all strings.
+ return-value
+ 0 nomatch
+ 1 wildcard match
+ 2 excact match
+ */
+static int
+pcmcia_strcmp(templ,val,flags,msg)
+ char *templ;
+ char *val;
+ int flags;
+ char *msg;
+{
+ char *ltempl=NULL,*lval=NULL;
+
+ if (flags & PC_SHOWME)
+ printf("%s = `%s'-`%s'\n", msg, templ ? templ : "X", val);
+
+ if(templ==NULL)
+ return 1;
+ while(*val) {
+ while(*templ=='*') {
+ ltempl=++templ;
+ lval=val;
+ }
+ if(*templ==*val) {
+ templ++;
+ val++;
+ } else {
+ if(ltempl==NULL)
+ return 0;
+ val=++lval;
+ templ=ltempl;
+ }
+ }
+ if(*templ!=0 && *templ!='*')
+ return 0;
+ return ltempl?1:2;
+}
+
+#ifdef PCMCIA_DEBUG
+static void
+pcmciadumpcf(cf)
+ struct pcmcia_conf * cf;
+{
+ int i;
+ static char *ios[] = {
+ "auto", "8bit", "16bit", "illegal"
+ };
+ printf("Driver name %s\n", cf->driver_name[0]);
+ printf("CFG offset %x\n", cf->cfg_off);
+ printf("IRQ type %s%s\n", cf->irq_level ? "Level " : "",
+ cf->irq_pulse ? "Pulse" : "");
+ printf("IRQ num %x\n", cf->irq_num);
+ printf("CFG type %x %x\n", cf->cfgtype,cf->cfgid);
+ printf("Cardtype %s\n", cf->iocard ? "IO" : "MEM");
+ for (i = 0; i < cf->iowin; i++) {
+ printf("iowin %x-%x %s\n", cf->io[i].start,
+ cf->io[i].start + cf->io[i].len - 1,
+ ios[(cf->io[i].flags &
+ (PCMCIA_MAP_8 | PCMCIA_MAP_16)) >> 8]);
+ }
+ for (i = 0; i < cf->memwin; i++) {
+ printf("memwin (%x)%x-%x %x\n",
+ cf->mem[i].caddr,
+ cf->mem[i].start,
+ cf->mem[i].start + cf->mem[i].len - 1,
+ cf->mem[i].flags);
+ }
+}
+#endif
--- /dev/null
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/device.h>
+
+#include <dev/pcmcia/pcmcia.h>
+#include <dev/pcmcia/pcmciabus.h>
+#include <dev/pcmcia/pcmcia_ioctl.h>
+
+#ifdef CFG_DEBUG
+static
+void dump(addr, len)
+ u_char *addr;
+ int len;
+{
+ int i;
+
+ for (i = 0; i < len; i++) {
+ printf("%02x ", addr[i]);
+ if (i != 0 && (i & 0xf) == 0)
+ printf("\n");
+ }
+ if (i != 0 && (i & 0xf) == 0)
+ printf("\n");
+}
+#endif
+
+int
+pcmcia_get_cf(pc_link, data, dlen, idx, pc_cf)
+ struct pcmcia_link *pc_link;
+ u_char *data;
+ int dlen, idx;
+ struct pcmcia_conf *pc_cf;
+{
+ u_char code, len, *tbuf, *endp;
+ int done;
+
+ endp = data + dlen;
+
+ done = 0;
+ while (!done && data < endp) {
+ code = *data++;
+ if (code == CIS_NULL) {
+ continue;
+ }
+ len = *data++;
+
+ tbuf = data;
+ data += len;
+ switch (code) {
+ case CIS_END:
+ done = 1;
+ break;
+ case CIS_CFG_INFO:
+ read_cfg_info(tbuf, len, pc_cf);
+ break;
+ case CIS_CFG_ENT:
+ if ((idx & CFGENTRYMASK) != CFGENTRYID ||
+ pc_cf->cfgid == 0)
+ parse_cfent(tbuf, len, idx, pc_cf);
+ break;
+ default:
+ break;
+ }
+ }
+ return 0;
+}
+
+
+int
+read_cfg_info(tbuf, len, pc_cf)
+ u_char *tbuf;
+ int len;
+ struct pcmcia_conf *pc_cf;
+{
+ int rasz, rmsz;
+
+ rasz = (tbuf[0] & TPCC_RASZ) >> TPCC_RASZ_SHIFT;
+ rmsz = (tbuf[0] & TPCC_RMSZ) >> TPCC_RMSZ_SHIFT;
+
+#ifdef CFG_DEBUG
+ printf("read_cfg_info\n");
+ dump(tbuf, len);
+#endif
+
+ pc_cf->cfg_off = 0;
+ switch (rasz) {
+ case 3:
+ pc_cf->cfg_off |= (tbuf[5] << 24);
+ case 2:
+ pc_cf->cfg_off |= (tbuf[4] << 16);
+ case 1:
+ pc_cf->cfg_off |= (tbuf[3] << 8);
+ case 0:
+ pc_cf->cfg_off |= tbuf[2];
+ }
+
+ tbuf += rasz + 3;
+ pc_cf->cfg_regmask = 0;
+ switch (rmsz & 3) {
+ case 3:
+ pc_cf->cfg_regmask |= (tbuf[3] << 24);
+ case 2:
+ pc_cf->cfg_regmask |= (tbuf[2] << 16);
+ case 1:
+ pc_cf->cfg_regmask |= (tbuf[1] << 8);
+ case 0:
+ pc_cf->cfg_regmask |= tbuf[0];
+ }
+}
+
+int
+parse_cfent(tbuf, len, slotid, pc_cf)
+ u_char *tbuf;
+ int len;
+ int slotid;
+ struct pcmcia_conf *pc_cf;
+{
+ int i, idx, defp, iop, io_16, ios, ftrs, intface, k;
+ int host_addr_p, addr_size, len_size;
+
+#ifdef CFG_DEBUG
+ printf("parse_cfent\n");
+ dump(tbuf, len);
+#endif
+
+ i = 0;
+ intface = (tbuf[i] & TPCE_INDX_INT);
+ idx = (tbuf[i] & TPCE_INDX_ENTRY);
+ defp = (tbuf[i] & TPCE_INDX_DEF);
+
+ if ((idx == slotid) || (defp && slotid!=-2 &&
+ (slotid & CFGENTRYMASK) == CFGENTRYMASK)) {
+ int j;
+ if (intface) {
+ i++;
+ pc_cf->iocard = (tbuf[i] & TPCE_IF_TYPE) == 1;
+ }
+ i++;
+ ftrs = tbuf[i++];
+ for (j = 0; j < (ftrs & TPCE_FS_PWR); j++) {
+ int pwr_desc = tbuf[i++];
+ /* for each struct, skip all parameter defns */
+ for (k = 0; k < 8; pwr_desc >>= 1, k++) {
+ if (pwr_desc & 0x01) {
+ /* skip bytes until non-ext found */
+ while (tbuf[i++] & 0x80)
+ continue;
+ }
+ }
+ }
+ /* TODO read timing info */
+ if (ftrs & TPCE_FS_TD) {
+#define BONE(a,b) (j & a) != 7 << b ? 1 : 0
+ int j = tbuf[i++];
+ i += ((j & TPCE_FS_TD_WAIT) != 3 ? 1 : 0);
+ i += BONE(TPCE_FS_TD_RDY,TPCE_FS_TD_RDY_SHIFT);
+ i += BONE(TPCE_FS_TD_RSV,TPCE_FS_TD_RSV_SHIFT);
+#undef BONE
+ }
+ if (ftrs & TPCE_FS_IO) {
+ int io_addrs[16], io_lens[16];
+ int io_16, io_block_len, io_block_size, io_lines;
+ int io_range;
+
+ iop = 1;
+ io_lines = tbuf[i] & TPCE_FS_IO_LINES;
+ io_16 = tbuf[i] & TPCE_FS_IO_BUS16;
+ io_range = tbuf[i] &TPCE_FS_IO_RANGE;
+ i++;
+ if (io_range) {
+ int iptr, ilen, elen;
+
+ io_block_len = (tbuf[i] & TPCE_FS_IO_LEN) >>
+ TPCE_FS_IO_LEN_SHIFT;
+ io_block_size = (tbuf[i] & TPCE_FS_IO_SIZE) >>
+ TPCE_FS_IO_SIZE_SHIFT;
+ ios = (tbuf[i] & TPCE_FS_IO_NUM) + 1;
+ i++;
+ if ((ftrs & TPCE_FS_IRQ) != 0) {
+ iptr=(ios * elen) + i;
+#define IRQTYPE (TPCE_FS_IRQ_PULSE|TPCE_FS_IRQ_LEVEL)
+#define IRQMASK TPCE_FS_IRQ_MASK
+ if ((tbuf[iptr] & IRQTYPE) == 0)
+ if ((tbuf[iptr-elen] &
+ IRQTYPE) != 0)
+ iptr -= elen;
+ if ((tbuf[iptr] & IRQMASK) != 0)
+ ilen = 2;
+ else
+ ilen=1;
+ }
+ else
+ ilen=0;
+
+ if ((i + (ios * elen) + ilen) > len) {
+ printf(
+"Warning: CIS range info doesn't fit in entry! Reducing # of ranges by 1\n");
+ ios--;
+ }
+
+ for (j = 0; j < ios; j++) {
+ io_addrs[j] = io_lens[j] = 0;
+ switch (io_block_size) {
+ case 3:
+ io_addrs[j] |= tbuf[i+3] << 24;
+ io_addrs[j] |= tbuf[i+2] << 16;
+ case 2:
+ io_addrs[j] |= tbuf[i+1] << 8;
+ case 1:
+ io_addrs[j] |= tbuf[i];
+ break;
+ }
+ pc_cf->io[j].start = io_addrs[j];
+ i += io_block_size +
+ (io_block_size == 3 ? 1 : 0);
+ switch (io_block_len) {
+ case 3:
+ io_lens[j] |= tbuf[i+3] << 24;
+ io_lens[j] |= tbuf[i+2] << 16;
+ case 2:
+ io_lens[j] |= tbuf[i+1] << 8;
+ case 1:
+ io_lens[j] |= tbuf[i];
+ break;
+ }
+ io_lens[j]++;
+ if(io_lens[j] & 1) {
+ printf(
+"Odd IO window length!! (Assuming incorrect CIS entry %d)\n", io_lens[j]);
+ io_lens[j]--;
+ }
+
+ pc_cf->io[j].len = io_lens[j];
+ pc_cf->io[j].flags = io_16 ?
+ PCMCIA_MAP_16 : PCMCIA_MAP_8;
+ i += io_block_len +
+ (io_block_len == 3 ? 1 : 0);
+ }
+ pc_cf->iowin = ios;
+ }
+ else {
+ pc_cf->iowin = 1;
+ pc_cf->io[0].len = 1 << io_lines;
+ pc_cf->io[0].start= 0 ;
+ pc_cf->io[0].flags = io_16 ?
+ PCMCIA_MAP_16 : PCMCIA_MAP_8;
+ }
+ }
+ if (ftrs & TPCE_FS_IRQ) {
+ int irq_mask, irqp, irq;
+ pc_cf->irq_level = (tbuf[i] & TPCE_FS_IRQ_LEVEL) != 0;
+ pc_cf->irq_pulse = (tbuf[i] & TPCE_FS_IRQ_PULSE) != 0;
+ pc_cf->irq_share = (tbuf[i] & TPCE_FS_IRQ_SHARE) != 0;
+ if (tbuf[i] & TPCE_FS_IRQ_MASK) {
+ pc_cf->irq_mask = (tbuf[i+2] << 8) + tbuf[i+1];
+ if (pc_cf->irq_mask & (1 << 2))
+ pc_cf->irq_mask |= 1 << 9;
+ i += 2;
+ } else {
+ pc_cf->irq_num = tbuf[i] & TPCE_FS_IRQ_IRQN;
+ pc_cf->irq_mask = -1;
+ }
+
+ i++;
+ }
+ if (ftrs & TPCE_FS_MEM) {
+ int memp, mems, mem_lens[16], mem_caddrs[16],
+ mem_haddrs[16];
+ memp = 1;
+ switch ((ftrs & TPCE_FS_MEM) >> TPCE_FS_MEM_SHIFT) {
+ case 1:
+ mems = 1;
+ mem_lens[0] = (tbuf[i+1] << 8) + tbuf[i];
+ mem_lens[0] <<= 8;
+
+ break;
+ case 2:
+ mems = 1;
+ mem_lens[0] = (tbuf[i+1] << 8) + tbuf[i];
+ mem_caddrs[0] = mem_haddrs[0] =
+ (tbuf[i+3] << 8) + tbuf[i+2];
+
+ mem_lens[0] <<= 8;
+ mem_caddrs[0] <<= 8;
+
+ break;
+ case 3:
+ host_addr_p = tbuf[i] & TPCE_FS_MEM_HOST;
+ addr_size = (tbuf[i] & TPCE_FS_MEM_ADDR) >>
+ TPCE_FS_MEM_ADDR_SHIFT;
+ len_size = (tbuf[i] & TPCE_FS_MEM_LEN) >>
+ TPCE_FS_MEM_LEN_SHIFT;
+ mems = (tbuf[i] & TPCE_FS_MEM_WINS) + 1;
+ i++;
+ for (j = 0; j < mems; j++) {
+ mem_lens[j] = 0;
+ mem_caddrs[j] = 0;
+ mem_haddrs[j] = 0;
+ switch (len_size) {
+ case 3:
+ mem_lens[j] |=
+ (tbuf[i+2] << 16);
+ case 2:
+ mem_lens[j] |=
+ (tbuf[i+1] << 8);
+ case 1:
+ mem_lens[j] |= tbuf[i];
+ }
+ i += len_size;
+ switch (addr_size) {
+ case 3:
+ mem_caddrs[j] |=
+ (tbuf[i+2] << 16);
+ case 2:
+ mem_caddrs[j] |=
+ (tbuf[i+1] << 8);
+ case 1:
+ mem_caddrs[j] |= tbuf[i];
+ }
+ i += addr_size;
+ if (host_addr_p) {
+ switch (addr_size) {
+ case 3:
+ mem_haddrs[j] |=
+ (tbuf[i+2] << 16);
+ case 2:
+ mem_haddrs[j] |=
+ (tbuf[i+1] << 8);
+ case 1:
+ mem_haddrs[j] |=
+ tbuf[i];
+ }
+ i += addr_size;
+ }
+ mem_lens[j] <<= 8;
+ mem_caddrs[j] <<= 8;
+ mem_haddrs[j] <<= 8;
+
+ }
+ }
+ for (j = 0; j < mems; j++) {
+ pc_cf->mem[j].len = mem_lens[j];
+ pc_cf->mem[j].caddr = mem_caddrs[j];
+ pc_cf->mem[j].start = mem_haddrs[j];
+ pc_cf->mem[j].flags = 0;
+ }
+ pc_cf->memwin = mems;
+ } else
+ pc_cf->memwin = 0;
+ return;
+ }
+
+
+ if (slotid == -2 ) {
+ /* find matching slotid */
+ struct pcmcia_conf tmp_cf;
+ /* get defaults */
+ parse_cfent(tbuf, len, -1, &tmp_cf);
+ /* change to selected */
+ parse_cfent(tbuf, len, idx, &tmp_cf);
+#ifdef CFG_DEBUG
+ printf("slotid %d %d iowin %d %d memwin %d %d wins %x %x %d %d\n",
+ pc_cf->iocard , tmp_cf.iocard,
+ pc_cf->iowin , tmp_cf.iowin,
+ pc_cf->memwin , tmp_cf.memwin,
+ pc_cf->io[0].start , tmp_cf.io[0].start,
+ pc_cf->io[0].len , tmp_cf.io[0].len
+ );
+#endif
+
+ if((pc_cf->iocard == tmp_cf.iocard) && /* same type */
+ (pc_cf->iowin == tmp_cf.iowin) &&
+ (pc_cf->memwin == tmp_cf.memwin)) {
+ int i;
+ for (i = 0; i < tmp_cf.iowin; i++)
+ if (pc_cf->io[i].len != tmp_cf.io[i].len ||
+ pc_cf->io[i].start != tmp_cf.io[i].start)
+ return;
+
+ for (i = 0; i < tmp_cf.memwin; i++)
+ if (pc_cf->mem[i].len!=tmp_cf.mem[i].len ||
+ pc_cf->mem[i].start!=tmp_cf.mem[i].start)
+ return;
+
+ /* *pc_cf = tmp_cf;/**/
+ pc_cf->cfgid = idx;
+ }
+ return;
+ }
+}
+
+void
+pcmcia_getstr(buf, pptr, end)
+ char *buf;
+ u_char **pptr;
+ u_char *end;
+{
+ u_char *ptr = *pptr;
+ char *eb = buf + MAX_CIS_NAMELEN - 1;
+
+ while (buf < eb && ptr < end)
+ switch (*ptr) {
+ case 0x00:
+ ptr++;
+ /*FALLTHROUGH*/
+ case 0xff:
+ *pptr = ptr;
+ *buf = '\0';
+ return;
+
+ default:
+ *buf++ = *ptr++;
+ break;
+ }
+ printf("Warning: Maximum CIS string length exceeded\n");
+ *buf = '\0';
+
+ /* Keep going until we find the end */
+ while (ptr < end)
+ switch (*ptr) {
+ case 0x00:
+ ptr++;
+ /*FALLTHROUGH*/
+ case 0xff:
+ *pptr = ptr;
+ return;
+
+ default:
+ ptr++;
+ break;
+ }
+
+ *pptr = ptr;
+}
+
+
+int
+pcmcia_get_cisver1(pc_link, data, len, manu, model, add_inf1, add_inf2)
+ struct pcmcia_link *pc_link;
+ u_char *data;
+ int len;
+ char *manu, *model, *add_inf1, *add_inf2;
+{
+ u_char *p, *end;
+
+ p = data;
+ end = data + len;
+ while ((*p != (u_char) 0xff) && (p < end)) {
+ int clen = *(p + 1);
+ int maj, min;
+ if (*p == CIS_VER1) {
+ u_char *pp = p + 2;
+ maj = *pp++;
+ min = *pp++;
+ if (maj != 4 || min != 1) {
+ printf("wrong version id %d.%d for card in slot %d\n",
+ maj, min, pc_link->slot);
+ return ENODEV;
+ }
+ pcmcia_getstr(manu, &pp, end);
+ pcmcia_getstr(model, &pp, end);
+ pcmcia_getstr(add_inf1, &pp, end);
+ pcmcia_getstr(add_inf2, &pp, end);
+ if (*pp != (u_char) 0xff) {
+ printf("WARNING: broken id for card in slot %d\n", pc_link->slot);
+ printf("manu %s model %s add_inf1 %s add_inf2 %s\n", manu, model, add_inf1, add_inf2);
+ return 0;
+ }
+ return 0;
+ }
+ p += clen + 2;
+ }
+ printf("%x %x\n", p, end);
+ return ENODEV;
+}
--- /dev/null
+/*
+ * Copyright (c) 1993, 1994 Stefan Grefen. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following dipclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by Charles Hannum.
+ * 4. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id: pcmciabus.h,v 1.1 1996/01/15 00:05:13 hvozda Exp $
+ */
+ /* derived from scsicconf.[ch] writenn by Julian Elischer et al */
+
+#ifndef _PCMCIA_PCMCIABUS_H_
+#define _PCMCIA_PCMCIABUS_H_ 1
+
+#include <sys/queue.h>
+#include <sys/select.h>
+#include <machine/cpu.h>
+
+/*
+ * The following documentation tries to describe the relationship between the
+ * various structures defined in this file:
+ *
+ * each adapter type has a pcmcia_adapter struct. This describes the adapter and
+ * identifies routines that can be called to use the adapter.
+ * each device type has a pcmcia_device struct. This describes the device and
+ * identifies routines that can be called to use the device.
+ * each existing device position (pcmciabus + port)
+ * can be described by a pcmcia_link struct.
+ * Only port positions that actually have devices, have a pcmcia_link
+ * structure assigned. so in effect each device has pcmcia_link struct.
+ * The pcmcia_link structure contains information identifying both the
+ * device driver and the adapter driver for that port on that pcmcia bus,
+ * and can be said to 'link' the two.
+ * each individual pcmcia bus has an array that points to all the pcmcia_link
+ * structs associated with that pcmcia bus. Slots with no device have
+ * a NULL pointer.
+ * each individual device also knows the address of it's own pcmcia_link
+ * structure.
+ *
+ * -------------
+ *
+ * The key to all this is the pcmcia_link structure which associates all the
+ * other structures with each other in the correct configuration. The
+ * pcmcia_link is the connecting information that allows each part of the
+ * pcmcia system to find the associated other parts.
+ */
+
+
+struct pcmcia_link;
+struct pcmcia_conf;
+struct pcmcia_adapter;
+
+/*
+ * These entrypoints are called by the high-end drivers to get services from
+ * whatever low-end drivers they are attached to each adapter type has one of
+ * these statically allocated.
+ */
+struct pcmcia_funcs {
+/* 4 map io range */
+ int (*pcmcia_map_io) __P((struct pcmcia_link *, u_int, u_int, int));
+/* 8 map memory window */
+ int (*pcmcia_map_mem) __P((struct pcmcia_link *, caddr_t,
+ u_int, u_int, int));
+/*12 map interrupt */
+ int (*pcmcia_map_intr) __P((struct pcmcia_link *, int, int));
+/*26 power on/off etc */
+ int (*pcmcia_service) __P((struct pcmcia_link *, int, void *, int));
+};
+
+struct pcmciabus_link { /* Link back to the bus we are on */
+ /* Bus specific configure */
+ int (*bus_config) __P((struct pcmcia_link *, struct device *,
+ struct pcmcia_conf *, struct cfdata *));
+ /* Bus specific unconfigure */
+ int (*bus_unconfig) __P((struct pcmcia_link *));
+ /* Bus specific probe */
+ int (*bus_probe) __P((struct device *, void *,
+ void *, struct pcmcia_link *));
+ /* Bus specific search */
+ int (*bus_search) __P((struct device *, void *, cfprint_t));
+ /* initialize scratch */
+ int (*bus_init) __P((struct device *, struct cfdata *,
+ void *, struct pcmcia_adapter *, int));
+};
+struct pcmcia_adapter {
+ struct pcmcia_funcs *chip_link;
+ struct pcmciabus_link *bus_link;
+ void * adapter_softc;
+ caddr_t scratch_mem; /* pointer to scratch window */
+ int scratch_memsiz; /* size of scratch window */
+ int scratch_inuse; /* window in use */
+};
+
+#define PCMCIA_MAP_ATTR 0x0100 /* for memory only */
+#define PCMCIA_MAP_8 0x0100 /* for io only */
+#define PCMCIA_MAP_16 0x0200
+#define PCMCIA_UNMAP 0x0400
+#define PCMCIA_PHYSICAL_ADDR 0x0800
+#define PCMCIA_UNMAP_ALL 0x0c00
+#define PCMCIA_FIXED_WIN 0x1000
+#define PCMCIA_LAST_WIN 0x0010
+#define PCMCIA_FIRST_WIN 0x0020
+#define PCMCIA_ANY_WIN 0x0030
+
+#define PCMCIA_OP_RESET 0x0000
+#define PCMCIA_OP_POWER 0x0001
+#define PCMCIA_OP_STATUS 0x0002
+#define PCMCIA_OP_GETREGS 0x0003
+#define PCMCIA_OP_WAIT 0x0004
+
+#define PCMCIA_POWER_ON 0x0001
+#define PCMCIA_POWER_5V 0x0002
+#define PCMCIA_POWER_3V 0x0004
+#define PCMCIA_POWER_AUTO 0x0008
+
+#define PCMCIA_CARD_PRESENT 0x0001
+#define PCMCIA_BATTERY 0x0002
+#define PCMCIA_WRITE_PROT 0x0004
+#define PCMCIA_READY 0x0008
+#define PCMCIA_POWER 0x0010
+#define PCMCIA_POWER_PP 0x0020
+#define PCMCIA_CARD_IS_MAPPED 0x1000
+#define PCMCIA_CARD_INUSE 0x2000
+
+
+/*
+ * This structure describes the connection between an adapter driver and
+ * a device driver, and is used by each to call services provided by
+ * the other, and to allow generic pcmcia glue code to call these services
+ * as well.
+ */
+struct pcmcia_link {
+ char pcmciabus; /* the Nth pcmciabus */
+ char slot; /* slot of this dev */
+ char flags;
+#define CARD_IS_MAPPED 0x01
+#define PCMCIA_ATTACH 0x02
+#define PCMCIA_REATTACH 0x04
+#define PCMCIA_SLOT_INUSE 0x08
+#define PCMCIA_ATTACH_TYPE (PCMCIA_ATTACH|PCMCIA_REATTACH)
+#define PCMCIA_SLOT_EVENT 0x80
+#define PCMCIA_SLOT_OPEN 0x40
+ char opennings;
+
+ char iowin;
+ char memwin;
+ char intr;
+ char dummy;
+ struct pcmcia_adapter *adapter; /* adapter entry points etc. */
+ struct pcmciadevs *device; /* device entry points etc. */
+ void *devp; /* pointer to configured device */
+ void *fordriver; /* for private use by the driver */
+ void *shuthook; /* shutdown hook handle */
+ struct selinfo pcmcialink_sel; /* for select users */
+};
+
+/*
+ * One of these is allocated and filled in for each pcmcia bus.
+ * it holds pointers to allow the pcmcia bus to get to the driver
+ * it also has a template entry which is the prototype struct
+ * supplied by the adapter driver, this is used to initialise
+ * the others, before they have the rest of the fields filled in
+ */
+struct pcmciabus_softc {
+ struct device sc_dev;
+ struct pcmcia_link *sc_link[8];
+};
+
+struct pcmcia_conf {
+ int irq_share:1;
+ int irq_level:1; /* 1 level */
+ int irq_pulse:1; /* 1 pulse */
+ int irq_vend:1;
+ int irq_iock:1;
+ int irq_berr:1;
+ int irq_nmi:1;
+ int iocard:1;
+ u_char iowin;
+ u_char memwin;
+ u_char irq_num;
+ u_char cfgtype;
+#define CFGENTRYID 0x20
+#define CFGENTRYMASK (CFGENTRYID|(CFGENTRYID-1))
+#define DOSRESET 0x40
+ int cfg_regmask;
+ int irq_mask;
+ int cfg_off;
+ struct iowin {
+ int start;
+ int len;
+ int flags;
+ }io[4];
+ struct memwin {
+ int start;
+ int caddr;
+ int len;
+ int flags;
+ }mem[4];
+ char driver_name[8][4]; /* up to four different functions on a card */
+ int unitid;
+ int cfgid;
+};
+
+struct pcmcia_device {
+ char *name;
+ int (*pcmcia_config) __P((struct pcmcia_link *, struct device *,
+ struct pcmcia_conf *, struct cfdata *));
+ int (*pcmcia_probe) __P((struct device *, void *,
+ void *, struct pcmcia_link *));
+ int (*pcmcia_insert) __P((struct pcmcia_link *, struct device *,
+ struct cfdata *));
+ int (*pcmcia_remove) __P((struct pcmcia_link *, struct device *));
+};
+
+struct pcmciadevs {
+ char *devname;
+ int flags; /* 1 show my comparisons during boot(debug) */
+#define PC_SHOWME 0x01
+ char *manufacturer;
+ char *model;
+ char *add_inf1;
+ char *add_inf2;
+ void *param;
+ struct pcmcia_device *dev;
+};
+
+#ifdef _KERNEL
+extern int pcmcia_add_device __P((struct pcmciadevs *));
+extern int pcmcia_get_cf __P((struct pcmcia_link *, u_char *, int, int,
+ struct pcmcia_conf *));
+extern int pcmcia_targmatch __P((struct device *, struct cfdata *, void *));
+#endif
+
+/* in pcmcia_conf.c, available for user space too: */
+extern int pcmcia_get_cisver1 __P((struct pcmcia_link *, u_char *, int,
+ char *, char *, char *, char *));
+int parse_cfent __P((u_char *, int, int, struct pcmcia_conf *));
+int read_cfg_info __P((u_char *, int, struct pcmcia_conf *));
+void pcmcia_getstr __P((char *buf, u_char **, u_char *));
+
+#endif /* _PCMCIA_PCMCIABUS_H_ */
projects / openbsd / commitdiff