root/dev/sdmmc/sdmmc_io.c

DEFINITIONS

1. sdmmc_io_enable
2. sdmmc_io_scan
3. sdmmc_io_init
4. sdmmc_io_function_ready
5. sdmmc_io_function_enable
6. sdmmc_io_function_disable
7. sdmmc_io_attach
8. sdmmc_submatch
9. sdmmc_print
10. sdmmc_io_detach
11. sdmmc_io_rw_direct
12. sdmmc_io_rw_extended
13. sdmmc_io_read_1
14. sdmmc_io_write_1
15. sdmmc_io_read_2
16. sdmmc_io_write_2
17. sdmmc_io_read_4
18. sdmmc_io_write_4
19. sdmmc_io_read_multi_1
20. sdmmc_io_write_multi_1
21. sdmmc_io_xchg
22. sdmmc_io_reset
23. sdmmc_io_send_op_cond
24. sdmmc_intr_enable
25. sdmmc_intr_disable
26. sdmmc_intr_establish
27. sdmmc_intr_disestablish
28. sdmmc_card_intr
29. sdmmc_intr_task

    1 /*      $OpenBSD: sdmmc_io.c,v 1.9 2007/06/02 01:48:37 uwe Exp $        */
    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  */
   19 /* Routines for SD I/O cards. */
   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>
   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>
   32 struct sdmmc_intr_handler {
   33         struct sdmmc_softc *ih_softc;
   34         char *ih_name;
   35         int (*ih_fun)(void *);
   36         void *ih_arg;
TAILQ_ENTRY(sdmmc_intr_handler) entry;
   38 };
   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 *);
   51 #ifdef SDMMC_DEBUG
   52 #define DPRINTF(s)      printf s
   53 #else
   54 #define DPRINTF(s)      /**/
   55 #endif
   57 #ifdef SDMMC_DEBUG
   58 int     sdmmc_verbose = 1;
   59 #else
   60 int     sdmmc_verbose = 0;
   61 #endif
   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
sdmmc_io_enable(struct sdmmc_softc *sc)
   70 {
u_int32_t host_ocr;
u_int32_t card_ocr;
   74         /* Set host mode to SD "combo" card. */
SET(sc->sc_flags, SMF_SD_MODE|SMF_IO_MODE|SMF_MEM_MODE);
   77         /* Reset I/O functions. */
sdmmc_io_reset(sc);
   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. */
CLR(sc->sc_flags, SMF_IO_MODE);
   89                 return 0;
   90         }
   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"). */
DPRINTF(("%s: no memory present\n", SDMMCDEVNAME(sc)));
CLR(sc->sc_flags, SMF_MEM_MODE);
   97         }
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. */
DPRINTF(("%s: no I/O functions\n", SDMMCDEVNAME(sc)));
CLR(sc->sc_flags, SMF_IO_MODE);
  103                 return 0;
  104         }
card_ocr &= SD_IO_OCR_MASK;
  107         /* Set the lowest voltage supported by the card and host. */
host_ocr = sdmmc_chip_host_ocr(sc->sct, sc->sch);
  109         if (sdmmc_set_bus_power(sc, host_ocr, card_ocr) != 0) {
printf("%s: can't supply voltage requested by card\n",
SDMMCDEVNAME(sc));
  112                 return 1;
  113         }
  115         /* Reset I/O functions (again). */
sdmmc_io_reset(sc);
  118         /* Send the new OCR value until all cards are ready. */
  119         if (sdmmc_io_send_op_cond(sc, host_ocr, NULL) != 0) {
printf("%s: can't send I/O OCR\n", SDMMCDEVNAME(sc));
  121                 return 1;
  122         }
  123         return 0;
  124 }
  126 /*
  127  * Allocate sdmmc_function structures for SD card I/O function
  128  * (including function 0).
  129  */
  130 void
