/*      $NetBSD: sdmmc_io.c,v 1.26 2026/01/17 13:56:08 jmcneill Exp $   */
/*      $OpenBSD: sdmmc_io.c,v 1.10 2007/09/17 01:33:33 krw Exp $       */

/*
 * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/* Routines for SD I/O cards. */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sdmmc_io.c,v 1.26 2026/01/17 13:56:08 jmcneill Exp $");

#ifdef _KERNEL_OPT
#include "opt_sdmmc.h"
#endif

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/systm.h>

#include <dev/sdmmc/sdmmc_ioreg.h>
#include <dev/sdmmc/sdmmcchip.h>
#include <dev/sdmmc/sdmmcreg.h>
#include <dev/sdmmc/sdmmcvar.h>

#ifdef SDMMC_DEBUG
#define DPRINTF(s)      do { printf s; } while (0)
#else
#define DPRINTF(s)      do {} while (0)
#endif

struct sdmmc_intr_handler {
        struct sdmmc_softc *ih_softc;
        char *ih_name;
        int (*ih_fun)(void *);
        void *ih_arg;
        TAILQ_ENTRY(sdmmc_intr_handler) entry;
};

static int      sdmmc_io_rw_direct(struct sdmmc_softc *,
                    struct sdmmc_function *, int, u_char *, int, bool);
static int      sdmmc_io_rw_extended(struct sdmmc_softc *,
                    struct sdmmc_function *, int, u_char *, int, int);
#if 0
static int      sdmmc_io_xchg(struct sdmmc_softc *, struct sdmmc_function *,
                    int, u_char *);
#endif
static void     sdmmc_io_reset(struct sdmmc_softc *);
static int      sdmmc_io_send_op_cond(struct sdmmc_softc *, uint32_t,
                    uint32_t *);

/*
 * Initialize SD I/O card functions (before memory cards).  The host
 * system and controller must support card interrupts in order to use
 * I/O functions.
 */
int
sdmmc_io_enable(struct sdmmc_softc *sc)
{
        uint32_t host_ocr;
        uint32_t card_ocr;
        int error;

        SDMMC_LOCK(sc);

        /* Set host mode to SD "combo" card. */
        SET(sc->sc_flags, SMF_SD_MODE|SMF_IO_MODE|SMF_MEM_MODE);

        /* Reset I/O functions. */
        sdmmc_io_reset(sc);

        /*
         * Read the I/O OCR value, determine the number of I/O
         * functions and whether memory is also present (a "combo
         * card") by issuing CMD5.  SD memory-only and MMC cards
         * do not respond to CMD5.
         */
        error = sdmmc_io_send_op_cond(sc, 0, &card_ocr);
        if (error) {
                /* No SDIO card; switch to SD memory-only mode. */
                CLR(sc->sc_flags, SMF_IO_MODE);
                error = 0;
                goto out;
        }

        /* Parse the additional bits in the I/O OCR value. */
        if (!ISSET(card_ocr, SD_IO_OCR_MEM_PRESENT)) {
                /* SDIO card without memory (not a "combo card"). */
                DPRINTF(("%s: no memory present\n", SDMMCDEVNAME(sc)));
                CLR(sc->sc_flags, SMF_MEM_MODE);
        }
        sc->sc_function_count = SD_IO_OCR_NUM_FUNCTIONS(card_ocr);
        if (sc->sc_function_count == 0) {
                /* Useless SDIO card without any I/O functions. */
                DPRINTF(("%s: no I/O functions\n", SDMMCDEVNAME(sc)));
                CLR(sc->sc_flags, SMF_IO_MODE);
                error = 0;
                goto out;
        }
        card_ocr &= SD_IO_OCR_MASK;

        /* Set the lowest voltage supported by the card and host. */
        host_ocr = sdmmc_chip_host_ocr(sc->sc_sct, sc->sc_sch);
        error = sdmmc_set_bus_power(sc, host_ocr, card_ocr);
        if (error) {
                aprint_error_dev(sc->sc_dev,
                    "couldn't supply voltage requested by card\n");
                goto out;
        }

        /* Send the new OCR value until all cards are ready. */
        error = sdmmc_io_send_op_cond(sc, host_ocr, NULL);
        if (error) {
                aprint_error_dev(sc->sc_dev, "couldn't send I/O OCR\n");
                goto out;
        }

out:
        SDMMC_UNLOCK(sc);

        return error;
}

