/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2018 Klaus P. Ohrhallinger <k@7he.at>
 * All rights reserved.
 *
 * Based on bcm2835_sdhci.c:
 * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@freebsd.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */
#include <sys/cdefs.h>
/*
 * pin 48-53 - card slot
 * pin 34-39 - radio module
 *
 * alt-0 - rubbish SDHCI  (0x7e202000) aka sdhost
 * alt-3 - advanced SDHCI (0x7e300000) aka sdhci/mmc/sdio
 *
 * driving card slot with mmc:
 *
 * sdhost_pins {
 *         brcm,pins = <0x30 0x31 0x32 0x33 0x34 0x35>;
 *         brcm,function = <0x7>;
 *         brcm,pull = <0x0 0x2 0x2 0x2 0x2 0x2>;
 *         phandle = <0x17>;
 * };
 * sdio_pins {
 *         brcm,pins = <0x22 0x23 0x24 0x25 0x26 0x27>;
 *         brcm,function = <0x4>;
 *         brcm,pull = <0x0 0x2 0x2 0x2 0x2 0x2>;
 *         phandle = <0x18>;
 * };
 *
 * driving card slot with sdhost:
 *
 * sdhost_pins {
 *         brcm,pins = <0x30 0x31 0x32 0x33 0x34 0x35>;
 *         brcm,function = <0x4>;
 *         brcm,pull = <0x0 0x2 0x2 0x2 0x2 0x2>;
 *         phandle = <0x17>;
 * };
 * sdio_pins {
 *         brcm,pins = <0x22 0x23 0x24 0x25 0x26 0x27>;
 *         brcm,function = <0x7>;
 *         brcm,pull = <0x0 0x2 0x2 0x2 0x2 0x2>;
 *         phandle = <0x18>;
 * };
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kobj.h>
#include <sys/bus.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/rman.h>
#include <sys/sysctl.h>
#include <sys/taskqueue.h>
#include <sys/gpio.h>

#include <machine/bus.h>

#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>

#include <dev/mmc/bridge.h>
#include <dev/mmc/mmcreg.h>

#include <dev/sdhci/sdhci.h>

#include "mmcbr_if.h"
#include "sdhci_if.h"

#include "opt_mmccam.h"

#include "bcm2835_dma.h"
#include <arm/broadcom/bcm2835/bcm2835_mbox_prop.h>
#include "bcm2835_vcbus.h"

/* #define SDHOST_DEBUG */

/* Registers */
#define HC_COMMAND              0x00    /* Command and flags */
#define HC_ARGUMENT             0x04
#define HC_TIMEOUTCOUNTER       0x08
#define HC_CLOCKDIVISOR         0x0c
#define HC_RESPONSE_0           0x10
#define HC_RESPONSE_1           0x14
#define HC_RESPONSE_2           0x18
#define HC_RESPONSE_3           0x1c
#define HC_HOSTSTATUS           0x20
#define HC_POWER                0x30
#define HC_DEBUG                0x34
#define HC_HOSTCONFIG           0x38
#define HC_BLOCKSIZE            0x3c
#define HC_DATAPORT             0x40
#define HC_BLOCKCOUNT           0x50

/* Flags for HC_COMMAND register */
#define HC_CMD_ENABLE                   0x8000
#define HC_CMD_FAILED                   0x4000
#define HC_CMD_BUSY                     0x0800
#define HC_CMD_RESPONSE_NONE            0x0400
#define HC_CMD_RESPONSE_LONG            0x0200
#define HC_CMD_WRITE                    0x0080
#define HC_CMD_READ                     0x0040
#define HC_CMD_COMMAND_MASK             0x003f

#define HC_CLOCKDIVISOR_MAXVAL          0x07ff

/* Flags for HC_HOSTSTATUS register */
#define HC_HSTST_HAVEDATA               0x0001
#define HC_HSTST_ERROR_FIFO             0x0008
#define HC_HSTST_ERROR_CRC7             0x0010
#define HC_HSTST_ERROR_CRC16            0x0020
#define HC_HSTST_TIMEOUT_CMD            0x0040
#define HC_HSTST_TIMEOUT_DATA           0x0080
#define HC_HSTST_INT_BLOCK              0x0200
#define HC_HSTST_INT_BUSY               0x0400

#define HC_HSTST_RESET                  0xffff

#define HC_HSTST_MASK_ERROR_DATA        (HC_HSTST_ERROR_FIFO | \
    HC_HSTST_ERROR_CRC7 | HC_HSTST_ERROR_CRC16 | HC_HSTST_TIMEOUT_DATA)

#define HC_HSTST_MASK_ERROR_ALL         (HC_HSTST_MASK_ERROR_DATA | \
    HC_HSTST_TIMEOUT_CMD)

/* Flags for HC_HOSTCONFIG register */
#define HC_HSTCF_INTBUS_WIDE            0x0002
#define HC_HSTCF_EXTBUS_4BIT            0x0004
#define HC_HSTCF_SLOW_CARD              0x0008
#define HC_HSTCF_INT_DATA               0x0010
#define HC_HSTCF_INT_BLOCK              0x0100
#define HC_HSTCF_INT_BUSY               0x0400

/* Flags for HC_DEBUG register */
#define HC_DBG_FIFO_THRESH_WRITE_SHIFT  9
#define HC_DBG_FIFO_THRESH_READ_SHIFT   14
#define HC_DBG_FIFO_THRESH_MASK         0x001f

/* Settings */
#define HC_FIFO_SIZE            16
#define HC_FIFO_THRESH_READ     4
#define HC_FIFO_THRESH_WRITE    4

#define HC_TIMEOUT_DEFAULT      0x00f00000

#define BCM2835_DEFAULT_SDHCI_FREQ      50

static int bcm2835_sdhost_debug = 0;

#ifdef SDHOST_DEBUG

