From owner-svn-src-all@freebsd.org Thu Jun 28 21:14:34 2018 Return-Path: Delivered-To: svn-src-all@mailman.ysv.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mailman.ysv.freebsd.org (Postfix) with ESMTP id E018B1027698; Thu, 28 Jun 2018 21:14:33 +0000 (UTC) (envelope-from gonzo@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client CN "mxrelay.nyi.freebsd.org", Issuer "Let's Encrypt Authority X3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 852D78E61E; Thu, 28 Jun 2018 21:14:33 +0000 (UTC) (envelope-from gonzo@FreeBSD.org) Received: from repo.freebsd.org (repo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:0]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 608CC179AB; Thu, 28 Jun 2018 21:14:33 +0000 (UTC) (envelope-from gonzo@FreeBSD.org) Received: from repo.freebsd.org ([127.0.1.37]) by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id w5SLEXHs061322; Thu, 28 Jun 2018 21:14:33 GMT (envelope-from gonzo@FreeBSD.org) Received: (from gonzo@localhost) by repo.freebsd.org (8.15.2/8.15.2/Submit) id w5SLEXr2061320; Thu, 28 Jun 2018 21:14:33 GMT (envelope-from gonzo@FreeBSD.org) Message-Id: <201806282114.w5SLEXr2061320@repo.freebsd.org> X-Authentication-Warning: repo.freebsd.org: gonzo set sender to gonzo@FreeBSD.org using -f From: Oleksandr Tymoshenko Date: Thu, 28 Jun 2018 21:14:33 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r335779 - in head/sys: arm/broadcom/bcm2835 conf X-SVN-Group: head X-SVN-Commit-Author: gonzo X-SVN-Commit-Paths: in head/sys: arm/broadcom/bcm2835 conf X-SVN-Commit-Revision: 335779 X-SVN-Commit-Repository: base MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: svn-src-all@freebsd.org X-Mailman-Version: 2.1.26 Precedence: list List-Id: "SVN commit messages for the entire src tree \(except for " user" and " projects" \)" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 28 Jun 2018 21:14:34 -0000 Author: gonzo Date: Thu Jun 28 21:14:33 2018 New Revision: 335779 URL: https://svnweb.freebsd.org/changeset/base/335779 Log: [rpi] Add SDHOST device driver for Raspberry Pi SDHOST is another SD controller that is present on Raspberry Pi (the other one is SDHC and handled by bcm2835_sdhci driver). Both controllers are capable of providing interface to SD card, actual configuration can be set in dtb file. At the moment custom DTBs for RPi/RPi2 have sdhost node disabled. On RPi3 sdhost is disabled in snapshot images by applying mmc.dtbo overlay. To enalbe both devices user has to edit config.txt on FAT partition and remove or comment "dtoverlay=mmc" line. When no overlay applied on RPi3 SDHOST controls SD card and SDHC interface can be used for SDIO. mmc.dtbo overlay disables SDHOST node and switches SD card over to SDHC. Likewise sdhost.dtbo overlay (not currently included in snapshot image, but can be obtained from firmare repo[1]) disabled SDHC node and switch SD card over to SDHOST. [1] https://github.com/raspberrypi/firmware/tree/master/boot/overlays Submitted by: Klaus P. Ohrhallinger Differential Revision: https://reviews.freebsd.org/D14168 Added: head/sys/arm/broadcom/bcm2835/bcm2835_sdhost.c (contents, props changed) Modified: head/sys/arm/broadcom/bcm2835/files.bcm283x head/sys/conf/files.arm64 Added: head/sys/arm/broadcom/bcm2835/bcm2835_sdhost.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/arm/broadcom/bcm2835/bcm2835_sdhost.c Thu Jun 28 21:14:33 2018 (r335779) @@ -0,0 +1,1301 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2018 Klaus P. Ohrhallinger + * All rights reserved. + * + * Based on bcm2835_sdhci.c: + * Copyright (c) 2012 Oleksandr Tymoshenko + * 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 +__FBSDID("$FreeBSD$"); + +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include + +#include + +#include "mmcbr_if.h" +#include "sdhci_if.h" + +#include "opt_mmccam.h" + +#include "bcm2835_dma.h" +#include +#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); +} + +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); +} + +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_generic_probe(dev); + bus_generic_attach(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; *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***