/*
 * Allocate sdmmc_function structures for SD card I/O function
 * (including function 0).
 */
void
sdmmc_io_scan(struct sdmmc_softc *sc)
{
        struct sdmmc_function *sf0, *sf;
        int error;
        int i;

        SDMMC_LOCK(sc);

        sf0 = sdmmc_function_alloc(sc);
        sf0->number = 0;
        error = sdmmc_set_relative_addr(sc, sf0);
        if (error) {
                aprint_error_dev(sc->sc_dev, "couldn't set I/O RCA\n");
                SET(sf0->flags, SFF_ERROR);
                goto out;
        }
        sc->sc_fn0 = sf0;
        SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf0, sf_list);

        /* Go to Data Transfer Mode, if possible. */
        sdmmc_chip_bus_rod(sc->sc_sct, sc->sc_sch, 0);

        /* Verify that the RCA has been set by selecting the card. */
        error = sdmmc_select_card(sc, sf0);
        if (error) {
                aprint_error_dev(sc->sc_dev, "couldn't select I/O RCA %d\n",
                    sf0->rca);
                SET(sf0->flags, SFF_ERROR);
                goto out;
        }

        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);
        }

out:
        SDMMC_UNLOCK(sc);
}

/*
 * Initialize SDIO card functions.
 */
int
sdmmc_io_init(struct sdmmc_softc *sc, struct sdmmc_function *sf)
{
        struct sdmmc_function *sf0 = sc->sc_fn0;
        int error = 0;
        uint8_t reg;

        SDMMC_LOCK(sc);

        sf->blklen = sdmmc_chip_host_maxblklen(sc->sc_sct, sc->sc_sch);

        if (sf->number == 0) {
                reg = sdmmc_io_read_1(sf, SD_IO_CCCR_CAPABILITY);
                if (!(reg & CCCR_CAPS_LSC) || (reg & CCCR_CAPS_4BLS)) {
                        sdmmc_io_write_1(sf, SD_IO_CCCR_BUS_WIDTH,
                            CCCR_BUS_WIDTH_4);
                        sf->width = 4;
                        error = sdmmc_chip_bus_width(sc->sc_sct, sc->sc_sch,
                            sf->width);
                        if (error)
                                aprint_error_dev(sc->sc_dev,
                                    "can't change bus width\n");
                }

                error = sdmmc_read_cis(sf, &sf->cis);
                if (error) {
                        aprint_error_dev(sc->sc_dev, "couldn't read CIS\n");
                        SET(sf->flags, SFF_ERROR);
                        goto out;
                }

                sdmmc_check_cis_quirks(sf);

#ifdef SDMMC_DEBUG
                if (sdmmcdebug)
                        sdmmc_print_cis(sf);
#endif

                reg = sdmmc_io_read_1(sf, SD_IO_CCCR_HIGH_SPEED);
                if (reg & CCCR_HIGH_SPEED_SHS) {
                        reg |= CCCR_HIGH_SPEED_EHS;
                        sdmmc_io_write_1(sf, SD_IO_CCCR_HIGH_SPEED, reg);
                        sf->csd.tran_speed = 50000;     /* 50MHz */

                        /* Wait 400KHz x 8 clock */
                        sdmmc_delay(20);
                }
                if (sc->sc_busclk > sf->csd.tran_speed)
                        sc->sc_busclk = sf->csd.tran_speed;
                error =
                    sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, sc->sc_busclk,
                        false);
                if (error)
                        aprint_error_dev(sc->sc_dev,
                            "can't change bus clock\n");

                aprint_normal_dev(sc->sc_dev, "%u-bit width,", sf->width);
                if ((sc->sc_busclk / 1000) != 0)
                        aprint_normal(" %u.%03u MHz\n",
                            sc->sc_busclk / 1000, sc->sc_busclk % 1000);
                else
                        aprint_normal(" %u KHz\n", sc->sc_busclk % 1000);


        } else {
                reg = sdmmc_io_read_1(sf0, SD_IO_FBR(sf->number) + 0x000);
                sf->interface = FBR_STD_FUNC_IF_CODE(reg);
                if (sf->interface == 0x0f)
                        sf->interface =
                            sdmmc_io_read_1(sf0, SD_IO_FBR(sf->number) + 0x001);
                error = sdmmc_read_cis(sf, &sf->cis);
                if (error) {
                        aprint_error_dev(sc->sc_dev, "couldn't read CIS\n");
                        SET(sf->flags, SFF_ERROR);
                        goto out;
                }

                sdmmc_check_cis_quirks(sf);

#ifdef SDMMC_DEBUG
                if (sdmmcdebug)
                        sdmmc_print_cis(sf);
#endif
        }