TUNABLE_INT("hw.bcm2835.sdhost.debug", &bcm2835_sdhost_debug);
SYSCTL_INT(_hw_sdhci, OID_AUTO, bcm2835_sdhost_debug, CTLFLAG_RWTUN,
    &bcm2835_sdhost_debug, 0, "bcm2835-sdhost Debug level");

#define dprintf(fmt, args...) \
        do { \
                if (bcm2835_sdhost_debug > 0) \
                        printf(fmt,##args); \
        } while (0)
#else

#define dprintf(fmt, args...)

#endif /* ! SDHOST_DEBUG */

static struct ofw_compat_data compat_data[] = {
        {"brcm,bcm2835-sdhost",         1},
        {NULL,                          0}
};

struct bcm_sdhost_softc {
        device_t                sc_dev;
        struct resource *       sc_mem_res;
        struct resource *       sc_irq_res;
        bus_space_tag_t         sc_bst;
        bus_space_handle_t      sc_bsh;
        void *                  sc_intrhand;
        struct mmc_request *    sc_req;
        struct sdhci_slot       sc_slot;

        struct mtx              mtx;

        char                    cmdbusy;
        char                    mmc_app_cmd;

        u_int32_t               sdhci_int_status;
        u_int32_t               sdhci_signal_enable;
        u_int32_t               sdhci_present_state;
        u_int32_t               sdhci_blocksize;
        u_int32_t               sdhci_blockcount;

        u_int32_t               sdcard_rca;
};

static int bcm_sdhost_probe(device_t);
static int bcm_sdhost_attach(device_t);
static int bcm_sdhost_detach(device_t);
static void bcm_sdhost_intr(void *);

static int bcm_sdhost_get_ro(device_t, device_t);

static inline uint32_t
RD4(struct bcm_sdhost_softc *sc, bus_size_t off)
{
        uint32_t val;

        val = bus_space_read_4(sc->sc_bst, sc->sc_bsh, off);

        return (val);
}

static inline void
WR4(struct bcm_sdhost_softc *sc, bus_size_t off, uint32_t val)
{

        bus_space_write_4(sc->sc_bst, sc->sc_bsh, off, val);
}

#ifdef notyet
static inline uint16_t
RD2(struct bcm_sdhost_softc *sc, bus_size_t off)
{
        uint32_t val;

        val = RD4(sc, off & ~3);

        return ((val >> (off & 3)*8) & 0xffff);
}
#endif

static inline uint8_t
RD1(struct bcm_sdhost_softc *sc, bus_size_t off)
{
        uint32_t val;

        val = RD4(sc, off & ~3);

        return ((val >> (off & 3)*8) & 0xff);
}

static inline void
WR2(struct bcm_sdhost_softc *sc, bus_size_t off, uint16_t val)
{
        uint32_t val32;

        val32 = RD4(sc, off & ~3);
        val32 &= ~(0xffff << (off & 3)*8);
        val32 |= (val << (off & 3)*8);
        WR4(sc, off & ~3, val32);
}

static inline void
WR1(struct bcm_sdhost_softc *sc, bus_size_t off, uint8_t val)
{
        uint32_t val32;

        val32 = RD4(sc, off & ~3);
        val32 &= ~(0xff << (off & 3)*8);
        val32 |= (val << (off & 3)*8);
        WR4(sc, off & ~3, val32);
}

static void
bcm_sdhost_print_regs(struct bcm_sdhost_softc *sc, struct sdhci_slot *slot,
    int line, int error)
{

        if (bcm2835_sdhost_debug > 0 || error > 0) {
                printf("%s: sc=%p slot=%p\n",
                    __func__, sc, slot);
                printf("HC_COMMAND:        0x%08x\n",
                    RD4(sc, HC_COMMAND));
                printf("HC_ARGUMENT:       0x%08x\n",
                    RD4(sc, HC_ARGUMENT));
                printf("HC_TIMEOUTCOUNTER: 0x%08x\n",
                    RD4(sc, HC_TIMEOUTCOUNTER));
                printf("HC_CLOCKDIVISOR:   0x%08x\n",
                    RD4(sc, HC_CLOCKDIVISOR));
                printf("HC_RESPONSE_0:     0x%08x\n",
                    RD4(sc, HC_RESPONSE_0));
                printf("HC_RESPONSE_1:     0x%08x\n",
                    RD4(sc, HC_RESPONSE_1));
                printf("HC_RESPONSE_2:     0x%08x\n",
                    RD4(sc, HC_RESPONSE_2));
                printf("HC_RESPONSE_3:     0x%08x\n",
                    RD4(sc, HC_RESPONSE_3));
                printf("HC_HOSTSTATUS:     0x%08x\n",
                    RD4(sc, HC_HOSTSTATUS));
                printf("HC_POWER:          0x%08x\n",
                    RD4(sc, HC_POWER));
                printf("HC_DEBUG:          0x%08x\n",
                    RD4(sc, HC_DEBUG));
                printf("HC_HOSTCONFIG:     0x%08x\n",
                    RD4(sc, HC_HOSTCONFIG));
                printf("HC_BLOCKSIZE:      0x%08x\n",
                    RD4(sc, HC_BLOCKSIZE));
                printf("HC_BLOCKCOUNT:     0x%08x\n",
                    RD4(sc, HC_BLOCKCOUNT));

        } else {
                /*
                printf("%04d | HC_COMMAND: 0x%08x HC_ARGUMENT: 0x%08x "
                    "HC_HOSTSTATUS: 0x%08x HC_HOSTCONFIG: 0x%08x\n",
                    line, RD4(sc, HC_COMMAND), RD4(sc, HC_ARGUMENT),
                    RD4(sc, HC_HOSTSTATUS), RD4(sc, HC_HOSTCONFIG));
                */
        }
}

static void
bcm_sdhost_reset(device_t dev, struct sdhci_slot *slot)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        u_int32_t dbg;

        WR4(sc, HC_POWER, 0);

        WR4(sc, HC_COMMAND, 0);
        WR4(sc, HC_ARGUMENT, 0);
        WR4(sc, HC_TIMEOUTCOUNTER, HC_TIMEOUT_DEFAULT);
        WR4(sc, HC_CLOCKDIVISOR, 0);
        WR4(sc, HC_HOSTSTATUS, HC_HSTST_RESET);
        WR4(sc, HC_HOSTCONFIG, 0);
        WR4(sc, HC_BLOCKSIZE, 0);
        WR4(sc, HC_BLOCKCOUNT, 0);

        dbg = RD4(sc, HC_DEBUG);
        dbg &= ~( (HC_DBG_FIFO_THRESH_MASK << HC_DBG_FIFO_THRESH_READ_SHIFT) |
                  (HC_DBG_FIFO_THRESH_MASK << HC_DBG_FIFO_THRESH_WRITE_SHIFT) );
        dbg |= (HC_FIFO_THRESH_READ << HC_DBG_FIFO_THRESH_READ_SHIFT) |
               (HC_FIFO_THRESH_WRITE << HC_DBG_FIFO_THRESH_WRITE_SHIFT);
        WR4(sc, HC_DEBUG, dbg);

        DELAY(250000);

        WR4(sc, HC_POWER, 1);

        DELAY(250000);

        sc->sdhci_present_state = SDHCI_CARD_PRESENT | SDHCI_CARD_STABLE |
                SDHCI_WRITE_PROTECT;

        WR4(sc, HC_CLOCKDIVISOR, HC_CLOCKDIVISOR_MAXVAL);
        WR4(sc, HC_HOSTCONFIG, HC_HSTCF_INT_BUSY);
}

