Annotation of sys/dev/pcmcia/pcmcia.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: pcmcia.c,v 1.37 2006/04/16 20:43:12 miod Exp $ */
! 2: /* $NetBSD: pcmcia.c,v 1.9 1998/08/13 02:10:55 eeh Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1997 Marc Horowitz. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed by Marc Horowitz.
! 18: * 4. The name of the author may not be used to endorse or promote products
! 19: * derived from this software without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 24: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 25: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 26: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 27: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 28: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 29: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 30: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 31: */
! 32:
! 33: #include <sys/types.h>
! 34: #include <sys/param.h>
! 35: #include <sys/systm.h>
! 36: #include <sys/device.h>
! 37: #include <sys/malloc.h>
! 38:
! 39: #include <dev/pcmcia/pcmciareg.h>
! 40: #include <dev/pcmcia/pcmciachip.h>
! 41: #include <dev/pcmcia/pcmciavar.h>
! 42:
! 43: #ifdef PCMCIADEBUG
! 44: #define DPRINTF(arg) printf arg
! 45: #else
! 46: #define DPRINTF(arg)
! 47: #endif
! 48:
! 49: #ifdef PCMCIAVERBOSE
! 50: int pcmcia_verbose = 1;
! 51: #else
! 52: int pcmcia_verbose = 0;
! 53: #endif
! 54:
! 55: int pcmcia_match(struct device *, void *, void *);
! 56: int pcmcia_submatch(struct device *, void *, void *);
! 57: void pcmcia_attach(struct device *, struct device *, void *);
! 58: int pcmcia_print(void *, const char *);
! 59: void pcmcia_card_detach_notify(struct device *, void *);
! 60: void pcmcia_power(int why, void *arg);
! 61:
! 62: static inline void pcmcia_socket_enable(pcmcia_chipset_tag_t,
! 63: pcmcia_chipset_handle_t *);
! 64: static inline void pcmcia_socket_disable(pcmcia_chipset_tag_t,
! 65: pcmcia_chipset_handle_t *);
! 66:
! 67: int pcmcia_card_intr(void *);
! 68:
! 69: struct cfdriver pcmcia_cd = {
! 70: NULL, "pcmcia", DV_DULL
! 71: };
! 72:
! 73: struct cfattach pcmcia_ca = {
! 74: sizeof(struct pcmcia_softc), pcmcia_match, pcmcia_attach
! 75: };
! 76:
! 77: int
! 78: pcmcia_ccr_read(pf, ccr)
! 79: struct pcmcia_function *pf;
! 80: int ccr;
! 81: {
! 82:
! 83: return (bus_space_read_1(pf->pf_ccrt, pf->pf_ccrh,
! 84: pf->pf_ccr_offset + ccr));
! 85: }
! 86:
! 87: void
! 88: pcmcia_ccr_write(pf, ccr, val)
! 89: struct pcmcia_function *pf;
! 90: int ccr;
! 91: int val;
! 92: {
! 93:
! 94: if ((pf->ccr_mask) & (1 << (ccr / 2))) {
! 95: bus_space_write_1(pf->pf_ccrt, pf->pf_ccrh,
! 96: pf->pf_ccr_offset + ccr, val);
! 97: }
! 98: }
! 99:
! 100: int
! 101: pcmcia_match(parent, match, aux)
! 102: struct device *parent;
! 103: void *match, *aux;
! 104: {
! 105: struct cfdata *cf = match;
! 106: struct pcmciabus_attach_args *paa = aux;
! 107:
! 108: if (strcmp(paa->paa_busname, cf->cf_driver->cd_name))
! 109: return 0;
! 110:
! 111: /* If the autoconfiguration got this far, there's a socket here. */
! 112: return (1);
! 113: }
! 114:
! 115: void
! 116: pcmcia_attach(parent, self, aux)
! 117: struct device *parent, *self;
! 118: void *aux;
! 119: {
! 120: struct pcmciabus_attach_args *paa = aux;
! 121: struct pcmcia_softc *sc = (struct pcmcia_softc *) self;
! 122:
! 123: printf("\n");
! 124:
! 125: sc->pct = paa->pct;
! 126: sc->pch = paa->pch;
! 127: sc->iobase = paa->iobase;
! 128: sc->iosize = paa->iosize;
! 129:
! 130: sc->ih = NULL;
! 131: powerhook_establish(pcmcia_power, sc);
! 132: }
! 133:
! 134: void
! 135: pcmcia_power(why, arg)
! 136: int why;
! 137: void *arg;
! 138: {
! 139: struct pcmcia_softc *sc = (struct pcmcia_softc *) arg;
! 140: struct pcmcia_function *pf;
! 141: struct device *d;
! 142: int act = DVACT_ACTIVATE;
! 143:
! 144: if (why != PWR_RESUME)
! 145: act = DVACT_DEACTIVATE;
! 146:
! 147: for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
! 148: pf = SIMPLEQ_NEXT(pf, pf_list)) {
! 149: if (SIMPLEQ_FIRST(&pf->cfe_head) == NULL)
! 150: continue;
! 151: d = pf->child;
! 152: if (d == NULL)
! 153: continue;
! 154: if (act == DVACT_ACTIVATE)
! 155: config_activate(pf->child);
! 156: else
! 157: config_deactivate(pf->child);
! 158: }
! 159: }
! 160:
! 161: int
! 162: pcmcia_card_attach(dev)
! 163: struct device *dev;
! 164: {
! 165: struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
! 166: struct pcmcia_function *pf;
! 167: struct pcmcia_attach_args paa;
! 168: int attached;
! 169:
! 170: /*
! 171: * this is here so that when socket_enable calls gettype, trt happens
! 172: */
! 173: SIMPLEQ_FIRST(&sc->card.pf_head) = NULL;
! 174:
! 175: pcmcia_chip_socket_enable(sc->pct, sc->pch);
! 176:
! 177: pcmcia_read_cis(sc);
! 178:
! 179: pcmcia_chip_socket_disable(sc->pct, sc->pch);
! 180:
! 181: pcmcia_check_cis_quirks(sc);
! 182:
! 183: /*
! 184: * Bail now if there was an error in the CIS.
! 185: */
! 186:
! 187: if (sc->card.error)
! 188: return (1);
! 189:
! 190: #if 0
! 191: if (SIMPLEQ_EMPTY(&sc->card.pf_head))
! 192: return (1);
! 193: #endif
! 194:
! 195: if (pcmcia_verbose)
! 196: pcmcia_print_cis(sc);
! 197:
! 198: /*
! 199: * If there was no function, this might be CIS-less card we still
! 200: * want to probe. Fixup a function element for it.
! 201: */
! 202: if (SIMPLEQ_FIRST(&sc->card.pf_head) == NULL) {
! 203: pf = malloc(sizeof *pf, M_DEVBUF, M_NOWAIT);
! 204: if (pf == NULL)
! 205: panic("pcmcia_card_attach");
! 206: bzero(pf, sizeof *pf);
! 207: pf->number = 0;
! 208: pf->pf_flags = PFF_FAKE;
! 209: pf->last_config_index = -1;
! 210: SIMPLEQ_INIT(&pf->cfe_head);
! 211: SIMPLEQ_INSERT_TAIL(&sc->card.pf_head, pf, pf_list);
! 212: }
! 213:
! 214: attached = 0;
! 215:
! 216: for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
! 217: pf = SIMPLEQ_NEXT(pf, pf_list)) {
! 218: pf->sc = sc;
! 219: pf->child = NULL;
! 220: pf->cfe = NULL;
! 221: pf->ih_fct = NULL;
! 222: pf->ih_arg = NULL;
! 223: }
! 224:
! 225: for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
! 226: pf = SIMPLEQ_NEXT(pf, pf_list)) {
! 227: paa.manufacturer = sc->card.manufacturer;
! 228: paa.product = sc->card.product;
! 229: paa.card = &sc->card;
! 230: paa.pf = pf;
! 231:
! 232: pf->child = config_found_sm(&sc->dev, &paa, pcmcia_print,
! 233: pcmcia_submatch);
! 234: if (pf->child) {
! 235: attached++;
! 236:
! 237: if ((pf->pf_flags & PFF_FAKE) == 0)
! 238: DPRINTF(("%s: function %d CCR at %d offset %lx"
! 239: ": %x %x %x %x, %x %x %x %x, %x\n",
! 240: sc->dev.dv_xname, pf->number,
! 241: pf->pf_ccr_window, pf->pf_ccr_offset,
! 242: pcmcia_ccr_read(pf, 0x00),
! 243: pcmcia_ccr_read(pf, 0x02),
! 244: pcmcia_ccr_read(pf, 0x04),
! 245: pcmcia_ccr_read(pf, 0x06),
! 246: pcmcia_ccr_read(pf, 0x0A),
! 247: pcmcia_ccr_read(pf, 0x0C),
! 248: pcmcia_ccr_read(pf, 0x0E),
! 249: pcmcia_ccr_read(pf, 0x10),
! 250: pcmcia_ccr_read(pf, 0x12)));
! 251: }
! 252: }
! 253: return (attached ? 0 : 1);
! 254: }
! 255:
! 256: void
! 257: pcmcia_card_detach(dev, flags)
! 258: struct device *dev;
! 259: int flags; /* DETACH_* flags */
! 260: {
! 261: struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
! 262: struct pcmcia_function *pf;
! 263: int error;
! 264:
! 265: /*
! 266: * We are running on either the PCMCIA socket's event thread
! 267: * or in user context detaching a device by user request.
! 268: */
! 269: for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
! 270: pf = SIMPLEQ_NEXT(pf, pf_list)) {
! 271: if (SIMPLEQ_FIRST(&pf->cfe_head) == NULL)
! 272: continue;
! 273: if (pf->child == NULL)
! 274: continue;
! 275: DPRINTF(("%s: detaching %s (function %d)\n",
! 276: sc->dev.dv_xname, pf->child->dv_xname, pf->number));
! 277: if ((error = config_detach(pf->child, flags)) != 0) {
! 278: printf("%s: error %d detaching %s (function %d)\n",
! 279: sc->dev.dv_xname, error, pf->child->dv_xname,
! 280: pf->number);
! 281: } else
! 282: pf->child = NULL;
! 283: }
! 284: }
! 285:
! 286: void
! 287: pcmcia_card_deactivate(dev)
! 288: struct device *dev;
! 289: {
! 290: struct pcmcia_softc *sc = (struct pcmcia_softc *) dev;
! 291: struct pcmcia_function *pf;
! 292:
! 293: /*
! 294: * We're in the chip's card removal interrupt handler.
! 295: * Deactivate the child driver. The PCMCIA socket's
! 296: * event thread will run later to finish the detach.
! 297: */
! 298: for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
! 299: pf = SIMPLEQ_NEXT(pf, pf_list)) {
! 300: if (SIMPLEQ_FIRST(&pf->cfe_head) == NULL)
! 301: continue;
! 302: if (pf->child == NULL)
! 303: continue;
! 304: DPRINTF(("%s: deactivating %s (function %d)\n",
! 305: sc->dev.dv_xname, pf->child->dv_xname, pf->number));
! 306: config_deactivate(pf->child);
! 307: }
! 308: }
! 309:
! 310: int
! 311: pcmcia_submatch(parent, match, aux)
! 312: struct device *parent;
! 313: void *match, *aux;
! 314: {
! 315: struct cfdata *cf = match;
! 316: struct pcmcia_attach_args *paa = aux;
! 317:
! 318: if (cf->cf_loc[0 /* PCMCIACF_FUNCTION */] !=
! 319: -1 /* PCMCIACF_FUNCTION_DEFAULT */ &&
! 320: cf->cf_loc[0 /* PCMCIACF_FUNCTION */] != paa->pf->number)
! 321: return (0);
! 322:
! 323: return ((*cf->cf_attach->ca_match)(parent, cf, aux));
! 324: }
! 325:
! 326: int
! 327: pcmcia_print(arg, pnp)
! 328: void *arg;
! 329: const char *pnp;
! 330: {
! 331: struct pcmcia_attach_args *pa = arg;
! 332: struct pcmcia_softc *sc = pa->pf->sc;
! 333: struct pcmcia_card *card = &sc->card;
! 334: int i;
! 335:
! 336: if (pnp) {
! 337: for (i = 0; i < 4 && card->cis1_info[i]; i++)
! 338: printf("%s%s", i ? ", " : "\"", card->cis1_info[i]);
! 339: if (i != 0)
! 340: printf("\"");
! 341:
! 342: if (card->manufacturer != PCMCIA_VENDOR_INVALID &&
! 343: card->product != PCMCIA_PRODUCT_INVALID) {
! 344: if (i != 0)
! 345: printf(" ");
! 346: printf("(");
! 347: if (card->manufacturer != PCMCIA_VENDOR_INVALID)
! 348: printf("manufacturer 0x%x%s",
! 349: card->manufacturer,
! 350: card->product == PCMCIA_PRODUCT_INVALID ?
! 351: "" : ", ");
! 352: if (card->product != PCMCIA_PRODUCT_INVALID)
! 353: printf("product 0x%x",
! 354: card->product);
! 355: printf(")");
! 356: }
! 357: if (i != 0)
! 358: printf(" ");
! 359: printf("at %s", pnp);
! 360: }
! 361: printf(" function %d", pa->pf->number);
! 362:
! 363: if (!pnp) {
! 364: for (i = 0; i < 3 && card->cis1_info[i]; i++)
! 365: printf("%s%s", i ? ", " : " \"", card->cis1_info[i]);
! 366: if (i != 0)
! 367: printf("\"");
! 368: }
! 369:
! 370: return (UNCONF);
! 371: }
! 372:
! 373: int
! 374: pcmcia_card_gettype(dev)
! 375: struct device *dev;
! 376: {
! 377: struct pcmcia_softc *sc = (struct pcmcia_softc *)dev;
! 378: struct pcmcia_function *pf;
! 379:
! 380: /*
! 381: * Set the iftype to memory if this card has no functions (not yet
! 382: * probed), or only one function, and that is not initialized yet or
! 383: * that is memory.
! 384: */
! 385: pf = SIMPLEQ_FIRST(&sc->card.pf_head);
! 386: if (pf == NULL || (SIMPLEQ_NEXT(pf, pf_list) == NULL &&
! 387: ((pf->pf_flags & PFF_FAKE) ||
! 388: pf->cfe == NULL || pf->cfe->iftype == PCMCIA_IFTYPE_MEMORY)))
! 389: return (PCMCIA_IFTYPE_MEMORY);
! 390: else
! 391: return (PCMCIA_IFTYPE_IO);
! 392: }
! 393:
! 394: /*
! 395: * Initialize a PCMCIA function. May be called as long as the function is
! 396: * disabled.
! 397: */
! 398: void
! 399: pcmcia_function_init(pf, cfe)
! 400: struct pcmcia_function *pf;
! 401: struct pcmcia_config_entry *cfe;
! 402: {
! 403: if (pf->pf_flags & PFF_ENABLED)
! 404: panic("pcmcia_function_init: function is enabled");
! 405:
! 406: /* Remember which configuration entry we are using. */
! 407: pf->cfe = cfe;
! 408: }
! 409:
! 410: static inline void pcmcia_socket_enable(pct, pch)
! 411: pcmcia_chipset_tag_t pct;
! 412: pcmcia_chipset_handle_t *pch;
! 413: {
! 414: pcmcia_chip_socket_enable(pct, pch);
! 415: }
! 416:
! 417: static inline void pcmcia_socket_disable(pct, pch)
! 418: pcmcia_chipset_tag_t pct;
! 419: pcmcia_chipset_handle_t *pch;
! 420: {
! 421: pcmcia_chip_socket_disable(pct, pch);
! 422: }
! 423:
! 424: /* Enable a PCMCIA function */
! 425: int
! 426: pcmcia_function_enable(pf)
! 427: struct pcmcia_function *pf;
! 428: {
! 429: struct pcmcia_function *tmp;
! 430: int reg;
! 431:
! 432: if (pf->cfe == NULL)
! 433: panic("pcmcia_function_enable: function not initialized");
! 434:
! 435: /*
! 436: * Increase the reference count on the socket, enabling power, if
! 437: * necessary.
! 438: */
! 439: if (pf->sc->sc_enabled_count++ == 0)
! 440: pcmcia_chip_socket_enable(pf->sc->pct, pf->sc->pch);
! 441: DPRINTF(("%s: ++enabled_count = %d\n", pf->sc->dev.dv_xname,
! 442: pf->sc->sc_enabled_count));
! 443:
! 444: if (pf->pf_flags & PFF_ENABLED) {
! 445: /*
! 446: * Don't do anything if we're already enabled.
! 447: */
! 448: DPRINTF(("%s: pcmcia_function_enable on enabled func\n"));
! 449: return (0);
! 450: }
! 451:
! 452: /* If there was no CIS don't mess with CCR */
! 453: if (pf->pf_flags & PFF_FAKE)
! 454: goto done;
! 455:
! 456: /*
! 457: * It's possible for different functions' CCRs to be in the same
! 458: * underlying page. Check for that.
! 459: */
! 460: SIMPLEQ_FOREACH(tmp, &pf->sc->card.pf_head, pf_list) {
! 461: if ((tmp->pf_flags & PFF_ENABLED) &&
! 462: (pf->ccr_base >= (tmp->ccr_base - tmp->pf_ccr_offset)) &&
! 463: ((pf->ccr_base + PCMCIA_CCR_SIZE) <=
! 464: (tmp->ccr_base - tmp->pf_ccr_offset +
! 465: tmp->pf_ccr_realsize))) {
! 466: pf->pf_ccrt = tmp->pf_ccrt;
! 467: pf->pf_ccrh = tmp->pf_ccrh;
! 468: pf->pf_ccr_realsize = tmp->pf_ccr_realsize;
! 469:
! 470: /*
! 471: * pf->pf_ccr_offset = (tmp->pf_ccr_offset -
! 472: * tmp->ccr_base) + pf->ccr_base;
! 473: */
! 474: pf->pf_ccr_offset =
! 475: (tmp->pf_ccr_offset + pf->ccr_base) -
! 476: tmp->ccr_base;
! 477: pf->pf_ccr_window = tmp->pf_ccr_window;
! 478: break;
! 479: }
! 480: }
! 481:
! 482: if (tmp == NULL) {
! 483: if (pcmcia_mem_alloc(pf, PCMCIA_CCR_SIZE, &pf->pf_pcmh))
! 484: goto bad;
! 485:
! 486: if (pcmcia_mem_map(pf, PCMCIA_MEM_ATTR, pf->ccr_base,
! 487: PCMCIA_CCR_SIZE, &pf->pf_pcmh, &pf->pf_ccr_offset,
! 488: &pf->pf_ccr_window)) {
! 489: pcmcia_mem_free(pf, &pf->pf_pcmh);
! 490: goto bad;
! 491: }
! 492: }
! 493:
! 494: reg = (pf->cfe->number & PCMCIA_CCR_OPTION_CFINDEX);
! 495: reg |= PCMCIA_CCR_OPTION_LEVIREQ;
! 496: if (pcmcia_mfc(pf->sc)) {
! 497: reg |= PCMCIA_CCR_OPTION_FUNC_ENABLE;
! 498: if (pf->ccr_mask & (1 << (PCMCIA_CCR_IOBASE0 / 2)))
! 499: reg |= PCMCIA_CCR_OPTION_ADDR_DECODE;
! 500: if (pf->ih_fct)
! 501: reg |= PCMCIA_CCR_OPTION_IREQ_ENABLE;
! 502:
! 503: }
! 504:
! 505: pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
! 506:
! 507: reg = 0;
! 508:
! 509: if ((pf->cfe->flags & PCMCIA_CFE_IO16) == 0)
! 510: reg |= PCMCIA_CCR_STATUS_IOIS8;
! 511: if (pf->cfe->flags & PCMCIA_CFE_AUDIO)
! 512: reg |= PCMCIA_CCR_STATUS_AUDIO;
! 513: pcmcia_ccr_write(pf, PCMCIA_CCR_STATUS, reg);
! 514:
! 515: pcmcia_ccr_write(pf, PCMCIA_CCR_SOCKETCOPY, 0);
! 516:
! 517: if (pcmcia_mfc(pf->sc)) {
! 518: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE0,
! 519: (pf->pf_mfc_iobase >> 0) & 0xff);
! 520: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE1,
! 521: (pf->pf_mfc_iobase >> 8) & 0xff);
! 522: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE2,
! 523: (pf->pf_mfc_iobase >> 16) & 0xff);
! 524: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE3,
! 525: (pf->pf_mfc_iobase >> 24) & 0xff);
! 526: pcmcia_ccr_write(pf, PCMCIA_CCR_IOSIZE,
! 527: pf->pf_mfc_iomax - pf->pf_mfc_iobase);
! 528: }
! 529:
! 530: #ifdef PCMCIADEBUG
! 531: SIMPLEQ_FOREACH(tmp, &pf->sc->card.pf_head, pf_list) {
! 532: printf("%s: function %d CCR at %d offset %lx: "
! 533: "%x %x %x %x, %x %x %x %x, %x\n",
! 534: tmp->sc->dev.dv_xname, tmp->number,
! 535: tmp->pf_ccr_window, tmp->pf_ccr_offset,
! 536: pcmcia_ccr_read(tmp, 0x00),
! 537: pcmcia_ccr_read(tmp, 0x02),
! 538: pcmcia_ccr_read(tmp, 0x04),
! 539: pcmcia_ccr_read(tmp, 0x06),
! 540:
! 541: pcmcia_ccr_read(tmp, 0x0A),
! 542: pcmcia_ccr_read(tmp, 0x0C),
! 543: pcmcia_ccr_read(tmp, 0x0E),
! 544: pcmcia_ccr_read(tmp, 0x10),
! 545:
! 546: pcmcia_ccr_read(tmp, 0x12));
! 547: }
! 548: #endif
! 549:
! 550: done:
! 551: pf->pf_flags |= PFF_ENABLED;
! 552: delay(1000);
! 553: return (0);
! 554:
! 555: bad:
! 556: /*
! 557: * Decrement the reference count, and power down the socket, if
! 558: * necessary.
! 559: */
! 560: if (--pf->sc->sc_enabled_count == 0)
! 561: pcmcia_chip_socket_disable(pf->sc->pct, pf->sc->pch);
! 562: DPRINTF(("%s: --enabled_count = %d\n", pf->sc->dev.dv_xname,
! 563: pf->sc->sc_enabled_count));
! 564:
! 565: return (1);
! 566: }
! 567:
! 568: /* Disable PCMCIA function. */
! 569: void
! 570: pcmcia_function_disable(pf)
! 571: struct pcmcia_function *pf;
! 572: {
! 573: struct pcmcia_function *tmp;
! 574:
! 575: if (pf->cfe == NULL)
! 576: panic("pcmcia_function_enable: function not initialized");
! 577:
! 578: if ((pf->pf_flags & PFF_ENABLED) == 0) {
! 579: /*
! 580: * Don't do anything if we're already disabled.
! 581: */
! 582: return;
! 583: }
! 584:
! 585: /* If there was no CIS don't mess with CCR */
! 586: if (pf->pf_flags & PFF_FAKE) {
! 587: pf->pf_flags &= ~PFF_ENABLED;
! 588: goto done;
! 589: }
! 590:
! 591: /*
! 592: * it's possible for different functions' CCRs to be in the same
! 593: * underlying page. Check for that. Note we mark us as disabled
! 594: * first to avoid matching ourself.
! 595: */
! 596: pf->pf_flags &= ~PFF_ENABLED;
! 597: SIMPLEQ_FOREACH(tmp, &pf->sc->card.pf_head, pf_list) {
! 598: if ((tmp->pf_flags & PFF_ENABLED) &&
! 599: (pf->ccr_base >= (tmp->ccr_base - tmp->pf_ccr_offset)) &&
! 600: ((pf->ccr_base + PCMCIA_CCR_SIZE) <=
! 601: (tmp->ccr_base - tmp->pf_ccr_offset + tmp->pf_ccr_realsize)))
! 602: break;
! 603: }
! 604:
! 605: /* Not used by anyone else; unmap the CCR. */
! 606: if (tmp == NULL) {
! 607: pcmcia_mem_unmap(pf, pf->pf_ccr_window);
! 608: pcmcia_mem_free(pf, &pf->pf_pcmh);
! 609: }
! 610:
! 611: done:
! 612: /*
! 613: * Decrement the reference count, and power down the socket, if
! 614: * necessary.
! 615: */
! 616: if (--pf->sc->sc_enabled_count == 0)
! 617: pcmcia_chip_socket_disable(pf->sc->pct, pf->sc->pch);
! 618: DPRINTF(("%s: --enabled_count = %d\n", pf->sc->dev.dv_xname,
! 619: pf->sc->sc_enabled_count));
! 620: }
! 621:
! 622: int
! 623: pcmcia_io_map(pf, width, offset, size, pcihp, windowp)
! 624: struct pcmcia_function *pf;
! 625: int width;
! 626: bus_addr_t offset;
! 627: bus_size_t size;
! 628: struct pcmcia_io_handle *pcihp;
! 629: int *windowp;
! 630: {
! 631: int reg;
! 632:
! 633: if (pcmcia_chip_io_map(pf->sc->pct, pf->sc->pch,
! 634: width, offset, size, pcihp, windowp))
! 635: return (1);
! 636:
! 637: /*
! 638: * XXX In the multifunction multi-iospace-per-function case, this
! 639: * needs to cooperate with io_alloc to make sure that the spaces
! 640: * don't overlap, and that the ccr's are set correctly.
! 641: */
! 642:
! 643: if (pcmcia_mfc(pf->sc) &&
! 644: (pf->ccr_mask & (1 << (PCMCIA_CCR_IOBASE0 / 2)))) {
! 645: bus_addr_t iobase = pcihp->addr;
! 646: bus_addr_t iomax = pcihp->addr + pcihp->size - 1;
! 647:
! 648: if (pf->pf_mfc_iomax == 0) {
! 649: pf->pf_mfc_iobase = iobase;
! 650: pf->pf_mfc_iomax = iomax;
! 651: } else {
! 652: if (iobase < pf->pf_mfc_iobase)
! 653: pf->pf_mfc_iobase = iobase;
! 654: if (iomax > pf->pf_mfc_iomax)
! 655: pf->pf_mfc_iomax = iomax;
! 656: }
! 657:
! 658: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE0,
! 659: (pf->pf_mfc_iobase >> 0) & 0xff);
! 660: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE1,
! 661: (pf->pf_mfc_iobase >> 8) & 0xff);
! 662: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE2,
! 663: (pf->pf_mfc_iobase >> 16) & 0xff);
! 664: pcmcia_ccr_write(pf, PCMCIA_CCR_IOBASE3,
! 665: (pf->pf_mfc_iobase >> 24) & 0xff);
! 666: pcmcia_ccr_write(pf, PCMCIA_CCR_IOSIZE,
! 667: pf->pf_mfc_iomax - pf->pf_mfc_iobase);
! 668:
! 669: reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
! 670: reg |= PCMCIA_CCR_OPTION_ADDR_DECODE;
! 671: pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
! 672: }
! 673: return (0);
! 674: }
! 675:
! 676: void *
! 677: pcmcia_intr_establish(pf, ipl, ih_fct, ih_arg, xname)
! 678: struct pcmcia_function *pf;
! 679: int ipl;
! 680: int (*ih_fct)(void *);
! 681: void *ih_arg;
! 682: char *xname;
! 683: {
! 684: void *ret;
! 685: int s, ihcnt, hiipl, reg;
! 686: struct pcmcia_function *pf2;
! 687:
! 688: /* Behave differently if this is a multifunction card. */
! 689: if (pcmcia_mfc(pf->sc)) {
! 690: /*
! 691: * Mask all the ipl's which are already used by this card,
! 692: * and find the highest ipl number (lowest priority).
! 693: */
! 694: ihcnt = 0;
! 695: SIMPLEQ_FOREACH(pf2, &pf->sc->card.pf_head, pf_list) {
! 696: if (pf2->ih_fct) {
! 697: DPRINTF(("%s: function %d has ih_fct %p\n",
! 698: pf->sc->dev.dv_xname, pf2->number,
! 699: pf2->ih_fct));
! 700:
! 701: if (ihcnt == 0)
! 702: hiipl = pf2->ih_ipl;
! 703: else if (pf2->ih_ipl > hiipl)
! 704: hiipl = pf2->ih_ipl;
! 705:
! 706: ihcnt++;
! 707: }
! 708: }
! 709:
! 710: /*
! 711: * Establish the real interrupt, changing the ipl if
! 712: * necessary.
! 713: */
! 714: if (ihcnt == 0) {
! 715: #ifdef DIAGNOSTIC
! 716: if (pf->sc->ih != NULL)
! 717: panic("card has intr handler, "
! 718: "but no function does");
! 719: #endif
! 720: s = spltty();
! 721:
! 722: /* Set up the handler for the new function. */
! 723: pf->ih_fct = ih_fct;
! 724: pf->ih_arg = ih_arg;
! 725: pf->ih_ipl = ipl;
! 726:
! 727: pf->sc->ih = pcmcia_chip_intr_establish(pf->sc->pct,
! 728: pf->sc->pch, pf, ipl, pcmcia_card_intr, pf->sc,
! 729: xname);
! 730: splx(s);
! 731: } else if (ipl > hiipl) {
! 732: #ifdef DIAGNOSTIC
! 733: if (pf->sc->ih == NULL)
! 734: panic("functions have ih, "
! 735: "but the card does not");
! 736: #endif
! 737:
! 738: s = spltty();
! 739:
! 740: pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch,
! 741: pf->sc->ih);
! 742:
! 743: /* set up the handler for the new function */
! 744: pf->ih_fct = ih_fct;
! 745: pf->ih_arg = ih_arg;
! 746: pf->ih_ipl = ipl;
! 747:
! 748: pf->sc->ih = pcmcia_chip_intr_establish(pf->sc->pct,
! 749: pf->sc->pch, pf, ipl, pcmcia_card_intr, pf->sc,
! 750: xname);
! 751:
! 752: splx(s);
! 753: } else {
! 754: s = spltty();
! 755:
! 756: /* Set up the handler for the new function. */
! 757: pf->ih_fct = ih_fct;
! 758: pf->ih_arg = ih_arg;
! 759: pf->ih_ipl = ipl;
! 760:
! 761: splx(s);
! 762: }
! 763:
! 764: ret = pf->sc->ih;
! 765:
! 766: if (ret != NULL) {
! 767: reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
! 768: reg |= PCMCIA_CCR_OPTION_IREQ_ENABLE;
! 769: pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
! 770:
! 771: reg = pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS);
! 772: reg |= PCMCIA_CCR_STATUS_INTRACK;
! 773: pcmcia_ccr_write(pf, PCMCIA_CCR_STATUS, reg);
! 774: }
! 775: } else
! 776: ret = pcmcia_chip_intr_establish(pf->sc->pct, pf->sc->pch,
! 777: pf, ipl, ih_fct, ih_arg, xname);
! 778:
! 779: return (ret);
! 780: }
! 781:
! 782: void
! 783: pcmcia_intr_disestablish(pf, ih)
! 784: struct pcmcia_function *pf;
! 785: void *ih;
! 786: {
! 787: int s, reg, ihcnt, hiipl;
! 788: struct pcmcia_function *pf2;
! 789:
! 790: /* Behave differently if this is a multifunction card. */
! 791: if (pcmcia_mfc(pf->sc)) {
! 792: /*
! 793: * Mask all the ipl's which are already used by this card,
! 794: * and find the highest ipl number (lowest priority). Skip
! 795: * the current function.
! 796: */
! 797: ihcnt = 0;
! 798: SIMPLEQ_FOREACH(pf2, &pf->sc->card.pf_head, pf_list) {
! 799: if (pf2 == pf)
! 800: continue;
! 801:
! 802: if (pf2->ih_fct) {
! 803: if (ihcnt == 0)
! 804: hiipl = pf2->ih_ipl;
! 805: else if (pf2->ih_ipl > hiipl)
! 806: hiipl = pf2->ih_ipl;
! 807: ihcnt++;
! 808: }
! 809: }
! 810:
! 811: /*
! 812: * If the ih being removed is lower priority than the lowest
! 813: * priority remaining interrupt, up the priority.
! 814: */
! 815:
! 816: /*
! 817: * ihcnt is the number of interrupt handlers *not* including
! 818: * the one about to be removed.
! 819: */
! 820: if (ihcnt == 0) {
! 821: #ifdef DIAGNOSTIC
! 822: if (pf->sc->ih == NULL)
! 823: panic("disestablishing last function, but card has no ih");
! 824: #endif
! 825: pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch,
! 826: pf->sc->ih);
! 827:
! 828: reg = pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION);
! 829: reg &= ~PCMCIA_CCR_OPTION_IREQ_ENABLE;
! 830: pcmcia_ccr_write(pf, PCMCIA_CCR_OPTION, reg);
! 831:
! 832: pf->ih_fct = NULL;
! 833: pf->ih_arg = NULL;
! 834:
! 835: pf->sc->ih = NULL;
! 836: } else if (pf->ih_ipl > hiipl) {
! 837: #ifdef DIAGNOSTIC
! 838: if (pf->sc->ih == NULL)
! 839: panic("changing ih ipl, but card has no ih");
! 840: #endif
! 841: s = spltty();
! 842:
! 843: pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch,
! 844: pf->sc->ih);
! 845: pf->sc->ih = pcmcia_chip_intr_establish(pf->sc->pct,
! 846: pf->sc->pch, pf, hiipl, pcmcia_card_intr, pf->sc,
! 847: NULL);
! 848:
! 849: /* Null out the handler for this function. */
! 850: pf->ih_fct = NULL;
! 851: pf->ih_arg = NULL;
! 852:
! 853: splx(s);
! 854: } else {
! 855: s = spltty();
! 856:
! 857: pf->ih_fct = NULL;
! 858: pf->ih_arg = NULL;
! 859:
! 860: splx(s);
! 861: }
! 862: } else
! 863: pcmcia_chip_intr_disestablish(pf->sc->pct, pf->sc->pch, ih);
! 864: }
! 865:
! 866: const char *
! 867: pcmcia_intr_string(pf, ih)
! 868: struct pcmcia_function *pf;
! 869: void *ih;
! 870: {
! 871: return pcmcia_chip_intr_string(pf->sc->pct, pf->sc->pch, ih);
! 872: }
! 873:
! 874: int
! 875: pcmcia_card_intr(arg)
! 876: void *arg;
! 877: {
! 878: struct pcmcia_softc *sc = arg;
! 879: struct pcmcia_function *pf;
! 880: int reg, ret, ret2;
! 881:
! 882: ret = 0;
! 883:
! 884: for (pf = SIMPLEQ_FIRST(&sc->card.pf_head); pf != NULL;
! 885: pf = SIMPLEQ_NEXT(pf, pf_list)) {
! 886: #ifdef PCMCIADEBUG
! 887: printf("%s: intr flags=%x fct=%d cor=%02x csr=%02x pin=%02x",
! 888: sc->dev.dv_xname, pf->pf_flags, pf->number,
! 889: pcmcia_ccr_read(pf, PCMCIA_CCR_OPTION),
! 890: pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS),
! 891: pcmcia_ccr_read(pf, PCMCIA_CCR_PIN));
! 892: #endif
! 893: if (pf->ih_fct != NULL &&
! 894: (pf->ccr_mask & (1 << (PCMCIA_CCR_STATUS / 2)))) {
! 895: reg = pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS);
! 896: if (reg & PCMCIA_CCR_STATUS_INTR) {
! 897: ret2 = (*pf->ih_fct)(pf->ih_arg);
! 898: if (ret2 != 0 && ret == 0)
! 899: ret = ret2;
! 900: reg = pcmcia_ccr_read(pf, PCMCIA_CCR_STATUS);
! 901: #ifdef PCMCIADEBUG
! 902: printf("; csr %02x->%02x",
! 903: reg, reg & ~PCMCIA_CCR_STATUS_INTR);
! 904: #endif
! 905: pcmcia_ccr_write(pf, PCMCIA_CCR_STATUS,
! 906: reg & ~PCMCIA_CCR_STATUS_INTR);
! 907: }
! 908: }
! 909: #ifdef PCMCIADEBUG
! 910: printf("\n");
! 911: #endif
! 912: }
! 913:
! 914: return (ret);
! 915: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to pcmcia.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pcmcia