out:
        SDMMC_UNLOCK(sc);

        return error;
}

/*
 * Indicate whether the function is ready to operate.
 */
static int
sdmmc_io_function_ready(struct sdmmc_function *sf)
{
        struct sdmmc_softc *sc = sf->sc;
        struct sdmmc_function *sf0 = sc->sc_fn0;
        uint8_t reg;

        if (sf->number == 0)
                return 1;       /* FN0 is always ready */

        SDMMC_LOCK(sc);
        reg = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_IOREADY);
        SDMMC_UNLOCK(sc);
        return (reg & (1 << sf->number)) != 0;
}

int
sdmmc_io_function_enable(struct sdmmc_function *sf)
{
        struct sdmmc_softc *sc = sf->sc;
        struct sdmmc_function *sf0 = sc->sc_fn0;
        uint8_t reg;
        int retry;

        if (sf->number == 0)
                return 0;       /* FN0 is always enabled */

        SDMMC_LOCK(sc);
        reg = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_ENABLE);
        SET(reg, (1U << sf->number));
        sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_ENABLE, reg);
        SDMMC_UNLOCK(sc);

        retry = 5;
        while (!sdmmc_io_function_ready(sf) && retry-- > 0)
                kpause("pause", false, hz, NULL);
        return (retry >= 0) ? 0 : ETIMEDOUT;
}

/*
 * Disable the I/O function.  Return zero if the function was
 * disabled successfully.
 */
void
sdmmc_io_function_disable(struct sdmmc_function *sf)
{
        struct sdmmc_softc *sc = sf->sc;
        struct sdmmc_function *sf0 = sc->sc_fn0;
        uint8_t reg;

        if (sf->number == 0)
                return;         /* FN0 is always enabled */

        SDMMC_LOCK(sc);
        reg = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_ENABLE);
        CLR(reg, (1U << sf->number));
        sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_ENABLE, reg);
        SDMMC_UNLOCK(sc);
}

static int
sdmmc_io_rw_direct(struct sdmmc_softc *sc, struct sdmmc_function *sf,
    int reg, u_char *datap, int arg, bool toutok)
{
        struct sdmmc_command cmd;
        int error;

        /* Don't lock */

        /* Make sure the card is selected. */
        error = sdmmc_select_card(sc, sf);
        if (error)
                return error;

        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;

        memset(&cmd, 0, sizeof cmd);
        cmd.c_opcode = SD_IO_RW_DIRECT;
        cmd.c_arg = arg;
        cmd.c_flags = SCF_CMD_AC | SCF_RSP_R5;
        if (toutok)
                cmd.c_flags |= SCF_TOUT_OK;

        error = sdmmc_mmc_command(sc, &cmd);
        if (error == 0)
                *datap = SD_R5_DATA(cmd.c_resp);

        if (error && error != ETIMEDOUT) {
                device_printf(sc->sc_dev,
                    "direct I/O error %d, r=%d p=%p %s\n",
                    error, reg, datap,
                    ISSET(arg, SD_ARG_CMD52_WRITE) ? "write" : "read");
        }

        return error;
}