static int
bcm_sdhost_probe(device_t dev)
{

        dprintf("%s:\n", __func__);

        if (!ofw_bus_status_okay(dev))
                return (ENXIO);

        if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
                return (ENXIO);

        device_set_desc(dev, "Broadcom 2708 SDHOST controller");

        return (BUS_PROBE_DEFAULT);
}

static int
bcm_sdhost_attach(device_t dev)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        int rid, err;
        u_int default_freq;

        dprintf("%s: dev=%p sc=%p unit=%d\n",
            __func__, dev, sc, device_get_unit(dev));

        mtx_init(&sc->mtx, "BCM SDHOST mtx", "bcm_sdhost",
            MTX_DEF | MTX_RECURSE);

        sc->sc_dev = dev;
        sc->sc_req = NULL;

        sc->cmdbusy = 0;
        sc->mmc_app_cmd = 0;
        sc->sdhci_int_status = 0;
        sc->sdhci_signal_enable = 0;
        sc->sdhci_present_state = 0;
        sc->sdhci_blocksize = 0;
        sc->sdhci_blockcount = 0;

        sc->sdcard_rca = 0;

        default_freq = 50;
        err = 0;

        if (bootverbose)
                device_printf(dev, "SDHCI frequency: %dMHz\n", default_freq);

        rid = 0;
        sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
            RF_ACTIVE);
        if (!sc->sc_mem_res) {
                device_printf(dev, "cannot allocate memory window\n");
                err = ENXIO;
                goto fail;
        }

        sc->sc_bst = rman_get_bustag(sc->sc_mem_res);
        sc->sc_bsh = rman_get_bushandle(sc->sc_mem_res);

        bcm_sdhost_reset(dev, &sc->sc_slot);

        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 0);

        rid = 0;
        sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
            RF_ACTIVE);
        if (!sc->sc_irq_res) {
                device_printf(dev, "cannot allocate interrupt\n");
                err = ENXIO;
                goto fail;
        }

        if (bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
            NULL, bcm_sdhost_intr, sc, &sc->sc_intrhand)) {
                device_printf(dev, "cannot setup interrupt handler\n");
                err = ENXIO;
                goto fail;
        }

        sc->sc_slot.caps = 0;
        sc->sc_slot.caps |= SDHCI_CAN_VDD_330;
        sc->sc_slot.caps |= SDHCI_CAN_DO_HISPD;
        sc->sc_slot.caps |= (default_freq << SDHCI_CLOCK_BASE_SHIFT);

        sc->sc_slot.quirks = 0;
        sc->sc_slot.quirks |= SDHCI_QUIRK_MISSING_CAPS;
        sc->sc_slot.quirks |= SDHCI_QUIRK_DONT_SHIFT_RESPONSE;

        sc->sc_slot.opt = 0;

        /* XXX ?
        sc->slot->timeout_clk = ...;
        */

        sdhci_init_slot(dev, &sc->sc_slot, 0);

        bus_identify_children(dev);
        bus_attach_children(dev);

        sdhci_start_slot(&sc->sc_slot);

        return (0);

    fail:
        if (sc->sc_intrhand)
                bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_intrhand);
        if (sc->sc_irq_res)
                bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res);
        if (sc->sc_mem_res)
                bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res);

        return (err);
}

static int
bcm_sdhost_detach(device_t dev)
{

        dprintf("%s:\n", __func__);

        return (EBUSY);
}

/*
 * rv 0 --> command finished
 * rv 1 --> command timed out
 */
static inline int
bcm_sdhost_waitcommand(struct bcm_sdhost_softc *sc)
{
        int timeout = 1000;

        mtx_assert(&sc->mtx, MA_OWNED);

        while ((RD4(sc, HC_COMMAND) & HC_CMD_ENABLE) && --timeout > 0) {
                DELAY(100);
        }

        return ((timeout > 0) ? 0 : 1);
}

static int
bcm_sdhost_waitcommand_status(struct bcm_sdhost_softc *sc)
{
        u_int32_t cdst;
        int i;

        /* wait for card to change status from
         * ''prg'' to ''trn''
         * card status: sd specs p. 103
         */
        i = 0;
        do {
                DELAY(1000);
                WR4(sc, HC_ARGUMENT, sc->sdcard_rca << 16);
                WR4(sc, HC_COMMAND,
                    MMC_SEND_STATUS | HC_CMD_ENABLE);
                bcm_sdhost_waitcommand(sc);
                cdst = RD4(sc, HC_RESPONSE_0);
                dprintf("%s: card status %08x (cs %d)\n",
                    __func__, cdst, (cdst & 0x0e00) >> 9);
                if (i++ > 100) {
                        printf("%s: giving up, "
                            "card status %08x (cs %d)\n",
                            __func__, cdst,
                            (cdst & 0x0e00) >> 9);
                        return (1);
                        break;
                }
        } while (((cdst & 0x0e00) >> 9) != 4);

        return (0);
}