sdmmc_io_scan(struct sdmmc_softc *sc)
  132 {
  133         struct sdmmc_function *sf0, *sf;
  134         int i;
sf0 = sdmmc_function_alloc(sc);
sf0->number = 0;
  138         if (sdmmc_set_relative_addr(sc, sf0) != 0) {
printf("%s: can't set I/O RCA\n", SDMMCDEVNAME(sc));
SET(sf0->flags, SFF_ERROR);
  141                 return;
  142         }
sc->sc_fn0 = sf0;
SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf0, sf_list);
  146         /* Verify that the RCA has been set by selecting the card. */
  147         if (sdmmc_select_card(sc, sf0) != 0) {
printf("%s: can't select I/O RCA %d\n", SDMMCDEVNAME(sc),
sf0->rca);
SET(sf0->flags, SFF_ERROR);
  151                 return;
  152         }
  154         for (i = 1; i <= sc->sc_function_count; i++) {
sf = sdmmc_function_alloc(sc);
sf->number = i;
sf->rca = sf0->rca;
SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf, sf_list);
  160         }
  161 }
  163 /*
  164  * Initialize SDIO card functions.
  165  */
  166 int
sdmmc_io_init(struct sdmmc_softc *sc, struct sdmmc_function *sf)
  168 {
  169         if (sf->number == 0) {
sdmmc_io_write_1(sf, SD_IO_CCCR_BUS_WIDTH,
CCCR_BUS_WIDTH_1);
  173                 if (sdmmc_read_cis(sf, &sf->cis) != 0) {
printf("%s: can't read CIS\n", SDMMCDEVNAME(sc));
SET(sf->flags, SFF_ERROR);
  176                         return 1;
  177                 }
sdmmc_check_cis_quirks(sf);
  181                 if (sdmmc_verbose)
sdmmc_print_cis(sf);
  183         }
  184         return 0;
  185 }
  187 /*
  188  * Indicate whether the function is ready to operate.
  189  */
  190 int
sdmmc_io_function_ready(struct sdmmc_function *sf)
  192 {
  193         struct sdmmc_softc *sc = sf->sc;
  194         struct sdmmc_function *sf0 = sc->sc_fn0;
u_int8_t rv;
  197         if (sf->number == 0)
  198                 return 1;       /* FN0 is always ready */
rv = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_READY);
  201         return (rv & (1 << sf->number)) != 0;
  202 }
  204 /*
  205  * Enable the I/O function.  Return zero if the function was
  206  * enabled successfully.
  207  */
  208 int
sdmmc_io_function_enable(struct sdmmc_function *sf)
  210 {
  211         struct sdmmc_softc *sc = sf->sc;
  212         struct sdmmc_function *sf0 = sc->sc_fn0;
u_int8_t rv;
  214         int retry = 5;
  216         if (sf->number == 0)
  217                 return 0;       /* FN0 is always enabled */
SDMMC_LOCK(sc);
rv = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_ENABLE);
rv |= (1<<sf->number);
sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_ENABLE, rv);
SDMMC_UNLOCK(sc);
  225         while (!sdmmc_io_function_ready(sf) && retry-- > 0)
tsleep(&lbolt, PPAUSE, "pause", 0);
  227         return (retry >= 0) ? 0 : ETIMEDOUT;
  228 }
  230 /*
  231  * Disable the I/O function.  Return zero if the function was
  232  * disabled successfully.
  233  */
  234 void
sdmmc_io_function_disable(struct sdmmc_function *sf)
  236 {
  237         struct sdmmc_softc *sc = sf->sc;
  238         struct sdmmc_function *sf0 = sc->sc_fn0;
u_int8_t rv;
  241         if (sf->number == 0)
  242                 return;         /* FN0 is always enabled */
SDMMC_LOCK(sc);
rv = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_ENABLE);
rv &= ~(1<<sf->number);
sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_ENABLE, rv);
SDMMC_UNLOCK(sc);
  249 }
  251 void