/*
 * Useful values of `arg' to pass in are either SD_ARG_CMD53_READ or
 * SD_ARG_CMD53_WRITE.  SD_ARG_CMD53_INCREMENT may be ORed into `arg'
 * to access successive register locations instead of accessing the
 * same register many times.  SD_ARG_CMD53_BLOCK_MODE may be ORed
 * into `arg' to indicate that the length is a number of blocks.
 */
static int
sdmmc_io_rw_extended(struct sdmmc_softc *sc, struct sdmmc_function *sf,
    int reg, u_char *datap, int len, int arg)
{
        struct sdmmc_command cmd;
        int error, datalen;

        /* Don't lock */

        datalen = len;
        if (ISSET(arg, SD_ARG_CMD53_BLOCK_MODE))
                datalen *= sf->blklen;

#if 0
        /* Make sure the card is selected. */
        error = sdmmc_select_card(sc, sf);
        if (error)
                return error;
#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 |= (len & SD_ARG_CMD53_LENGTH_MASK) <<
            SD_ARG_CMD53_LENGTH_SHIFT;

        memset(&cmd, 0, sizeof cmd);
        cmd.c_opcode = SD_IO_RW_EXTENDED;
        cmd.c_arg = arg;
        cmd.c_flags = SCF_CMD_ADTC | SCF_RSP_R5 | SCF_NO_STOP;
        cmd.c_data = datap;
        cmd.c_datalen = datalen;
        cmd.c_blklen = MIN(datalen, sf->blklen);

        if (!ISSET(arg, SD_ARG_CMD53_WRITE))
                cmd.c_flags |= SCF_CMD_READ;

        if (ISSET(sc->sc_caps, SMC_CAPS_DMA) && datalen > 8) {
                int lflags, preops, postops;

                if (cmd.c_flags & SCF_CMD_READ) {
                        lflags = BUS_DMA_READ;
                        preops = BUS_DMASYNC_PREREAD;
                        postops = BUS_DMASYNC_POSTREAD;
                } else {
                        lflags = BUS_DMA_WRITE;
                        preops = BUS_DMASYNC_PREWRITE;
                        postops = BUS_DMASYNC_POSTWRITE;
                }

                error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmap,
                    datap, datalen, NULL, lflags);
                if (error != 0) {
                        DPRINTF(("%s: dmamap load error = %d\n", __func__,
                            error));
                        goto do_pio;
                }
                if (!sdmmc_alignment_ok(sc, sc->sc_dmap)) {
                        bus_dmamap_unload(sc->sc_dmat, sc->sc_dmap);
                        goto do_pio;
                }

                bus_dmamap_sync(sc->sc_dmat, sc->sc_dmap,
                    0, datalen, preops);
                cmd.c_dmamap = sc->sc_dmap;
                error = sdmmc_mmc_command(sc, &cmd);
                if (error == 0) {
                        bus_dmamap_sync(sc->sc_dmat, sc->sc_dmap,
                            0, datalen, postops);
                }

                bus_dmamap_unload(sc->sc_dmat, sc->sc_dmap);
        } else {
do_pio:
                error = sdmmc_mmc_command(sc, &cmd);
        }

        if (error) {
                device_printf(sc->sc_dev,
                    "extended I/O error %d, r=%d p=%p l=%d %s\n",
                    error, reg, datap, datalen,
                    ISSET(arg, SD_ARG_CMD53_WRITE) ? "write" : "read");
        }

        return error;
}