static void
bcm_sdhost_intr(void *arg)
{
        struct bcm_sdhost_softc *sc = arg;
        struct sdhci_slot *slot = &sc->sc_slot;
        uint32_t hstst;
        uint32_t cmd;

        mtx_lock(&sc->mtx);

        hstst = RD4(sc, HC_HOSTSTATUS);
        cmd = RD4(sc, HC_COMMAND);
        if (hstst & HC_HSTST_HAVEDATA) {
                if (cmd & HC_CMD_READ) {
                        sc->sdhci_present_state |= SDHCI_DATA_AVAILABLE;
                        sc->sdhci_int_status |= SDHCI_INT_DATA_AVAIL;
                } else if (cmd & HC_CMD_WRITE) {
                        sc->sdhci_present_state |= SDHCI_SPACE_AVAILABLE;
                        sc->sdhci_int_status |= SDHCI_INT_SPACE_AVAIL;
                } else {
                        panic("%s: hstst & HC_HSTST_HAVEDATA but no "
                            "HC_CMD_READ or HC_CMD_WRITE: cmd=%0x8 "
                            "hstst=%08x\n", __func__, cmd, hstst);
                }
        } else {
                sc->sdhci_present_state &=
                    ~(SDHCI_DATA_AVAILABLE|SDHCI_SPACE_AVAILABLE);
                sc->sdhci_int_status &=
                    ~(SDHCI_INT_DATA_AVAIL|SDHCI_INT_SPACE_AVAIL);
        }

        if (hstst & HC_HSTST_MASK_ERROR_ALL) {
                printf("%s: ERROR: HC_HOSTSTATUS: %08x\n", __func__, hstst);
                bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 1);
                sc->sdhci_int_status |= SDHCI_INT_ERROR;
        } else {
                sc->sdhci_int_status &= ~SDHCI_INT_ERROR;
        }

        dprintf("%s: hstst=%08x offset=%08lx sdhci_present_state=%08x "
            "sdhci_int_status=%08x\n", __func__, hstst, slot->offset,
            sc->sdhci_present_state, sc->sdhci_int_status);

        sdhci_generic_intr(&sc->sc_slot);

        sc->sdhci_int_status &=
            ~(SDHCI_INT_ERROR|SDHCI_INT_DATA_AVAIL|SDHCI_INT_DATA_END);
        sc->sdhci_present_state &= ~SDHCI_DATA_AVAILABLE;

        if ((hstst & HC_HSTST_HAVEDATA) &&
            (sc->sdhci_blocksize * sc->sdhci_blockcount == slot->offset)) {
                dprintf("%s: offset=%08lx sdhci_blocksize=%08x "
                    "sdhci_blockcount=%08x\n", __func__, slot->offset,
                    sc->sdhci_blocksize, sc->sdhci_blockcount);
                sc->sdhci_int_status &=
                    ~(SDHCI_INT_DATA_AVAIL|SDHCI_INT_SPACE_AVAIL);
                sc->sdhci_int_status |= SDHCI_INT_DATA_END;
                sdhci_generic_intr(&sc->sc_slot);
                sc->sdhci_int_status &= ~SDHCI_INT_DATA_END;

                if ((cmd & HC_CMD_COMMAND_MASK) == MMC_READ_MULTIPLE_BLOCK ||
                    (cmd & HC_CMD_COMMAND_MASK) == MMC_WRITE_MULTIPLE_BLOCK) {
                        WR4(sc, HC_ARGUMENT, 0x00000000);
                        WR4(sc, HC_COMMAND,
                            MMC_STOP_TRANSMISSION | HC_CMD_ENABLE);

                        if (bcm_sdhost_waitcommand(sc)) {
                                printf("%s: timeout #1\n", __func__);
                                bcm_sdhost_print_regs(sc, &sc->sc_slot,
                                    __LINE__, 1);
                        }
                }

                if (cmd & HC_CMD_WRITE) {
                        if (bcm_sdhost_waitcommand_status(sc) != 0)
                                sc->sdhci_int_status |= SDHCI_INT_ERROR;
                }

                slot->data_done = 1;

                sc->sdhci_int_status |= SDHCI_INT_RESPONSE;
                sdhci_generic_intr(&sc->sc_slot);
                sc->sdhci_int_status &= ~(SDHCI_INT_RESPONSE|SDHCI_INT_ERROR);
        }

        /* this resets the interrupt */
        WR4(sc, HC_HOSTSTATUS,
            (HC_HSTST_INT_BUSY|HC_HSTST_INT_BLOCK|HC_HSTST_HAVEDATA));

        mtx_unlock(&sc->mtx);
}

static int
bcm_sdhost_get_ro(device_t bus, device_t child)
{

        dprintf("%s:\n", __func__);

        return (0);
}

static bool
bcm_sdhost_get_card_present(device_t dev, struct sdhci_slot *slot)
{

        dprintf("%s:\n", __func__);

        return (1);
}

