Annotation of sys/dev/sdmmc/sdmmc_io.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: sdmmc_io.c,v 1.9 2007/06/02 01:48:37 uwe Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: /* Routines for SD I/O cards. */
! 20:
! 21: #include <sys/param.h>
! 22: #include <sys/kernel.h>
! 23: #include <sys/malloc.h>
! 24: #include <sys/proc.h>
! 25: #include <sys/systm.h>
! 26:
! 27: #include <dev/sdmmc/sdmmc_ioreg.h>
! 28: #include <dev/sdmmc/sdmmcchip.h>
! 29: #include <dev/sdmmc/sdmmcreg.h>
! 30: #include <dev/sdmmc/sdmmcvar.h>
! 31:
! 32: struct sdmmc_intr_handler {
! 33: struct sdmmc_softc *ih_softc;
! 34: char *ih_name;
! 35: int (*ih_fun)(void *);
! 36: void *ih_arg;
! 37: TAILQ_ENTRY(sdmmc_intr_handler) entry;
! 38: };
! 39:
! 40: int sdmmc_submatch(struct device *, void *, void *);
! 41: int sdmmc_print(void *, const char *);
! 42: int sdmmc_io_rw_direct(struct sdmmc_softc *, struct sdmmc_function *,
! 43: int, u_char *, int);
! 44: int sdmmc_io_rw_extended(struct sdmmc_softc *, struct sdmmc_function *,
! 45: int, u_char *, int, int);
! 46: int sdmmc_io_xchg(struct sdmmc_softc *, struct sdmmc_function *,
! 47: int, u_char *);
! 48: void sdmmc_io_reset(struct sdmmc_softc *);
! 49: int sdmmc_io_send_op_cond(struct sdmmc_softc *, u_int32_t, u_int32_t *);
! 50:
! 51: #ifdef SDMMC_DEBUG
! 52: #define DPRINTF(s) printf s
! 53: #else
! 54: #define DPRINTF(s) /**/
! 55: #endif
! 56:
! 57: #ifdef SDMMC_DEBUG
! 58: int sdmmc_verbose = 1;
! 59: #else
! 60: int sdmmc_verbose = 0;
! 61: #endif
! 62:
! 63: /*
! 64: * Initialize SD I/O card functions (before memory cards). The host
! 65: * system and controller must support card interrupts in order to use
! 66: * I/O functions.
! 67: */
! 68: int
! 69: sdmmc_io_enable(struct sdmmc_softc *sc)
! 70: {
! 71: u_int32_t host_ocr;
! 72: u_int32_t card_ocr;
! 73:
! 74: /* Set host mode to SD "combo" card. */
! 75: SET(sc->sc_flags, SMF_SD_MODE|SMF_IO_MODE|SMF_MEM_MODE);
! 76:
! 77: /* Reset I/O functions. */
! 78: sdmmc_io_reset(sc);
! 79:
! 80: /*
! 81: * Read the I/O OCR value, determine the number of I/O
! 82: * functions and whether memory is also present (a "combo
! 83: * card") by issuing CMD5. SD memory-only and MMC cards
! 84: * do not respond to CMD5.
! 85: */
! 86: if (sdmmc_io_send_op_cond(sc, 0, &card_ocr) != 0) {
! 87: /* No SDIO card; switch to SD memory-only mode. */
! 88: CLR(sc->sc_flags, SMF_IO_MODE);
! 89: return 0;
! 90: }
! 91:
! 92: /* Parse the additional bits in the I/O OCR value. */
! 93: if (!ISSET(card_ocr, SD_IO_OCR_MEM_PRESENT)) {
! 94: /* SDIO card without memory (not a "combo card"). */
! 95: DPRINTF(("%s: no memory present\n", SDMMCDEVNAME(sc)));
! 96: CLR(sc->sc_flags, SMF_MEM_MODE);
! 97: }
! 98: sc->sc_function_count = SD_IO_OCR_NUM_FUNCTIONS(card_ocr);
! 99: if (sc->sc_function_count == 0) {
! 100: /* Useless SDIO card without any I/O functions. */
! 101: DPRINTF(("%s: no I/O functions\n", SDMMCDEVNAME(sc)));
! 102: CLR(sc->sc_flags, SMF_IO_MODE);
! 103: return 0;
! 104: }
! 105: card_ocr &= SD_IO_OCR_MASK;
! 106:
! 107: /* Set the lowest voltage supported by the card and host. */
! 108: host_ocr = sdmmc_chip_host_ocr(sc->sct, sc->sch);
! 109: if (sdmmc_set_bus_power(sc, host_ocr, card_ocr) != 0) {
! 110: printf("%s: can't supply voltage requested by card\n",
! 111: SDMMCDEVNAME(sc));
! 112: return 1;
! 113: }
! 114:
! 115: /* Reset I/O functions (again). */
! 116: sdmmc_io_reset(sc);
! 117:
! 118: /* Send the new OCR value until all cards are ready. */
! 119: if (sdmmc_io_send_op_cond(sc, host_ocr, NULL) != 0) {
! 120: printf("%s: can't send I/O OCR\n", SDMMCDEVNAME(sc));
! 121: return 1;
! 122: }
! 123: return 0;
! 124: }
! 125:
! 126: /*
! 127: * Allocate sdmmc_function structures for SD card I/O function
! 128: * (including function 0).
! 129: */
! 130: void
! 131: sdmmc_io_scan(struct sdmmc_softc *sc)
! 132: {
! 133: struct sdmmc_function *sf0, *sf;
! 134: int i;
! 135:
! 136: sf0 = sdmmc_function_alloc(sc);
! 137: sf0->number = 0;
! 138: if (sdmmc_set_relative_addr(sc, sf0) != 0) {
! 139: printf("%s: can't set I/O RCA\n", SDMMCDEVNAME(sc));
! 140: SET(sf0->flags, SFF_ERROR);
! 141: return;
! 142: }
! 143: sc->sc_fn0 = sf0;
! 144: SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf0, sf_list);
! 145:
! 146: /* Verify that the RCA has been set by selecting the card. */
! 147: if (sdmmc_select_card(sc, sf0) != 0) {
! 148: printf("%s: can't select I/O RCA %d\n", SDMMCDEVNAME(sc),
! 149: sf0->rca);
! 150: SET(sf0->flags, SFF_ERROR);
! 151: return;
! 152: }
! 153:
! 154: for (i = 1; i <= sc->sc_function_count; i++) {
! 155: sf = sdmmc_function_alloc(sc);
! 156: sf->number = i;
! 157: sf->rca = sf0->rca;
! 158:
! 159: SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf, sf_list);
! 160: }
! 161: }
! 162:
! 163: /*
! 164: * Initialize SDIO card functions.
! 165: */
! 166: int
! 167: sdmmc_io_init(struct sdmmc_softc *sc, struct sdmmc_function *sf)
! 168: {
! 169: if (sf->number == 0) {
! 170: sdmmc_io_write_1(sf, SD_IO_CCCR_BUS_WIDTH,
! 171: CCCR_BUS_WIDTH_1);
! 172:
! 173: if (sdmmc_read_cis(sf, &sf->cis) != 0) {
! 174: printf("%s: can't read CIS\n", SDMMCDEVNAME(sc));
! 175: SET(sf->flags, SFF_ERROR);
! 176: return 1;
! 177: }
! 178:
! 179: sdmmc_check_cis_quirks(sf);
! 180:
! 181: if (sdmmc_verbose)
! 182: sdmmc_print_cis(sf);
! 183: }
! 184: return 0;
! 185: }
! 186:
! 187: /*
! 188: * Indicate whether the function is ready to operate.
! 189: */
! 190: int
! 191: sdmmc_io_function_ready(struct sdmmc_function *sf)
! 192: {
! 193: struct sdmmc_softc *sc = sf->sc;
! 194: struct sdmmc_function *sf0 = sc->sc_fn0;
! 195: u_int8_t rv;
! 196:
! 197: if (sf->number == 0)
! 198: return 1; /* FN0 is always ready */
! 199:
! 200: rv = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_READY);
! 201: return (rv & (1 << sf->number)) != 0;
! 202: }
! 203:
! 204: /*
! 205: * Enable the I/O function. Return zero if the function was
! 206: * enabled successfully.
! 207: */
! 208: int
! 209: sdmmc_io_function_enable(struct sdmmc_function *sf)
! 210: {
! 211: struct sdmmc_softc *sc = sf->sc;
! 212: struct sdmmc_function *sf0 = sc->sc_fn0;
! 213: u_int8_t rv;
! 214: int retry = 5;
! 215:
! 216: if (sf->number == 0)
! 217: return 0; /* FN0 is always enabled */
! 218:
! 219: SDMMC_LOCK(sc);
! 220: rv = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_ENABLE);
! 221: rv |= (1<<sf->number);
! 222: sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_ENABLE, rv);
! 223: SDMMC_UNLOCK(sc);
! 224:
! 225: while (!sdmmc_io_function_ready(sf) && retry-- > 0)
! 226: tsleep(&lbolt, PPAUSE, "pause", 0);
! 227: return (retry >= 0) ? 0 : ETIMEDOUT;
! 228: }
! 229:
! 230: /*
! 231: * Disable the I/O function. Return zero if the function was
! 232: * disabled successfully.
! 233: */
! 234: void
! 235: sdmmc_io_function_disable(struct sdmmc_function *sf)
! 236: {
! 237: struct sdmmc_softc *sc = sf->sc;
! 238: struct sdmmc_function *sf0 = sc->sc_fn0;
! 239: u_int8_t rv;
! 240:
! 241: if (sf->number == 0)
! 242: return; /* FN0 is always enabled */
! 243:
! 244: SDMMC_LOCK(sc);
! 245: rv = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_ENABLE);
! 246: rv &= ~(1<<sf->number);
! 247: sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_ENABLE, rv);
! 248: SDMMC_UNLOCK(sc);
! 249: }
! 250:
! 251: void
! 252: sdmmc_io_attach(struct sdmmc_softc *sc)
! 253: {
! 254: struct sdmmc_function *sf;
! 255: struct sdmmc_attach_args saa;
! 256:
! 257: SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
! 258: if (sf->number < 1)
! 259: continue;
! 260:
! 261: bzero(&saa, sizeof saa);
! 262: saa.sf = sf;
! 263:
! 264: sf->child = config_found_sm(&sc->sc_dev, &saa, sdmmc_print,
! 265: sdmmc_submatch);
! 266: }
! 267: }
! 268:
! 269: int
! 270: sdmmc_submatch(struct device *parent, void *match, void *aux)
! 271: {
! 272: struct cfdata *cf = match;
! 273:
! 274: /* Skip the scsibus, it is configured directly. */
! 275: if (strcmp(cf->cf_driver->cd_name, "scsibus") == 0)
! 276: return 0;
! 277:
! 278: return cf->cf_attach->ca_match(parent, cf, aux);
! 279: }
! 280:
! 281: int
! 282: sdmmc_print(void *aux, const char *pnp)
! 283: {
! 284: struct sdmmc_attach_args *sa = aux;
! 285: struct sdmmc_function *sf = sa->sf;
! 286: struct sdmmc_cis *cis = &sf->sc->sc_fn0->cis;
! 287: int i;
! 288:
! 289: if (pnp) {
! 290: if (sf->number == 0)
! 291: return QUIET;
! 292:
! 293: for (i = 0; i < 4 && cis->cis1_info[i]; i++)
! 294: printf("%s%s", i ? ", " : "\"", cis->cis1_info[i]);
! 295: if (i != 0)
! 296: printf("\"");
! 297:
! 298: if (cis->manufacturer != SDMMC_VENDOR_INVALID &&
! 299: cis->product != SDMMC_PRODUCT_INVALID) {
! 300: printf("%s(", i ? " " : "");
! 301: if (cis->manufacturer != SDMMC_VENDOR_INVALID)
! 302: printf("manufacturer 0x%x%s",
! 303: cis->manufacturer,
! 304: cis->product == SDMMC_PRODUCT_INVALID ?
! 305: "" : ", ");
! 306: if (cis->product != SDMMC_PRODUCT_INVALID)
! 307: printf("product 0x%x", cis->product);
! 308: printf(")");
! 309: }
! 310: printf("%sat %s", i ? " " : "", pnp);
! 311: }
! 312: printf(" function %d", sf->number);
! 313:
! 314: if (!pnp) {
! 315: for (i = 0; i < 3 && cis->cis1_info[i]; i++)
! 316: printf("%s%s", i ? ", " : " \"", cis->cis1_info[i]);
! 317: if (i != 0)
! 318: printf("\"");
! 319: }
! 320: return UNCONF;
! 321: }
! 322:
! 323: void
! 324: sdmmc_io_detach(struct sdmmc_softc *sc)
! 325: {
! 326: struct sdmmc_function *sf;
! 327:
! 328: SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
! 329: if (sf->child != NULL) {
! 330: config_detach(sf->child, DETACH_FORCE);
! 331: sf->child = NULL;
! 332: }
! 333: }
! 334:
! 335: KASSERT(TAILQ_EMPTY(&sc->sc_intrq));
! 336: }
! 337:
! 338: int
! 339: sdmmc_io_rw_direct(struct sdmmc_softc *sc, struct sdmmc_function *sf,
! 340: int reg, u_char *datap, int arg)
! 341: {
! 342: struct sdmmc_command cmd;
! 343: int error;
! 344:
! 345: SDMMC_LOCK(sc);
! 346:
! 347: /* Make sure the card is selected. */
! 348: if ((error = sdmmc_select_card(sc, sf)) != 0) {
! 349: SDMMC_UNLOCK(sc);
! 350: return error;
! 351: }
! 352:
! 353: arg |= ((sf == NULL ? 0 : sf->number) & SD_ARG_CMD52_FUNC_MASK) <<
! 354: SD_ARG_CMD52_FUNC_SHIFT;
! 355: arg |= (reg & SD_ARG_CMD52_REG_MASK) <<
! 356: SD_ARG_CMD52_REG_SHIFT;
! 357: arg |= (*datap & SD_ARG_CMD52_DATA_MASK) <<
! 358: SD_ARG_CMD52_DATA_SHIFT;
! 359:
! 360: bzero(&cmd, sizeof cmd);
! 361: cmd.c_opcode = SD_IO_RW_DIRECT;
! 362: cmd.c_arg = arg;
! 363: cmd.c_flags = SCF_CMD_AC | SCF_RSP_R5;
! 364:
! 365: error = sdmmc_mmc_command(sc, &cmd);
! 366: *datap = SD_R5_DATA(cmd.c_resp);
! 367:
! 368: SDMMC_UNLOCK(sc);
! 369: return error;
! 370: }
! 371:
! 372: /*
! 373: * Useful values of `arg' to pass in are either SD_ARG_CMD53_READ or
! 374: * SD_ARG_CMD53_WRITE. SD_ARG_CMD53_INCREMENT may be ORed into `arg'
! 375: * to access successive register locations instead of accessing the
! 376: * same register many times.
! 377: */
! 378: int
! 379: sdmmc_io_rw_extended(struct sdmmc_softc *sc, struct sdmmc_function *sf,
! 380: int reg, u_char *datap, int datalen, int arg)
! 381: {
! 382: struct sdmmc_command cmd;
! 383: int error;
! 384:
! 385: SDMMC_LOCK(sc);
! 386:
! 387: #if 0
! 388: /* Make sure the card is selected. */
! 389: if ((error = sdmmc_select_card(sc, sf)) != 0) {
! 390: SDMMC_UNLOCK(sc);
! 391: return error;
! 392: }
! 393: #endif
! 394:
! 395: arg |= ((sf == NULL ? 0 : sf->number) & SD_ARG_CMD53_FUNC_MASK) <<
! 396: SD_ARG_CMD53_FUNC_SHIFT;
! 397: arg |= (reg & SD_ARG_CMD53_REG_MASK) <<
! 398: SD_ARG_CMD53_REG_SHIFT;
! 399: arg |= (datalen & SD_ARG_CMD53_LENGTH_MASK) <<
! 400: SD_ARG_CMD53_LENGTH_SHIFT;
! 401:
! 402: bzero(&cmd, sizeof cmd);
! 403: cmd.c_opcode = SD_IO_RW_EXTENDED;
! 404: cmd.c_arg = arg;
! 405: cmd.c_flags = SCF_CMD_AC | SCF_RSP_R5;
! 406: cmd.c_data = datap;
! 407: cmd.c_datalen = datalen;
! 408: cmd.c_blklen = MIN(datalen, sdmmc_chip_host_maxblklen(sc->sct, sc->sch));
! 409:
! 410: if (!ISSET(arg, SD_ARG_CMD53_WRITE))
! 411: cmd.c_flags |= SCF_CMD_READ;
! 412:
! 413: error = sdmmc_mmc_command(sc, &cmd);
! 414: SDMMC_UNLOCK(sc);
! 415: return error;
! 416: }
! 417:
! 418: u_int8_t
! 419: sdmmc_io_read_1(struct sdmmc_function *sf, int reg)
! 420: {
! 421: u_int8_t data = 0;
! 422:
! 423: (void)sdmmc_io_rw_direct(sf->sc, sf, reg, (u_char *)&data,
! 424: SD_ARG_CMD52_READ);
! 425: return data;
! 426: }
! 427:
! 428: void
! 429: sdmmc_io_write_1(struct sdmmc_function *sf, int reg, u_int8_t data)
! 430: {
! 431: (void)sdmmc_io_rw_direct(sf->sc, sf, reg, (u_char *)&data,
! 432: SD_ARG_CMD52_WRITE);
! 433: }
! 434:
! 435: u_int16_t
! 436: sdmmc_io_read_2(struct sdmmc_function *sf, int reg)
! 437: {
! 438: u_int16_t data = 0;
! 439:
! 440: (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 2,
! 441: SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
! 442: return data;
! 443: }
! 444:
! 445: void
! 446: sdmmc_io_write_2(struct sdmmc_function *sf, int reg, u_int16_t data)
! 447: {
! 448: (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 2,
! 449: SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
! 450: }
! 451:
! 452: u_int32_t
! 453: sdmmc_io_read_4(struct sdmmc_function *sf, int reg)
! 454: {
! 455: u_int32_t data = 0;
! 456:
! 457: (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 4,
! 458: SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
! 459: return data;
! 460: }
! 461:
! 462: void
! 463: sdmmc_io_write_4(struct sdmmc_function *sf, int reg, u_int32_t data)
! 464: {
! 465: (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 4,
! 466: SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
! 467: }
! 468:
! 469: int
! 470: sdmmc_io_read_multi_1(struct sdmmc_function *sf, int reg, u_char *data,
! 471: int datalen)
! 472: {
! 473: int error;
! 474:
! 475: while (datalen > SD_ARG_CMD53_LENGTH_MAX) {
! 476: error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
! 477: SD_ARG_CMD53_LENGTH_MAX, SD_ARG_CMD53_READ);
! 478: if (error)
! 479: return error;
! 480: data += SD_ARG_CMD53_LENGTH_MAX;
! 481: datalen -= SD_ARG_CMD53_LENGTH_MAX;
! 482: }
! 483:
! 484: return sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
! 485: SD_ARG_CMD53_READ);
! 486: }
! 487:
! 488: int
! 489: sdmmc_io_write_multi_1(struct sdmmc_function *sf, int reg, u_char *data,
! 490: int datalen)
! 491: {
! 492: int error;
! 493:
! 494: while (datalen > SD_ARG_CMD53_LENGTH_MAX) {
! 495: error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
! 496: SD_ARG_CMD53_LENGTH_MAX, SD_ARG_CMD53_WRITE);
! 497: if (error)
! 498: return error;
! 499: data += SD_ARG_CMD53_LENGTH_MAX;
! 500: datalen -= SD_ARG_CMD53_LENGTH_MAX;
! 501: }
! 502:
! 503: return sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
! 504: SD_ARG_CMD53_WRITE);
! 505: }
! 506:
! 507: int
! 508: sdmmc_io_xchg(struct sdmmc_softc *sc, struct sdmmc_function *sf,
! 509: int reg, u_char *datap)
! 510: {
! 511: return sdmmc_io_rw_direct(sc, sf, reg, datap,
! 512: SD_ARG_CMD52_WRITE|SD_ARG_CMD52_EXCHANGE);
! 513: }
! 514:
! 515: /*
! 516: * Reset the I/O functions of the card.
! 517: */
! 518: void
! 519: sdmmc_io_reset(struct sdmmc_softc *sc)
! 520: {
! 521: #if 0 /* XXX command fails */
! 522: (void)sdmmc_io_write(sc, NULL, SD_IO_REG_CCCR_CTL, CCCR_CTL_RES);
! 523: sdmmc_delay(100000);
! 524: #endif
! 525: }
! 526:
! 527: /*
! 528: * Get or set the card's I/O OCR value (SDIO).
! 529: */
! 530: int
! 531: sdmmc_io_send_op_cond(struct sdmmc_softc *sc, u_int32_t ocr, u_int32_t *ocrp)
! 532: {
! 533: struct sdmmc_command cmd;
! 534: int error;
! 535: int i;
! 536:
! 537: SDMMC_LOCK(sc);
! 538:
! 539: /*
! 540: * If we change the OCR value, retry the command until the OCR
! 541: * we receive in response has the "CARD BUSY" bit set, meaning
! 542: * that all cards are ready for identification.
! 543: */
! 544: for (i = 0; i < 100; i++) {
! 545: bzero(&cmd, sizeof cmd);
! 546: cmd.c_opcode = SD_IO_SEND_OP_COND;
! 547: cmd.c_arg = ocr;
! 548: cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R4;
! 549:
! 550: error = sdmmc_mmc_command(sc, &cmd);
! 551: if (error != 0)
! 552: break;
! 553: if (ISSET(MMC_R4(cmd.c_resp), SD_IO_OCR_MEM_READY) ||
! 554: ocr == 0)
! 555: break;
! 556: error = ETIMEDOUT;
! 557: sdmmc_delay(10000);
! 558: }
! 559: if (error == 0 && ocrp != NULL)
! 560: *ocrp = MMC_R4(cmd.c_resp);
! 561:
! 562: SDMMC_UNLOCK(sc);
! 563: return error;
! 564: }
! 565:
! 566: /*
! 567: * Card interrupt handling
! 568: */
! 569:
! 570: void
! 571: sdmmc_intr_enable(struct sdmmc_function *sf)
! 572: {
! 573: struct sdmmc_softc *sc = sf->sc;
! 574: struct sdmmc_function *sf0 = sc->sc_fn0;
! 575: u_int8_t imask;
! 576:
! 577: SDMMC_LOCK(sc);
! 578: imask = sdmmc_io_read_1(sf0, SD_IO_CCCR_INT_ENABLE);
! 579: imask |= 1 << sf->number;
! 580: sdmmc_io_write_1(sf0, SD_IO_CCCR_INT_ENABLE, imask);
! 581: SDMMC_UNLOCK(sc);
! 582: }
! 583:
! 584: void
! 585: sdmmc_intr_disable(struct sdmmc_function *sf)
! 586: {
! 587: struct sdmmc_softc *sc = sf->sc;
! 588: struct sdmmc_function *sf0 = sc->sc_fn0;
! 589: u_int8_t imask;
! 590:
! 591: SDMMC_LOCK(sc);
! 592: imask = sdmmc_io_read_1(sf0, SD_IO_CCCR_INT_ENABLE);
! 593: imask &= ~(1 << sf->number);
! 594: sdmmc_io_write_1(sf0, SD_IO_CCCR_INT_ENABLE, imask);
! 595: SDMMC_UNLOCK(sc);
! 596: }
! 597:
! 598: /*
! 599: * Establish a handler for the SDIO card interrupt. Because the
! 600: * interrupt may be shared with different SDIO functions, multiple
! 601: * handlers can be established.
! 602: */
! 603: void *
! 604: sdmmc_intr_establish(struct device *sdmmc, int (*fun)(void *),
! 605: void *arg, const char *name)
! 606: {
! 607: struct sdmmc_softc *sc = (struct sdmmc_softc *)sdmmc;
! 608: struct sdmmc_intr_handler *ih;
! 609: int s;
! 610:
! 611: if (sc->sct->card_intr_mask == NULL)
! 612: return NULL;
! 613:
! 614: ih = malloc(sizeof *ih, M_DEVBUF, M_WAITOK | M_CANFAIL);
! 615: if (ih == NULL)
! 616: return NULL;
! 617:
! 618: bzero(ih, sizeof *ih);
! 619: ih->ih_name = malloc(strlen(name), M_DEVBUF, M_WAITOK | M_CANFAIL);
! 620: if (ih->ih_name == NULL) {
! 621: free(ih, M_DEVBUF);
! 622: return NULL;
! 623: }
! 624: strlcpy(ih->ih_name, name, strlen(name));
! 625: ih->ih_softc = sc;
! 626: ih->ih_fun = fun;
! 627: ih->ih_arg = arg;
! 628:
! 629: s = splhigh();
! 630: if (TAILQ_EMPTY(&sc->sc_intrq)) {
! 631: sdmmc_intr_enable(sc->sc_fn0);
! 632: sdmmc_chip_card_intr_mask(sc->sct, sc->sch, 1);
! 633: }
! 634: TAILQ_INSERT_TAIL(&sc->sc_intrq, ih, entry);
! 635: splx(s);
! 636: return ih;
! 637: }
! 638:
! 639: /*
! 640: * Disestablish the given handler.
! 641: */
! 642: void
! 643: sdmmc_intr_disestablish(void *cookie)
! 644: {
! 645: struct sdmmc_intr_handler *ih = cookie;
! 646: struct sdmmc_softc *sc = ih->ih_softc;
! 647: int s;
! 648:
! 649: if (sc->sct->card_intr_mask == NULL)
! 650: return;
! 651:
! 652: s = splhigh();
! 653: TAILQ_REMOVE(&sc->sc_intrq, ih, entry);
! 654: if (TAILQ_EMPTY(&sc->sc_intrq)) {
! 655: sdmmc_chip_card_intr_mask(sc->sct, sc->sch, 0);
! 656: sdmmc_intr_disable(sc->sc_fn0);
! 657: }
! 658: splx(s);
! 659:
! 660: free(ih->ih_name, M_DEVBUF);
! 661: free(ih, M_DEVBUF);
! 662: }
! 663:
! 664: /*
! 665: * Call established SDIO card interrupt handlers. The host controller
! 666: * must call this function from its own interrupt handler to handle an
! 667: * SDIO interrupt from the card.
! 668: */
! 669: void
! 670: sdmmc_card_intr(struct device *sdmmc)
! 671: {
! 672: struct sdmmc_softc *sc = (struct sdmmc_softc *)sdmmc;
! 673:
! 674: if (sc->sct->card_intr_mask == NULL)
! 675: return;
! 676:
! 677: if (!sdmmc_task_pending(&sc->sc_intr_task))
! 678: sdmmc_add_task(sc, &sc->sc_intr_task);
! 679: }
! 680:
! 681: void
! 682: sdmmc_intr_task(void *arg)
! 683: {
! 684: struct sdmmc_softc *sc = arg;
! 685: struct sdmmc_intr_handler *ih;
! 686: int s;
! 687:
! 688: s = splhigh();
! 689: TAILQ_FOREACH(ih, &sc->sc_intrq, entry) {
! 690: splx(s);
! 691:
! 692: /* XXX examine return value and do evcount stuff*/
! 693: (void)ih->ih_fun(ih->ih_arg);
! 694:
! 695: s = splhigh();
! 696: }
! 697: sdmmc_chip_card_intr_ack(sc->sct, sc->sch);
! 698: splx(s);
! 699: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sdmmc_io.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sdmmc