uint8_t
sdmmc_io_read_1(struct sdmmc_function *sf, int reg)
{
        uint8_t data = 0;

        /* Don't lock */

        (void)sdmmc_io_rw_direct(sf->sc, sf, reg, (u_char *)&data,
            SD_ARG_CMD52_READ, false);
        return data;
}

void
sdmmc_io_write_1(struct sdmmc_function *sf, int reg, uint8_t data)
{

        /* Don't lock */

        (void)sdmmc_io_rw_direct(sf->sc, sf, reg, (u_char *)&data,
            SD_ARG_CMD52_WRITE, false);
}

uint16_t
sdmmc_io_read_2(struct sdmmc_function *sf, int reg)
{
        uint16_t data = 0;

        /* Don't lock */

        (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 2,
            SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
        return data;
}

void
sdmmc_io_write_2(struct sdmmc_function *sf, int reg, uint16_t data)
{

        /* Don't lock */

        (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 2,
            SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
}

uint32_t
sdmmc_io_read_4(struct sdmmc_function *sf, int reg)
{
        uint32_t data = 0;

        /* Don't lock */

        (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 4,
            SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
        return data;
}

void
sdmmc_io_write_4(struct sdmmc_function *sf, int reg, uint32_t data)
{

        /* Don't lock */

        (void)sdmmc_io_rw_extended(sf->sc, sf, reg, (u_char *)&data, 4,
            SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
}


int
sdmmc_io_read_multi_1(struct sdmmc_function *sf, int reg, u_char *data,
    int datalen)
{
        int blocks, error = 0;

        /* Don't lock */

        while (datalen >= sf->blklen) {
                blocks = imin(datalen / sf->blklen,
                              SD_ARG_CMD53_LENGTH_MAX);
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
                    blocks, SD_ARG_CMD53_READ | SD_ARG_CMD53_BLOCK_MODE);
                if (error)
                        goto error;
                data += blocks * sf->blklen;
                datalen -= blocks * sf->blklen;
        }

        if (datalen)
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
                    SD_ARG_CMD53_READ);
error:
        return error;
}

int
sdmmc_io_write_multi_1(struct sdmmc_function *sf, int reg, u_char *data,
    int datalen)
{
        int blocks, error = 0;

        /* Don't lock */

        while (datalen >= sf->blklen) {
                blocks = imin(datalen / sf->blklen,
                             SD_ARG_CMD53_LENGTH_MAX);
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
                    blocks, SD_ARG_CMD53_WRITE | SD_ARG_CMD53_BLOCK_MODE);
                if (error)
                        goto error;
                data += blocks * sf->blklen;
                datalen -= blocks * sf->blklen;
        }

        if (datalen)
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
                    SD_ARG_CMD53_WRITE);
error:
        return error;
}


int
sdmmc_io_read_region_1(struct sdmmc_function *sf, int reg, u_char *data,
    int datalen)
{
        int blocks, error = 0;

        /* Don't lock */

        while (datalen >= sf->blklen) {
                blocks = imin(datalen / sf->blklen,
                              SD_ARG_CMD53_LENGTH_MAX);
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
                    blocks, SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT |
                    SD_ARG_CMD53_BLOCK_MODE);
                if (error)
                        goto error;
                reg += blocks * sf->blklen;
                data += blocks * sf->blklen;
                datalen -= blocks * sf->blklen;
        }

        if (datalen)
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
                    SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT);
error:
        return error;
}

int
sdmmc_io_write_region_1(struct sdmmc_function *sf, int reg, u_char *data,
    int datalen)
{
        int blocks, error = 0;

        /* Don't lock */

        while (datalen >= sf->blklen) {
                blocks = imin(datalen / sf->blklen,
                              SD_ARG_CMD53_LENGTH_MAX);
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data,
                    blocks, SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT |
                    SD_ARG_CMD53_BLOCK_MODE);
                if (error)
                        goto error;
                reg += blocks * sf->blklen;
                data += blocks * sf->blklen;
                datalen -= blocks * sf->blklen;
        }

        if (datalen)
                error = sdmmc_io_rw_extended(sf->sc, sf, reg, data, datalen,
                    SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT);