static void
bcm_sdhost_command(device_t dev, struct sdhci_slot *slot, uint16_t val)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        struct mmc_data *data = slot->curcmd->data;
        uint16_t val2;
        uint8_t opcode;
        uint8_t flags;

        mtx_assert(&sc->mtx, MA_OWNED);

        if (RD4(sc, HC_COMMAND) & HC_CMD_ENABLE) {
                panic("%s: HC_CMD_ENABLE on entry\n", __func__);
        }

        if (sc->cmdbusy == 1)
                panic("%s: cmdbusy\n", __func__);

        sc->cmdbusy = 1;

        val2 = ((val >> 8) & HC_CMD_COMMAND_MASK) | HC_CMD_ENABLE;

        opcode = val >> 8;
        flags = val & 0xff;

        if (opcode == MMC_APP_CMD)
                sc->mmc_app_cmd = 1;

        if ((flags & SDHCI_CMD_RESP_MASK) == SDHCI_CMD_RESP_LONG)
                val2 |= HC_CMD_RESPONSE_LONG;
        else if ((flags & SDHCI_CMD_RESP_MASK) == SDHCI_CMD_RESP_SHORT_BUSY)
                /* XXX XXX when enabled, cmd 7 (select card) blocks forever */
                ;/*val2 |= HC_CMD_BUSY; */
        else if ((flags & SDHCI_CMD_RESP_MASK) == SDHCI_CMD_RESP_SHORT)
                ;
        else
                val2 |= HC_CMD_RESPONSE_NONE;

        if (val2 & HC_CMD_BUSY)
                sc->sdhci_present_state |=
                    SDHCI_CMD_INHIBIT | SDHCI_DAT_INHIBIT;

        if (data != NULL && data->flags & MMC_DATA_READ)
                val2 |= HC_CMD_READ;
        else if (data != NULL && data->flags & MMC_DATA_WRITE)
                val2 |= HC_CMD_WRITE;

        dprintf("%s: SDHCI_COMMAND_FLAGS --> HC_COMMAND   %04x --> %04x\n",
            __func__, val, val2);

        if (opcode == MMC_READ_MULTIPLE_BLOCK ||
            opcode == MMC_WRITE_MULTIPLE_BLOCK) {
                u_int32_t save_sdarg;

                dprintf("%s: issuing MMC_SET_BLOCK_COUNT: CMD %08x ARG %08x\n",
                    __func__, MMC_SET_BLOCK_COUNT | HC_CMD_ENABLE,
                    sc->sdhci_blockcount);

                save_sdarg = RD4(sc, HC_ARGUMENT);
                WR4(sc, HC_ARGUMENT, sc->sdhci_blockcount);
                WR4(sc, HC_COMMAND, MMC_SET_BLOCK_COUNT | HC_CMD_ENABLE);

                /* Seems to always return timeout */

                if (bcm_sdhost_waitcommand(sc)) {
                        printf("%s: timeout #2\n", __func__);
                        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 1);
                } else {
                        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 0);
                }
                WR4(sc, HC_ARGUMENT, save_sdarg);

        } else if (opcode == MMC_SELECT_CARD) {
                sc->sdcard_rca = (RD4(sc, HC_ARGUMENT) >> 16);
        }

        /* actually issuing the command */
        WR4(sc, HC_COMMAND, val2);

        if (val2 & HC_CMD_READ || val2 & HC_CMD_WRITE) {
                u_int8_t hstcfg;

                hstcfg = RD4(sc, HC_HOSTCONFIG);
                hstcfg |= (HC_HSTCF_INT_BUSY | HC_HSTCF_INT_DATA);
                WR4(sc, HC_HOSTCONFIG, hstcfg);
                slot->data_done = 0;

                if (bcm_sdhost_waitcommand(sc)) {
                        printf("%s: timeout #3\n", __func__);
                        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 1);
                }

        } else if (opcode == MMC_ERASE) {
                if (bcm_sdhost_waitcommand_status(sc) != 0) {
                        printf("%s: timeout #4\n", __func__);
                        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 1);
                }
                slot->data_done = 1;
                sc->sdhci_present_state &=
                    ~(SDHCI_CMD_INHIBIT | SDHCI_DAT_INHIBIT);

        } else {
                if (bcm_sdhost_waitcommand(sc)) {
                        printf("%s: timeout #5\n", __func__);
                        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 1);
                }
                slot->data_done = 1;
                sc->sdhci_present_state &=
                    ~(SDHCI_CMD_INHIBIT | SDHCI_DAT_INHIBIT);
        }

        bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 0);

        if (RD4(sc, HC_HOSTSTATUS) & HC_HSTST_TIMEOUT_CMD)
                slot->curcmd->error = MMC_ERR_TIMEOUT;
        else if (RD4(sc, HC_COMMAND) & HC_CMD_FAILED)
                slot->curcmd->error = MMC_ERR_FAILED;

        dprintf("%s: curcmd->flags=%d data_done=%d\n",
            __func__, slot->curcmd->flags, slot->data_done);

        if (val2 & HC_CMD_RESPONSE_NONE)
                slot->curcmd->error = 0;

        if (sc->mmc_app_cmd == 1 && opcode != MMC_APP_CMD)
                sc->mmc_app_cmd = 0;

        if (RD4(sc, HC_COMMAND) & HC_CMD_ENABLE) {
                bcm_sdhost_print_regs(sc, &sc->sc_slot, __LINE__, 1);
                panic("%s: still HC_CMD_ENABLE on exit\n", __func__);
        }

        sc->cmdbusy = 0;

        if (!(val2 & HC_CMD_READ || val2 & HC_CMD_WRITE))
                sc->sdhci_int_status |= SDHCI_INT_RESPONSE;

        /* HACK, so sdhci_finish_command() does not
         * have to be exported
         */
        mtx_unlock(&slot->mtx);
        sdhci_generic_intr(slot);
        mtx_lock(&slot->mtx);
        sc->sdhci_int_status &= ~SDHCI_INT_RESPONSE;
}

