Skip site navigation (1)Skip section navigation (2)
Date:      Thu, 28 Jun 2018 21:14:33 +0000 (UTC)
From:      Oleksandr Tymoshenko <gonzo@FreeBSD.org>
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
Message-ID:  <201806282114.w5SLEXr2061320@repo.freebsd.org>

next in thread | raw e-mail | index | archive | help
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 <k@7he.at>
  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 <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>
+__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 <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);
+}
+
+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 ***



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201806282114.w5SLEXr2061320>