error:
        return error;
}

#if 0
static int
sdmmc_io_xchg(struct sdmmc_softc *sc, struct sdmmc_function *sf,
    int reg, u_char *datap)
{

        /* Don't lock */

        return sdmmc_io_rw_direct(sc, sf, reg, datap,
            SD_ARG_CMD52_WRITE|SD_ARG_CMD52_EXCHANGE, false);
}
#endif

/*
 * Abort I/O function of the card
 */
int
sdmmc_io_function_abort(struct sdmmc_function *sf)
{
        u_char data = CCCR_CTL_AS(sf->number);

        return sdmmc_io_rw_direct(sf->sc, NULL, SD_IO_CCCR_CTL, &data,
            SD_ARG_CMD52_WRITE, true);
}

/*
 * Reset the I/O functions of the card.
 */
static void
sdmmc_io_reset(struct sdmmc_softc *sc)
{
        u_char data = CCCR_CTL_RES;

        if (sdmmc_io_rw_direct(sc, NULL, SD_IO_CCCR_CTL, &data,
            SD_ARG_CMD52_WRITE, true) == 0)
                sdmmc_pause(100000, NULL); /* XXX SDMMC_LOCK */
}

/*
 * Get or set the card's I/O OCR value (SDIO).
 */
static int
sdmmc_io_send_op_cond(struct sdmmc_softc *sc, u_int32_t ocr, u_int32_t *ocrp)
{
        struct sdmmc_command cmd;
        int error;
        int retry;

        DPRINTF(("sdmmc_io_send_op_cond: ocr = %#x\n", ocr));

        /* Don't lock */

        /*
         * If we change the OCR value, retry the command until the OCR
         * we receive in response has the "CARD BUSY" bit set, meaning
         * that all cards are ready for identification.
         */
        for (retry = 0; retry < 100; retry++) {
                memset(&cmd, 0, sizeof cmd);
                cmd.c_opcode = SD_IO_SEND_OP_COND;
                cmd.c_arg = ocr;
                cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R4 | SCF_TOUT_OK;

                error = sdmmc_mmc_command(sc, &cmd);
                if (error)
                        break;
                if (ISSET(MMC_R4(cmd.c_resp), SD_IO_OCR_MEM_READY) || ocr == 0)
                        break;

                error = ETIMEDOUT;
                sdmmc_pause(10000, NULL);
        }
        if (error == 0 && ocrp != NULL)
                *ocrp = MMC_R4(cmd.c_resp);

        DPRINTF(("sdmmc_io_send_op_cond: error = %d\n", error));

        return error;
}

/*
 * Card interrupt handling
 */

void
sdmmc_intr_enable(struct sdmmc_function *sf)
{
        struct sdmmc_softc *sc = sf->sc;
        struct sdmmc_function *sf0 = sc->sc_fn0;
        uint8_t reg;

        SDMMC_LOCK(sc);
        reg = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_INTEN);
        reg |= 1 << sf->number;
        sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_INTEN, reg);
        SDMMC_UNLOCK(sc);
}

void
sdmmc_intr_disable(struct sdmmc_function *sf)
{
        struct sdmmc_softc *sc = sf->sc;
        struct sdmmc_function *sf0 = sc->sc_fn0;
        uint8_t reg;

        SDMMC_LOCK(sc);
        reg = sdmmc_io_read_1(sf0, SD_IO_CCCR_FN_INTEN);
        reg &= ~(1 << sf->number);
        sdmmc_io_write_1(sf0, SD_IO_CCCR_FN_INTEN, reg);
        SDMMC_UNLOCK(sc);
}

/*
 * Establish a handler for the SDIO card interrupt.  Because the
 * interrupt may be shared with different SDIO functions, multiple
 * handlers can be established.
 */