static uint8_t
bcm_sdhost_read_1(device_t dev, struct sdhci_slot *slot, bus_size_t off)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        uint32_t val1, val2;

        mtx_lock(&sc->mtx);

        switch (off) {
        case SDHCI_HOST_CONTROL:
                val1 = RD4(sc, HC_HOSTCONFIG);
                val2 = 0;
                if (val1 & HC_HSTCF_EXTBUS_4BIT)
                        val2 |= SDHCI_CTRL_4BITBUS;
                dprintf("%s: SDHCI_HOST_CONTROL --> HC_HOSTCONFIG val2 %02x\n",
                    __func__, val2);
                break;
        case SDHCI_POWER_CONTROL:
                val1 = RD1(sc, HC_POWER);
                val2 = (val1 == 1) ? 0x0f : 0;
                dprintf("%s: SDHCI_POWER_CONTROL --> HC_POWER     val2 %02x\n",
                    __func__, val2);
                break;
        case SDHCI_BLOCK_GAP_CONTROL:
                dprintf("%s: SDHCI_BLOCK_GAP_CONTROL\n", __func__);
                val2 = 0;
                break;
        case SDHCI_WAKE_UP_CONTROL:
                dprintf("%s: SDHCI_WAKE_UP_CONTROL\n", __func__);
                val2 = 0;
                break;
        case SDHCI_TIMEOUT_CONTROL:
                dprintf("%s: SDHCI_TIMEOUT_CONTROL\n", __func__);
                val2 = 0;
                break;
        case SDHCI_SOFTWARE_RESET:
                dprintf("%s: SDHCI_SOFTWARE_RESET\n", __func__);
                val2 = 0;
                break;
        case SDHCI_ADMA_ERR:
                dprintf("%s: SDHCI_ADMA_ERR\n", __func__);
                val2 = 0;
                break;
        default:
                dprintf("%s: UNKNOWN off=%08lx\n", __func__, off);
                val2 = 0;
                break;
        }

        mtx_unlock(&sc->mtx);

        return (val2);
}

static uint16_t
bcm_sdhost_read_2(device_t dev, struct sdhci_slot *slot, bus_size_t off)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        uint32_t val2, val; /* = RD4(sc, off & ~3); */

        mtx_lock(&sc->mtx);

        switch (off) {
        case SDHCI_BLOCK_SIZE:
                val2 = sc->sdhci_blocksize;
                dprintf("%s: SDHCI_BLOCK_SIZE      --> HC_BLOCKSIZE   %08x\n",
                    __func__, val2);
                break;
        case SDHCI_BLOCK_COUNT:
                val2 = sc->sdhci_blockcount;
                dprintf("%s: SDHCI_BLOCK_COUNT     --> HC_BLOCKCOUNT  %08x\n",
                    __func__, val2);
                break;
        case SDHCI_TRANSFER_MODE:
                dprintf("%s: SDHCI_TRANSFER_MODE\n", __func__);
                val2 = 0;
                break;
        case SDHCI_CLOCK_CONTROL:
                val = RD4(sc, HC_CLOCKDIVISOR);
                val2 = (val << SDHCI_DIVIDER_SHIFT) |
                    SDHCI_CLOCK_CARD_EN | SDHCI_CLOCK_INT_EN |
                    SDHCI_CLOCK_INT_STABLE;
                dprintf("%s: SDHCI_CLOCK_CONTROL     %04x --> %04x\n",
                    __func__, val, val2);
                break;
        case SDHCI_ACMD12_ERR:
                dprintf("%s: SDHCI_ACMD12_ERR\n", __func__);
                val2 = 0;
                break;
        case SDHCI_HOST_CONTROL2:
                dprintf("%s: SDHCI_HOST_CONTROL2\n", __func__);
                val2 = 0;
                break;
        case SDHCI_SLOT_INT_STATUS:
                dprintf("%s: SDHCI_SLOT_INT_STATUS\n", __func__);
                val2 = 0;
                break;
        case SDHCI_HOST_VERSION:
                dprintf("%s: SDHCI_HOST_VERSION\n", __func__);
                val2 = 0;
                break;
        default:
                dprintf("%s: UNKNOWN off=%08lx\n", __func__, off);
                val2 = 0;
                break;
        }

        mtx_unlock(&sc->mtx);

        return (val2);
}

static uint32_t
bcm_sdhost_read_4(device_t dev, struct sdhci_slot *slot, bus_size_t off)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        uint32_t val2;

        mtx_lock(&sc->mtx);

        switch (off) {
        case SDHCI_DMA_ADDRESS:
                dprintf("%s: SDHCI_DMA_ADDRESS\n", __func__);
                val2 = 0;
                break;
        case SDHCI_ARGUMENT:
                dprintf("%s: SDHCI_ARGUMENT\n", __func__);
                val2 = (RD4(sc, HC_COMMAND) << 16) |
                    (RD4(sc, HC_ARGUMENT) & 0x0000ffff);
                break;
        case SDHCI_RESPONSE + 0:
                val2 = RD4(sc, HC_RESPONSE_0);
                dprintf("%s: SDHCI_RESPONSE+0       %08x\n", __func__, val2);
                break;
        case SDHCI_RESPONSE + 4:
                val2 = RD4(sc, HC_RESPONSE_1);
                dprintf("%s: SDHCI_RESPONSE+4       %08x\n", __func__, val2);
                break;
        case SDHCI_RESPONSE + 8:
                val2 = RD4(sc, HC_RESPONSE_2);
                dprintf("%s: SDHCI_RESPONSE+8       %08x\n", __func__, val2);
                break;
        case SDHCI_RESPONSE + 12:
                val2 = RD4(sc, HC_RESPONSE_3);
                dprintf("%s: SDHCI_RESPONSE+12      %08x\n", __func__, val2);
                break;
        case SDHCI_BUFFER:
                dprintf("%s: SDHCI_BUFFER\n", __func__);
                val2 = 0;
                break;
        case SDHCI_PRESENT_STATE:
                dprintf("%s: SDHCI_PRESENT_STATE      %08x\n",
                    __func__, sc->sdhci_present_state);
                val2 = sc->sdhci_present_state;
                break;
        case SDHCI_INT_STATUS:
                dprintf("%s: SDHCI_INT_STATUS        %08x\n",
                    __func__, sc->sdhci_int_status);
                val2 = sc->sdhci_int_status;
                break;
        case SDHCI_INT_ENABLE:
                dprintf("%s: SDHCI_INT_ENABLE\n", __func__);
                val2 = 0;
                break;
        case SDHCI_SIGNAL_ENABLE:
                dprintf("%s: SDHCI_SIGNAL_ENABLE      %08x\n",
                    __func__, sc->sdhci_signal_enable);
                val2 = sc->sdhci_signal_enable;
                break;
        case SDHCI_CAPABILITIES:
                val2 = 0;
                break;
        case SDHCI_CAPABILITIES2:
                dprintf("%s: SDHCI_CAPABILITIES2\n", __func__);
                val2 = 0;
                break;
        case SDHCI_MAX_CURRENT:
                dprintf("%s: SDHCI_MAX_CURRENT\n", __func__);
                val2 = 0;
                break;
        case SDHCI_ADMA_ADDRESS_LO:
                dprintf("%s: SDHCI_ADMA_ADDRESS_LO\n", __func__);
                val2 = 0;
                break;
        default:
                dprintf("%s: UNKNOWN off=%08lx\n", __func__, off);
                val2 = 0;
                break;
        }

        mtx_unlock(&sc->mtx);

        return (val2);
}