sdmmc_io_attach(struct sdmmc_softc *sc)
  253 {
  254         struct sdmmc_function *sf;
  255         struct sdmmc_attach_args saa;
SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
  258                 if (sf->number < 1)
  259                         continue;
bzero(&saa, sizeof saa);
saa.sf = sf;
sf->child = config_found_sm(&sc->sc_dev, &saa, sdmmc_print,
sdmmc_submatch);
  266         }
  267 }
  269 int
sdmmc_submatch(struct device *parent, void *match, void *aux)
  271 {
  272         struct cfdata *cf = match;
  274         /* Skip the scsibus, it is configured directly. */
  275         if (strcmp(cf->cf_driver->cd_name, "scsibus") == 0)
  276                 return 0;
  278         return cf->cf_attach->ca_match(parent, cf, aux);
  279 }
  281 int
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;
  289         if (pnp) {
  290                 if (sf->number == 0)
  291                         return QUIET;
  293                 for (i = 0; i < 4 && cis->cis1_info[i]; i++)
printf("%s%s", i ? ", " : "\"", cis->cis1_info[i]);
  295                 if (i != 0)
printf("\"");
  298                 if (cis->manufacturer != SDMMC_VENDOR_INVALID &&
cis->product != SDMMC_PRODUCT_INVALID) {
printf("%s(", i ? " " : "");
  301                         if (cis->manufacturer != SDMMC_VENDOR_INVALID)
printf("manufacturer 0x%x%s",
cis->manufacturer,
cis->product == SDMMC_PRODUCT_INVALID ?
  305                                     "" : ", ");
  306                         if (cis->product != SDMMC_PRODUCT_INVALID)
printf("product 0x%x", cis->product);
printf(")");
  309                 }
printf("%sat %s", i ? " " : "", pnp);
  311         }
printf(" function %d", sf->number);
  314         if (!pnp) {
  315                 for (i = 0; i < 3 && cis->cis1_info[i]; i++)
printf("%s%s", i ? ", " : " \"", cis->cis1_info[i]);
  317                 if (i != 0)
printf("\"");
  319         }
  320         return UNCONF;
  321 }
  323 void
sdmmc_io_detach(struct sdmmc_softc *sc)
  325 {
  326         struct sdmmc_function *sf;
SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
  329                 if (sf->child != NULL) {
config_detach(sf->child, DETACH_FORCE);
sf->child = NULL;
  332                 }
  333         }
KASSERT(TAILQ_EMPTY(&sc->sc_intrq));
  336 }
  338 int
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;
SDMMC_LOCK(sc);
  347         /* Make sure the card is selected. */
  348         if ((error = sdmmc_select_card(sc, sf)) != 0) {
SDMMC_UNLOCK(sc);
  350                 return error;
  351         }
arg |= ((sf == NULL ? 0 : sf->number) & SD_ARG_CMD52_FUNC_MASK) <<
SD_ARG_CMD52_FUNC_SHIFT;
arg |= (reg & SD_ARG_CMD52_REG_MASK) <<
SD_ARG_CMD52_REG_SHIFT;
arg |= (*datap & SD_ARG_CMD52_DATA_MASK) <<
SD_ARG_CMD52_DATA_SHIFT;
bzero(&cmd, sizeof cmd);
cmd.c_opcode = SD_IO_RW_DIRECT;
cmd.c_arg = arg;
cmd.c_flags = SCF_CMD_AC | SCF_RSP_R5;
error = sdmmc_mmc_command(sc, &cmd);
  366         *datap = SD_R5_DATA(cmd.c_resp);
SDMMC_UNLOCK(sc);
  369         return error;
  370 }
  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
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;
SDMMC_LOCK(sc);
  387 #if 0
  388         /* Make sure the card is selected. */
  389         if ((error = sdmmc_select_card(sc, sf)) != 0) {
SDMMC_UNLOCK(sc);
  391                 return error;
  392         }
  393 #endif