void *
sdmmc_intr_establish(device_t dev, int (*fun)(void *), void *arg,
    const char *name)
{
        struct sdmmc_softc *sc = device_private(dev);
        struct sdmmc_intr_handler *ih;

        if (sc->sc_sct->card_enable_intr == NULL)
                return NULL;

        ih = malloc(sizeof *ih, M_DEVBUF, M_WAITOK|M_ZERO);
        if (ih == NULL)
                return NULL;

        ih->ih_name = malloc(strlen(name) + 1, M_DEVBUF, M_WAITOK|M_ZERO);
        if (ih->ih_name == NULL) {
                free(ih, M_DEVBUF);
                return NULL;
        }
        strlcpy(ih->ih_name, name, strlen(name));
        ih->ih_softc = sc;
        ih->ih_fun = fun;
        ih->ih_arg = arg;

        mutex_enter(&sc->sc_mtx);
        if (TAILQ_EMPTY(&sc->sc_intrq)) {
                sdmmc_intr_enable(sc->sc_fn0);
                sdmmc_chip_card_enable_intr(sc->sc_sct, sc->sc_sch, 1);
        }
        TAILQ_INSERT_TAIL(&sc->sc_intrq, ih, entry);
        mutex_exit(&sc->sc_mtx);

        return ih;
}

/*
 * Disestablish the given handler.
 */
void
sdmmc_intr_disestablish(void *cookie)
{
        struct sdmmc_intr_handler *ih = cookie;
        struct sdmmc_softc *sc = ih->ih_softc;

        if (sc->sc_sct->card_enable_intr == NULL)
                return;

        mutex_enter(&sc->sc_mtx);
        TAILQ_REMOVE(&sc->sc_intrq, ih, entry);
        if (TAILQ_EMPTY(&sc->sc_intrq)) {
                sdmmc_chip_card_enable_intr(sc->sc_sct, sc->sc_sch, 0);
                sdmmc_intr_disable(sc->sc_fn0);
        }
        mutex_exit(&sc->sc_mtx);

        free(ih->ih_name, M_DEVBUF);
        free(ih, M_DEVBUF);
}

/*
 * Call established SDIO card interrupt handlers.  The host controller
 * must call this function from its own interrupt handler to handle an
 * SDIO interrupt from the card.
 */
void
sdmmc_card_intr(device_t dev)
{
        struct sdmmc_softc *sc = device_private(dev);

        if (sc->sc_sct->card_enable_intr == NULL)
                return;

        sdmmc_add_task(sc, &sc->sc_intr_task);
}

void
sdmmc_intr_task(void *arg)
{
        struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
        struct sdmmc_intr_handler *ih;

        mutex_enter(&sc->sc_mtx);
        TAILQ_FOREACH(ih, &sc->sc_intrq, entry) {
                /* XXX examine return value and do evcount stuff*/
                (void)(*ih->ih_fun)(ih->ih_arg);
        }
        mutex_exit(&sc->sc_mtx);

        sdmmc_chip_card_intr_ack(sc->sc_sct, sc->sc_sch);
}

int
sdmmc_io_set_blocklen(struct sdmmc_function *sf,
     int blklen)
{
        struct sdmmc_softc *sc = sf->sc;
        struct sdmmc_function *sf0 = sc->sc_fn0;
        int error = EINVAL;

        SDMMC_LOCK(sc);

        if (blklen <= 0 ||
            blklen > sdmmc_chip_host_maxblklen(sc->sc_sct, sc->sc_sch))
                goto err;

        sdmmc_io_write_1(sf0, SD_IO_FBR(sf->number) +
            SD_IO_FBR_BLOCKLEN, blklen & 0xff);
        sdmmc_io_write_1(sf0, SD_IO_FBR(sf->number) +
            SD_IO_FBR_BLOCKLEN + 1, (blklen >> 8) & 0xff);

        sf->blklen = blklen;
        error = 0;

err:
        SDMMC_UNLOCK(sc);

        return error;
}