static void
bcm_sdhost_read_multi_4(device_t dev, struct sdhci_slot *slot, bus_size_t off,
    uint32_t *data, bus_size_t count)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        bus_size_t i;
        bus_size_t avail;
        uint32_t edm;

        mtx_lock(&sc->mtx);

        dprintf("%s: off=%08lx count=%08lx\n", __func__, off, count);

        for (i = 0; i < count;) {
                edm = RD4(sc, HC_DEBUG);
                avail = ((edm >> 4) & 0x1f);
                if (i + avail > count)
                        avail = count - i;
                if (avail > 0)
                        bus_space_read_multi_4(sc->sc_bst, sc->sc_bsh,
                            HC_DATAPORT, data + i, avail);
                i += avail;
                DELAY(1);
        }

        mtx_unlock(&sc->mtx);
}

static void
bcm_sdhost_write_1(device_t dev, struct sdhci_slot *slot,
    bus_size_t off, uint8_t val)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        uint32_t val2;

        mtx_lock(&sc->mtx);

        switch (off) {
        case SDHCI_HOST_CONTROL:
                val2 = RD4(sc, HC_HOSTCONFIG);
                val2 |= HC_HSTCF_INT_BUSY;
                val2 |= HC_HSTCF_INTBUS_WIDE | HC_HSTCF_SLOW_CARD;
                if (val & SDHCI_CTRL_4BITBUS)
                        val2 |= HC_HSTCF_EXTBUS_4BIT;
                dprintf("%s: SDHCI_HOST_CONTROL --> HC_HOSTC %04x --> %04x\n",
                    __func__, val, val2);
                WR4(sc, HC_HOSTCONFIG, val2);
                break;
        case SDHCI_POWER_CONTROL:
                val2 = (val != 0) ? 1 : 0;
                dprintf("%s: SDHCI_POWER_CONTROL --> HC_POWER %02x --> %02x\n",
                    __func__, val, val2);
                WR1(sc, HC_POWER, val2);
                break;
        case SDHCI_BLOCK_GAP_CONTROL:
                dprintf("%s: SDHCI_BLOCK_GAP_CONTROL   val=%02x\n",
                    __func__, val);
                break;
        case SDHCI_TIMEOUT_CONTROL:
                dprintf("%s: SDHCI_TIMEOUT_CONTROL     val=%02x\n",
                    __func__, val);
                break;
        case SDHCI_SOFTWARE_RESET:
                dprintf("%s: SDHCI_SOFTWARE_RESET      val=%02x\n",
                    __func__, val);
                break;
        case SDHCI_ADMA_ERR:
                dprintf("%s: SDHCI_ADMA_ERR            val=%02x\n",
                    __func__, val);
                break;
        default:
                dprintf("%s: UNKNOWN off=%08lx val=%08x\n",
                    __func__, off, val);
                break;
        }

        mtx_unlock(&sc->mtx);
}

static void
bcm_sdhost_write_2(device_t dev, struct sdhci_slot *slot, bus_size_t off, uint16_t val)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        uint16_t val2;

        mtx_lock(&sc->mtx);

        switch (off) {
        case SDHCI_BLOCK_SIZE:
                dprintf("%s: SDHCI_BLOCK_SIZE          val=%04x\n" ,
                    __func__, val);
                sc->sdhci_blocksize = val;
                WR2(sc, HC_BLOCKSIZE, val);
                break;

        case SDHCI_BLOCK_COUNT:
                dprintf("%s: SDHCI_BLOCK_COUNT         val=%04x\n" ,
                    __func__, val);
                sc->sdhci_blockcount = val;
                WR2(sc, HC_BLOCKCOUNT, val);
                break;

        case SDHCI_TRANSFER_MODE:
                dprintf("%s: SDHCI_TRANSFER_MODE       val=%04x\n" ,
                    __func__, val);
                break;

        case SDHCI_COMMAND_FLAGS:
                bcm_sdhost_command(dev, slot, val);
                break;

        case SDHCI_CLOCK_CONTROL:
                val2 = (val & ~SDHCI_DIVIDER_MASK) >> SDHCI_DIVIDER_SHIFT;
                /* get crc16 errors with cdiv=0 */
                if (val2 == 0)
                        val2 = 1;
                dprintf("%s: SDHCI_CLOCK_CONTROL       %04x --> SCDIV %04x\n",
                    __func__, val, val2);
                WR4(sc, HC_CLOCKDIVISOR, val2);
                break;

        case SDHCI_ACMD12_ERR:
                dprintf("%s: SDHCI_ACMD12_ERR          val=%04x\n" ,
                    __func__, val);
                break;

        case SDHCI_HOST_CONTROL2:
                dprintf("%s: SDHCI_HOST_CONTROL2       val=%04x\n" ,
                    __func__, val);
                break;

        case SDHCI_SLOT_INT_STATUS:
                dprintf("%s: SDHCI_SLOT_INT_STATUS     val=%04x\n" ,
                    __func__, val);
                break;

        default:
                dprintf("%s: UNKNOWN off=%08lx val=%04x\n",
                    __func__, off, val);
                break;
        }

        mtx_unlock(&sc->mtx);
}