arg |= ((sf == NULL ? 0 : sf->number) & SD_ARG_CMD53_FUNC_MASK) <<
SD_ARG_CMD53_FUNC_SHIFT;
arg |= (reg & SD_ARG_CMD53_REG_MASK) <<
SD_ARG_CMD53_REG_SHIFT;
arg |= (datalen & SD_ARG_CMD53_LENGTH_MASK) <<
SD_ARG_CMD53_LENGTH_SHIFT;
bzero(&cmd, sizeof cmd);
cmd.c_opcode = SD_IO_RW_EXTENDED;
cmd.c_arg = arg;
cmd.c_flags = SCF_CMD_AC | SCF_RSP_R5;
cmd.c_data = datap;
cmd.c_datalen = datalen;
cmd.c_blklen = MIN(datalen, sdmmc_chip_host_maxblklen(sc->sct, sc->sch));
  410         if (!ISSET(arg, SD_ARG_CMD53_WRITE))
cmd.c_flags |= SCF_CMD_READ;
error = sdmmc_mmc_command(sc, &cmd);
SDMMC_UNLOCK(sc);
  415         return error;
  416 }
u_int8_t
sdmmc_io_read_1(struct sdmmc_function *sf, int reg)
  420 {
u_int8_t data = 0;
  423         (void)sdmmc_io_rw_direct(sf->sc, sf, reg, (u_char *)&data,
SD_ARG_CMD52_READ);
  425         return data;
  426 }
  428 void
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,
SD_ARG_CMD52_WRITE);
  433 }
u_int16_t
sdmmc_io_read_2(struct sdmmc_function *sf, int reg)
  437 {
u_int16_t data = 0;
  440         (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 2,
SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
  442         return data;
  443 }
  445 void
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,
SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
  450 }
u_int32_t
sdmmc_io_read_4(struct sdmmc_function *sf, int reg)
  454 {
u_int32_t data = 0;
  457         (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 4,
SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
  459         return data;
  460 }
  462 void
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,
SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
  467 }
  469 int
sdmmc_io_read_multi_1(struct sdmmc_function *sf, int reg, u_char *data,
  471     int datalen)
  472 {
  473         int error;
  475         while (datalen > SD_ARG_CMD53_LENGTH_MAX) {
error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
SD_ARG_CMD53_LENGTH_MAX, SD_ARG_CMD53_READ);
  478                 if (error)
  479                         return error;
data += SD_ARG_CMD53_LENGTH_MAX;
datalen -= SD_ARG_CMD53_LENGTH_MAX;
  482         }
  484         return sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
SD_ARG_CMD53_READ);
  486 }
  488 int
sdmmc_io_write_multi_1(struct sdmmc_function *sf, int reg, u_char *data,
  490     int datalen)
  491 {
  492         int error;
  494         while (datalen > SD_ARG_CMD53_LENGTH_MAX) {
error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
SD_ARG_CMD53_LENGTH_MAX, SD_ARG_CMD53_WRITE);
  497                 if (error)
  498                         return error;
data += SD_ARG_CMD53_LENGTH_MAX;
datalen -= SD_ARG_CMD53_LENGTH_MAX;
  501         }
  503         return sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
SD_ARG_CMD53_WRITE);
  505 }
  507 int
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,
SD_ARG_CMD52_WRITE|SD_ARG_CMD52_EXCHANGE);
  513 }
  515 /*
  516  * Reset the I/O functions of the card.
  517  */
  518 void
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);
sdmmc_delay(100000);
  524 #endif
  525 }
  527 /*
  528  * Get or set the card's I/O OCR value (SDIO).
  529  */
  530 int
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;
SDMMC_LOCK(sc);
  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++) {
bzero(&cmd, sizeof cmd);
cmd.c_opcode = SD_IO_SEND_OP_COND;
cmd.c_arg = ocr;
cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R4;
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) ||
ocr == 0)
  555                         break;
error = ETIMEDOUT;
sdmmc_delay(10000);
  558         }
  559         if (error == 0 && ocrp != NULL)
  560                 *ocrp = MMC_R4(cmd.c_resp);
SDMMC_UNLOCK(sc);
  563         return error;
  564 }
  566 /*
  567  * Card interrupt handling
  568  */
  570 void
