Driver for the pcmcia slots in the Tadpole SPARCbook machines.

Currently only tested with wi(4), and there are still some sporadic
"device timeout" issues left - your mileage may vary.

1 files changed, 768 insertions, 0 deletions

diff --git a/sys/arch/sparc/dev/ts102.c b/sys/arch/sparc/dev/ts102.c
new file mode 100644
index 00000000000..dfddc79ef96
--- /dev/null
+++ b/sys/arch/sparc/dev/ts102.c
@@ -0,0 +1,768 @@
+/*	$OpenBSD: ts102.c,v 1.1 2003/06/23 09:29:55 miod Exp $	*/
+/*
+ * Copyright (c) 2003, Miodrag Vallat.
+ *
+ * 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.
+ *
+ * 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.
+ */
+
+/*
+ * Driver for the PCMCIA controller found in Tadpole SPARCbook 3 series
+ * notebooks.
+ *
+ * Based on the information provided in the SPARCbook 3 Technical Reference
+ * Manual (s3gxtrmb.pdf), chapter 7.  A few ramblings against this document
+ * and/or the chip itself are scattered across this file.
+ *
+ * Implementation notes:
+ *
+ * - The TS102 exports its PCMCIA windows as SBus memory ranges: 64MB for
+ *   the common memory window, and 16MB for the attribute and I/O windows.
+ *
+ *   Mapping the whole windows would consume 192MB of address space, which
+ *   is much more that what the iospace can offer.
+ *
+ *   A best-effort solution would be to map the windows on demand. However,
+ *   due to the wap mapdev() works, the va used for the mappings would be
+ *   lost after unmapping (although using an extent to register iospace memory
+ *   usage would fix this). So, instead, we will do a fixed mapping of a subset
+ *   of each window upon attach - this is similar to what the stp4020 driver
+ *   does.
+ *
+ * - IPL for the cards interrupt handles are not respected. See the stp4020
+ *   driver source for comments about this.
+ * 
+ * Endianness farce:
+ *
+ * - The documentation pretends that the endianness settings only affect the
+ *   common memory window. Gee, thanks a lot. What about other windows, then?
+ *   As a result, this driver runs with endianness conversions turned off.
+ *
+ * - One of the little-endian SBus and big-endian PCMCIA flags has the reverse
+ *   meaning, actually. To achieve a ``no endianness conversion'' status,
+ *   one has to be set and the other unset. It does not matter which one,
+ *   though.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/conf.h>
+#include <sys/device.h>
+#include <sys/kthread.h>
+#include <sys/malloc.h>
+#include <sys/proc.h>
+#include <sys/queue.h>
+
+#include <machine/bus.h>
+
+#include <uvm/uvm_extern.h>
+
+#include <dev/pcmcia/pcmciareg.h>
+#include <dev/pcmcia/pcmciavar.h>
+#include <dev/pcmcia/pcmciachip.h>
+
+#include <sparc/dev/sbusvar.h>
+#include <sparc/dev/ts102reg.h>
+
+#define	TS102_NUM_SLOTS		2
+
+/*
+ * Memory ranges
+ */
+#define	TS102_RANGE_COMMON	0
+#define	TS102_RANGE_ATTR	1
+#define	TS102_RANGE_IO		2
+
+#define	TS102_RANGE_CNT		3
+#define	TS102_NUM_RANGES	(TS102_RANGE_CNT * TS102_NUM_SLOTS)
+
+#define	TS102_ARBITRARY_MAP_SIZE	(1 * 1024 * 1024)
+
+struct	tslot_softc;
+
+/*
+ * Slot event structure
+ */
+struct	tslot_event {
+	SIMPLEQ_ENTRY(tslot_event) te_q;
+	int	te_what;
+	int	te_slot;
+};
+
+#define	TSLOT_EVENT_INSERT	0
+#define	TSLOT_EVENT_REMOVE	1
+
+const char *tslot_event_descr[] = {
+	"insertion",
+	"removal"
+};
+
+/*
+ * Per-slot data
+ */
+struct	tslot_data {
+	struct tslot_softc	*td_parent;
+	struct device		*td_pcmcia;
+
+	volatile u_int8_t	*td_regs;
+	vaddr_t			td_space[TS102_RANGE_CNT];
+
+	/* Interrupt handler */
+	int			(*td_intr)(void *);
+	void			*td_intrarg;
+
+	/* Socket status */
+	int			td_slot;
+	int			td_status;
+#define	TS_UNKNOWN	-1
+#define	TS_EMPTY	0
+#define	TS_CARD		1
+};
+
+struct	tslot_softc {
+	struct device	sc_dev;
+	struct sbusdev	sc_sd;
+
+	struct intrhand	sc_ih;
+	
+	pcmcia_chipset_tag_t sc_pct;
+
+	struct proc	*sc_thread;			/* event thread */
+	SIMPLEQ_HEAD(, tslot_event) sc_events;
+
+	struct tslot_data sc_slot[TS102_NUM_SLOTS];
+};
+
+void	tslot_attach(struct device *, struct device *, void *);
+void	tslot_create_event_thread(void *);
+void	tslot_event_thread(void *);
+int	tslot_intr(void *);
+void	tslot_intr_disestablish(pcmcia_chipset_handle_t, void *);
+void	*tslot_intr_establish(pcmcia_chipset_handle_t, struct pcmcia_function *,
+    int, int (*)(void *), void *, char *);
+int	tslot_io_alloc(pcmcia_chipset_handle_t, bus_addr_t, bus_size_t,
+    bus_size_t, struct pcmcia_io_handle *);
+void	tslot_io_free(pcmcia_chipset_handle_t, struct pcmcia_io_handle *);
+int	tslot_io_map(pcmcia_chipset_handle_t, int, bus_addr_t, bus_size_t,
+    struct pcmcia_io_handle *, int *);
+void	tslot_io_unmap(pcmcia_chipset_handle_t, int);
+int	tslot_match(struct device *, void *, void *);
+int	tslot_mem_alloc(pcmcia_chipset_handle_t, bus_size_t,
+    struct pcmcia_mem_handle *);
+void	tslot_mem_free(pcmcia_chipset_handle_t, struct pcmcia_mem_handle *);
+int	tslot_mem_map(pcmcia_chipset_handle_t, int, bus_addr_t, bus_size_t,
+    struct pcmcia_mem_handle *, bus_addr_t *, int *);
+void	tslot_mem_unmap(pcmcia_chipset_handle_t, int);
+int	tslot_print(void *, const char *);
+int	tslot_queue_event(struct tslot_softc *, int, int);
+void	tslot_reset(struct tslot_data *, u_int32_t);
+void	tslot_slot_disable(pcmcia_chipset_handle_t);
+void	tslot_slot_enable(pcmcia_chipset_handle_t);
+void	tslot_slot_intr(struct tslot_data *, int);
+
+struct	cfattach tslot_ca = {
+	sizeof(struct tslot_softc), tslot_match, tslot_attach
+};
+
+struct	cfdriver tslot_cd = {
+	NULL, "tslot", DV_DULL
+};
+
+/*
+ * PCMCIA chipset methods
+ */
+struct	pcmcia_chip_functions tslot_functions = {
+	tslot_mem_alloc,
+	tslot_mem_free,
+	tslot_mem_map,
+	tslot_mem_unmap,
+
+	tslot_io_alloc,
+	tslot_io_free,
+	tslot_io_map,
+	tslot_io_unmap,
+
+	tslot_intr_establish,
+	tslot_intr_disestablish,
+
+	tslot_slot_enable,
+	tslot_slot_disable
+};
+
+#define	TSLOT_READ(slot, offset) \
+	*(volatile u_int16_t *)((slot)->td_regs + (offset))
+#define	TSLOT_WRITE(slot, offset, value) \
+	*(volatile u_int16_t *)((slot)->td_regs + (offset)) = (value)
+
+/*
+ * Attachment and initialization
+ */
+
+int
+tslot_match(struct device *parent, void *vcf, void *aux)
+{
+	struct confargs *ca = aux;
+
+	return (strcmp("ts102", ca->ca_ra.ra_name) == 0);
+}
+
+void
+tslot_attach(struct device *parent, struct device *self, void *args)
+{
+	struct confargs *ca = args;
+	struct tslot_softc *sc = (struct tslot_softc *)self;
+	struct romaux *ra;
+	struct rom_reg reg;
+	struct rom_range ranges[TS102_NUM_RANGES], *range;
+	struct tslot_data *td;
+	volatile u_int8_t *regs;
+	int node, nranges, slot, rnum;
+
+	ra = &ca->ca_ra;
+	node = ra->ra_node;
+	regs = mapiodev(&ra->ra_reg[0], 0, ra->ra_len);
+
+	/*
+	 * Find memory ranges
+	 */
+	nranges = getproplen(node, "ranges") / sizeof(struct rom_range);
+	if (nranges < TS102_NUM_RANGES) {
+		printf(": expected %d memory ranges, got %d\n",
+		    TS102_NUM_RANGES, nranges);
+		return;
+	}
+	getprop(node, "ranges", ranges, sizeof ranges);
+
+	/*
+	 * Ranges being relative to this sbus slot, turn them into absolute
+	 * addresses.
+	 */
+	for (rnum = 0; rnum < TS102_NUM_RANGES; rnum++) {
+		ranges[rnum].poffset -= TS102_OFFSET_REGISTERS;
+	}
+
+	sc->sc_ih.ih_fun = tslot_intr;
+	sc->sc_ih.ih_arg = sc;
+	intr_establish(ra->ra_intr[0].int_pri, &sc->sc_ih, -1);
+	printf(" pri %d", ra->ra_intr[0].int_pri);
+
+	sbus_establish(&sc->sc_sd, self);
+
+	printf(": %d slots\n", TS102_NUM_SLOTS);
+
+	/*
+	 * Setup asynchronous event handler
+	 */
+	SIMPLEQ_INIT(&sc->sc_events);
+	kthread_create_deferred(tslot_create_event_thread, sc);
+
+	sc->sc_pct = (pcmcia_chipset_tag_t)&tslot_functions;
+
+	/*
+	 * Setup slots
+	 */
+	for (slot = 0; slot < TS102_NUM_SLOTS; slot++) {
+		td = &sc->sc_slot[slot];
+		for (rnum = 0; rnum < TS102_RANGE_CNT; rnum++) {
+			range = ranges + (slot * TS102_RANGE_CNT + rnum);
+			reg = ra->ra_reg[0];
+			reg.rr_iospace = range->pspace;
+			reg.rr_paddr = (void *)
+			   ((u_int32_t)reg.rr_paddr + range->poffset);
+			td->td_space[rnum] = (vaddr_t)mapiodev(&reg, 0,
+			    TS102_ARBITRARY_MAP_SIZE);
+		}
+		td->td_parent = sc;
+		td->td_regs = regs +
+		    slot * (TS102_REG_CARD_B_INT - TS102_REG_CARD_A_INT);
+		td->td_slot = slot;
+		tslot_reset(td, TS102_ARBITRARY_MAP_SIZE);
+	}
+}
+
+void
+tslot_reset(struct tslot_data *td, u_int32_t iosize)
+{
+	struct pcmciabus_attach_args paa;
+	int ctl;
+
+	paa.paa_busname = "pcmcia";
+	paa.pct = (pcmcia_chipset_tag_t)td->td_parent->sc_pct;
+	paa.pch = (pcmcia_chipset_handle_t)td;
+	paa.iobase = 0;
+	paa.iosize = iosize;
+
+	td->td_pcmcia = config_found(&td->td_parent->sc_dev, &paa, tslot_print);
+
+	if (td->td_pcmcia == NULL) {
+		/*
+		 * If no pcmcia attachment, power down the slot.
+		 */
+		tslot_slot_disable((pcmcia_chipset_handle_t)td);
+		return;
+	}
+
+	/*
+	 * Reset slot and initialize it
+	 */
+
+	TSLOT_WRITE(td, TS102_REG_CARD_A_INT, TS102_CARD_INT_SOFT_RESET);
+
+	ctl = TSLOT_READ(td, TS102_REG_CARD_A_CTL);
+	/* force low addresses */
+	ctl &= ~(TS102_CARD_CTL_AA_MASK | TS102_CARD_CTL_IA_MASK);
+	/* Put SBus and PCMCIA in their respective endian mode */
+	ctl |= TS102_CARD_CTL_SBLE;	/* this is not what it looks like! */
+	ctl &= ~TS102_CARD_CTL_PCMBE;
+	/* disable read ahead and address increment */
+	ctl &= ~TS102_CARD_CTL_RAHD;
+	ctl &= ~TS102_CARD_CTL_INCDIS;
+	/* power on */
+	ctl &= ~TS102_CARD_CTL_PWRD;
+	TSLOT_WRITE(td, TS102_REG_CARD_A_CTL, ctl);
+
+	/*
+	 * Enable interrupt upon insertion/removal
+	 */
+
+	TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
+	    TS102_CARD_INT_MASK_CARDDETECT_STATUS);
+
+	/*
+	 * Force immediate probe - this will depend on the worker
+	 * thread, so will not really happen until interrupts are enabled,
+	 * which is exactly what we need.
+	 */
+	td->td_status = TS_UNKNOWN;
+	tslot_slot_intr(td, TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED);
+}
+
+/* XXX there ought to be a common function for this... */
+int
+tslot_print(void *aux, const char *description)
+{
+	struct pcmciabus_attach_args *paa = aux;
+	struct tslot_data *td = (struct tslot_data *)paa->pch;
+
+	printf(" socket %d", td->td_slot);
+	return (UNCONF);
+}
+
+/*
+ * PCMCIA Helpers
+ */
+
+int
+tslot_io_alloc(pcmcia_chipset_handle_t pch, bus_addr_t start, bus_size_t size,
+    bus_size_t align, struct pcmcia_io_handle *pih)
+{
+#ifdef TSLOT_DEBUG
+	printf("[io alloc %x]", size);
+#endif
+
+	pih->iot = 0;
+	pih->ioh = 0;
+	pih->addr = start;
+	pih->size = size;
+	pih->flags = 0;
+
+	return (0);
+}
+
+void
+tslot_io_free(pcmcia_chipset_handle_t pch, struct pcmcia_io_handle *pih)
+{
+#ifdef TSLOT_DEBUG
+	printf("[io free]");
+#endif
+}
+
+int
+tslot_io_map(pcmcia_chipset_handle_t pch, int width, bus_addr_t offset,
+    bus_size_t size, struct pcmcia_io_handle *pih, int *windowp)
+{
+	struct tslot_data *td = (struct tslot_data *)pch;
+
+#ifdef TSLOT_DEBUG
+	printf("[io map %x-%x", offset, size);
+#endif
+
+	pih->iot = 0;
+	pih->ioh = (bus_space_handle_t)(td->td_space[TS102_RANGE_IO]);
+	*windowp = TS102_RANGE_IO;
+
+#ifdef TSLOT_DEBUG
+	printf("->%p/%x]", pih->ioh, size);
+#endif
+
+	return (0);
+}
+
+void
+tslot_io_unmap(pcmcia_chipset_handle_t pch, int win)
+{
+#ifdef TSLOT_DEBUG
+	printf("[io unmap]");
+#endif
+}
+
+int
+tslot_mem_alloc(pcmcia_chipset_handle_t pch, bus_size_t size,
+    struct pcmcia_mem_handle *pmh)
+{
+#ifdef TSLOT_DEBUG
+	printf("[mem alloc %x]", size);
+#endif
+	pmh->memt = 0;
+	pmh->size = round_page(size);
+	pmh->addr = 0;
+	pmh->mhandle = 0;
+	pmh->realsize = 0;	/* nothing so far! */
+
+	return (0);
+}
+
+void
+tslot_mem_free(pcmcia_chipset_handle_t pch, struct pcmcia_mem_handle *pmh)
+{
+#ifdef TSLOT_DEBUG
+	printf("[mem free]");
+#endif
+}
+
+int
+tslot_mem_map(pcmcia_chipset_handle_t pch, int kind, bus_addr_t addr,
+    bus_size_t size, struct pcmcia_mem_handle *pmh, bus_addr_t *offsetp,
+    int *windowp)
+{
+	struct tslot_data *td = (struct tslot_data *)pch;
+	int slot;
+
+	slot = kind & PCMCIA_MEM_ATTR ? TS102_RANGE_ATTR : TS102_RANGE_COMMON;
+#ifdef TSLOT_DEBUG
+	printf("[mem map %d %x-%x", slot, addr, size);
+#endif
+
+	addr += pmh->addr;
+
+	pmh->memt = 0;
+	pmh->memh = (bus_space_handle_t)(td->td_space[slot] + addr);
+	pmh->realsize = TS102_ARBITRARY_MAP_SIZE - addr;
+	*offsetp = 0;
+	*windowp = slot;
+
+#ifdef TSLOT_DEBUG
+	printf("->%p/%x]", pmh->memh, size);
+#endif
+
+	return (0);
+}
+
+void
+tslot_mem_unmap(pcmcia_chipset_handle_t pch, int win)
+{
+#ifdef TSLOT_DEBUG
+	printf("[mem unmap %d]", win);
+#endif
+}
+
+void
+tslot_slot_disable(pcmcia_chipset_handle_t pch)
+{
+	struct tslot_data *td = (struct tslot_data *)pch;
+#ifdef TSLOT_DEBUG
+	printf("%s: disable slot %d\n",
+	    td->td_parent->sc_dev.dv_xname, td->td_slot);
+#endif
+
+	/*
+	 * Disable card access.
+	 */
+	TSLOT_WRITE(td, TS102_REG_CARD_A_STS,
+	    TSLOT_READ(td, TS102_REG_CARD_A_STS) & ~TS102_CARD_STS_ACEN);
+
+	/*
+	 * Disable interrupts, except for insertion.
+	 */
+	TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
+	    TS102_CARD_INT_MASK_CARDDETECT_STATUS);
+}
+
+void
+tslot_slot_enable(pcmcia_chipset_handle_t pch)
+{
+	struct tslot_data *td = (struct tslot_data *)pch;
+	int status, i;
+#ifdef TSLOT_DEBUG
+	printf("%s: enable slot %d\n",
+	    td->td_parent->sc_dev.dv_xname, td->td_slot);
+#endif
+
+	/*
+	 * Power on the card if not already done, and enable card access
+	 */
+	status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
+	status |= TS102_CARD_STS_ACEN;
+	status &= ~TS102_CARD_STS_VCCEN;
+	TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status);
+	DELAY(200 * 1000);
+
+	/*
+	 * Wait until the card is unbusy. If it is still busy after 3 seconds,
+	 * give up. We could enable card interrupts and wait for the interrupt
+	 * to happen when BUSY is released, but the interrupt could also be
+	 * triggered by the card itself if it's an I/O card, so better poll
+	 * here.
+	 */
+	for (i = 30000; i != 0; i--) {
+		if (TSLOT_READ(td, TS102_REG_CARD_A_STS) & TS102_CARD_STS_RDY)
+			break;
+		else
+			DELAY(100);
+	}
+
+	if (i == 0) {
+		printf("%s: slot %d still busy after 3 seconds, status 0x%x\n",
+		    td->td_parent->sc_dev.dv_xname, td->td_slot,
+		    TSLOT_READ(td, TS102_REG_CARD_A_STS));
+		return;
+	}
+
+	/*
+	 * Enable the card interrupts if this is an I/O card.
+	 * Note that the TS102_CARD_STS_IO bit in the status register will
+	 * never get set, despite what the documentation says!
+	 */
+	if (pcmcia_card_gettype(td->td_pcmcia) == PCMCIA_IFTYPE_IO) {
+		TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
+		    TS102_CARD_INT_MASK_CARDDETECT_STATUS |
+		    TS102_CARD_INT_MASK_IRQ);
+	}
+}
+
+/*
+ * Event management
+ */
+void
+tslot_create_event_thread(void *v)
+{
+	struct tslot_softc *sc = v;
+	const char *name = sc->sc_dev.dv_xname;
+
+	if (kthread_create(tslot_event_thread, sc, &sc->sc_thread, "%s",
+	    name) != 0) {
+		panic("%s: unable to create event kthread", name);
+	}
+}
+
+void
+tslot_event_thread(void *v)
+{
+	struct tslot_softc *sc = v;
+	struct tslot_data *td;
+	struct tslot_event *te;
+	int s;
+
+	for (;;) {
+		s = splhigh();
+
+		if ((te = SIMPLEQ_FIRST(&sc->sc_events)) == NULL) {
+			splx(s);
+			tsleep(&sc->sc_events, PWAIT, "tslot_event", 0);
+			continue;
+		}
+
+		SIMPLEQ_REMOVE_HEAD(&sc->sc_events, te, te_q);
+		splx(s);
+
+		if (te->te_slot >= TS102_NUM_SLOTS) {
+			printf("%s: invalid slot number %d\n",
+			    sc->sc_dev.dv_xname, te->te_slot);
+		} else {
+			td = &sc->sc_slot[te->te_slot];
+			switch (te->te_what) {
+			case TSLOT_EVENT_INSERT:
+				pcmcia_card_attach(td->td_pcmcia);
+				break;
+			case TSLOT_EVENT_REMOVE:
+				pcmcia_card_detach(td->td_pcmcia, DETACH_FORCE);
+				break;
+			default:
+				printf("%s: invalid event type %d on slot %d\n",
+				    sc->sc_dev.dv_xname,
+				    te->te_slot, te->te_what);
+			}
+		}
+		free(te, M_TEMP);
+	}
+}
+
+/*
+ * Interrupt handling
+ */
+
+int
+tslot_intr(void *v)
+{
+	struct tslot_softc *sc = v;
+	struct tslot_data *td;
+	int intregs[TS102_NUM_SLOTS], *intreg;
+	int i, rc = 0;
+
+	/*
+	 * Scan slots, and acknowledge the interrupt if necessary first
+	 */
+	for (i = 0; i < TS102_NUM_SLOTS; i++) {
+		td = &sc->sc_slot[i];
+		intreg = &intregs[i];
+		*intreg = TSLOT_READ(td, TS102_REG_CARD_A_INT);
+
+		/*
+		 * Acknowledge all interrupt situations at once, even if they
+		 * did not occur.
+		 */
+		if ((*intreg & (TS102_CARD_INT_STATUS_IRQ |
+		    TS102_CARD_INT_STATUS_WP_STATUS_CHANGED |
+		    TS102_CARD_INT_STATUS_BATTERY_STATUS_CHANGED |
+		    TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED)) != 0) {
+			rc = 1;
+			TSLOT_WRITE(td, TS102_REG_CARD_A_INT, *intreg |
+			    TS102_CARD_INT_RQST_IRQ |
+			    TS102_CARD_INT_RQST_WP_STATUS_CHANGED |
+			    TS102_CARD_INT_RQST_BATTERY_STATUS_CHANGED |
+			    TS102_CARD_INT_RQST_CARDDETECT_STATUS_CHANGED);
+		}
+	}
+
+	/*
+	 * Invoke the interrupt handler for each slot
+	 */
+	for (i = 0; i < TS102_NUM_SLOTS; i++) {
+		td = &sc->sc_slot[i];
+		intreg = &intregs[i];
+
+		if ((*intreg & (TS102_CARD_INT_STATUS_IRQ |
+		    TS102_CARD_INT_STATUS_WP_STATUS_CHANGED |
+		    TS102_CARD_INT_STATUS_BATTERY_STATUS_CHANGED |
+		    TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED)) != 0)
+			tslot_slot_intr(td, *intreg);
+	}
+
+	return (rc);
+}
+
+int
+tslot_queue_event(struct tslot_softc *sc, int slot, int what)
+{
+	struct tslot_event *te;
+	int s;
+
+	te = malloc(sizeof(*te), M_TEMP, M_NOWAIT);
+	if (te == NULL) {
+		printf("%s: %s event lost on slot %d\n",
+		    sc->sc_dev.dv_xname, tslot_event_descr[what], slot);
+		return (ENOMEM);
+	}
+
+	te->te_what = what;
+	te->te_slot = slot;
+	s = splhigh();
+	SIMPLEQ_INSERT_TAIL(&sc->sc_events, te, te_q);
+	splx(s);
+	wakeup(&sc->sc_events);
+
+	return (0);
+}
+
+void
+tslot_slot_intr(struct tslot_data *td, int intreg)
+{
+	int status, sockstat;
+
+	status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
+#ifdef TSLOT_DEBUG
+	printf("%s: interrupt on socket %d ir %x sts %x\n",
+	    td->td_parent->sc_dev.dv_xname, td->td_slot, intreg, status);
+#endif
+
+	sockstat = td->td_status;
+
+	if (intreg & TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED) {
+		if (status & TS102_CARD_STS_PRES) {
+			if (sockstat != TS_CARD) {
+				if (tslot_queue_event(td->td_parent,
+				    td->td_slot, TSLOT_EVENT_INSERT) == 0)
+					td->td_status = TS_CARD;
+			}
+		} else {
+			if (sockstat != TS_EMPTY &&
+			    tslot_queue_event(td->td_parent, td->td_slot,
+			      TSLOT_EVENT_REMOVE) == 0)
+				td->td_status = TS_EMPTY;
+		}
+#ifdef TSLOT_DEBUG
+		printf("%s: slot %d status changed from %d to %d\n",
+		    td->td_parent->sc_dev.dv_xname,
+		    td->td_slot, sockstat, td->td_status);
+#endif
+		/*
+		 * Ignore extra interrupt bits, they are part of the change.
+		 */
+		return;
+	}
+
+	if (intreg & TS102_CARD_INT_STATUS_IRQ) {
+		if (sockstat != TS_CARD) {
+			printf("%s: spurious interrupt on slot %d\n",
+			    td->td_parent->sc_dev.dv_xname, td->td_slot);
+			return;
+		}
+
+		if (td->td_intr != NULL) {
+			/*
+			 * XXX There is no way to honour the interrupt handler
+			 * requested IPL level...
+			 */
+			(*td->td_intr)(td->td_intrarg);
+		}
+	}
+}
+
+void
+tslot_intr_disestablish(pcmcia_chipset_handle_t pch, void *ih)
+{
+	struct tslot_data *td = (struct tslot_data *)pch;
+
+	td->td_intr = NULL;
+	td->td_intrarg = NULL;
+}
+
+void *
+tslot_intr_establish(pcmcia_chipset_handle_t pch, struct pcmcia_function *pf,
+    int ipl, int (*handler)(void *), void *arg, char *xname)
+{
+	struct tslot_data *td = (struct tslot_data *)pch;
+
+	td->td_intr = handler;
+	td->td_intrarg = arg;
+
+	return (td);
+}