static void
bcm_sdhost_write_4(device_t dev, struct sdhci_slot *slot, bus_size_t off, uint32_t val)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        uint32_t val2;
        uint32_t hstcfg;

        mtx_lock(&sc->mtx);

        switch (off) {
        case SDHCI_ARGUMENT:
                val2 = val;
                dprintf("%s: SDHCI_ARGUMENT --> HC_ARGUMENT   val=%08x\n",
                    __func__, val);
                WR4(sc, HC_ARGUMENT, val2);
                break;
        case SDHCI_INT_STATUS:
                dprintf("%s: SDHCI_INT_STATUS           val=%08x\n",
                    __func__, val);
                sc->sdhci_int_status = val;
                break;
        case SDHCI_INT_ENABLE:
                dprintf("%s: SDHCI_INT_ENABLE          val=%08x\n" ,
                     __func__, val);
                break;
        case SDHCI_SIGNAL_ENABLE:
                sc->sdhci_signal_enable = val;
                hstcfg = RD4(sc, HC_HOSTCONFIG);
                if (val != 0)
                        hstcfg &= ~(HC_HSTCF_INT_BLOCK | HC_HSTCF_INT_DATA);
                else
                        hstcfg |= (HC_HSTCF_INT_BUSY|HC_HSTCF_INT_BLOCK|
                                 HC_HSTCF_INT_DATA);
                hstcfg |= HC_HSTCF_INT_BUSY;
                dprintf("%s: SDHCI_SIGNAL_ENABLE --> HC_HOSTC %08x --> %08x\n" ,
                    __func__, val, hstcfg);
                WR4(sc, HC_HOSTCONFIG, hstcfg);
                break;
        case SDHCI_CAPABILITIES:
                dprintf("%s: SDHCI_CAPABILITIES        val=%08x\n",
                    __func__, val);
                break;
        case SDHCI_CAPABILITIES2:
                dprintf("%s: SDHCI_CAPABILITIES2       val=%08x\n",
                    __func__, val);
                break;
        case SDHCI_MAX_CURRENT:
                dprintf("%s: SDHCI_MAX_CURRENT         val=%08x\n",
                    __func__, val);
                break;
        case SDHCI_ADMA_ADDRESS_LO:
                dprintf("%s: SDHCI_ADMA_ADDRESS_LO     val=%08x\n",
                    __func__, val);
                break;
        default:
                dprintf("%s: UNKNOWN off=%08lx val=%08x\n",
                    __func__, off, val);
                break;
        }

        mtx_unlock(&sc->mtx);
}

static void
bcm_sdhost_write_multi_4(device_t dev, struct sdhci_slot *slot,
    bus_size_t off, uint32_t *data, bus_size_t count)
{
        struct bcm_sdhost_softc *sc = device_get_softc(dev);
        bus_size_t i;
        bus_size_t space;
        uint32_t edm;

        mtx_lock(&sc->mtx);

        dprintf("%s: off=%08lx count=%02lx\n", __func__, off, count);

        for (i = 0; i < count;) {
                edm = RD4(sc, HC_DEBUG);
                space = HC_FIFO_SIZE - ((edm >> 4) & 0x1f);
                if (i + space > count)
                        space = count - i;
                if (space > 0)
                        bus_space_write_multi_4(sc->sc_bst, sc->sc_bsh,
                            HC_DATAPORT, data + i, space);
                i += space;
                DELAY(1);
        }

        /* wait until FIFO is really empty */
        while (((RD4(sc, HC_DEBUG) >> 4) & 0x1f) > 0)
                DELAY(1);

        mtx_unlock(&sc->mtx);
}

static device_method_t bcm_sdhost_methods[] = {
        /* Device interface */
        DEVMETHOD(device_probe,         bcm_sdhost_probe),
        DEVMETHOD(device_attach,        bcm_sdhost_attach),
        DEVMETHOD(device_detach,        bcm_sdhost_detach),

        /* Bus interface */
        DEVMETHOD(bus_read_ivar,        sdhci_generic_read_ivar),
        DEVMETHOD(bus_write_ivar,       sdhci_generic_write_ivar),

        /* MMC bridge interface */
        DEVMETHOD(mmcbr_update_ios,     sdhci_generic_update_ios),
        DEVMETHOD(mmcbr_request,        sdhci_generic_request),
        DEVMETHOD(mmcbr_get_ro,         bcm_sdhost_get_ro),
        DEVMETHOD(mmcbr_acquire_host,   sdhci_generic_acquire_host),
        DEVMETHOD(mmcbr_release_host,   sdhci_generic_release_host),

        /* SDHCI registers accessors */
        DEVMETHOD(sdhci_read_1,         bcm_sdhost_read_1),
        DEVMETHOD(sdhci_read_2,         bcm_sdhost_read_2),
        DEVMETHOD(sdhci_read_4,         bcm_sdhost_read_4),
        DEVMETHOD(sdhci_read_multi_4,   bcm_sdhost_read_multi_4),
        DEVMETHOD(sdhci_write_1,        bcm_sdhost_write_1),
        DEVMETHOD(sdhci_write_2,        bcm_sdhost_write_2),
        DEVMETHOD(sdhci_write_4,        bcm_sdhost_write_4),
        DEVMETHOD(sdhci_write_multi_4,  bcm_sdhost_write_multi_4),
        DEVMETHOD(sdhci_get_card_present,bcm_sdhost_get_card_present),

        DEVMETHOD_END
};

static driver_t bcm_sdhost_driver = {
        "sdhost_bcm",
        bcm_sdhost_methods,
        sizeof(struct bcm_sdhost_softc),
};

DRIVER_MODULE(sdhost_bcm, simplebus, bcm_sdhost_driver, NULL, NULL);
SDHCI_DEPEND(sdhost_bcm);
#ifndef MMCCAM
MMC_DECLARE_BRIDGE(sdhost_bcm);
#endif