 @@ -1,14 +1,14 @@
-/*	$NetBSD: omap3_sdhc.c,v 1.15 2015/01/12 01:02:35 jakllsch Exp $	*/
+/*	$NetBSD: omap3_sdhc.c,v 1.16 2015/04/14 18:45:25 bouyer Exp $	*/
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas of 3am Software Foundry.
+ *
  * 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
 @@ -19,76 +19,112 @@
  * ``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 FOUNDATION 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>
-__KERNEL_RCSID(0, "$NetBSD: omap3_sdhc.c,v 1.15 2015/01/12 01:02:35 jakllsch Exp $");
+__KERNEL_RCSID(0, "$NetBSD: omap3_sdhc.c,v 1.16 2015/04/14 18:45:25 bouyer Exp $");
 #include "opt_omap.h"
 #include "edma.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/bus.h>
 #include <arm/omap/omap2_obiovar.h>
 #include <arm/omap/omap2_reg.h>
 #include <arm/omap/omap3_sdmmcreg.h>
 #ifdef TI_AM335X
 #  include <arm/omap/am335x_prcm.h>
 #  include <arm/omap/omap2_prcm.h>
 #endif
 #if NEDMA > 0
 #  include <arm/omap/omap_edma.h>
 #endif
 #include <dev/sdmmc/sdhcreg.h>
 #include <dev/sdmmc/sdhcvar.h>
 #include <dev/sdmmc/sdmmcvar.h>
 #ifdef TI_AM335X
 #define EDMA_MAX_PARAMS		32
 #endif
 #ifdef OM3SDHC_DEBUG
 int om3sdhcdebug = 1;
 #define DPRINTF(n,s)    do { if ((n) <= om3sdhcdebug) device_printf s; } while (0)
 #else
 #define DPRINTF(n,s)    do {} while (0)
 #endif
 #define CLKD(kz)	(sc->sc.sc_clkbase / (kz))
 #define SDHC_READ(sc, reg) \
 	bus_space_read_4((sc)->sc_bst, (sc)->sc_sdhc_bsh, (reg))
 #define SDHC_WRITE(sc, reg, val) \
 	bus_space_write_4((sc)->sc_bst, (sc)->sc_sdhc_bsh, (reg), (val))
 static int obiosdhc_match(device_t, cfdata_t, void *);
 static void obiosdhc_attach(device_t, device_t, void *);
 static int obiosdhc_detach(device_t, int);
 static int obiosdhc_bus_clock(struct sdhc_softc *, int);
 static int obiosdhc_rod(struct sdhc_softc *, int);
 static int obiosdhc_write_protect(struct sdhc_softc *);
 static int obiosdhc_card_detect(struct sdhc_softc *);
 struct obiosdhc_softc {
 	struct sdhc_softc	sc;
 	bus_space_tag_t		sc_bst;
 	bus_space_handle_t	sc_bsh;
 	bus_space_handle_t	sc_sdhc_bsh;
 	struct sdhc_host	*sc_hosts[1];
 	void 			*sc_ih;		/* interrupt vectoring */
 #if NEDMA > 0
 	struct edma_channel	*sc_edma_tx;
 	struct edma_channel	*sc_edma_rx;
 	uint16_t		sc_edma_param_tx[EDMA_MAX_PARAMS];
 	uint16_t		sc_edma_param_rx[EDMA_MAX_PARAMS];
 	kmutex_t		sc_edma_lock;
 	kcondvar_t		sc_edma_cv;
 	bus_addr_t		sc_edma_fifo;
 	bool			sc_edma_pending;
 #endif
 };
 #if NEDMA > 0
 static void obiosdhc_edma_init(struct obiosdhc_softc *, unsigned int);
 static int obiosdhc_edma_xfer_data(struct sdhc_softc *, struct sdmmc_command *);
 static void obiosdhc_edma_done(void *);
 #endif
 #ifdef TI_AM335X
 struct am335x_sdhc {
 	const char *as_name;
 	bus_addr_t as_base_addr;
 	int as_intr;
 	struct omap_module as_module;
 };
 static const struct am335x_sdhc am335x_sdhc[] = {
 	/* XXX All offset by 0x100 because of the am335x's mmc registers.  */
 	{ "MMCHS0", SDMMC1_BASE_TIAM335X, 64, { AM335X_PRCM_CM_PER, 0x3c } },
 	{ "MMC1",   SDMMC2_BASE_TIAM335X, 28, { AM335X_PRCM_CM_PER, 0xf4 } },
 	{ "MMCHS2", SDMMC3_BASE_TIAM335X, 29, { AM335X_PRCM_CM_WKUP, 0xf8 } },
 @@ -137,35 +173,35 @@ obiosdhc_match(device_t parent, cfdata_t
         return 0;
+}
 static void
 obiosdhc_attach(device_t parent, device_t self, void *aux)
+{
 	struct obiosdhc_softc * const sc = device_private(self);
 	struct obio_attach_args * const oa = aux;
 	prop_dictionary_t prop = device_properties(self);
 	uint32_t clkd, stat;
 	int error, timo, clksft, n;
 	bool support8bit = false;
 	const char *transfer_mode = "PIO";
 #ifdef TI_AM335X
 	size_t i;
 #endif
 	prop_dictionary_get_bool(prop, "8bit", &support8bit);
 	sc->sc.sc_dmat = oa->obio_dmat;
 	sc->sc.sc_dev = self;
 	//sc->sc.sc_flags |= SDHC_FLAG_USE_DMA;
 	sc->sc.sc_flags |= SDHC_FLAG_32BIT_ACCESS;
 	sc->sc.sc_flags |= SDHC_FLAG_NO_LED_ON;
 	sc->sc.sc_flags |= SDHC_FLAG_RSP136_CRC;
 	sc->sc.sc_flags |= SDHC_FLAG_SINGLE_ONLY;
 	if (support8bit)
 		sc->sc.sc_flags |= SDHC_FLAG_8BIT_MODE;
 #ifdef TI_AM335X
 	sc->sc.sc_flags |= SDHC_FLAG_WAIT_RESET;
 	sc->sc.sc_flags &= ~SDHC_FLAG_SINGLE_ONLY;
 #endif
 #if defined(OMAP_3530)
 	sc->sc.sc_flags &= ~SDHC_FLAG_SINGLE_ONLY;
 #endif
 @@ -182,28 +218,44 @@ obiosdhc_attach(device_t parent, device_
 	clksft = ffs(sc->sc.sc_clkmsk) - 1;
 	error = bus_space_map(sc->sc_bst, oa->obio_addr, oa->obio_size, 0,
 	    &sc->sc_bsh);
 	if (error) {
 		aprint_error_dev(self,
 		    "can't map registers: %d\n", error);
 		return;
+	}
 	bus_space_subregion(sc->sc_bst, sc->sc_bsh, OMAP3_SDMMC_SDHC_OFFSET,
 	    OMAP3_SDMMC_SDHC_SIZE, &sc->sc_sdhc_bsh);
-	aprint_naive(": SDHC controller\n");
+#if NEDMA > 0
-	aprint_normal(": SDHC controller\n");
+	if (oa->obio_edmabase != -1) {
 		mutex_init(&sc->sc_edma_lock, MUTEX_DEFAULT, IPL_SCHED);
 		cv_init(&sc->sc_edma_cv, "sdhcedma");
 		sc->sc_edma_fifo = oa->obio_addr +
 		    OMAP3_SDMMC_SDHC_OFFSET + SDHC_DATA;
 		obiosdhc_edma_init(sc, oa->obio_edmabase);
 		sc->sc.sc_flags |= SDHC_FLAG_USE_DMA;
 		sc->sc.sc_flags |= SDHC_FLAG_EXTERNAL_DMA;
 		sc->sc.sc_flags |= SDHC_FLAG_EXTDMA_DMAEN;
 		sc->sc.sc_flags &= ~SDHC_FLAG_SINGLE_ONLY;
 		sc->sc.sc_vendor_transfer_data_dma = obiosdhc_edma_xfer_data;
 		transfer_mode = "EDMA";
+	}
 #endif
 	aprint_naive("\n");
 	aprint_normal(": SDHC controller (%s)\n", transfer_mode);
 #ifdef TI_AM335X
 	/* XXX Not really AM335X-specific.  */
 	for (i = 0; i < __arraycount(am335x_sdhc); i++)
 		if ((oa->obio_addr == am335x_sdhc[i].as_base_addr) &&
 		    (oa->obio_intr == am335x_sdhc[i].as_intr)) {
 			prcm_module_enable(&am335x_sdhc[i].as_module);
 			break;
+		}
 	KASSERT(i < __arraycount(am335x_sdhc));
 #endif
 	/* XXXXXX: Turn-on regulator via I2C. */
 @@ -370,13 +422,155 @@ obiosdhc_bus_clock(struct sdhc_softc *sc
 	struct obiosdhc_softc *osc = (struct obiosdhc_softc *)sc;
 	uint32_t ctl;
 	ctl = bus_space_read_4(osc->sc_bst, osc->sc_bsh, MMCHS_SYSCTL);
 	if (clk == 0) {
 		ctl &= ~SYSCTL_CEN;
 	} else {
 		ctl |= SYSCTL_CEN;
+	}
 	bus_space_write_4(osc->sc_bst, osc->sc_bsh, MMCHS_SYSCTL, ctl);
 	return 0;
+}
 #if NEDMA > 0
 static void
 obiosdhc_edma_init(struct obiosdhc_softc *sc, unsigned int edmabase)
+{
 	int i;
 	/* Request tx and rx DMA channels */
 	sc->sc_edma_tx = edma_channel_alloc(EDMA_TYPE_DMA, edmabase + 0,
 	    obiosdhc_edma_done, sc);
 	KASSERT(sc->sc_edma_tx != NULL);
 	sc->sc_edma_rx = edma_channel_alloc(EDMA_TYPE_DMA, edmabase + 1,
 	    obiosdhc_edma_done, sc);
 	KASSERT(sc->sc_edma_rx != NULL);
 	device_printf(sc->sc.sc_dev, "EDMA tx channel %d, rx channel %d\n",
 	    edma_channel_index(sc->sc_edma_tx),
 	    edma_channel_index(sc->sc_edma_rx));
 	/* Allocate some PaRAM pages */
 	for (i = 0; i < __arraycount(sc->sc_edma_param_tx); i++) {
 		sc->sc_edma_param_tx[i] = edma_param_alloc(sc->sc_edma_tx);
 		KASSERT(sc->sc_edma_param_tx[i] != 0xffff);
+	}
 	for (i = 0; i < __arraycount(sc->sc_edma_param_rx); i++) {
 		sc->sc_edma_param_rx[i] = edma_param_alloc(sc->sc_edma_rx);
 		KASSERT(sc->sc_edma_param_rx[i] != 0xffff);
+	}
 	return;
+}
 static int
 obiosdhc_edma_xfer_data(struct sdhc_softc *sdhc_sc, struct sdmmc_command *cmd)
+{
 	struct obiosdhc_softc *sc = device_private(sdhc_sc->sc_dev);
 	struct edma_channel *edma;
 	uint16_t *edma_param;
 	struct edma_param ep;
 	size_t seg;
 	int error;
 	int blksize = MIN(cmd->c_datalen, cmd->c_blklen);
 	edma = ISSET(cmd->c_flags, SCF_CMD_READ) ?
 	    sc->sc_edma_rx : sc->sc_edma_tx;
 	edma_param = ISSET(cmd->c_flags, SCF_CMD_READ) ?
 	    sc->sc_edma_param_rx : sc->sc_edma_param_tx;
 	DPRINTF(1, (sc->sc.sc_dev, "edma xfer: nsegs=%d ch# %d\n",
 	    cmd->c_dmamap->dm_nsegs, edma_channel_index(edma)));
 	if (cmd->c_dmamap->dm_nsegs > EDMA_MAX_PARAMS) {
 		return ENOMEM;
+	}
 	for (seg = 0; seg < cmd->c_dmamap->dm_nsegs; seg++) {
 		ep.ep_opt = __SHIFTIN(2, EDMA_PARAM_OPT_FWID) /* 32-bit */;
 		ep.ep_opt |= __SHIFTIN(edma_channel_index(edma),
 				       EDMA_PARAM_OPT_TCC);
 		if (seg == cmd->c_dmamap->dm_nsegs - 1) {
 			ep.ep_opt |= EDMA_PARAM_OPT_TCINTEN;
 			ep.ep_link = 0xffff;
 		} else {
 			ep.ep_link = EDMA_PARAM_BASE(edma_param[seg+1]);
+		}
 		if (ISSET(cmd->c_flags, SCF_CMD_READ)) {
 			ep.ep_opt |= EDMA_PARAM_OPT_SAM;
 			ep.ep_src = sc->sc_edma_fifo;
 			ep.ep_dst = cmd->c_dmamap->dm_segs[seg].ds_addr;
 		} else {
 			ep.ep_opt |= EDMA_PARAM_OPT_DAM;
 			ep.ep_src = cmd->c_dmamap->dm_segs[seg].ds_addr;
 			ep.ep_dst = sc->sc_edma_fifo;
+		}
 		KASSERT(cmd->c_dmamap->dm_segs[seg].ds_len <= 65536 * 4);
                 /*
 		 * For unknown reason, the A-DMA transfers never completes for
 		 * transfers larger than 64 butes. So use a AB transfer,
 		 * with a 64 bytes A len
 		 */
 		ep.ep_bcntrld = 0;	/* not used for AB-synchronous mode */
 		ep.ep_opt |= EDMA_PARAM_OPT_SYNCDIM;
 		ep.ep_acnt = min(cmd->c_dmamap->dm_segs[seg].ds_len, 64);
 		ep.ep_bcnt = min(cmd->c_dmamap->dm_segs[seg].ds_len, blksize) /
 			     ep.ep_acnt;
 		ep.ep_ccnt = cmd->c_dmamap->dm_segs[seg].ds_len /
 			     (ep.ep_acnt * ep.ep_bcnt);
 		ep.ep_srcbidx = ep.ep_dstbidx = 0;
 		ep.ep_srccidx = ep.ep_dstcidx = 0;
 		if (ISSET(cmd->c_flags, SCF_CMD_READ)) {
 			ep.ep_dstbidx = ep.ep_acnt;
 			ep.ep_dstcidx = ep.ep_acnt * ep.ep_bcnt;
 		} else {
 			ep.ep_srcbidx = ep.ep_acnt;
 			ep.ep_srccidx = ep.ep_acnt * ep.ep_bcnt;
+		}
 		edma_set_param(edma, edma_param[seg], &ep);
 #ifdef OM3SDHC_DEBUG
 		if (om3sdhcdebug >= 1) {
 			printf("target OPT: %08x\n", ep.ep_opt);
 			edma_dump_param(edma, edma_param[seg]);
+		}
 #endif
+	}
 	mutex_enter(&sc->sc_edma_lock);
 	error = 0;
 	sc->sc_edma_pending = true;
 	edma_transfer_enable(edma, edma_param[0]);
 	while (sc->sc_edma_pending) {
 		error = cv_timedwait(&sc->sc_edma_cv, &sc->sc_edma_lock, hz*10);
 		if (error == EWOULDBLOCK) {
 			device_printf(sc->sc.sc_dev, "transfer timeout!\n");
 			edma_dump(edma);
 			edma_dump_param(edma, edma_param[0]);
 			edma_halt(edma);
 			sc->sc_edma_pending = false;
 			error = ETIMEDOUT;
 			break;
+		}
+	}
 	edma_halt(edma);
 	mutex_exit(&sc->sc_edma_lock);
 	return error;
+}
 static void
 obiosdhc_edma_done(void *priv)
+{
 	struct obiosdhc_softc *sc = priv;
 	mutex_enter(&sc->sc_edma_lock);
 	KASSERT(sc->sc_edma_pending == true);
 	sc->sc_edma_pending = false;
 	cv_broadcast(&sc->sc_edma_cv);
 	mutex_exit(&sc->sc_edma_lock);
+}
 #endif