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

   1 From aa9beb8d637dbe2509f9307cb5f7a809deb35e55 Mon Sep 17 00:00:00 2001
   2 From: Phil Elwell <phil@raspberrypi.org>
   3 Date: Wed, 17 Jun 2015 11:36:53 +0100
   4 Subject: [PATCH 076/222] bcm2835-sdhost: Improve error handling and recovery
   5
   6 1) Expose the hw_reset method to the MMC framework, removing many
   7    internal calls by the driver.
   8
   9 2) Reduce overclock setting on error.
  10
  11 3) Increase timeout to cope with high capacity cards.
  12
  13 4) Add properties and parameters to control pio_limit and debug.
  14
  15 5) Reduce messages at probe time.
  16 ---
  17  arch/arm/boot/dts/overlays/README             |   8 +-
  18  arch/arm/boot/dts/overlays/sdhost-overlay.dts |   4 +-
  19  drivers/mmc/host/bcm2835-sdhost.c             | 578 ++++++++++++++++++--------
  20  3 files changed, 404 insertions(+), 186 deletions(-)
  21
  22 --- a/arch/arm/boot/dts/overlays/README
  23 +++ b/arch/arm/boot/dts/overlays/README
  24 @@ -408,7 +408,13 @@ Info:   Selects the bcm2835-sdhost SD/MM
  25  Load:   dtoverlay=sdhost,<param>=<val>
  26  Params: overclock_50             Clock (in MHz) to use when the MMC framework
  27                                   requests 50MHz
  28 -        force_pio                Disable DMA support
  29 +
  30 +        force_pio                Disable DMA support (default off)
  31 +
  32 +        pio_limit                Number of blocks above which to use DMA
  33 +                                 (default 2)
  34 +
  35 +        debug                    Enable debug output (default off)
  36
  37
  38  Name:   spi-bcm2708
  39 --- a/arch/arm/boot/dts/overlays/sdhost-overlay.dts
  40 +++ b/arch/arm/boot/dts/overlays/sdhost-overlay.dts
  41 @@ -22,6 +22,7 @@
  42                                 dma-names = "tx", "rx";
  43                                 brcm,delay-after-stop = <0>;
  44                                 brcm,overclock-50 = <0>;
  45 +                               brcm,pio-limit = <2>;
  46                                 status = "okay";
  47                         };
  48                 };
  49 @@ -70,9 +71,10 @@
  50         };
  51
  52         __overrides__ {
  53 -               delay_after_stop = <&sdhost>,"brcm,delay-after-stop:0";
  54                 overclock_50     = <&sdhost>,"brcm,overclock-50:0";
  55                 force_pio        = <&sdhost>,"brcm,force-pio?";
  56 +               pio_limit        = <&sdhost>,"brcm,pio-limit:0";
  57 +               debug            = <&sdhost>,"brcm,debug?";
  58                 sdhost_freq      = <&clk_sdhost>,"clock-frequency:0";
  59         };
  60  };
  61 --- a/drivers/mmc/host/bcm2835-sdhost.c
  62 +++ b/drivers/mmc/host/bcm2835-sdhost.c
  63 @@ -90,9 +90,8 @@
  64  /* Reserved */
  65  #define SDHSTS_DATA_FLAG                0x01
  66
  67 -#define SDHSTS_TRANSFER_ERROR_MASK      (SDHSTS_CRC16_ERROR|SDHSTS_REW_TIME_OUT|SDHSTS_FIFO_ERROR)
  68 +#define SDHSTS_TRANSFER_ERROR_MASK      (SDHSTS_CRC7_ERROR|SDHSTS_CRC16_ERROR|SDHSTS_REW_TIME_OUT|SDHSTS_FIFO_ERROR)
  69  #define SDHSTS_ERROR_MASK               (SDHSTS_CMD_TIME_OUT|SDHSTS_TRANSFER_ERROR_MASK)
  70 -/* SDHSTS_CRC7_ERROR - ignore this as MMC cards generate this spuriously */
  71
  72  #define SDHCFG_BUSY_IRPT_EN     (1<<10)
  73  #define SDHCFG_BLOCK_IRPT_EN    (1<<8)
  74 @@ -111,16 +110,7 @@
  75  #define SDEDM_READ_THRESHOLD_SHIFT 14
  76  #define SDEDM_THRESHOLD_MASK     0x1f
  77
  78 -/* the inclusive limit in bytes under which PIO will be used instead of DMA */
  79 -#ifdef CONFIG_MMC_BCM2835_SDHOST_PIO_DMA_BARRIER
  80 -#define PIO_DMA_BARRIER CONFIG_MMC_BCM2835_SDHOST_PIO_DMA_BARRIER
  81 -#else
  82 -#define PIO_DMA_BARRIER 0
  83 -#endif
  84 -
  85 -#define MIN_FREQ 400000
  86 -#define TIMEOUT_VAL 0xE
  87 -#define BCM2835_SDHOST_WRITE_DELAY(f)  (((2 * 1000000) / f) + 1)
  88 +#define MHZ 1000000
  89
  90  #ifndef BCM2708_PERI_BASE
  91   #define BCM2708_PERI_BASE 0x20000000
  92 @@ -138,19 +128,20 @@ struct bcm2835_host {
  93
  94         struct mmc_host         *mmc;
  95
  96 -       u32                     timeout;
  97 +       u32                     pio_timeout;    /* In jiffies */
  98
  99         int                     clock;          /* Current clock speed */
 100
 101         bool                    slow_card;      /* Force 11-bit divisor */
 102
 103         unsigned int            max_clk;        /* Max possible freq */
 104 -       unsigned int            timeout_clk;    /* Timeout freq (KHz) */
 105
 106         struct tasklet_struct   finish_tasklet; /* Tasklet structures */
 107
 108         struct timer_list       timer;          /* Timer for timeouts */
 109
 110 +       struct timer_list       pio_timer;      /* PIO error detection timer */
 111 +
 112         struct sg_mapping_iter  sg_miter;       /* SG state for PIO */
 113         unsigned int            blocks;         /* remaining PIO blocks */
 114
 115 @@ -170,6 +161,10 @@ struct bcm2835_host {
 116
 117         unsigned int                    use_busy:1;             /* Wait for busy interrupt */
 118
 119 +       unsigned int                    reduce_overclock:1;     /* ...at the next opportunity */
 120 +
 121 +       unsigned int                    debug:1;                /* Enable debug output */
 122 +
 123         u32                             thread_isr;
 124
 125         /*DMA part*/
 126 @@ -185,7 +180,8 @@ struct bcm2835_host {
 127         struct timeval                  stop_time;      /* when the last stop was issued */
 128         u32                             delay_after_stop; /* minimum time between stop and subsequent data transfer */
 129         u32                             overclock_50;   /* frequency to use when 50MHz is requested (in MHz) */
 130 -       u32                             max_overclock;  /* Highest reported */
 131 +       u32                             overclock;      /* Current frequency if overclocked, else zero */
 132 +       u32                             pio_limit;      /* Maximum block count for PIO (0 = always DMA) */
 133  };
 134
 135
 136 @@ -204,41 +200,79 @@ static inline u32 bcm2835_sdhost_read_re
 137         return readl_relaxed(host->ioaddr + reg);
 138  }
 139
 140 +static void bcm2835_sdhost_dumpcmd(struct bcm2835_host *host,
 141 +                                  struct mmc_command *cmd,
 142 +                                  const char *label)
 143 +{
 144 +       if (cmd)
 145 +               pr_info("%s:%c%s op %d arg 0x%x flags 0x%x - resp %08x %08x %08x %08x, err %d\n",
 146 +                       mmc_hostname(host->mmc),
 147 +                       (cmd == host->cmd) ? '>' : ' ',
 148 +                       label, cmd->opcode, cmd->arg, cmd->flags,
 149 +                       cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3],
 150 +                       cmd->error);
 151 +}
 152 +
 153  static void bcm2835_sdhost_dumpregs(struct bcm2835_host *host)
 154  {
 155 -       pr_info(DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n",
 156 +       bcm2835_sdhost_dumpcmd(host, host->mrq->sbc, "sbc");
 157 +       bcm2835_sdhost_dumpcmd(host, host->mrq->cmd, "cmd");
 158 +       if (host->mrq->data)
 159 +               pr_err("%s: data blocks %x blksz %x - err %d\n",
 160 +                      mmc_hostname(host->mmc),
 161 +                      host->mrq->data->blocks,
 162 +                      host->mrq->data->blksz,
 163 +                      host->mrq->data->error);
 164 +       bcm2835_sdhost_dumpcmd(host, host->mrq->stop, "stop");
 165 +
 166 +       pr_info("%s: =========== REGISTER DUMP ===========\n",
 167                 mmc_hostname(host->mmc));
 168
 169 -       pr_info(DRIVER_NAME ": SDCMD  0x%08x\n",
 170 +       pr_info("%s: SDCMD  0x%08x\n",
 171 +               mmc_hostname(host->mmc),
 172                 bcm2835_sdhost_read(host, SDCMD));
 173 -       pr_info(DRIVER_NAME ": SDARG  0x%08x\n",
 174 +       pr_info("%s: SDARG  0x%08x\n",
 175 +               mmc_hostname(host->mmc),
 176                 bcm2835_sdhost_read(host, SDARG));
 177 -       pr_info(DRIVER_NAME ": SDTOUT 0x%08x\n",
 178 +       pr_info("%s: SDTOUT 0x%08x\n",
 179 +               mmc_hostname(host->mmc),
 180                 bcm2835_sdhost_read(host, SDTOUT));
 181 -       pr_info(DRIVER_NAME ": SDCDIV 0x%08x\n",
 182 +       pr_info("%s: SDCDIV 0x%08x\n",
 183 +               mmc_hostname(host->mmc),
 184                 bcm2835_sdhost_read(host, SDCDIV));
 185 -       pr_info(DRIVER_NAME ": SDRSP0 0x%08x\n",
 186 +       pr_info("%s: SDRSP0 0x%08x\n",
 187 +               mmc_hostname(host->mmc),
 188                 bcm2835_sdhost_read(host, SDRSP0));
 189 -       pr_info(DRIVER_NAME ": SDRSP1 0x%08x\n",
 190 +       pr_info("%s: SDRSP1 0x%08x\n",
 191 +               mmc_hostname(host->mmc),
 192                 bcm2835_sdhost_read(host, SDRSP1));
 193 -       pr_info(DRIVER_NAME ": SDRSP2 0x%08x\n",
 194 +       pr_info("%s: SDRSP2 0x%08x\n",
 195 +               mmc_hostname(host->mmc),
 196                 bcm2835_sdhost_read(host, SDRSP2));
 197 -       pr_info(DRIVER_NAME ": SDRSP3 0x%08x\n",
 198 +       pr_info("%s: SDRSP3 0x%08x\n",
 199 +               mmc_hostname(host->mmc),
 200                 bcm2835_sdhost_read(host, SDRSP3));
 201 -       pr_info(DRIVER_NAME ": SDHSTS 0x%08x\n",
 202 +       pr_info("%s: SDHSTS 0x%08x\n",
 203 +               mmc_hostname(host->mmc),
 204                 bcm2835_sdhost_read(host, SDHSTS));
 205 -       pr_info(DRIVER_NAME ": SDVDD  0x%08x\n",
 206 +       pr_info("%s: SDVDD  0x%08x\n",
 207 +               mmc_hostname(host->mmc),
 208                 bcm2835_sdhost_read(host, SDVDD));
 209 -       pr_info(DRIVER_NAME ": SDEDM  0x%08x\n",
 210 +       pr_info("%s: SDEDM  0x%08x\n",
 211 +               mmc_hostname(host->mmc),
 212                 bcm2835_sdhost_read(host, SDEDM));
 213 -       pr_info(DRIVER_NAME ": SDHCFG 0x%08x\n",
 214 +       pr_info("%s: SDHCFG 0x%08x\n",
 215 +               mmc_hostname(host->mmc),
 216                 bcm2835_sdhost_read(host, SDHCFG));
 217 -       pr_info(DRIVER_NAME ": SDHBCT 0x%08x\n",
 218 +       pr_info("%s: SDHBCT 0x%08x\n",
 219 +               mmc_hostname(host->mmc),
 220                 bcm2835_sdhost_read(host, SDHBCT));
 221 -       pr_info(DRIVER_NAME ": SDHBLC 0x%08x\n",
 222 +       pr_info("%s: SDHBLC 0x%08x\n",
 223 +               mmc_hostname(host->mmc),
 224                 bcm2835_sdhost_read(host, SDHBLC));
 225
 226 -       pr_debug(DRIVER_NAME ": ===========================================\n");
 227 +       pr_info("%s: ===========================================\n",
 228 +               mmc_hostname(host->mmc));
 229  }
 230
 231
 232 @@ -248,12 +282,10 @@ static void bcm2835_sdhost_set_power(str
 233  }
 234
 235
 236 -static void bcm2835_sdhost_reset(struct bcm2835_host *host)
 237 +static void bcm2835_sdhost_reset_internal(struct bcm2835_host *host)
 238  {
 239         u32 temp;
 240
 241 -       pr_debug("bcm2835_sdhost_reset\n");
 242 -
 243         bcm2835_sdhost_set_power(host, false);
 244
 245         bcm2835_sdhost_write(host, 0, SDCMD);
 246 @@ -281,6 +313,20 @@ static void bcm2835_sdhost_reset(struct
 247         mmiowb();
 248  }
 249
 250 +
 251 +static void bcm2835_sdhost_reset(struct mmc_host *mmc)
 252 +{
 253 +       struct bcm2835_host *host = mmc_priv(mmc);
 254 +       unsigned long flags;
 255 +       if (host->debug)
 256 +               pr_info("%s: reset\n", mmc_hostname(mmc));
 257 +       spin_lock_irqsave(&host->lock, flags);
 258 +
 259 +       bcm2835_sdhost_reset_internal(host);
 260 +
 261 +       spin_unlock_irqrestore(&host->lock, flags);
 262 +}
 263 +
 264  static void bcm2835_sdhost_set_ios(struct mmc_host *mmc, struct mmc_ios *ios);
 265
 266  static void bcm2835_sdhost_init(struct bcm2835_host *host, int soft)
 267 @@ -290,7 +336,7 @@ static void bcm2835_sdhost_init(struct b
 268         /* Set interrupt enables */
 269         host->hcfg = SDHCFG_BUSY_IRPT_EN;
 270
 271 -       bcm2835_sdhost_reset(host);
 272 +       bcm2835_sdhost_reset_internal(host);
 273
 274         if (soft) {
 275                 /* force clock reconfiguration */
 276 @@ -420,6 +466,40 @@ static void bcm2835_sdhost_dma_complete(
 277         spin_unlock_irqrestore(&host->lock, flags);
 278  }
 279
 280 +static bool data_transfer_wait(struct bcm2835_host *host, const char *caller)
 281 +{
 282 +       unsigned long timeout = 1000000;
 283 +       u32 hsts;
 284 +       while (timeout)
 285 +       {
 286 +               hsts = bcm2835_sdhost_read(host, SDHSTS);
 287 +               if (hsts & (SDHSTS_TRANSFER_ERROR_MASK |
 288 +                           SDHSTS_DATA_FLAG)) {
 289 +                       bcm2835_sdhost_write(host, SDHSTS_TRANSFER_ERROR_MASK,
 290 +                                            SDHSTS);
 291 +                       break;
 292 +               }
 293 +               timeout--;
 294 +       }
 295 +
 296 +       if (hsts & (SDHSTS_CRC16_ERROR |
 297 +                   SDHSTS_CRC7_ERROR |
 298 +                   SDHSTS_FIFO_ERROR)) {
 299 +               pr_err("%s: data error in %s - HSTS %x\n",
 300 +                      mmc_hostname(host->mmc), caller, hsts);
 301 +               host->data->error = -EILSEQ;
 302 +               return false;
 303 +       } else if ((timeout == 0) ||
 304 +                  (hsts & (SDHSTS_CMD_TIME_OUT |
 305 +                           SDHSTS_REW_TIME_OUT))) {
 306 +               pr_err("%s: timeout in %s - HSTS %x\n",
 307 +                      mmc_hostname(host->mmc), caller, hsts);
 308 +               host->data->error = -ETIMEDOUT;
 309 +               return false;
 310 +       }
 311 +       return true;
 312 +}
 313 +
 314  static void bcm2835_sdhost_read_block_pio(struct bcm2835_host *host)
 315  {
 316         unsigned long flags;
 317 @@ -443,35 +523,15 @@ static void bcm2835_sdhost_read_block_pi
 318                 buf = (u32 *)host->sg_miter.addr;
 319
 320                 while (len) {
 321 -                       while (1) {
 322 -                               u32 hsts;
 323 -                               hsts = bcm2835_sdhost_read(host, SDHSTS);
 324 -                               if (hsts & SDHSTS_DATA_FLAG)
 325 -                                       break;
 326 -
 327 -                               if (hsts & SDHSTS_ERROR_MASK) {
 328 -                                       pr_err("%s: Transfer error - HSTS %x, HBCT %x - %x left\n",
 329 -                                              mmc_hostname(host->mmc),
 330 -                                              hsts,
 331 -                                              bcm2835_sdhost_read(host, SDHBCT),
 332 -                                              blksize + len);
 333 -                                       if (hsts & SDHSTS_REW_TIME_OUT)
 334 -                                               host->data->error = -ETIMEDOUT;
 335 -                                       else if (hsts & (SDHSTS_CRC16_ERROR ||
 336 -                                                   SDHSTS_CRC7_ERROR))
 337 -                                               host->data->error = -EILSEQ;
 338 -                                       else {
 339 -                                               pr_err("%s: unexpected data error\n",
 340 -                                                      mmc_hostname(host->mmc));
 341 -                                               bcm2835_sdhost_dumpregs(host);
 342 -                                               host->cmd->error = -EIO;
 343 -                                       }
 344 -                               }
 345 -                       }
 346 +                       if (!data_transfer_wait(host, "read_block_pio"))
 347 +                               break;
 348
 349                         *(buf++) = bcm2835_sdhost_read(host, SDDATA);
 350                         len -= 4;
 351                 }
 352 +
 353 +               if (host->data->error)
 354 +                       break;
 355         }
 356
 357         sg_miter_stop(&host->sg_miter);
 358 @@ -502,11 +562,15 @@ static void bcm2835_sdhost_write_block_p
 359                 buf = host->sg_miter.addr;
 360
 361                 while (len) {
 362 -                       while (!(bcm2835_sdhost_read(host, SDHSTS) & SDHSTS_DATA_FLAG))
 363 -                               continue;
 364 +                       if (!data_transfer_wait(host, "write_block_pio"))
 365 +                               break;
 366 +
 367                         bcm2835_sdhost_write(host, *(buf++), SDDATA);
 368                         len -= 4;
 369                 }
 370 +
 371 +               if (host->data->error)
 372 +                       break;
 373         }
 374
 375         sg_miter_stop(&host->sg_miter);
 376 @@ -519,10 +583,15 @@ static void bcm2835_sdhost_transfer_pio(
 377  {
 378         BUG_ON(!host->data);
 379
 380 -       if (host->data->flags & MMC_DATA_READ)
 381 +       if (host->data->flags & MMC_DATA_READ) {
 382                 bcm2835_sdhost_read_block_pio(host);
 383 -       else
 384 +       } else {
 385                 bcm2835_sdhost_write_block_pio(host);
 386 +
 387 +               /* Start a timer in case a transfer error occurs because
 388 +                  there is no error interrupt */
 389 +               mod_timer(&host->pio_timer, jiffies + host->pio_timeout);
 390 +       }
 391  }
 392
 393
 394 @@ -607,6 +676,7 @@ static void bcm2835_sdhost_prepare_data(
 395         host->flush_fifo = 0;
 396         host->data->bytes_xfered = 0;
 397
 398 +       host->use_dma = host->have_dma && (data->blocks > host->pio_limit);
 399         if (!host->use_dma) {
 400                 int flags;
 401
 402 @@ -619,8 +689,6 @@ static void bcm2835_sdhost_prepare_data(
 403                 host->blocks = data->blocks;
 404         }
 405
 406 -       host->use_dma = host->have_dma && data->blocks > PIO_DMA_BARRIER;
 407 -
 408         bcm2835_sdhost_set_transfer_irqs(host);
 409
 410         bcm2835_sdhost_write(host, data->blksz, SDHBCT);
 411 @@ -638,22 +706,25 @@ void bcm2835_sdhost_send_command(struct
 412
 413         WARN_ON(host->cmd);
 414
 415 -       if (1) {
 416 -               pr_debug("bcm2835_sdhost_send_command: %08x %08x (flags %x)\n",
 417 -                        cmd->opcode, cmd->arg, (cmd->flags & 0xff) | (cmd->data ? cmd->data->flags : 0));
 418 -               if (cmd->data)
 419 -                       pr_debug("bcm2835_sdhost_send_command: %s %d*%x\n",
 420 -                                (cmd->data->flags & MMC_DATA_READ) ?
 421 -                                "read" : "write", cmd->data->blocks,
 422 -                                cmd->data->blksz);
 423 -       }
 424 +       if (cmd->data)
 425 +               pr_debug("%s: send_command %d 0x%x "
 426 +                        "(flags 0x%x) - %s %d*%d\n",
 427 +                        mmc_hostname(host->mmc),
 428 +                        cmd->opcode, cmd->arg, cmd->flags,
 429 +                        (cmd->data->flags & MMC_DATA_READ) ?
 430 +                        "read" : "write", cmd->data->blocks,
 431 +                        cmd->data->blksz);
 432 +       else
 433 +               pr_debug("%s: send_command %d 0x%x (flags 0x%x)\n",
 434 +                        mmc_hostname(host->mmc),
 435 +                        cmd->opcode, cmd->arg, cmd->flags);
 436
 437         /* Wait max 10 ms */
 438         timeout = 1000;
 439
 440         while (bcm2835_sdhost_read(host, SDCMD) & SDCMD_NEW_FLAG) {
 441                 if (timeout == 0) {
 442 -                       pr_err("%s: Previous command never completed.\n",
 443 +                       pr_err("%s: previous command never completed.\n",
 444                                 mmc_hostname(host->mmc));
 445                         bcm2835_sdhost_dumpregs(host);
 446                         cmd->error = -EIO;
 447 @@ -666,16 +737,16 @@ void bcm2835_sdhost_send_command(struct
 448
 449         if ((1000-timeout)/100 > 1 && (1000-timeout)/100 > host->max_delay) {
 450                 host->max_delay = (1000-timeout)/100;
 451 -               pr_warning("Warning: SDHost controller hung for %d ms\n", host->max_delay);
 452 +               pr_warning("%s: controller hung for %d ms\n",
 453 +                          mmc_hostname(host->mmc),
 454 +                          host->max_delay);
 455         }
 456
 457         timeout = jiffies;
 458 -#ifdef CONFIG_ARCH_BCM2835
 459         if (!cmd->data && cmd->busy_timeout > 9000)
 460                 timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
 461         else
 462 -#endif
 463 -       timeout += 10 * HZ;
 464 +               timeout += 10 * HZ;
 465         mod_timer(&host->timer, timeout);
 466
 467         host->cmd = cmd;
 468 @@ -685,7 +756,7 @@ void bcm2835_sdhost_send_command(struct
 469         bcm2835_sdhost_write(host, cmd->arg, SDARG);
 470
 471         if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
 472 -               pr_err("%s: Unsupported response type!\n",
 473 +               pr_err("%s: unsupported response type!\n",
 474                         mmc_hostname(host->mmc));
 475                 cmd->error = -EINVAL;
 476                 tasklet_schedule(&host->finish_tasklet);
 477 @@ -783,13 +854,6 @@ static void bcm2835_sdhost_transfer_comp
 478         pr_debug("transfer_complete(error %d, stop %d)\n",
 479                data->error, data->stop ? 1 : 0);
 480
 481 -       if (data->error)
 482 -               /*
 483 -                * The controller needs a reset of internal state machines
 484 -                * upon error conditions.
 485 -                */
 486 -               bcm2835_sdhost_reset(host);
 487 -
 488         /*
 489          * Need to send CMD12 if -
 490          * a) open-ended multiblock transfer (no CMD23)
 491 @@ -845,7 +909,7 @@ static void bcm2835_sdhost_finish_comman
 492  #endif
 493
 494         if (timeout == 0) {
 495 -               pr_err("%s: Command never completed.\n",
 496 +               pr_err("%s: command never completed.\n",
 497                        mmc_hostname(host->mmc));
 498                 bcm2835_sdhost_dumpregs(host);
 499                 host->cmd->error = -EIO;
 500 @@ -875,14 +939,23 @@ static void bcm2835_sdhost_finish_comman
 501         {
 502                 u32 sdhsts = bcm2835_sdhost_read(host, SDHSTS);
 503
 504 -               pr_debug("%s: error detected - CMD %x, HSTS %03x, EDM %x\n",
 505 -                      mmc_hostname(host->mmc), sdcmd, sdhsts,
 506 -                      bcm2835_sdhost_read(host, SDEDM));
 507 -
 508 -               if (sdhsts & SDHSTS_CMD_TIME_OUT)
 509 +               if (host->debug)
 510 +                       pr_info("%s: error detected - CMD %x, HSTS %03x, EDM %x\n",
 511 +                               mmc_hostname(host->mmc), sdcmd, sdhsts,
 512 +                               bcm2835_sdhost_read(host, SDEDM));
 513 +
 514 +               if (sdhsts & SDHSTS_CMD_TIME_OUT) {
 515 +                       switch (host->cmd->opcode) {
 516 +                       case 5: case 52: case 53:
 517 +                               /* Don't warn about SDIO commands */
 518 +                               break;
 519 +                       default:
 520 +                               pr_err("%s: command timeout\n",
 521 +                                      mmc_hostname(host->mmc));
 522 +                               break;
 523 +                       }
 524                         host->cmd->error = -ETIMEDOUT;
 525 -               else
 526 -               {
 527 +               } else {
 528                         pr_err("%s: unexpected command error\n",
 529                                mmc_hostname(host->mmc));
 530                         bcm2835_sdhost_dumpregs(host);
 531 @@ -897,11 +970,13 @@ static void bcm2835_sdhost_finish_comman
 532                         int i;
 533                         for (i = 0; i < 4; i++)
 534                                 host->cmd->resp[3 - i] = bcm2835_sdhost_read(host, SDRSP0 + i*4);
 535 -                       pr_debug("bcm2835_sdhost_finish_command: %08x %08x %08x %08x\n",
 536 +                       pr_debug("%s: finish_command %08x %08x %08x %08x\n",
 537 +                                mmc_hostname(host->mmc),
 538                                  host->cmd->resp[0], host->cmd->resp[1], host->cmd->resp[2], host->cmd->resp[3]);
 539                 } else {
 540                         host->cmd->resp[0] = bcm2835_sdhost_read(host, SDRSP0);
 541 -                       pr_debug("bcm2835_sdhost_finish_command: %08x\n",
 542 +                       pr_debug("%s: finish_command %08x\n",
 543 +                                mmc_hostname(host->mmc),
 544                                  host->cmd->resp[0]);
 545                 }
 546         }
 547 @@ -932,7 +1007,7 @@ static void bcm2835_sdhost_finish_comman
 548         }
 549  }
 550
 551 -static void bcm2835_sdhost_timeout_timer(unsigned long data)
 552 +static void bcm2835_sdhost_timeout(unsigned long data)
 553  {
 554         struct bcm2835_host *host;
 555         unsigned long flags;
 556 @@ -942,7 +1017,7 @@ static void bcm2835_sdhost_timeout_timer
 557         spin_lock_irqsave(&host->lock, flags);
 558
 559         if (host->mrq) {
 560 -               pr_err("%s: Timeout waiting for hardware interrupt.\n",
 561 +               pr_err("%s: timeout waiting for hardware interrupt.\n",
 562                         mmc_hostname(host->mmc));
 563                 bcm2835_sdhost_dumpregs(host);
 564
 565 @@ -964,6 +1039,41 @@ static void bcm2835_sdhost_timeout_timer
 566         spin_unlock_irqrestore(&host->lock, flags);
 567  }
 568
 569 +static void bcm2835_sdhost_pio_timeout(unsigned long data)
 570 +{
 571 +       struct bcm2835_host *host;
 572 +       unsigned long flags;
 573 +
 574 +       host = (struct bcm2835_host *)data;
 575 +
 576 +       spin_lock_irqsave(&host->lock, flags);
 577 +
 578 +       if (host->data) {
 579 +               u32 hsts = bcm2835_sdhost_read(host, SDHSTS);
 580 +
 581 +               if (hsts & SDHSTS_REW_TIME_OUT) {
 582 +                       pr_err("%s: transfer timeout\n",
 583 +                              mmc_hostname(host->mmc));
 584 +                       if (host->debug)
 585 +                               bcm2835_sdhost_dumpregs(host);
 586 +               } else {
 587 +                       pr_err("%s: unexpected transfer timeout\n",
 588 +                              mmc_hostname(host->mmc));
 589 +                       bcm2835_sdhost_dumpregs(host);
 590 +               }
 591 +
 592 +               bcm2835_sdhost_write(host, SDHSTS_TRANSFER_ERROR_MASK,
 593 +                                    SDHSTS);
 594 +
 595 +               host->data->error = -ETIMEDOUT;
 596 +
 597 +               bcm2835_sdhost_finish_data(host);
 598 +       }
 599 +
 600 +       mmiowb();
 601 +       spin_unlock_irqrestore(&host->lock, flags);
 602 +}
 603 +
 604  static void bcm2835_sdhost_enable_sdio_irq_nolock(struct bcm2835_host *host, int enable)
 605  {
 606         if (enable)
 607 @@ -979,7 +1089,7 @@ static void bcm2835_sdhost_enable_sdio_i
 608         struct bcm2835_host *host = mmc_priv(mmc);
 609         unsigned long flags;
 610
 611 -       pr_debug("bcm2835_sdhost_enable_sdio_irq(%d)\n", enable);
 612 +       pr_debug("%s: enable_sdio_irq(%d)\n", mmc_hostname(mmc), enable);
 613         spin_lock_irqsave(&host->lock, flags);
 614         bcm2835_sdhost_enable_sdio_irq_nolock(host, enable);
 615         spin_unlock_irqrestore(&host->lock, flags);
 616 @@ -987,11 +1097,12 @@ static void bcm2835_sdhost_enable_sdio_i
 617
 618  static u32 bcm2835_sdhost_busy_irq(struct bcm2835_host *host, u32 intmask)
 619  {
 620 -       const u32 handled = (SDHSTS_CMD_TIME_OUT | SDHSTS_CRC16_ERROR |
 621 -                            SDHSTS_CRC7_ERROR | SDHSTS_FIFO_ERROR);
 622 +       const u32 handled = (SDHSTS_REW_TIME_OUT | SDHSTS_CMD_TIME_OUT |
 623 +                            SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR |
 624 +                            SDHSTS_FIFO_ERROR);
 625
 626         if (!host->cmd) {
 627 -               pr_err("%s: Got command busy interrupt 0x%08x even "
 628 +               pr_err("%s: got command busy interrupt 0x%08x even "
 629                         "though no command operation was in progress.\n",
 630                         mmc_hostname(host->mmc), (unsigned)intmask);
 631                 bcm2835_sdhost_dumpregs(host);
 632 @@ -999,7 +1110,7 @@ static u32 bcm2835_sdhost_busy_irq(struc
 633         }
 634
 635         if (!host->use_busy) {
 636 -               pr_err("%s: Got command busy interrupt 0x%08x even "
 637 +               pr_err("%s: got command busy interrupt 0x%08x even "
 638                         "though not expecting one.\n",
 639                         mmc_hostname(host->mmc), (unsigned)intmask);
 640                 bcm2835_sdhost_dumpregs(host);
 641 @@ -1007,14 +1118,28 @@ static u32 bcm2835_sdhost_busy_irq(struc
 642         }
 643         host->use_busy = 0;
 644
 645 -       if (intmask & SDHSTS_CMD_TIME_OUT)
 646 -               host->cmd->error = -ETIMEDOUT;
 647 -       else if (intmask & (SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR |
 648 -                       SDHSTS_FIFO_ERROR))
 649 -               host->cmd->error = -EILSEQ;
 650 +       if (intmask & SDHSTS_ERROR_MASK)
 651 +       {
 652 +               pr_err("sdhost_busy_irq: intmask %x, data %p\n", intmask, host->mrq->data);
 653 +               if (intmask & SDHSTS_CRC7_ERROR)
 654 +                       host->cmd->error = -EILSEQ;
 655 +               else if (intmask & (SDHSTS_CRC16_ERROR |
 656 +                                   SDHSTS_FIFO_ERROR)) {
 657 +                       if (host->mrq->data)
 658 +                               host->mrq->data->error = -EILSEQ;
 659 +                       else
 660 +                               host->cmd->error = -EILSEQ;
 661 +               } else if (intmask & SDHSTS_REW_TIME_OUT) {
 662 +                       if (host->mrq->data)
 663 +                               host->mrq->data->error = -ETIMEDOUT;
 664 +                       else
 665 +                               host->cmd->error = -ETIMEDOUT;
 666 +               } else if (intmask & SDHSTS_CMD_TIME_OUT)
 667 +                       host->cmd->error = -ETIMEDOUT;
 668
 669 -       if (host->cmd->error)
 670 +               bcm2835_sdhost_dumpregs(host);
 671                 tasklet_schedule(&host->finish_tasklet);
 672 +       }
 673         else
 674                 bcm2835_sdhost_finish_command(host);
 675
 676 @@ -1023,8 +1148,9 @@ static u32 bcm2835_sdhost_busy_irq(struc
 677
 678  static u32 bcm2835_sdhost_data_irq(struct bcm2835_host *host, u32 intmask)
 679  {
 680 -       const u32 handled = (SDHSTS_CMD_TIME_OUT | SDHSTS_CRC16_ERROR |
 681 -                            SDHSTS_CRC7_ERROR | SDHSTS_FIFO_ERROR);
 682 +       const u32 handled = (SDHSTS_REW_TIME_OUT |
 683 +                            SDHSTS_CRC16_ERROR |
 684 +                            SDHSTS_FIFO_ERROR);
 685
 686         /* There are no dedicated data/space available interrupt
 687            status bits, so it is necessary to use the single shared
 688 @@ -1034,13 +1160,19 @@ static u32 bcm2835_sdhost_data_irq(struc
 689         if (!host->data)
 690                 return 0;
 691
 692 -       // XXX FIFO_ERROR
 693 -       if (intmask & SDHSTS_CMD_TIME_OUT)
 694 -               host->cmd->error = -ETIMEDOUT;
 695 -       else if ((intmask & (SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR)) &&
 696 -                ((bcm2835_sdhost_read(host, SDCMD) & SDCMD_CMD_MASK)
 697 -                 != MMC_BUS_TEST_R))
 698 -               host->cmd->error = -EILSEQ;
 699 +       if (intmask & (SDHSTS_CRC16_ERROR |
 700 +                      SDHSTS_FIFO_ERROR |
 701 +                      SDHSTS_REW_TIME_OUT)) {
 702 +               if (intmask & (SDHSTS_CRC16_ERROR |
 703 +                              SDHSTS_FIFO_ERROR))
 704 +                       host->data->error = -EILSEQ;
 705 +               else
 706 +                       host->data->error = -ETIMEDOUT;
 707 +
 708 +               bcm2835_sdhost_dumpregs(host);
 709 +               tasklet_schedule(&host->finish_tasklet);
 710 +               return handled;
 711 +       }
 712
 713         /* Use the block interrupt for writes after the first block */
 714         if (host->data->flags & MMC_DATA_WRITE) {
 715 @@ -1067,31 +1199,48 @@ static u32 bcm2835_sdhost_block_irq(stru
 716  {
 717         struct dma_chan *dma_chan;
 718         u32 dir_data;
 719 -       const u32 handled = (SDHSTS_CMD_TIME_OUT | SDHSTS_CRC16_ERROR |
 720 -                            SDHSTS_CRC7_ERROR | SDHSTS_FIFO_ERROR);
 721 +       const u32 handled = (SDHSTS_REW_TIME_OUT |
 722 +                            SDHSTS_CRC16_ERROR |
 723 +                            SDHSTS_FIFO_ERROR);
 724
 725         if (!host->data) {
 726 -               pr_err("%s: Got block interrupt 0x%08x even "
 727 +               pr_err("%s: got block interrupt 0x%08x even "
 728                         "though no data operation was in progress.\n",
 729                         mmc_hostname(host->mmc), (unsigned)intmask);
 730                 bcm2835_sdhost_dumpregs(host);
 731                 return handled;
 732         }
 733
 734 -       if (intmask & SDHSTS_CMD_TIME_OUT)
 735 -               host->cmd->error = -ETIMEDOUT;
 736 -       else if ((intmask & (SDHSTS_CRC16_ERROR | SDHSTS_CRC7_ERROR)) &&
 737 -                ((bcm2835_sdhost_read(host, SDCMD) & SDCMD_CMD_MASK)
 738 -                 != MMC_BUS_TEST_R))
 739 -               host->cmd->error = -EILSEQ;
 740 +       if (intmask & (SDHSTS_CRC16_ERROR |
 741 +                      SDHSTS_FIFO_ERROR |
 742 +                      SDHSTS_REW_TIME_OUT)) {
 743 +               if (intmask & (SDHSTS_CRC16_ERROR |
 744 +                              SDHSTS_FIFO_ERROR))
 745 +                       host->data->error = -EILSEQ;
 746 +               else
 747 +                       host->data->error = -ETIMEDOUT;
 748 +
 749 +               if (host->debug)
 750 +                       bcm2835_sdhost_dumpregs(host);
 751 +               tasklet_schedule(&host->finish_tasklet);
 752 +               return handled;
 753 +       }
 754
 755         if (!host->use_dma) {
 756                 BUG_ON(!host->blocks);
 757                 host->blocks--;
 758 -               if ((host->blocks == 0) || host->data->error)
 759 +               if ((host->blocks == 0) || host->data->error) {
 760 +                       /* Cancel the timer */
 761 +                       del_timer(&host->pio_timer);
 762 +
 763                         bcm2835_sdhost_finish_data(host);
 764 -               else
 765 +               } else {
 766                         bcm2835_sdhost_transfer_pio(host);
 767 +
 768 +                       /* Reset the timer */
 769 +                       mod_timer(&host->pio_timer,
 770 +                                 jiffies + host->pio_timeout);
 771 +               }
 772         } else if (host->data->flags & MMC_DATA_WRITE) {
 773                 dma_chan = host->dma_chan_tx;
 774                 dir_data = DMA_TO_DEVICE;
 775 @@ -1125,7 +1274,7 @@ static irqreturn_t bcm2835_sdhost_irq(in
 776                                      SDHSTS_BLOCK_IRPT |
 777                                      SDHSTS_SDIO_IRPT |
 778                                      SDHSTS_DATA_FLAG);
 779 -               if ((handled == SDHSTS_DATA_FLAG) && // XXX
 780 +               if ((handled == SDHSTS_DATA_FLAG) &&
 781                     (loops == 0) && !host->data) {
 782                         pr_err("%s: sdhost_irq data interrupt 0x%08x even "
 783                                "though no data operation was in progress.\n",
 784 @@ -1177,10 +1326,11 @@ static irqreturn_t bcm2835_sdhost_irq(in
 785         spin_unlock(&host->lock);
 786
 787         if (early)
 788 -               pr_debug("%s: early %x (loops %d)\n", mmc_hostname(host->mmc), early, loops);
 789 +               pr_debug("%s: early %x (loops %d)\n",
 790 +                        mmc_hostname(host->mmc), early, loops);
 791
 792         if (unexpected) {
 793 -               pr_err("%s: Unexpected interrupt 0x%08x.\n",
 794 +               pr_err("%s: unexpected interrupt 0x%08x.\n",
 795                            mmc_hostname(host->mmc), unexpected);
 796                 bcm2835_sdhost_dumpregs(host);
 797         }
 798 @@ -1227,8 +1377,22 @@ void bcm2835_sdhost_set_clock(struct bcm
 799         int div = 0; /* Initialized for compiler warning */
 800         unsigned int input_clock = clock;
 801
 802 -       if (host->overclock_50 && (clock == 50000000))
 803 -               clock = host->overclock_50 * 1000000 + 999999;
 804 +       if (host->debug)
 805 +               pr_info("%s: set_clock(%d)\n", mmc_hostname(host->mmc), clock);
 806 +
 807 +       if ((clock == 0) && host->reduce_overclock) {
 808 +               /* This is a reset following data corruption - reduce any
 809 +                  overclock */
 810 +               host->reduce_overclock = 0;
 811 +               if (host->overclock_50 > 50) {
 812 +                       pr_warn("%s: reducing overclock due to errors\n",
 813 +                               mmc_hostname(host->mmc));
 814 +                       host->overclock_50--;
 815 +               }
 816 +       }
 817 +
 818 +       if (host->overclock_50 && (clock == 50*MHZ))
 819 +               clock = host->overclock_50 * MHZ + (MHZ - 1);
 820
 821         /* The SDCDIV register has 11 bits, and holds (div - 2).
 822            But in data mode the max is 50MHz wihout a minimum, and only the
 823 @@ -1275,17 +1439,34 @@ void bcm2835_sdhost_set_clock(struct bcm
 824         clock = host->max_clk / (div + 2);
 825         host->mmc->actual_clock = clock;
 826
 827 -       if ((clock > input_clock) && (clock > host->max_overclock)) {
 828 -               pr_warn("%s: Overclocking to %dHz\n",
 829 -                       mmc_hostname(host->mmc), clock);
 830 -               host->max_overclock = clock;
 831 +       if (clock > input_clock) {
 832 +               /* Save the closest value, to make it easier
 833 +                  to reduce in the event of error */
 834 +               host->overclock_50 = (clock/MHZ);
 835 +
 836 +               if (clock != host->overclock) {
 837 +                       pr_warn("%s: overclocking to %dHz\n",
 838 +                               mmc_hostname(host->mmc), clock);
 839 +                       host->overclock = clock;
 840 +               }
 841 +       }
 842 +       else if ((clock == 50 * MHZ) && host->overclock)
 843 +       {
 844 +               pr_warn("%s: cancelling overclock\n",
 845 +                       mmc_hostname(host->mmc));
 846 +               host->overclock = 0;
 847         }
 848
 849         host->cdiv = div;
 850         bcm2835_sdhost_write(host, host->cdiv, SDCDIV);
 851
 852 -       pr_debug(DRIVER_NAME ": clock=%d -> max_clk=%d, cdiv=%x (actual clock %d)\n",
 853 -                input_clock, host->max_clk, host->cdiv, host->mmc->actual_clock);
 854 +       /* Set the timeout to 500ms */
 855 +       bcm2835_sdhost_write(host, host->mmc->actual_clock/2, SDTOUT);
 856 +
 857 +       if (host->debug)
 858 +               pr_info("%s: clock=%d -> max_clk=%d, cdiv=%x (actual clock %d)\n",
 859 +                       mmc_hostname(host->mmc), input_clock,
 860 +                       host->max_clk, host->cdiv, host->mmc->actual_clock);
 861  }
 862
 863  static void bcm2835_sdhost_request(struct mmc_host *mmc, struct mmc_request *mrq)
 864 @@ -1293,29 +1474,32 @@ static void bcm2835_sdhost_request(struc
 865         struct bcm2835_host *host;
 866         unsigned long flags;
 867
 868 -       if (1) {
 869 +       host = mmc_priv(mmc);
 870 +
 871 +       if (host->debug) {
 872                 struct mmc_command *cmd = mrq->cmd;
 873 -               const char *src = "cmd";
 874                 BUG_ON(!cmd);
 875 -               pr_debug("bcm2835_sdhost_request: %s %08x %08x (flags %x)\n",
 876 -                        src, cmd->opcode, cmd->arg, cmd->flags);
 877                 if (cmd->data)
 878 -                       pr_debug("bcm2835_sdhost_request: %s %d*%d\n",
 879 -                                (cmd->data->flags & MMC_DATA_READ) ?
 880 -                                "read" : "write", cmd->data->blocks,
 881 -                                cmd->data->blksz);
 882 +                       pr_info("%s: cmd %d 0x%x (flags 0x%x) - %s %d*%d\n",
 883 +                               mmc_hostname(mmc),
 884 +                               cmd->opcode, cmd->arg, cmd->flags,
 885 +                               (cmd->data->flags & MMC_DATA_READ) ?
 886 +                               "read" : "write", cmd->data->blocks,
 887 +                               cmd->data->blksz);
 888 +               else
 889 +                       pr_info("%s: cmd %d 0x%x (flags 0x%x)\n",
 890 +                               mmc_hostname(mmc),
 891 +                               cmd->opcode, cmd->arg, cmd->flags);
 892         }
 893
 894         if (mrq->data && !is_power_of_2(mrq->data->blksz)) {
 895 -               pr_err("%s: Unsupported block size (%d bytes)\n",
 896 +               pr_err("%s: unsupported block size (%d bytes)\n",
 897                        mmc_hostname(mmc), mrq->data->blksz);
 898                 mrq->cmd->error = -EINVAL;
 899                 mmc_request_done(mmc, mrq);
 900                 return;
 901         }
 902
 903 -       host = mmc_priv(mmc);
 904 -
 905         spin_lock_irqsave(&host->lock, flags);
 906
 907         WARN_ON(host->mrq != NULL);
 908 @@ -1345,9 +1529,12 @@ static void bcm2835_sdhost_set_ios(struc
 909         struct bcm2835_host *host = mmc_priv(mmc);
 910         unsigned long flags;
 911
 912 -       pr_debug("bcm2835_sdhost_set_ios: clock %d, pwr %d, bus_width %d, timing %d, vdd %d, drv_type %d\n",
 913 -              ios->clock, ios->power_mode, ios->bus_width,
 914 -              ios->timing, ios->signal_voltage, ios->drv_type);
 915 +       if (host->debug)
 916 +               pr_info("%s: ios clock %d, pwr %d, bus_width %d, "
 917 +                       "timing %d, vdd %d, drv_type %d\n",
 918 +                       mmc_hostname(mmc),
 919 +                       ios->clock, ios->power_mode, ios->bus_width,
 920 +                       ios->timing, ios->signal_voltage, ios->drv_type);
 921
 922         spin_lock_irqsave(&host->lock, flags);
 923
 924 @@ -1396,6 +1583,7 @@ static struct mmc_host_ops bcm2835_sdhos
 925         .request = bcm2835_sdhost_request,
 926         .set_ios = bcm2835_sdhost_set_ios,
 927         .enable_sdio_irq = bcm2835_sdhost_enable_sdio_irq,
 928 +       .hw_reset = bcm2835_sdhost_reset,
 929         .multi_io_quirk = bcm2835_sdhost_multi_io_quirk,
 930  };
 931
 932 @@ -1423,15 +1611,24 @@ static void bcm2835_sdhost_tasklet_finis
 933
 934         mrq = host->mrq;
 935
 936 -       /*
 937 -        * The controller needs a reset of internal state machines
 938 -        * upon error conditions.
 939 -        */
 940 -       if (((mrq->cmd && mrq->cmd->error) ||
 941 -                (mrq->data && (mrq->data->error ||
 942 -                 (mrq->data->stop && mrq->data->stop->error))))) {
 943 +       /* Drop the overclock after any data corruption, or after any
 944 +          error overclocked */
 945 +       if (mrq->data && (mrq->data->error == -EILSEQ))
 946 +               host->reduce_overclock = 1;
 947 +       else if (host->overclock) {
 948 +               /* Convert timeout errors while overclocked to data errors,
 949 +                  because the system recovers better. */
 950 +               if (mrq->cmd && mrq->cmd->error) {
 951 +                       host->reduce_overclock = 1;
 952 +                       if (mrq->cmd->error == -ETIMEDOUT)
 953 +                               mrq->cmd->error = -EILSEQ;
 954 +               }
 955
 956 -               bcm2835_sdhost_reset(host);
 957 +               if (mrq->data && mrq->data->error) {
 958 +                       host->reduce_overclock = 1;
 959 +                       if (mrq->data->error == -ETIMEDOUT)
 960 +                               mrq->data->error = -EILSEQ;
 961 +               }
 962         }
 963
 964         host->mrq = NULL;
 965 @@ -1450,35 +1647,37 @@ int bcm2835_sdhost_add_host(struct bcm28
 966  {
 967         struct mmc_host *mmc;
 968         struct dma_slave_config cfg;
 969 +       char pio_limit_string[20];
 970         int ret;
 971
 972         mmc = host->mmc;
 973
 974 -       bcm2835_sdhost_reset(host);
 975 +       bcm2835_sdhost_reset_internal(host);
 976
 977         mmc->f_max = host->max_clk;
 978         mmc->f_min = host->max_clk / SDCDIV_MAX_CDIV;
 979
 980 -       /* SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK */
 981 -       host->timeout_clk = mmc->f_max / 1000;
 982 -#ifdef CONFIG_ARCH_BCM2835
 983 -       mmc->max_busy_timeout = (1 << 27) / host->timeout_clk;
 984 -#endif
 985 +       mmc->max_busy_timeout =  (~(unsigned int)0)/(mmc->f_max/1000);
 986 +
 987 +       pr_debug("f_max %d, f_min %d, max_busy_timeout %d\n",
 988 +                mmc->f_max, mmc->f_min, mmc->max_busy_timeout);
 989 +
 990         /* host controller capabilities */
 991         mmc->caps |= /* MMC_CAP_SDIO_IRQ |*/ MMC_CAP_4_BIT_DATA |
 992                 MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED |
 993 -               MMC_CAP_NEEDS_POLL |
 994 +               MMC_CAP_NEEDS_POLL | MMC_CAP_HW_RESET |
 995                 (ALLOW_CMD23 * MMC_CAP_CMD23);
 996
 997         spin_lock_init(&host->lock);
 998
 999         if (host->allow_dma) {
1000 -               if (!host->dma_chan_tx || !host->dma_chan_rx ||
1001 -                   IS_ERR(host->dma_chan_tx) || IS_ERR(host->dma_chan_rx)) {
1002 -                       pr_err("%s: Unable to initialise DMA channels. Falling back to PIO\n", DRIVER_NAME);
1003 +               if (IS_ERR_OR_NULL(host->dma_chan_tx) ||
1004 +                   IS_ERR_OR_NULL(host->dma_chan_rx)) {
1005 +                       pr_err("%s: unable to initialise DMA channels. "
1006 +                              "Falling back to PIO\n",
1007 +                              mmc_hostname(mmc));
1008                         host->have_dma = false;
1009                 } else {
1010 -                       pr_info("DMA channels allocated for the SDHost driver");
1011                         host->have_dma = true;
1012
1013                         cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
1014 @@ -1496,7 +1695,6 @@ int bcm2835_sdhost_add_host(struct bcm28
1015                         ret = dmaengine_slave_config(host->dma_chan_rx, &cfg);
1016                 }
1017         } else {
1018 -               pr_info("Forcing PIO mode\n");
1019                 host->have_dma = false;
1020         }
1021
1022 @@ -1512,18 +1710,23 @@ int bcm2835_sdhost_add_host(struct bcm28
1023         tasklet_init(&host->finish_tasklet,
1024                 bcm2835_sdhost_tasklet_finish, (unsigned long)host);
1025
1026 -       setup_timer(&host->timer, bcm2835_sdhost_timeout_timer, (unsigned long)host);
1027 +       setup_timer(&host->timer, bcm2835_sdhost_timeout,
1028 +                   (unsigned long)host);
1029 +
1030 +       setup_timer(&host->pio_timer, bcm2835_sdhost_pio_timeout,
1031 +                   (unsigned long)host);
1032
1033         bcm2835_sdhost_init(host, 0);
1034  #ifndef CONFIG_ARCH_BCM2835
1035         ret = request_irq(host->irq, bcm2835_sdhost_irq, 0 /*IRQF_SHARED*/,
1036                                   mmc_hostname(mmc), host);
1037  #else
1038 -       ret = request_threaded_irq(host->irq, bcm2835_sdhost_irq, bcm2835_sdhost_thread_irq,
1039 +       ret = request_threaded_irq(host->irq, bcm2835_sdhost_irq,
1040 +                                  bcm2835_sdhost_thread_irq,
1041                                    IRQF_SHARED, mmc_hostname(mmc), host);
1042  #endif
1043         if (ret) {
1044 -               pr_err("%s: Failed to request IRQ %d: %d\n",
1045 +               pr_err("%s: failed to request IRQ %d: %d\n",
1046                        mmc_hostname(mmc), host->irq, ret);
1047                 goto untasklet;
1048         }
1049 @@ -1531,10 +1734,13 @@ int bcm2835_sdhost_add_host(struct bcm28
1050         mmiowb();
1051         mmc_add_host(mmc);
1052
1053 -       pr_info("Load BCM2835 SDHost driver\n");
1054 -       if (host->delay_after_stop)
1055 -               pr_info("BCM2835 SDHost: delay_after_stop=%dus\n",
1056 -                       host->delay_after_stop);
1057 +       pio_limit_string[0] = '\0';
1058 +       if (host->have_dma && (host->pio_limit > 0))
1059 +               sprintf(pio_limit_string, " (>%d)", host->pio_limit);
1060 +       pr_info("%s: %s loaded - DMA %s%s\n",
1061 +               mmc_hostname(mmc), DRIVER_NAME,
1062 +               host->have_dma ? "enabled" : "disabled",
1063 +               pio_limit_string);
1064
1065         return 0;
1066
1067 @@ -1562,7 +1768,7 @@ static int bcm2835_sdhost_probe(struct p
1068         mmc->ops = &bcm2835_sdhost_ops;
1069         host = mmc_priv(mmc);
1070         host->mmc = mmc;
1071 -       host->timeout = msecs_to_jiffies(1000);
1072 +       host->pio_timeout = msecs_to_jiffies(500);
1073         spin_lock_init(&host->lock);
1074
1075         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1076 @@ -1588,8 +1794,12 @@ static int bcm2835_sdhost_probe(struct p
1077                 of_property_read_u32(node,
1078                                      "brcm,overclock-50",
1079                                      &host->overclock_50);
1080 +               of_property_read_u32(node,
1081 +                                    "brcm,pio-limit",
1082 +                                    &host->pio_limit);
1083                 host->allow_dma = ALLOW_DMA &&
1084                         !of_property_read_bool(node, "brcm,force-pio");
1085 +               host->debug = of_property_read_bool(node, "brcm,debug");
1086         }
1087
1088         if (host->allow_dma) {