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