Annotation of sys/arch/sparc/dev/ts102.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ts102.c,v 1.18 2006/08/11 18:57:35 miod Exp $ */
! 2: /*
! 3: * Copyright (c) 2003, 2004, Miodrag Vallat.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice, this list of conditions and the following disclaimer in the
! 12: * documentation and/or other materials provided with the distribution.
! 13: *
! 14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 15: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 16: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 17: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 18: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 19: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 20: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 21: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 22: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 23: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 24: * POSSIBILITY OF SUCH DAMAGE.
! 25: */
! 26:
! 27: /*
! 28: * Driver for the PCMCIA controller found in Tadpole SPARCbook 3 series
! 29: * notebooks.
! 30: *
! 31: * Based on the information provided in the SPARCbook 3 Technical Reference
! 32: * Manual (s3gxtrmb.pdf), chapter 7. A few ramblings against this document
! 33: * and/or the chip itself are scattered across this file.
! 34: *
! 35: * Implementation notes:
! 36: *
! 37: * - The TS102 exports its PCMCIA windows as SBus memory ranges: 64MB for
! 38: * the common memory window, and 16MB for the attribute and I/O windows.
! 39: *
! 40: * Mapping the whole windows would consume 192MB of address space, which
! 41: * is much more that what the iospace can offer.
! 42: *
! 43: * A best-effort solution would be to map the windows on demand. However,
! 44: * due to the way mapdev() works, the va used for the mappings would be
! 45: * lost after unmapping (although using an extent to register iospace memory
! 46: * usage would fix this). So, instead, we will do a fixed mapping of a subset
! 47: * of each window upon attach - this is similar to what the stp4020 driver
! 48: * does.
! 49: *
! 50: * - IPL for the cards interrupt handlers are not respected. See the stp4020
! 51: * driver source for comments about this.
! 52: *
! 53: * Endianness farce:
! 54: *
! 55: * - The documentation pretends that the endianness settings only affect the
! 56: * common memory window. Gee, thanks a lot. What about other windows, then?
! 57: * As a result, this driver runs with endianness conversions turned off.
! 58: *
! 59: * - One of the little-endian SBus and big-endian PCMCIA flags has the reverse
! 60: * meaning, actually. To achieve a ``no endianness conversion'' status,
! 61: * one has to be set and the other unset. It does not matter which one,
! 62: * though.
! 63: */
! 64:
! 65: #include <sys/param.h>
! 66: #include <sys/systm.h>
! 67: #include <sys/conf.h>
! 68: #include <sys/device.h>
! 69: #include <sys/kthread.h>
! 70: #include <sys/proc.h>
! 71: #include <sys/queue.h>
! 72:
! 73: #include <machine/bus.h>
! 74:
! 75: #include <uvm/uvm_extern.h>
! 76:
! 77: #include <dev/pcmcia/pcmciareg.h>
! 78: #include <dev/pcmcia/pcmciavar.h>
! 79: #include <dev/pcmcia/pcmciachip.h>
! 80:
! 81: #include <sparc/dev/sbusvar.h>
! 82: #include <sparc/dev/tctrlvar.h>
! 83: #include <sparc/dev/ts102reg.h>
! 84:
! 85: #define TS102_NUM_SLOTS 2
! 86:
! 87: /*
! 88: * Memory ranges
! 89: */
! 90: #define TS102_RANGE_COMMON 0
! 91: #define TS102_RANGE_ATTR 1
! 92: #define TS102_RANGE_IO 2
! 93:
! 94: #define TS102_RANGE_CNT 3
! 95: #define TS102_NUM_RANGES (TS102_RANGE_CNT * TS102_NUM_SLOTS)
! 96:
! 97: #define TS102_ARBITRARY_MAP_SIZE (1 * 1024 * 1024)
! 98:
! 99: struct tslot_softc;
! 100:
! 101: /*
! 102: * Per-slot data
! 103: */
! 104: struct tslot_data {
! 105: struct tslot_softc *td_parent;
! 106: struct device *td_pcmcia;
! 107:
! 108: volatile u_int8_t *td_regs;
! 109: struct rom_reg td_rr;
! 110: vaddr_t td_space[TS102_RANGE_CNT];
! 111:
! 112: /* Interrupt handler */
! 113: int (*td_intr)(void *);
! 114: void *td_intrarg;
! 115:
! 116: /* Socket status */
! 117: int td_slot;
! 118: int td_status;
! 119: #define TS_CARD 0x0001
! 120: };
! 121:
! 122: struct tslot_softc {
! 123: struct device sc_dev;
! 124:
! 125: struct intrhand sc_ih;
! 126:
! 127: pcmcia_chipset_tag_t sc_pct;
! 128:
! 129: struct proc *sc_thread; /* event thread */
! 130: unsigned int sc_events; /* sockets with pending events */
! 131:
! 132: struct tslot_data sc_slot[TS102_NUM_SLOTS];
! 133: };
! 134:
! 135: void tslot_attach(struct device *, struct device *, void *);
! 136: void tslot_create_event_thread(void *);
! 137: void tslot_event_thread(void *);
! 138: int tslot_intr(void *);
! 139: void tslot_intr_disestablish(pcmcia_chipset_handle_t, void *);
! 140: void *tslot_intr_establish(pcmcia_chipset_handle_t, struct pcmcia_function *,
! 141: int, int (*)(void *), void *, char *);
! 142: const char *tslot_intr_string(pcmcia_chipset_handle_t, void *);
! 143: int tslot_io_alloc(pcmcia_chipset_handle_t, bus_addr_t, bus_size_t,
! 144: bus_size_t, struct pcmcia_io_handle *);
! 145: void tslot_io_free(pcmcia_chipset_handle_t, struct pcmcia_io_handle *);
! 146: int tslot_io_map(pcmcia_chipset_handle_t, int, bus_addr_t, bus_size_t,
! 147: struct pcmcia_io_handle *, int *);
! 148: void tslot_io_unmap(pcmcia_chipset_handle_t, int);
! 149: int tslot_match(struct device *, void *, void *);
! 150: int tslot_mem_alloc(pcmcia_chipset_handle_t, bus_size_t,
! 151: struct pcmcia_mem_handle *);
! 152: void tslot_mem_free(pcmcia_chipset_handle_t, struct pcmcia_mem_handle *);
! 153: int tslot_mem_map(pcmcia_chipset_handle_t, int, bus_addr_t, bus_size_t,
! 154: struct pcmcia_mem_handle *, bus_size_t *, int *);
! 155: void tslot_mem_unmap(pcmcia_chipset_handle_t, int);
! 156: int tslot_print(void *, const char *);
! 157: void tslot_queue_event(struct tslot_softc *, int);
! 158: void tslot_reset(struct tslot_data *, u_int32_t);
! 159: void tslot_slot_disable(pcmcia_chipset_handle_t);
! 160: void tslot_slot_enable(pcmcia_chipset_handle_t);
! 161: void tslot_slot_intr(struct tslot_data *, int);
! 162:
! 163: struct cfattach tslot_ca = {
! 164: sizeof(struct tslot_softc), tslot_match, tslot_attach
! 165: };
! 166:
! 167: struct cfdriver tslot_cd = {
! 168: NULL, "tslot", DV_DULL
! 169: };
! 170:
! 171: /*
! 172: * PCMCIA chipset methods
! 173: */
! 174: struct pcmcia_chip_functions tslot_functions = {
! 175: tslot_mem_alloc,
! 176: tslot_mem_free,
! 177: tslot_mem_map,
! 178: tslot_mem_unmap,
! 179:
! 180: tslot_io_alloc,
! 181: tslot_io_free,
! 182: tslot_io_map,
! 183: tslot_io_unmap,
! 184:
! 185: tslot_intr_establish,
! 186: tslot_intr_disestablish,
! 187: tslot_intr_string,
! 188:
! 189: tslot_slot_enable,
! 190: tslot_slot_disable
! 191: };
! 192:
! 193: #define TSLOT_READ(slot, offset) \
! 194: *(volatile u_int16_t *)((slot)->td_regs + (offset))
! 195: #define TSLOT_WRITE(slot, offset, value) \
! 196: *(volatile u_int16_t *)((slot)->td_regs + (offset)) = (value)
! 197:
! 198: /*
! 199: * Attachment and initialization
! 200: */
! 201:
! 202: int
! 203: tslot_match(struct device *parent, void *vcf, void *aux)
! 204: {
! 205: struct confargs *ca = aux;
! 206:
! 207: return (strcmp("ts102", ca->ca_ra.ra_name) == 0);
! 208: }
! 209:
! 210: void
! 211: tslot_attach(struct device *parent, struct device *self, void *args)
! 212: {
! 213: struct confargs *ca = args;
! 214: struct tslot_softc *sc = (struct tslot_softc *)self;
! 215: struct romaux *ra;
! 216: struct rom_range ranges[TS102_NUM_RANGES], *range;
! 217: struct tslot_data *td;
! 218: volatile u_int8_t *regs;
! 219: int node, nranges, slot, rnum;
! 220:
! 221: ra = &ca->ca_ra;
! 222: node = ra->ra_node;
! 223: regs = mapiodev(&ra->ra_reg[0], 0, ra->ra_len);
! 224:
! 225: /*
! 226: * Find memory ranges
! 227: */
! 228: nranges = getproplen(node, "ranges") / sizeof(struct rom_range);
! 229: if (nranges < TS102_NUM_RANGES) {
! 230: printf(": expected %d memory ranges, got %d\n",
! 231: TS102_NUM_RANGES, nranges);
! 232: return;
! 233: }
! 234: getprop(node, "ranges", ranges, sizeof ranges);
! 235:
! 236: /*
! 237: * Ranges being relative to this sbus slot, turn them into absolute
! 238: * addresses.
! 239: */
! 240: for (rnum = 0; rnum < TS102_NUM_RANGES; rnum++) {
! 241: ranges[rnum].poffset -= TS102_OFFSET_REGISTERS;
! 242: }
! 243:
! 244: sc->sc_ih.ih_fun = tslot_intr;
! 245: sc->sc_ih.ih_arg = sc;
! 246: intr_establish(ra->ra_intr[0].int_pri, &sc->sc_ih, -1, self->dv_xname);
! 247: printf(" pri %d", ra->ra_intr[0].int_pri);
! 248:
! 249: printf(": %d slots\n", TS102_NUM_SLOTS);
! 250:
! 251: /*
! 252: * Setup asynchronous event handler
! 253: */
! 254: sc->sc_events = 0;
! 255: kthread_create_deferred(tslot_create_event_thread, sc);
! 256:
! 257: sc->sc_pct = (pcmcia_chipset_tag_t)&tslot_functions;
! 258:
! 259: /*
! 260: * Setup slots
! 261: */
! 262: for (slot = 0; slot < TS102_NUM_SLOTS; slot++) {
! 263: td = &sc->sc_slot[slot];
! 264: for (rnum = 0; rnum < TS102_RANGE_CNT; rnum++) {
! 265: range = ranges + (slot * TS102_RANGE_CNT + rnum);
! 266: td->td_rr = ra->ra_reg[0];
! 267: td->td_rr.rr_iospace = range->pspace;
! 268: td->td_rr.rr_paddr = (void *)
! 269: ((u_int32_t)td->td_rr.rr_paddr + range->poffset);
! 270: td->td_space[rnum] = (vaddr_t)mapiodev(&td->td_rr, 0,
! 271: TS102_ARBITRARY_MAP_SIZE);
! 272: }
! 273: td->td_parent = sc;
! 274: td->td_regs = regs +
! 275: slot * (TS102_REG_CARD_B_INT - TS102_REG_CARD_A_INT);
! 276: td->td_slot = slot;
! 277: SET_TAG_LITTLE_ENDIAN(&td->td_rr);
! 278: tslot_reset(td, TS102_ARBITRARY_MAP_SIZE);
! 279: }
! 280: }
! 281:
! 282: void
! 283: tslot_reset(struct tslot_data *td, u_int32_t iosize)
! 284: {
! 285: struct pcmciabus_attach_args paa;
! 286: int ctl, status;
! 287:
! 288: paa.paa_busname = "pcmcia";
! 289: paa.pct = (pcmcia_chipset_tag_t)td->td_parent->sc_pct;
! 290: paa.pch = (pcmcia_chipset_handle_t)td;
! 291: paa.iobase = 0;
! 292: paa.iosize = iosize;
! 293:
! 294: td->td_pcmcia = config_found(&td->td_parent->sc_dev, &paa, tslot_print);
! 295:
! 296: if (td->td_pcmcia == NULL) {
! 297: /*
! 298: * If no pcmcia attachment, power down the slot.
! 299: */
! 300: tslot_slot_disable((pcmcia_chipset_handle_t)td);
! 301: return;
! 302: }
! 303:
! 304: /*
! 305: * Initialize the slot
! 306: */
! 307:
! 308: ctl = TSLOT_READ(td, TS102_REG_CARD_A_CTL);
! 309: /* force low addresses */
! 310: ctl &= ~(TS102_CARD_CTL_AA_MASK | TS102_CARD_CTL_IA_MASK);
! 311: /* Put SBus and PCMCIA in their respective endian mode */
! 312: ctl |= TS102_CARD_CTL_SBLE; /* this is not what it looks like! */
! 313: ctl &= ~TS102_CARD_CTL_PCMBE;
! 314: /* disable read ahead and address increment */
! 315: ctl &= ~TS102_CARD_CTL_RAHD;
! 316: ctl |= TS102_CARD_CTL_INCDIS;
! 317: /* power on */
! 318: ctl &= ~TS102_CARD_CTL_PWRD;
! 319: TSLOT_WRITE(td, TS102_REG_CARD_A_CTL, ctl);
! 320:
! 321: /*
! 322: * Enable interrupt upon insertion/removal
! 323: */
! 324:
! 325: TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
! 326: TS102_CARD_INT_MASK_CARDDETECT_STATUS);
! 327:
! 328: status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
! 329: if (status & TS102_CARD_STS_PRES) {
! 330: tadpole_set_pcmcia(td->td_slot, 1);
! 331: td->td_status = TS_CARD;
! 332: pcmcia_card_attach(td->td_pcmcia);
! 333: } else {
! 334: tadpole_set_pcmcia(td->td_slot, 0);
! 335: td->td_status = 0;
! 336: }
! 337: }
! 338:
! 339: /* XXX there ought to be a common function for this... */
! 340: int
! 341: tslot_print(void *aux, const char *description)
! 342: {
! 343: struct pcmciabus_attach_args *paa = aux;
! 344: struct tslot_data *td = (struct tslot_data *)paa->pch;
! 345:
! 346: printf(" socket %d", td->td_slot);
! 347: return (UNCONF);
! 348: }
! 349:
! 350: /*
! 351: * PCMCIA Helpers
! 352: */
! 353:
! 354: int
! 355: tslot_io_alloc(pcmcia_chipset_handle_t pch, bus_addr_t start, bus_size_t size,
! 356: bus_size_t align, struct pcmcia_io_handle *pih)
! 357: {
! 358: struct tslot_data *td = (struct tslot_data *)pch;
! 359:
! 360: #ifdef TSLOT_DEBUG
! 361: printf("[io alloc %x-%x]", start, size);
! 362: #endif
! 363:
! 364: pih->iot = &td->td_rr;
! 365: pih->ioh = (bus_space_handle_t)(td->td_space[TS102_RANGE_IO]);
! 366: pih->addr = start;
! 367: pih->size = size;
! 368: pih->flags = 0;
! 369:
! 370: return (0);
! 371: }
! 372:
! 373: void
! 374: tslot_io_free(pcmcia_chipset_handle_t pch, struct pcmcia_io_handle *pih)
! 375: {
! 376: #ifdef TSLOT_DEBUG
! 377: printf("[io free %x-%x]", pih->start, pih->size);
! 378: #endif
! 379: }
! 380:
! 381: int
! 382: tslot_io_map(pcmcia_chipset_handle_t pch, int width, bus_addr_t offset,
! 383: bus_size_t size, struct pcmcia_io_handle *pih, int *windowp)
! 384: {
! 385: struct tslot_data *td = (struct tslot_data *)pch;
! 386:
! 387: #ifdef TSLOT_DEBUG
! 388: printf("[io map %x-%x", offset, size);
! 389: #endif
! 390:
! 391: pih->iot = &td->td_rr;
! 392: bus_space_subregion(&td->td_rr, td->td_space[TS102_RANGE_IO],
! 393: offset, size, &pih->ioh);
! 394: *windowp = TS102_RANGE_IO;
! 395:
! 396: #ifdef TSLOT_DEBUG
! 397: printf("->%p/%x]", pih->ioh, size);
! 398: #endif
! 399:
! 400: return (0);
! 401: }
! 402:
! 403: void
! 404: tslot_io_unmap(pcmcia_chipset_handle_t pch, int win)
! 405: {
! 406: #ifdef TSLOT_DEBUG
! 407: printf("[io unmap]");
! 408: #endif
! 409: }
! 410:
! 411: int
! 412: tslot_mem_alloc(pcmcia_chipset_handle_t pch, bus_size_t size,
! 413: struct pcmcia_mem_handle *pmh)
! 414: {
! 415: struct tslot_data *td = (struct tslot_data *)pch;
! 416:
! 417: #ifdef TSLOT_DEBUG
! 418: printf("[mem alloc %x]", size);
! 419: #endif
! 420: pmh->memt = &td->td_rr;
! 421: pmh->size = round_page(size);
! 422: pmh->addr = 0;
! 423: pmh->mhandle = 0;
! 424: pmh->realsize = 0; /* nothing so far! */
! 425:
! 426: return (0);
! 427: }
! 428:
! 429: void
! 430: tslot_mem_free(pcmcia_chipset_handle_t pch, struct pcmcia_mem_handle *pmh)
! 431: {
! 432: #ifdef TSLOT_DEBUG
! 433: printf("[mem free %x]", pmh->size);
! 434: #endif
! 435: }
! 436:
! 437: int
! 438: tslot_mem_map(pcmcia_chipset_handle_t pch, int kind, bus_addr_t addr,
! 439: bus_size_t size, struct pcmcia_mem_handle *pmh, bus_size_t *offsetp,
! 440: int *windowp)
! 441: {
! 442: struct tslot_data *td = (struct tslot_data *)pch;
! 443: int slot;
! 444:
! 445: slot = kind & PCMCIA_MEM_ATTR ? TS102_RANGE_ATTR : TS102_RANGE_COMMON;
! 446: #ifdef TSLOT_DEBUG
! 447: printf("[mem map %d %x-%x", slot, addr, size);
! 448: #endif
! 449:
! 450: addr += pmh->addr;
! 451:
! 452: pmh->memt = &td->td_rr;
! 453: bus_space_subregion(&td->td_rr, td->td_space[slot],
! 454: addr, size, &pmh->memh);
! 455: pmh->realsize = TS102_ARBITRARY_MAP_SIZE - addr;
! 456: *offsetp = 0;
! 457: *windowp = slot;
! 458:
! 459: #ifdef TSLOT_DEBUG
! 460: printf("->%p/%x]", pmh->memh, size);
! 461: #endif
! 462:
! 463: return (0);
! 464: }
! 465:
! 466: void
! 467: tslot_mem_unmap(pcmcia_chipset_handle_t pch, int win)
! 468: {
! 469: #ifdef TSLOT_DEBUG
! 470: printf("[mem unmap %d]", win);
! 471: #endif
! 472: }
! 473:
! 474: void
! 475: tslot_slot_disable(pcmcia_chipset_handle_t pch)
! 476: {
! 477: struct tslot_data *td = (struct tslot_data *)pch;
! 478:
! 479: #ifdef TSLOT_DEBUG
! 480: printf("%s: disable slot %d\n",
! 481: td->td_parent->sc_dev.dv_xname, td->td_slot);
! 482: #endif
! 483:
! 484: /*
! 485: * Disable card access.
! 486: */
! 487: TSLOT_WRITE(td, TS102_REG_CARD_A_STS,
! 488: TSLOT_READ(td, TS102_REG_CARD_A_STS) & ~TS102_CARD_STS_ACEN);
! 489:
! 490: /*
! 491: * Disable interrupts, except for insertion.
! 492: */
! 493: TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
! 494: TS102_CARD_INT_MASK_CARDDETECT_STATUS);
! 495: }
! 496:
! 497: void
! 498: tslot_slot_enable(pcmcia_chipset_handle_t pch)
! 499: {
! 500: struct tslot_data *td = (struct tslot_data *)pch;
! 501: int status, intr, i;
! 502:
! 503: #ifdef TSLOT_DEBUG
! 504: printf("%s: enable slot %d\n",
! 505: td->td_parent->sc_dev.dv_xname, td->td_slot);
! 506: #endif
! 507:
! 508: /* Power down the socket to reset it */
! 509: status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
! 510: TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status | TS102_CARD_STS_VCCEN);
! 511:
! 512: /*
! 513: * wait 300ms until power fails (Tpf). Then, wait 100ms since we
! 514: * are changing Vcc (Toff).
! 515: */
! 516: DELAY((300 + 100) * 1000);
! 517:
! 518: /*
! 519: * Power on the card if not already done, and enable card access
! 520: */
! 521: status |= TS102_CARD_STS_ACEN;
! 522: status &= ~TS102_CARD_STS_VCCEN;
! 523: TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status);
! 524:
! 525: /*
! 526: * wait 100ms until power raise (Tpr) and 20ms to become
! 527: * stable (Tsu(Vcc)).
! 528: */
! 529: DELAY((100 + 20) * 1000);
! 530:
! 531: status &= ~TS102_CARD_STS_VPP1_MASK;
! 532: status |= TS102_CARD_STS_VPP1_VCC;
! 533: TSLOT_WRITE(td, TS102_REG_CARD_A_STS, status);
! 534:
! 535: /*
! 536: * hold RESET at least 20us.
! 537: */
! 538: intr = TSLOT_READ(td, TS102_REG_CARD_A_INT);
! 539: TSLOT_WRITE(td, TS102_REG_CARD_A_INT, TS102_CARD_INT_SOFT_RESET);
! 540: DELAY(20);
! 541: TSLOT_WRITE(td, TS102_REG_CARD_A_INT, intr);
! 542:
! 543: /* wait 20ms as per pc card standard (r2.01) section 4.3.6 */
! 544: DELAY(20 * 1000);
! 545:
! 546: /* We need level-triggered interrupts for PC Card hardware */
! 547: TSLOT_WRITE(td, TS102_REG_CARD_A_STS,
! 548: TSLOT_READ(td, TS102_REG_CARD_A_STS) | TS102_CARD_STS_LVL);
! 549:
! 550: /*
! 551: * Wait until the card is unbusy. If it is still busy after 3 seconds,
! 552: * give up. We could enable card interrupts and wait for the interrupt
! 553: * to happen when BUSY is released, but the interrupt could also be
! 554: * triggered by the card itself if it's an I/O card, so better poll
! 555: * here.
! 556: */
! 557: for (i = 30000; i != 0; i--) {
! 558: status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
! 559: /* If the card has been removed, abort */
! 560: if ((status & TS102_CARD_STS_PRES) == 0) {
! 561: tslot_slot_disable(pch);
! 562: return;
! 563: }
! 564: if (status & TS102_CARD_STS_RDY)
! 565: break;
! 566: else
! 567: DELAY(100);
! 568: }
! 569:
! 570: if (i == 0) {
! 571: printf("%s: slot %d still busy after 3 seconds, status 0x%x\n",
! 572: td->td_parent->sc_dev.dv_xname, td->td_slot,
! 573: TSLOT_READ(td, TS102_REG_CARD_A_STS));
! 574: return;
! 575: }
! 576:
! 577: /*
! 578: * Enable the card interrupts if this is an I/O card.
! 579: * Note that the TS102_CARD_STS_IO bit in the status register will
! 580: * never get set, despite what the documentation says!
! 581: */
! 582: if (pcmcia_card_gettype(td->td_pcmcia) == PCMCIA_IFTYPE_IO) {
! 583: TSLOT_WRITE(td, TS102_REG_CARD_A_STS,
! 584: TSLOT_READ(td, TS102_REG_CARD_A_STS) | TS102_CARD_STS_IO);
! 585: TSLOT_WRITE(td, TS102_REG_CARD_A_INT,
! 586: TS102_CARD_INT_MASK_CARDDETECT_STATUS |
! 587: TS102_CARD_INT_MASK_IRQ);
! 588: }
! 589: }
! 590:
! 591: /*
! 592: * Event management
! 593: */
! 594: void
! 595: tslot_create_event_thread(void *v)
! 596: {
! 597: struct tslot_softc *sc = v;
! 598: const char *name = sc->sc_dev.dv_xname;
! 599:
! 600: if (kthread_create(tslot_event_thread, sc, &sc->sc_thread, "%s",
! 601: name) != 0) {
! 602: panic("%s: unable to create event kthread", name);
! 603: }
! 604: }
! 605:
! 606: void
! 607: tslot_event_thread(void *v)
! 608: {
! 609: struct tslot_softc *sc = v;
! 610: struct tslot_data *td;
! 611: int s, status;
! 612: unsigned int socket;
! 613:
! 614: for (;;) {
! 615: s = splhigh();
! 616:
! 617: if ((socket = ffs(sc->sc_events)) == 0) {
! 618: splx(s);
! 619: tsleep(&sc->sc_events, PWAIT, "tslot_event", 0);
! 620: continue;
! 621: }
! 622: socket--;
! 623: sc->sc_events &= ~(1 << socket);
! 624: splx(s);
! 625:
! 626: if (socket >= TS102_NUM_SLOTS) {
! 627: #ifdef DEBUG
! 628: printf("%s: invalid slot number %d\n",
! 629: sc->sc_dev.dv_xname, te->te_slot);
! 630: #endif
! 631: continue;
! 632: }
! 633:
! 634: td = &sc->sc_slot[socket];
! 635: status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
! 636:
! 637: if (status & TS102_CARD_STS_PRES) {
! 638: /* Card insertion */
! 639: if ((td->td_status & TS_CARD) == 0) {
! 640: td->td_status |= TS_CARD;
! 641: tadpole_set_pcmcia(td->td_slot, 1);
! 642: pcmcia_card_attach(td->td_pcmcia);
! 643: }
! 644: } else {
! 645: /* Card removal */
! 646: if ((td->td_status & TS_CARD) != 0) {
! 647: td->td_status &= ~TS_CARD;
! 648: tadpole_set_pcmcia(td->td_slot, 0);
! 649: pcmcia_card_detach(td->td_pcmcia,
! 650: DETACH_FORCE);
! 651: }
! 652: }
! 653: }
! 654: }
! 655:
! 656: /*
! 657: * Interrupt handling
! 658: */
! 659:
! 660: int
! 661: tslot_intr(void *v)
! 662: {
! 663: struct tslot_softc *sc = v;
! 664: struct tslot_data *td;
! 665: int intregs[TS102_NUM_SLOTS], *intreg;
! 666: int i, rc = 0;
! 667:
! 668: /*
! 669: * Scan slots, and acknowledge the interrupt if necessary first
! 670: */
! 671: for (i = 0; i < TS102_NUM_SLOTS; i++) {
! 672: td = &sc->sc_slot[i];
! 673: intreg = &intregs[i];
! 674: *intreg = TSLOT_READ(td, TS102_REG_CARD_A_INT);
! 675:
! 676: /*
! 677: * Acknowledge all interrupt situations at once, even if they
! 678: * did not occur.
! 679: */
! 680: if ((*intreg & (TS102_CARD_INT_STATUS_IRQ |
! 681: TS102_CARD_INT_STATUS_WP_STATUS_CHANGED |
! 682: TS102_CARD_INT_STATUS_BATTERY_STATUS_CHANGED |
! 683: TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED)) != 0) {
! 684: rc = 1;
! 685: TSLOT_WRITE(td, TS102_REG_CARD_A_INT, *intreg |
! 686: TS102_CARD_INT_RQST_IRQ |
! 687: TS102_CARD_INT_RQST_WP_STATUS_CHANGED |
! 688: TS102_CARD_INT_RQST_BATTERY_STATUS_CHANGED |
! 689: TS102_CARD_INT_RQST_CARDDETECT_STATUS_CHANGED);
! 690: }
! 691: }
! 692:
! 693: /*
! 694: * Invoke the interrupt handler for each slot
! 695: */
! 696: for (i = 0; i < TS102_NUM_SLOTS; i++) {
! 697: td = &sc->sc_slot[i];
! 698: intreg = &intregs[i];
! 699:
! 700: if ((*intreg & (TS102_CARD_INT_STATUS_IRQ |
! 701: TS102_CARD_INT_STATUS_WP_STATUS_CHANGED |
! 702: TS102_CARD_INT_STATUS_BATTERY_STATUS_CHANGED |
! 703: TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED)) != 0)
! 704: tslot_slot_intr(td, *intreg);
! 705: }
! 706:
! 707: return (rc);
! 708: }
! 709:
! 710: void
! 711: tslot_queue_event(struct tslot_softc *sc, int slot)
! 712: {
! 713: int s;
! 714:
! 715: s = splhigh();
! 716: sc->sc_events |= (1 << slot);
! 717: splx(s);
! 718: wakeup(&sc->sc_events);
! 719: }
! 720:
! 721: void
! 722: tslot_slot_intr(struct tslot_data *td, int intreg)
! 723: {
! 724: struct tslot_softc *sc = td->td_parent;
! 725: int status, sockstat;
! 726:
! 727: status = TSLOT_READ(td, TS102_REG_CARD_A_STS);
! 728: #ifdef TSLOT_DEBUG
! 729: printf("%s: interrupt on socket %d ir %x sts %x\n",
! 730: sc->sc_dev.dv_xname, td->td_slot, intreg, status);
! 731: #endif
! 732:
! 733: sockstat = td->td_status;
! 734:
! 735: /*
! 736: * The TS102 queues interrupt requests, and may trigger an interrupt
! 737: * for a condition the driver does not want to receive anymore (for
! 738: * example, after a card gets removed).
! 739: * Thus, only proceed if the driver is currently allowing a particular
! 740: * condition.
! 741: */
! 742:
! 743: if ((intreg & TS102_CARD_INT_STATUS_CARDDETECT_STATUS_CHANGED) != 0 &&
! 744: (intreg & TS102_CARD_INT_MASK_CARDDETECT_STATUS) != 0) {
! 745: tslot_queue_event(sc, td->td_slot);
! 746: #ifdef TSLOT_DEBUG
! 747: printf("%s: slot %d status changed from %d to %d\n",
! 748: sc->sc_dev.dv_xname, td->td_slot, sockstat, td->td_status);
! 749: #endif
! 750: /*
! 751: * Ignore extra interrupt bits, they are part of the change.
! 752: */
! 753: return;
! 754: }
! 755:
! 756: if ((intreg & TS102_CARD_INT_STATUS_IRQ) != 0 &&
! 757: (intreg & TS102_CARD_INT_MASK_IRQ) != 0) {
! 758: /* ignore interrupts if we have a pending state change */
! 759: if (sc->sc_events & (1 << td->td_slot))
! 760: return;
! 761:
! 762: if ((sockstat & TS_CARD) == 0) {
! 763: printf("%s: spurious interrupt on slot %d isr %x\n",
! 764: sc->sc_dev.dv_xname, td->td_slot, intreg);
! 765: return;
! 766: }
! 767:
! 768: if (td->td_intr != NULL) {
! 769: /*
! 770: * XXX There is no way to honour the interrupt handler
! 771: * requested IPL level...
! 772: */
! 773: (*td->td_intr)(td->td_intrarg);
! 774: }
! 775: }
! 776: }
! 777:
! 778: void
! 779: tslot_intr_disestablish(pcmcia_chipset_handle_t pch, void *ih)
! 780: {
! 781: struct tslot_data *td = (struct tslot_data *)pch;
! 782:
! 783: td->td_intr = NULL;
! 784: td->td_intrarg = NULL;
! 785: }
! 786:
! 787: const char *
! 788: tslot_intr_string(pcmcia_chipset_handle_t pch, void *ih)
! 789: {
! 790: if (ih == NULL)
! 791: return ("couldn't establish interrupt");
! 792: else
! 793: return (""); /* nothing for now */
! 794: }
! 795:
! 796:
! 797: void *
! 798: tslot_intr_establish(pcmcia_chipset_handle_t pch, struct pcmcia_function *pf,
! 799: int ipl, int (*handler)(void *), void *arg, char *xname)
! 800: {
! 801: struct tslot_data *td = (struct tslot_data *)pch;
! 802:
! 803: td->td_intr = handler;
! 804: td->td_intrarg = arg;
! 805:
! 806: return (td);
! 807: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ts102.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev