openwrtv4/target/linux/brcm2708/patches-4.1/0076-bcm2835-sdhost-Improve-error-handling-and-recovery.patch

From 59435defecf72f8e5c9f4ee28591df33ffa78939 Mon Sep 17 00:00:00 2001
From: Phil Elwell <phil@raspberrypi.org>
Date: Wed, 17 Jun 2015 11:36:53 +0100
Subject: [PATCH 076/203] bcm2835-sdhost: Improve error handling and recovery

1) Expose the hw_reset method to the MMC framework, removing many
   internal calls by the driver.

2) Reduce overclock setting on error.

3) Increase timeout to cope with high capacity cards.

4) Add properties and parameters to control pio_limit and debug.

5) Reduce messages at probe time.
---
 arch/arm/boot/dts/overlays/README             |   8 +-
 arch/arm/boot/dts/overlays/sdhost-overlay.dts |   4 +-
 drivers/mmc/host/bcm2835-sdhost.c             | 578 ++++++++++++++++++--------
 3 files changed, 404 insertions(+), 186 deletions(-)

--- a/arch/arm/boot/dts/overlays/README
+++ b/arch/arm/boot/dts/overlays/README
@@ -408,7 +408,13 @@ Info:   Selects the bcm2835-sdhost SD/MM
 Load:   dtoverlay=sdhost,<param>=<val>
 Params: overclock_50             Clock (in MHz) to use when the MMC framework
                                  requests 50MHz
-        force_pio                Disable DMA support
+
+        force_pio                Disable DMA support (default off)
+
+        pio_limit                Number of blocks above which to use DMA
+                                 (default 2)
+
+        debug                    Enable debug output (default off)
 
 
 Name:   spi-bcm2708
--- a/arch/arm/boot/dts/overlays/sdhost-overlay.dts
+++ b/arch/arm/boot/dts/overlays/sdhost-overlay.dts
@@ -22,6 +22,7 @@
 				dma-names = "tx", "rx";
 				brcm,delay-after-stop = <0>;
 				brcm,overclock-50 = <0>;
+				brcm,pio-limit = <2>;
 				status = "okay";
 			};
 		};
@@ -70,9 +71,10 @@
 	};
 
 	__overrides__ {
-		delay_after_stop = <&sdhost>,"brcm,delay-after-stop:0";
 		overclock_50     = <&sdhost>,"brcm,overclock-50:0";
 		force_pio        = <&sdhost>,"brcm,force-pio?";
+		pio_limit        = <&sdhost>,"brcm,pio-limit:0";
+		debug            = <&sdhost>,"brcm,debug?";
 		sdhost_freq      = <&clk_sdhost>,"clock-frequency:0";
 	};
 };
--- a/drivers/mmc/host/bcm2835-sdhost.c
+++ b/drivers/mmc/host/bcm2835-sdhost.c
@@ -90,9 +90,8 @@
 /* Reserved */
 #define SDHSTS_DATA_FLAG                0x01
 
-#define SDHSTS_TRANSFER_ERROR_MASK      (SDHSTS_CRC16_ERROR|SDHSTS_REW_TIME_OUT|SDHSTS_FIFO_ERROR)
+#define SDHSTS_TRANSFER_ERROR_MASK      (SDHSTS_CRC7_ERROR|SDHSTS_CRC16_ERROR|SDHSTS_REW_TIME_OUT|SDHSTS_FIFO_ERROR)
 #define SDHSTS_ERROR_MASK               (SDHSTS_CMD_TIME_OUT|SDHSTS_TRANSFER_ERROR_MASK)
-/* SDHSTS_CRC7_ERROR - ignore this as MMC cards generate this spuriously */
 
 #define SDHCFG_BUSY_IRPT_EN     (1<<10)
 #define SDHCFG_BLOCK_IRPT_EN    (1<<8)
@@ -111,16 +110,7 @@
 #define SDEDM_READ_THRESHOLD_SHIFT 14
 #define SDEDM_THRESHOLD_MASK     0x1f
 
-/* the inclusive limit in bytes under which PIO will be used instead of DMA */
-#ifdef CONFIG_MMC_BCM2835_SDHOST_PIO_DMA_BARRIER
-#define PIO_DMA_BARRIER CONFIG_MMC_BCM2835_SDHOST_PIO_DMA_BARRIER
-#else
-#define PIO_DMA_BARRIER 0
-#endif
-
-#define MIN_FREQ 400000
-#define TIMEOUT_VAL 0xE
-#define BCM2835_SDHOST_WRITE_DELAY(f)	(((2 * 1000000) / f) + 1)
+#define MHZ 1000000
 
 #ifndef BCM2708_PERI_BASE
  #define BCM2708_PERI_BASE 0x20000000
@@ -138,19 +128,20 @@ struct bcm2835_host {
 
 	struct mmc_host		*mmc;
 
-	u32			timeout;
+	u32			pio_timeout;	/* In jiffies */
 
 	int			clock;		/* Current clock speed */
 
 	bool			slow_card;	/* Force 11-bit divisor */
 
 	unsigned int		max_clk;	/* Max possible freq */
-	unsigned int		timeout_clk;	/* Timeout freq (KHz) */
 
 	struct tasklet_struct	finish_tasklet;	/* Tasklet structures */
 
 	struct timer_list	timer;		/* Timer for timeouts */
 
+	struct timer_list	pio_timer;	/* PIO error detection timer */
+
 	struct sg_mapping_iter	sg_miter;	/* SG state for PIO */
 	unsigned int		blocks;		/* remaining PIO blocks */
 
@@ -170,6 +161,10 @@ struct bcm2835_host {
 
 	unsigned int			use_busy:1;		/* Wait for busy interrupt */
 
+	unsigned int			reduce_overclock:1;	/* ...at the next opportunity */
+
+	unsigned int			debug:1;		/* Enable debug output */
+
 	u32				thread_isr;
 
 	/*DMA part*/
@@ -185,7 +180,8 @@ struct bcm2835_host {
 	struct timeval			stop_time;	/* when the last stop was issued */
 	u32				delay_after_stop; /* minimum time between stop and subsequent data transfer */
 	u32				overclock_50;	/* frequency to use when 50MHz is requested (in MHz) */
-	u32				max_overclock;	/* Highest reported */
+	u32				overclock;	/* Current frequency if overclocked, else zero */
+	u32				pio_limit;	/* Maximum block count for PIO (0 = always DMA) */
 };
 
 
@@ -204,41 +200,79 @@ static inline u32 bcm2835_sdhost_read_re
 	return readl_relaxed(host->ioaddr + reg);
 }
 
+static void bcm2835_sdhost_dumpcmd(struct bcm2835_host *host,
+				   struct mmc_command *cmd,
+				   const char *label)
+{
+	if (cmd)
+		pr_info("%s:%c%s op %d arg 0x%x flags 0x%x - resp %08x %08x %08x %08x, err %d\n",
+			mmc_hostname(host->mmc),
+			(cmd == host->cmd) ? '>' : ' ',
+			label, cmd->opcode, cmd->arg, cmd->flags,
+			cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3],
+			cmd->error);
+}
+
 static void bcm2835_sdhost_dumpregs(struct bcm2835_host *host)
 {
-	pr_info(DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n",
+	bcm2835_sdhost_dumpcmd(host, host->mrq->sbc, "sbc");
+	bcm2835_sdhost_dumpcmd(host, host->mrq->cmd, "cmd");
+	if (host->mrq->data)
+		pr_err("%s: data blocks %x blksz %x - err %d\n",
+		       mmc_hostname(host->mmc),
+		       host->mrq->data->blocks,
+		       host->mrq->data->blksz,
+		       host->mrq->data->error);
+	bcm2835_sdhost_dumpcmd(host, host->mrq->stop, "stop");
+
+	pr_info("%s: =========== REGISTER DUMP ===========\n",
 		mmc_hostname(host->mmc));
 
-	pr_info(DRIVER_NAME ": SDCMD  0x%08x\n",
+	pr_info("%s: SDCMD  0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDCMD));
-	pr_info(DRIVER_NAME ": SDARG  0x%08x\n",
+	pr_info("%s: SDARG  0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDARG));
-	pr_info(DRIVER_NAME ": SDTOUT 0x%08x\n",
+	pr_info("%s: SDTOUT 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDTOUT));
-	pr_info(DRIVER_NAME ": SDCDIV 0x%08x\n",
+	pr_info("%s: SDCDIV 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDCDIV));
-	pr_info(DRIVER_NAME ": SDRSP0 0x%08x\n",
+	pr_info("%s: SDRSP0 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDRSP0));
-	pr_info(DRIVER_NAME ": SDRSP1 0x%08x\n",
+	pr_info("%s: SDRSP1 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDRSP1));
-	pr_info(DRIVER_NAME ": SDRSP2 0x%08x\n",
+	pr_info("%s: SDRSP2 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDRSP2));
-	pr_info(DRIVER_NAME ": SDRSP3 0x%08x\n",
+	pr_info("%s: SDRSP3 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDRSP3));
-	pr_info(DRIVER_NAME ": SDHSTS 0x%08x\n",
+	pr_info("%s: SDHSTS 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDHSTS));
-	pr_info(DRIVER_NAME ": SDVDD  0x%08x\n",
+	pr_info("%s: SDVDD  0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDVDD));
-	pr_info(DRIVER_NAME ": SDEDM  0x%08x\n",
+	pr_info("%s: SDEDM  0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDEDM));
-	pr_info(DRIVER_NAME ": SDHCFG 0x%08x\n",
+	pr_info("%s: SDHCFG 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDHCFG));
-	pr_info(DRIVER_NAME ": SDHBCT 0x%08x\n",
+	pr_info("%s: SDHBCT 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDHBCT));
-	pr_info(DRIVER_NAME ": SDHBLC 0x%08x\n",
+	pr_info("%s: SDHBLC 0x%08x\n",
+		mmc_hostname(host->mmc),
 		bcm2835_sdhost_read(host, SDHBLC));
 
-	pr_debug(DRIVER_NAME ": ===========================================\n");
+	pr_info("%s: ===========================================\n",
+		mmc_hostname(host->mmc));
 }
 
 
@@ -248,12 +282,10 @@ static void bcm2835_sdhost_set_power(str
 }
 
 
-static void bcm2835_sdhost_reset(struct bcm2835_host *host)
+static void bcm2835_sdhost_reset_internal(struct bcm2835_host *host)
 {
 	u32 temp;
 
-	pr_debug("bcm2835_sdhost_reset\n");
-
 	bcm2835_sdhost_set_power(host, false);
 
 	bcm2835_sdhost_write(host, 0, SDCMD);
@@ -281,6 +313,20 @@ static void bcm2835_sdhost_reset(struct
 	mmiowb();
 }
 
+
+static void bcm2835_sdhost_reset(struct mmc_host *mmc)
+{
+	struct bcm2835_host *host = mmc_priv(mmc);
+	unsigned long flags;
+	if (host->debug)
+		pr_info("%s: reset\n", mmc_hostname(mmc));
+	spin_lock_irqsave(&host->lock, flags);
+
+	bcm2835_sdhost_reset_internal(host);
+
+	spin_unlock_irqrestore(&host->lock, flags);
+}
+
 static void bcm2835_sdhost_set_ios(struct mmc_host *mmc, struct mmc_ios *ios);
 
 static void bcm2835_sdhost_init(struct bcm2835_host *host, int soft)
@@ -290,7 +336,7 @@ static void bcm2835_sdhost_init(struct b
 	/* Set interrupt enables */
 	host->hcfg = SDHCFG_BUSY_IRPT_EN;
 
-	bcm2835_sdhost_reset(host);
+	bcm2835_sdhost_reset_internal(host);
 
 	if (soft) {
 		/* force clock reconfiguration */
@@ -420,6 +466,40 @@ static void bcm2835_sdhost_dma_complete(
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
+static bool data_transfer_wait(struct bcm2835_host *host, const char *caller)
+{
+	unsigned long timeout = 1000000;
+	u32 hsts;
+	while (timeout)
+	{
+		hsts = bcm2835_sdhost_read(host, SDHSTS);
+		if (hsts & (SDHSTS_TRANSFER_ERROR_MASK |
+			    SDHSTS_DATA_FLAG)) {
+			bcm2835_sdhost_write(host, SDHSTS_TRANSFER_ERROR_MASK,
+					     SDHSTS);
+			break;
+		}
+		timeout--;
+	}
+
+	if (hsts & (SDHSTS_CRC16_ERROR |
+		    SDHSTS_CRC7_ERROR |
+		    SDHSTS_FIFO_ERROR)) {
+		pr_err("%s: data error in %s - HSTS %x\n",
+		       mmc_hostname(host->mmc), caller, hsts);
+		host->data->error = -EILSEQ;
+		return false;
+	} else if ((timeout == 0) ||
+		   (hsts & (SDHSTS_CMD_TIME_OUT |
+			    SDHSTS_REW_TIME_OUT))) {
+		pr_err("%s: timeout in %s - HSTS %x\n",
+		       mmc_hostname(host->mmc), caller, hsts);
+		host->data->error = -ETIMEDOUT;
+		return false;
+	}
+	return true;
+}
+
 static void bcm2835_sdhost_read_block_pio(struct bcm2835_host *host)
 {
 	unsigned long flags;
@@ -443,35 +523,15 @@ static void bcm2835_sdhost_read_block_pi
 		buf = (u32 *)host->sg_miter.addr;
 
 		while (len) {
-			while (1) {
-				u32 hsts;
-				hsts = bcm2835_sdhost_read(host, SDHSTS);
-				if (hsts & SDHSTS_DATA_FLAG)
-					break;
-
-				if (hsts & SDHSTS_ERROR_MASK) {
-					pr_err("%s: Transfer error - HSTS %x, HBCT %x - %x left\n",
-					       mmc_hostname(host->mmc),
-					       hsts,
-					       bcm2835_sdhost_read(host, SDHBCT),
-					       blksize + len);
-					if (hsts & SDHSTS_REW_TIME_OUT)
-						host->data->error = -ETIMEDOUT;
-					else if (hsts & (SDHSTS_CRC16_ERROR ||
-						    SDHSTS_CRC7_ERROR))
-						host->data->error = -EILSEQ;
-					else {
-						pr_err("%s: unexpected data error\n",
-						       mmc_hostname(host->mmc));
-						bcm2835_sdhost_dumpregs(host);
-						host->cmd->error = -EIO;
-					}
-				}
-			}
+			if (!data_transfer_wait(host, "read_block_pio"))
+				break;
 
 			*(buf++) = bcm2835_sdhost_read(host, SDDATA);
 			len -= 4;
 		}
+
+		if (host->data->error)
+			break;
 	}
 
 	sg_miter_stop(&host->sg_miter);
@@ -502,11 +562,15 @@ static void bcm2835_sdhost_write_block_p
 		buf = host->sg_miter.addr;
 
 		while (len) {
-			while (!(bcm2835_sdhost_read(host, SDHSTS) & SDHSTS_DATA_FLAG))
-				continue;
+			if (!data_transfer_wait(host, "write_block_pio"))
+				break;
+
 			bcm2835_sdhost_write(host, *(buf++), SDDATA);
 			len -= 4;
 		}
+
+		if (host->data->error)
+			break;
 	}
 
 	sg_miter_stop(&host->sg_miter);
@@ -519,10 +583,15 @@ static void bcm2835_sdhost_transfer_pio(
 {
 	BUG_ON(!host->data);
 
-	if (host->data->flags & MMC_DATA_READ)
+	if (host->data->flags & MMC_DATA_READ) {
 		bcm2835_sdhost_read_block_pio(host);
-	else
+	} else {
 		bcm2835_sdhost_write_block_pio(host);
+
+		/* Start a timer in case a transfer error occurs because
+		   there is no error interrupt */
+		mod_timer(&host->pio_timer, jiffies + host->pio_timeout);
+	}
 }
 
 
@@ -607,6 +676,7 @@ static void bcm2835_sdhost_prepare_data(
 	host->flush_fifo = 0;
 	host->data->bytes_xfered = 0;
 
+	host->use_dma = host->have_dma && (data->blocks > host->pio_limit);
 	if (!host->use_dma) {
 		int flags;
 
@@ -619,8 +689,6 @@ static void bcm2835_sdhost_prepare_data(
 		host->blocks = data->blocks;
 	}
 
-	host->use_dma = host->have_dma && data->blocks > PIO_DMA_BARRIER;
-
 	bcm2835_sdhost_set_transfer_irqs(host);
 
 	bcm2835_sdhost_write(host, data->blksz, SDHBCT);
@@ -638,22 +706,25 @@ void bcm2835_sdhost_send_command(struct
 
 	WARN_ON(host->cmd);
 
-	if (1) {
-		pr_debug("bcm2835_sdhost_send_command: %08x %08x (flags %x)\n",
-			 cmd->opcode, cmd->arg, (cmd->flags & 0xff) | (cmd->data ? cmd->data->flags : 0));
-		if (cmd->data)
-			pr_debug("bcm2835_sdhost_send_command: %s %d*%x\n",
-				 (cmd->data->flags & MMC_DATA_READ) ?
-				 "read" : "write", cmd->data->blocks,
-				 cmd->data->blksz);
-	}
+	if (cmd->data)
+		pr_debug("%s: send_command %d 0x%x "
+			 "(flags 0x%x) - %s %d*%d\n",
+			 mmc_hostname(host->mmc),
+			 cmd->opcode, cmd->arg, cmd->flags,
+			 (cmd->data->flags & MMC_DATA_READ) ?
+			 "read" : "write", cmd->data->blocks,
+			 cmd->data->blksz);
+	else
+		pr_debug("%s: send_command %d 0x%x (flags 0x%x)\n",
+			 mmc_hostname(host->mmc),
+			 cmd->opcode, cmd->arg, cmd->flags);
 
 	/* Wait max 10 ms */
 	timeout = 1000;
 
 	while (bcm2835_sdhost_read(host, SDCMD) & SDCMD_NEW_FLAG) {
 		if (timeout == 0) {
-			pr_err("%s: Previous command never completed.\n",
+			pr_err("%s: previous command never completed.\n",
 				mmc_hostname(host->mmc));
 			bcm2835_sdhost_dumpregs(host);
 			cmd->error = -EIO;
@@ -666,16 +737,16 @@ void bcm2835_sdhost_send_command(struct
 
 	if ((1000-timeout)/100 > 1 && (1000-timeout)/100 > host->max_delay) {
 		host->max_delay = (1000-timeout)/100;
-		pr_warning("Warning: SDHost controller hung for %d ms\n", host->max_delay);
+		pr_warning("%s: controller hung for %d ms\n",
+			   mmc_hostname(host->mmc),
+			   host->max_delay);
 	}
 
 	timeout = jiffies;
-#ifdef CONFIG_ARCH_BCM2835
 	if (!cmd->data && cmd->busy_timeout > 9000)
 		timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
 	else
-#endif
-	timeout += 10 * HZ;
+		timeout += 10 * HZ;
 	mod_timer(&host->timer, timeout);
 
 	host->cmd = cmd;
@@ -685,7 +756,7 @@ void bcm2835_sdhost_send_command(struct
 	bcm2835_sdhost_write(host, cmd->arg, SDARG);
 
 	if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
-		pr_err("%s: Unsupported response type!\n",
+		pr_err("%s: unsupported response type!\n",
 			mmc_hostname(host->mmc));
 		cmd->error = -EINVAL;
 		tasklet_schedule(&host->finish_tasklet);
@@ -783,13 +854,6 @@ static void bcm2835_sdhost_transfer_comp
 	pr_debug("transfer_complete(error %d, stop %d)\n",
 	       data->error, data->stop ? 1 : 0);
 
-	if (data->error)
-		/*
-		 * The controller needs a reset of internal state machines
-		 * upon error conditions.
-		 */
-		bcm2835_sdhost_reset(host);
-
 	/*
 	 * Need to send CMD12 if -
 	 * a) open-ended multiblock transfer (no CMD23)
@@ -845,7 +909,7 @@ static void bcm2835_sdhost_finish_comman
 #endif
 
 	if (timeout == 0) {
-		pr_err("%s: Command never completed.\n",
+		pr_err("%s: command never completed.\n",
 		       mmc_hostname(host->mmc));
 		bcm2835_sdhost_dumpregs(host);
 		host->cmd->error = -EIO;
@@ -875,14 +939,23 @@ static void bcm2835_sdhost_finish_comman
 	{
 		u32 sdhsts = bcm2835_sdhost_read(host, SDHSTS);
 
-		pr_debug("%s: error detected - CMD %x, HSTS %03x, EDM %x\n",
-		       mmc_hostname(host->mmc), sdcmd, sdhsts,
-		       bcm2835_sdhost_read(host, SDEDM));
-
-		if (sdhsts & SDHSTS_CMD_TIME_OUT)
+		if (host->debug)
+			pr_info("%s: error detected - CMD %x, HSTS %03x, EDM %x\n",
+				mmc_hostname(host->mmc), sdcmd, sdhsts,
+				bcm2835_sdhost_read(host, SDEDM));
+
+		if (sdhsts & SDHSTS_CMD_TIME_OUT) {
+			switch (host->cmd->opcode) {
+			case 5: case 52: case 53:
+				/* Don't warn about SDIO commands */
+				break;
+			default:
+				pr_err("%s: command timeout\n",
+				       mmc_hostname(host->mmc));
+				break;
+			}
 			host->cmd->error = -ETIMEDOUT;
-		else
-		{
+		} else {
 			pr_err("%s: unexpected command error\n",
 			       mmc_hostname(host->mmc));
 			bcm2835_sdhost_dumpregs(host);
@@ -897,11 +970,13 @@ static void bcm2835_sdhost_finish_comman
 			int i;
 			for (i = 0; i < 4; i++)
 				host->cmd->resp[3 - i] = bcm2835_sdhost_read(host, SDRSP0 + i*4);
-			pr_debug("bcm2835_sdhost_finish_command: %08x %08x %08x %08x\n",
+			pr_debug("%s: finish_command %08x %08x %08x %08x\n",
+				 mmc_hostname(host->mmc),
 				 host->cmd->resp[0], host->cmd->resp[1], host->cmd->resp[2], host->cmd->resp[3]);
 		} else {
 			host->cmd->resp[0] = bcm2835_sdhost_read(host, SDRSP0);
-			pr_debug("bcm2835_sdhost_finish_command: %08x\n",
+			pr_debug("%s: finish_command %08x\n",
+				 mmc_hostname(host->mmc),
 				 host->cmd->resp[0]);
 		}
 	}
@@ -932,7 +1007,7 @@ static void bcm2835_sdhost_finish_comman
 	}
 }
 
-static void bcm2835_sdhost_timeout_timer(unsigned long data)
+static void bcm2835_sdhost_timeout(unsigned long data)
 {
 	struct bcm2835_host *host;
 	unsigned long flags;
@@ -942,7 +1017,7 @@ static void bcm2835_sdhost_timeout_timer
 	spin_lock_irqsave(&host->lock, flags);
 
 	if (host->mrq) {
-		pr_err("%s: Timeout waiting for hardware interrupt.\n",
+		pr_err("%s: timeout waiting for hardware interrupt.\n",
 			mmc_hostname(host->mmc));
 		bcm2835_sdhost_dumpregs(host);
 
@@ -964,6 +1039,41 @@ static void bcm2835_sdhost_timeout_timer
 	spin_unlock_irqrestore(&host->lock, flags);
 }
 
+static void bcm2835_sdhost_pio_timeout(unsigned long data)
+{
+	struct bcm2835_host *host;
+	unsigned long flags;
+
+	host = (struct bcm2835_host *)data;
+
+	spin_lock_irqsave(&host->lock, flags);
+
+	if (host->data) {
+		u32 hsts = bcm2835_sdhost_read(host, SDHSTS);
+
+		if (hsts & SDHSTS_REW_TIME_OUT) {
+			pr_err("%s: transfer timeout\n",
+			       mmc_hostname(host->mmc));
+			if (host->debug)
+				bcm2835_sdhost_dumpregs(host);
+		} else {
+			pr_err("%s: unexpected transfer timeout\n",
+			       mmc_hostname(host->mmc));
+			bcm2835_sdhost_dumpregs(host);
+		}
+
+		bcm2835_sdhost_write(host, SDHSTS_TRANSFER_ERROR_MASK,
+				     SDHSTS);
+
+		host->data->error = -ETIMEDOUT;
+
+		bcm2835_sdhost_finish_data(host);
+	}
+
+	mmiowb();
+	spin_unlock_irqrestore(&host->lock, flags);
+}
+
 static void bcm2835_sdhost_enable_sdio_irq_nolock(struct bcm2835_host *host, int enable)
 {
 	if (enable)
@@ -979,7 +1089,7 @@ static void bcm2835_sdhost_enable_sdio_i
 	struct bcm2835_host *host = mmc_priv(mmc);
 	unsigned long flags;
 
-	pr_debug("bcm2835_sdhost_enable_sdio_irq(%d)\n", enable);
+	pr_debug("%s: enable_sdio_irq(%d)\n", mmc_hostname(mmc), enable);
 	spin_lock_irqsave(&host->lock, flags);
 	bcm2835_sdhost_enable_sdio_irq_nolock(host, enable);
 	spin_unlock_irqrestore(&host->lock, flags);
@@ -987,11 +1097,12 @@ static void bcm2835_sdhost_enable_sdio_i
 
 static u32 bcm2835_sdhost_busy_irq(struct bcm2835_host *host, u32 intmask)
 {
-	const u32 handled = (SDHSTS_CMD_TIME_OUT | SDHSTS_CRC16_ERROR |
-			     SDHSTS_CRC7_ERROR | SDHSTS_FIFO_ERROR);
+	const u32 handled = (SDHSTS_REW_TIME_OUT | SDHSTS_CMD_TIME_OUT |
+			     SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR |
+			     SDHSTS_FIFO_ERROR);
 
 	if (!host->cmd) {
-		pr_err("%s: Got command busy interrupt 0x%08x even "
+		pr_err("%s: got command busy interrupt 0x%08x even "
 			"though no command operation was in progress.\n",
 			mmc_hostname(host->mmc), (unsigned)intmask);
 		bcm2835_sdhost_dumpregs(host);
@@ -999,7 +1110,7 @@ static u32 bcm2835_sdhost_busy_irq(struc
 	}
 
 	if (!host->use_busy) {
-		pr_err("%s: Got command busy interrupt 0x%08x even "
+		pr_err("%s: got command busy interrupt 0x%08x even "
 			"though not expecting one.\n",
 			mmc_hostname(host->mmc), (unsigned)intmask);
 		bcm2835_sdhost_dumpregs(host);
@@ -1007,14 +1118,28 @@ static u32 bcm2835_sdhost_busy_irq(struc
 	}
 	host->use_busy = 0;
 
-	if (intmask & SDHSTS_CMD_TIME_OUT)
-		host->cmd->error = -ETIMEDOUT;
-	else if (intmask & (SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR |
-			SDHSTS_FIFO_ERROR))
-		host->cmd->error = -EILSEQ;
+	if (intmask & SDHSTS_ERROR_MASK)
+	{
+		pr_err("sdhost_busy_irq: intmask %x, data %p\n", intmask, host->mrq->data);
+		if (intmask & SDHSTS_CRC7_ERROR)
+			host->cmd->error = -EILSEQ;
+		else if (intmask & (SDHSTS_CRC16_ERROR |
+				    SDHSTS_FIFO_ERROR)) {
+			if (host->mrq->data)
+				host->mrq->data->error = -EILSEQ;
+			else
+				host->cmd->error = -EILSEQ;
+		} else if (intmask & SDHSTS_REW_TIME_OUT) {
+			if (host->mrq->data)
+				host->mrq->data->error = -ETIMEDOUT;
+			else
+				host->cmd->error = -ETIMEDOUT;
+		} else if (intmask & SDHSTS_CMD_TIME_OUT)
+			host->cmd->error = -ETIMEDOUT;
 
-	if (host->cmd->error)
+		bcm2835_sdhost_dumpregs(host);
 		tasklet_schedule(&host->finish_tasklet);
+	}
 	else
 		bcm2835_sdhost_finish_command(host);
 
@@ -1023,8 +1148,9 @@ static u32 bcm2835_sdhost_busy_irq(struc
 
 static u32 bcm2835_sdhost_data_irq(struct bcm2835_host *host, u32 intmask)
 {
-	const u32 handled = (SDHSTS_CMD_TIME_OUT | SDHSTS_CRC16_ERROR |
-			     SDHSTS_CRC7_ERROR | SDHSTS_FIFO_ERROR);
+	const u32 handled = (SDHSTS_REW_TIME_OUT |
+			     SDHSTS_CRC16_ERROR |
+			     SDHSTS_FIFO_ERROR);
 
 	/* There are no dedicated data/space available interrupt
 	   status bits, so it is necessary to use the single shared
@@ -1034,13 +1160,19 @@ static u32 bcm2835_sdhost_data_irq(struc
 	if (!host->data)
 		return 0;
 
-	// XXX FIFO_ERROR
-	if (intmask & SDHSTS_CMD_TIME_OUT)
-		host->cmd->error = -ETIMEDOUT;
-	else if ((intmask & (SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR)) &&
-		 ((bcm2835_sdhost_read(host, SDCMD) & SDCMD_CMD_MASK)
-		  != MMC_BUS_TEST_R))
-		host->cmd->error = -EILSEQ;
+	if (intmask & (SDHSTS_CRC16_ERROR |
+		       SDHSTS_FIFO_ERROR |
+		       SDHSTS_REW_TIME_OUT)) {
+		if (intmask & (SDHSTS_CRC16_ERROR |
+			       SDHSTS_FIFO_ERROR))
+			host->data->error = -EILSEQ;
+		else
+			host->data->error = -ETIMEDOUT;
+
+		bcm2835_sdhost_dumpregs(host);
+		tasklet_schedule(&host->finish_tasklet);
+		return handled;
+	}
 
 	/* Use the block interrupt for writes after the first block */
 	if (host->data->flags & MMC_DATA_WRITE) {
@@ -1067,31 +1199,48 @@ static u32 bcm2835_sdhost_block_irq(stru
 {
 	struct dma_chan *dma_chan;
 	u32 dir_data;
-	const u32 handled = (SDHSTS_CMD_TIME_OUT | SDHSTS_CRC16_ERROR |
-			     SDHSTS_CRC7_ERROR | SDHSTS_FIFO_ERROR);
+	const u32 handled = (SDHSTS_REW_TIME_OUT |
+			     SDHSTS_CRC16_ERROR |
+			     SDHSTS_FIFO_ERROR);
 
 	if (!host->data) {
-		pr_err("%s: Got block interrupt 0x%08x even "
+		pr_err("%s: got block interrupt 0x%08x even "
 			"though no data operation was in progress.\n",
 			mmc_hostname(host->mmc), (unsigned)intmask);
 		bcm2835_sdhost_dumpregs(host);
 		return handled;
 	}
 
-	if (intmask & SDHSTS_CMD_TIME_OUT)
-		host->cmd->error = -ETIMEDOUT;
-	else if ((intmask & (SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR)) &&
-		 ((bcm2835_sdhost_read(host, SDCMD) & SDCMD_CMD_MASK)
-		  != MMC_BUS_TEST_R))
-		host->cmd->error = -EILSEQ;
+	if (intmask & (SDHSTS_CRC16_ERROR |
+		       SDHSTS_FIFO_ERROR |
+		       SDHSTS_REW_TIME_OUT)) {
+		if (intmask & (SDHSTS_CRC16_ERROR |
+			       SDHSTS_FIFO_ERROR))
+			host->data->error = -EILSEQ;
+		else
+			host->data->error = -ETIMEDOUT;
+
+		if (host->debug)
+			bcm2835_sdhost_dumpregs(host);
+		tasklet_schedule(&host->finish_tasklet);
+		return handled;
+	}
 
 	if (!host->use_dma) {
 		BUG_ON(!host->blocks);
 		host->blocks--;
-		if ((host->blocks == 0) || host->data->error)
+		if ((host->blocks == 0) || host->data->error) {
+			/* Cancel the timer */
+			del_timer(&host->pio_timer);
+
 			bcm2835_sdhost_finish_data(host);
-		else
+		} else {
 			bcm2835_sdhost_transfer_pio(host);
+
+			/* Reset the timer */
+			mod_timer(&host->pio_timer,
+				  jiffies + host->pio_timeout);
+		}
 	} else if (host->data->flags & MMC_DATA_WRITE) {
 		dma_chan = host->dma_chan_tx;
 		dir_data = DMA_TO_DEVICE;
@@ -1125,7 +1274,7 @@ static irqreturn_t bcm2835_sdhost_irq(in
 				     SDHSTS_BLOCK_IRPT |
 				     SDHSTS_SDIO_IRPT |
 				     SDHSTS_DATA_FLAG);
-		if ((handled == SDHSTS_DATA_FLAG) && // XXX
+		if ((handled == SDHSTS_DATA_FLAG) &&
 		    (loops == 0) && !host->data) {
 			pr_err("%s: sdhost_irq data interrupt 0x%08x even "
 			       "though no data operation was in progress.\n",
@@ -1177,10 +1326,11 @@ static irqreturn_t bcm2835_sdhost_irq(in
 	spin_unlock(&host->lock);
 
 	if (early)
-		pr_debug("%s: early %x (loops %d)\n", mmc_hostname(host->mmc), early, loops);
+		pr_debug("%s: early %x (loops %d)\n",
+			 mmc_hostname(host->mmc), early, loops);
 
 	if (unexpected) {
-		pr_err("%s: Unexpected interrupt 0x%08x.\n",
+		pr_err("%s: unexpected interrupt 0x%08x.\n",
 			   mmc_hostname(host->mmc), unexpected);
 		bcm2835_sdhost_dumpregs(host);
 	}
@@ -1227,8 +1377,22 @@ void bcm2835_sdhost_set_clock(struct bcm
 	int div = 0; /* Initialized for compiler warning */
 	unsigned int input_clock = clock;
 
-	if (host->overclock_50 && (clock == 50000000))
-		clock = host->overclock_50 * 1000000 + 999999;
+	if (host->debug)
+		pr_info("%s: set_clock(%d)\n", mmc_hostname(host->mmc), clock);
+
+	if ((clock == 0) && host->reduce_overclock) {
+		/* This is a reset following data corruption - reduce any
+		   overclock */
+		host->reduce_overclock = 0;
+		if (host->overclock_50 > 50) {
+			pr_warn("%s: reducing overclock due to errors\n",
+				mmc_hostname(host->mmc));
+			host->overclock_50--;
+		}
+	}
+
+	if (host->overclock_50 && (clock == 50*MHZ))
+		clock = host->overclock_50 * MHZ + (MHZ - 1);
 
 	/* The SDCDIV register has 11 bits, and holds (div - 2).
 	   But in data mode the max is 50MHz wihout a minimum, and only the
@@ -1275,17 +1439,34 @@ void bcm2835_sdhost_set_clock(struct bcm
 	clock = host->max_clk / (div + 2);
 	host->mmc->actual_clock = clock;
 
-	if ((clock > input_clock) && (clock > host->max_overclock)) {
-		pr_warn("%s: Overclocking to %dHz\n",
-			mmc_hostname(host->mmc), clock);
-		host->max_overclock = clock;
+	if (clock > input_clock) {
+		/* Save the closest value, to make it easier
+		   to reduce in the event of error */
+		host->overclock_50 = (clock/MHZ);
+
+		if (clock != host->overclock) {
+			pr_warn("%s: overclocking to %dHz\n",
+				mmc_hostname(host->mmc), clock);
+			host->overclock = clock;
+		}
+	}
+	else if ((clock == 50 * MHZ) && host->overclock)
+	{
+		pr_warn("%s: cancelling overclock\n",
+			mmc_hostname(host->mmc));
+		host->overclock = 0;
 	}
 
 	host->cdiv = div;
 	bcm2835_sdhost_write(host, host->cdiv, SDCDIV);
 
-	pr_debug(DRIVER_NAME ": clock=%d -> max_clk=%d, cdiv=%x (actual clock %d)\n",
-		 input_clock, host->max_clk, host->cdiv, host->mmc->actual_clock);
+	/* Set the timeout to 500ms */
+	bcm2835_sdhost_write(host, host->mmc->actual_clock/2, SDTOUT);
+
+	if (host->debug)
+		pr_info("%s: clock=%d -> max_clk=%d, cdiv=%x (actual clock %d)\n",
+			mmc_hostname(host->mmc), input_clock,
+			host->max_clk, host->cdiv, host->mmc->actual_clock);
 }
 
 static void bcm2835_sdhost_request(struct mmc_host *mmc, struct mmc_request *mrq)
@@ -1293,29 +1474,32 @@ static void bcm2835_sdhost_request(struc
 	struct bcm2835_host *host;
 	unsigned long flags;
 
-	if (1) {
+	host = mmc_priv(mmc);
+
+	if (host->debug) {
 		struct mmc_command *cmd = mrq->cmd;
-		const char *src = "cmd";
 		BUG_ON(!cmd);
-		pr_debug("bcm2835_sdhost_request: %s %08x %08x (flags %x)\n",
-			 src, cmd->opcode, cmd->arg, cmd->flags);
 		if (cmd->data)
-			pr_debug("bcm2835_sdhost_request: %s %d*%d\n",
-				 (cmd->data->flags & MMC_DATA_READ) ?
-				 "read" : "write", cmd->data->blocks,
-				 cmd->data->blksz);
+			pr_info("%s: cmd %d 0x%x (flags 0x%x) - %s %d*%d\n",
+				mmc_hostname(mmc),
+				cmd->opcode, cmd->arg, cmd->flags,
+				(cmd->data->flags & MMC_DATA_READ) ?
+				"read" : "write", cmd->data->blocks,
+				cmd->data->blksz);
+		else
+			pr_info("%s: cmd %d 0x%x (flags 0x%x)\n",
+				mmc_hostname(mmc),
+				cmd->opcode, cmd->arg, cmd->flags);
 	}
 
 	if (mrq->data && !is_power_of_2(mrq->data->blksz)) {
-		pr_err("%s: Unsupported block size (%d bytes)\n",
+		pr_err("%s: unsupported block size (%d bytes)\n",
 		       mmc_hostname(mmc), mrq->data->blksz);
 		mrq->cmd->error = -EINVAL;
 		mmc_request_done(mmc, mrq);
 		return;
 	}
 
-	host = mmc_priv(mmc);
-
 	spin_lock_irqsave(&host->lock, flags);
 
 	WARN_ON(host->mrq != NULL);
@@ -1345,9 +1529,12 @@ static void bcm2835_sdhost_set_ios(struc
 	struct bcm2835_host *host = mmc_priv(mmc);
 	unsigned long flags;
 
-	pr_debug("bcm2835_sdhost_set_ios: clock %d, pwr %d, bus_width %d, timing %d, vdd %d, drv_type %d\n",
-	       ios->clock, ios->power_mode, ios->bus_width,
-	       ios->timing, ios->signal_voltage, ios->drv_type);
+	if (host->debug)
+		pr_info("%s: ios clock %d, pwr %d, bus_width %d, "
+			"timing %d, vdd %d, drv_type %d\n",
+			mmc_hostname(mmc),
+			ios->clock, ios->power_mode, ios->bus_width,
+			ios->timing, ios->signal_voltage, ios->drv_type);
 
 	spin_lock_irqsave(&host->lock, flags);
 
@@ -1396,6 +1583,7 @@ static struct mmc_host_ops bcm2835_sdhos
 	.request = bcm2835_sdhost_request,
 	.set_ios = bcm2835_sdhost_set_ios,
 	.enable_sdio_irq = bcm2835_sdhost_enable_sdio_irq,
+	.hw_reset = bcm2835_sdhost_reset,
 	.multi_io_quirk = bcm2835_sdhost_multi_io_quirk,
 };
 
@@ -1423,15 +1611,24 @@ static void bcm2835_sdhost_tasklet_finis
 
 	mrq = host->mrq;
 
-	/*
-	 * The controller needs a reset of internal state machines
-	 * upon error conditions.
-	 */
-	if (((mrq->cmd && mrq->cmd->error) ||
-		 (mrq->data && (mrq->data->error ||
-		  (mrq->data->stop && mrq->data->stop->error))))) {
+	/* Drop the overclock after any data corruption, or after any
+	   error overclocked */
+	if (mrq->data && (mrq->data->error == -EILSEQ))
+		host->reduce_overclock = 1;
+	else if (host->overclock) {
+		/* Convert timeout errors while overclocked to data errors,
+		   because the system recovers better. */
+		if (mrq->cmd && mrq->cmd->error) {
+			host->reduce_overclock = 1;
+			if (mrq->cmd->error == -ETIMEDOUT)
+				mrq->cmd->error = -EILSEQ;
+		}
 
-		bcm2835_sdhost_reset(host);
+		if (mrq->data && mrq->data->error) {
+			host->reduce_overclock = 1;
+			if (mrq->data->error == -ETIMEDOUT)
+				mrq->data->error = -EILSEQ;
+		}
 	}
 
 	host->mrq = NULL;
@@ -1450,35 +1647,37 @@ int bcm2835_sdhost_add_host(struct bcm28
 {
 	struct mmc_host *mmc;
 	struct dma_slave_config cfg;
+	char pio_limit_string[20];
 	int ret;
 
 	mmc = host->mmc;
 
-	bcm2835_sdhost_reset(host);
+	bcm2835_sdhost_reset_internal(host);
 
 	mmc->f_max = host->max_clk;
 	mmc->f_min = host->max_clk / SDCDIV_MAX_CDIV;
 
-	/* SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK */
-	host->timeout_clk = mmc->f_max / 1000;
-#ifdef CONFIG_ARCH_BCM2835
-	mmc->max_busy_timeout = (1 << 27) / host->timeout_clk;
-#endif
+	mmc->max_busy_timeout =  (~(unsigned int)0)/(mmc->f_max/1000);
+
+	pr_debug("f_max %d, f_min %d, max_busy_timeout %d\n",
+		 mmc->f_max, mmc->f_min, mmc->max_busy_timeout);
+
 	/* host controller capabilities */
 	mmc->caps |= /* MMC_CAP_SDIO_IRQ |*/ MMC_CAP_4_BIT_DATA |
 		MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED |
-		MMC_CAP_NEEDS_POLL |
+		MMC_CAP_NEEDS_POLL | MMC_CAP_HW_RESET |
 		(ALLOW_CMD23 * MMC_CAP_CMD23);
 
 	spin_lock_init(&host->lock);
 
 	if (host->allow_dma) {
-		if (!host->dma_chan_tx || !host->dma_chan_rx ||
-		    IS_ERR(host->dma_chan_tx) || IS_ERR(host->dma_chan_rx)) {
-			pr_err("%s: Unable to initialise DMA channels. Falling back to PIO\n", DRIVER_NAME);
+		if (IS_ERR_OR_NULL(host->dma_chan_tx) ||
+		    IS_ERR_OR_NULL(host->dma_chan_rx)) {
+			pr_err("%s: unable to initialise DMA channels. "
+			       "Falling back to PIO\n",
+			       mmc_hostname(mmc));
 			host->have_dma = false;
 		} else {
-			pr_info("DMA channels allocated for the SDHost driver");
 			host->have_dma = true;
 
 			cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
@@ -1496,7 +1695,6 @@ int bcm2835_sdhost_add_host(struct bcm28
 			ret = dmaengine_slave_config(host->dma_chan_rx, &cfg);
 		}
 	} else {
-		pr_info("Forcing PIO mode\n");
 		host->have_dma = false;
 	}
 
@@ -1512,18 +1710,23 @@ int bcm2835_sdhost_add_host(struct bcm28
 	tasklet_init(&host->finish_tasklet,
 		bcm2835_sdhost_tasklet_finish, (unsigned long)host);
 
-	setup_timer(&host->timer, bcm2835_sdhost_timeout_timer, (unsigned long)host);
+	setup_timer(&host->timer, bcm2835_sdhost_timeout,
+		    (unsigned long)host);
+
+	setup_timer(&host->pio_timer, bcm2835_sdhost_pio_timeout,
+		    (unsigned long)host);
 
 	bcm2835_sdhost_init(host, 0);
 #ifndef CONFIG_ARCH_BCM2835
 	ret = request_irq(host->irq, bcm2835_sdhost_irq, 0 /*IRQF_SHARED*/,
 				  mmc_hostname(mmc), host);
 #else
-	ret = request_threaded_irq(host->irq, bcm2835_sdhost_irq, bcm2835_sdhost_thread_irq,
+	ret = request_threaded_irq(host->irq, bcm2835_sdhost_irq,
+				   bcm2835_sdhost_thread_irq,
 				   IRQF_SHARED,	mmc_hostname(mmc), host);
 #endif
 	if (ret) {
-		pr_err("%s: Failed to request IRQ %d: %d\n",
+		pr_err("%s: failed to request IRQ %d: %d\n",
 		       mmc_hostname(mmc), host->irq, ret);
 		goto untasklet;
 	}
@@ -1531,10 +1734,13 @@ int bcm2835_sdhost_add_host(struct bcm28
 	mmiowb();
 	mmc_add_host(mmc);
 
-	pr_info("Load BCM2835 SDHost driver\n");
-	if (host->delay_after_stop)
-		pr_info("BCM2835 SDHost: delay_after_stop=%dus\n",
-			host->delay_after_stop);
+	pio_limit_string[0] = '\0';
+	if (host->have_dma && (host->pio_limit > 0))
+		sprintf(pio_limit_string, " (>%d)", host->pio_limit);
+	pr_info("%s: %s loaded - DMA %s%s\n",
+		mmc_hostname(mmc), DRIVER_NAME,
+		host->have_dma ? "enabled" : "disabled",
+		pio_limit_string);
 
 	return 0;
 
@@ -1562,7 +1768,7 @@ static int bcm2835_sdhost_probe(struct p
 	mmc->ops = &bcm2835_sdhost_ops;
 	host = mmc_priv(mmc);
 	host->mmc = mmc;
-	host->timeout = msecs_to_jiffies(1000);
+	host->pio_timeout = msecs_to_jiffies(500);
 	spin_lock_init(&host->lock);
 
 	iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1588,8 +1794,12 @@ static int bcm2835_sdhost_probe(struct p
 		of_property_read_u32(node,
 				     "brcm,overclock-50",
 				     &host->overclock_50);
+		of_property_read_u32(node,
+				     "brcm,pio-limit",
+				     &host->pio_limit);
 		host->allow_dma = ALLOW_DMA &&
 			!of_property_read_bool(node, "brcm,force-pio");
+		host->debug = of_property_read_bool(node, "brcm,debug");
 	}
 
 	if (host->allow_dma) {