sdmmc_intr_enable(struct sdmmc_function *sf)
  572 {
  573         struct sdmmc_softc *sc = sf->sc;
  574         struct sdmmc_function *sf0 = sc->sc_fn0;
u_int8_t imask;
SDMMC_LOCK(sc);
imask = sdmmc_io_read_1(sf0, SD_IO_CCCR_INT_ENABLE);
imask |= 1 << sf->number;
sdmmc_io_write_1(sf0, SD_IO_CCCR_INT_ENABLE, imask);
SDMMC_UNLOCK(sc);
  582 }
  584 void
sdmmc_intr_disable(struct sdmmc_function *sf)
  586 {
  587         struct sdmmc_softc *sc = sf->sc;
  588         struct sdmmc_function *sf0 = sc->sc_fn0;
u_int8_t imask;
SDMMC_LOCK(sc);
imask = sdmmc_io_read_1(sf0, SD_IO_CCCR_INT_ENABLE);
imask &= ~(1 << sf->number);
sdmmc_io_write_1(sf0, SD_IO_CCCR_INT_ENABLE, imask);
SDMMC_UNLOCK(sc);
  596 }
  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 *
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;
  611         if (sc->sct->card_intr_mask == NULL)
  612                 return NULL;
ih = malloc(sizeof *ih, M_DEVBUF, M_WAITOK | M_CANFAIL);
  615         if (ih == NULL)
  616                 return NULL;
bzero(ih, sizeof *ih);
ih->ih_name = malloc(strlen(name), M_DEVBUF, M_WAITOK | M_CANFAIL);
  620         if (ih->ih_name == NULL) {
free(ih, M_DEVBUF);
  622                 return NULL;
  623         }
strlcpy(ih->ih_name, name, strlen(name));
ih->ih_softc = sc;
ih->ih_fun = fun;
ih->ih_arg = arg;
s = splhigh();
  630         if (TAILQ_EMPTY(&sc->sc_intrq)) {
sdmmc_intr_enable(sc->sc_fn0);
sdmmc_chip_card_intr_mask(sc->sct, sc->sch, 1);
  633         }
TAILQ_INSERT_TAIL(&sc->sc_intrq, ih, entry);
splx(s);
  636         return ih;
  637 }
  639 /*
  640  * Disestablish the given handler.
  641  */
  642 void
sdmmc_intr_disestablish(void *cookie)
  644 {
  645         struct sdmmc_intr_handler *ih = cookie;
  646         struct sdmmc_softc *sc = ih->ih_softc;
  647         int s;
  649         if (sc->sct->card_intr_mask == NULL)
  650                 return;
s = splhigh();
TAILQ_REMOVE(&sc->sc_intrq, ih, entry);
  654         if (TAILQ_EMPTY(&sc->sc_intrq)) {
sdmmc_chip_card_intr_mask(sc->sct, sc->sch, 0);
sdmmc_intr_disable(sc->sc_fn0);
  657         }
splx(s);
free(ih->ih_name, M_DEVBUF);
free(ih, M_DEVBUF);
  662 }
  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
sdmmc_card_intr(struct device *sdmmc)
  671 {
  672         struct sdmmc_softc *sc = (struct sdmmc_softc *)sdmmc;
  674         if (sc->sct->card_intr_mask == NULL)
  675                 return;
  677         if (!sdmmc_task_pending(&sc->sc_intr_task))
sdmmc_add_task(sc, &sc->sc_intr_task);
  679 }
  681 void
sdmmc_intr_task(void *arg)
  683 {
  684         struct sdmmc_softc *sc = arg;
  685         struct sdmmc_intr_handler *ih;
  686         int s;
s = splhigh();
TAILQ_FOREACH(ih, &sc->sc_intrq, entry) {
splx(s);
  692                 /* XXX examine return value and do evcount stuff*/
  693                 (void)ih->ih_fun(ih->ih_arg);
s = splhigh();
  696         }
sdmmc_chip_card_intr_ack(sc->sct, sc->sch);
splx(s);
  699 }