target/linux/generic-2.6/patches-2.6.23/301-mmc_sdhci_fixes.patch

   1 Index: linux-2.6.23.17/drivers/mmc/host/sdhci.c
   2 ===================================================================
   3 --- linux-2.6.23.17.orig/drivers/mmc/host/sdhci.c
   4 +++ linux-2.6.23.17/drivers/mmc/host/sdhci.c
   5 @@ -481,16 +481,16 @@ static void sdhci_finish_data(struct sdh
   6          * Controller doesn't count down when in single block mode.
   7          */
   8         if (data->blocks == 1)
   9 -               blocks = (data->error == MMC_ERR_NONE) ? 0 : 1;
  10 +               blocks = (data->error == 0) ? 0 : 1;
  11         else
  12                 blocks = readw(host->ioaddr + SDHCI_BLOCK_COUNT);
  13         data->bytes_xfered = data->blksz * (data->blocks - blocks);
  14
  15 -       if ((data->error == MMC_ERR_NONE) && blocks) {
  16 +       if (!data->error && blocks) {
  17                 printk(KERN_ERR "%s: Controller signalled completion even "
  18                         "though there were blocks left.\n",
  19                         mmc_hostname(host->mmc));
  20 -               data->error = MMC_ERR_FAILED;
  21 +               data->error = -EIO;
  22         }
  23
  24         if (data->stop) {
  25 @@ -498,7 +498,7 @@ static void sdhci_finish_data(struct sdh
  26                  * The controller needs a reset of internal state machines
  27                  * upon error conditions.
  28                  */
  29 -               if (data->error != MMC_ERR_NONE) {
  30 +               if (data->error) {
  31                         sdhci_reset(host, SDHCI_RESET_CMD);
  32                         sdhci_reset(host, SDHCI_RESET_DATA);
  33                 }
  34 @@ -533,7 +533,7 @@ static void sdhci_send_command(struct sd
  35                         printk(KERN_ERR "%s: Controller never released "
  36                                 "inhibit bit(s).\n", mmc_hostname(host->mmc));
  37                         sdhci_dumpregs(host);
  38 -                       cmd->error = MMC_ERR_FAILED;
  39 +                       cmd->error = -EIO;
  40                         tasklet_schedule(&host->finish_tasklet);
  41                         return;
  42                 }
  43 @@ -554,7 +554,7 @@ static void sdhci_send_command(struct sd
  44         if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
  45                 printk(KERN_ERR "%s: Unsupported response type!\n",
  46                         mmc_hostname(host->mmc));
  47 -               cmd->error = MMC_ERR_INVALID;
  48 +               cmd->error = -EINVAL;
  49                 tasklet_schedule(&host->finish_tasklet);
  50                 return;
  51         }
  52 @@ -601,7 +601,7 @@ static void sdhci_finish_command(struct
  53                 }
  54         }
  55
  56 -       host->cmd->error = MMC_ERR_NONE;
  57 +       host->cmd->error = 0;
  58
  59         if (host->data && host->data_early)
  60                 sdhci_finish_data(host);
  61 @@ -722,7 +722,7 @@ static void sdhci_request(struct mmc_hos
  62         host->mrq = mrq;
  63
  64         if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
  65 -               host->mrq->cmd->error = MMC_ERR_TIMEOUT;
  66 +               host->mrq->cmd->error = -ENOMEDIUM;
  67                 tasklet_schedule(&host->finish_tasklet);
  68         } else
  69                 sdhci_send_command(host, mrq->cmd);
  70 @@ -831,7 +831,7 @@ static void sdhci_tasklet_card(unsigned
  71                         sdhci_reset(host, SDHCI_RESET_CMD);
  72                         sdhci_reset(host, SDHCI_RESET_DATA);
  73
  74 -                       host->mrq->cmd->error = MMC_ERR_FAILED;
  75 +                       host->mrq->cmd->error = -ENOMEDIUM;
  76                         tasklet_schedule(&host->finish_tasklet);
  77                 }
  78         }
  79 @@ -859,9 +859,9 @@ static void sdhci_tasklet_finish(unsigne
  80          * The controller needs a reset of internal state machines
  81          * upon error conditions.
  82          */
  83 -       if ((mrq->cmd->error != MMC_ERR_NONE) ||
  84 -               (mrq->data && ((mrq->data->error != MMC_ERR_NONE) ||
  85 -               (mrq->data->stop && (mrq->data->stop->error != MMC_ERR_NONE))))) {
  86 +       if (mrq->cmd->error ||
  87 +               (mrq->data && (mrq->data->error ||
  88 +               (mrq->data->stop && mrq->data->stop->error)))) {
  89
  90                 /* Some controllers need this kick or reset won't work here */
  91                 if (host->chip->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) {
  92 @@ -906,13 +906,13 @@ static void sdhci_timeout_timer(unsigned
  93                 sdhci_dumpregs(host);
  94
  95                 if (host->data) {
  96 -                       host->data->error = MMC_ERR_TIMEOUT;
  97 +                       host->data->error = -ETIMEDOUT;
  98                         sdhci_finish_data(host);
  99                 } else {
 100                         if (host->cmd)
 101 -                               host->cmd->error = MMC_ERR_TIMEOUT;
 102 +                               host->cmd->error = -ETIMEDOUT;
 103                         else
 104 -                               host->mrq->cmd->error = MMC_ERR_TIMEOUT;
 105 +                               host->mrq->cmd->error = -ETIMEDOUT;
 106
 107                         tasklet_schedule(&host->finish_tasklet);
 108                 }
 109 @@ -941,13 +941,12 @@ static void sdhci_cmd_irq(struct sdhci_h
 110         }
 111
 112         if (intmask & SDHCI_INT_TIMEOUT)
 113 -               host->cmd->error = MMC_ERR_TIMEOUT;
 114 -       else if (intmask & SDHCI_INT_CRC)
 115 -               host->cmd->error = MMC_ERR_BADCRC;
 116 -       else if (intmask & (SDHCI_INT_END_BIT | SDHCI_INT_INDEX))
 117 -               host->cmd->error = MMC_ERR_FAILED;
 118 +               host->cmd->error = -ETIMEDOUT;
 119 +       else if (intmask & (SDHCI_INT_CRC | SDHCI_INT_END_BIT |
 120 +                       SDHCI_INT_INDEX))
 121 +               host->cmd->error = -EILSEQ;
 122
 123 -       if (host->cmd->error != MMC_ERR_NONE)
 124 +       if (host->cmd->error)
 125                 tasklet_schedule(&host->finish_tasklet);
 126         else if (intmask & SDHCI_INT_RESPONSE)
 127                 sdhci_finish_command(host);
 128 @@ -974,13 +973,11 @@ static void sdhci_data_irq(struct sdhci_
 129         }
 130
 131         if (intmask & SDHCI_INT_DATA_TIMEOUT)
 132 -               host->data->error = MMC_ERR_TIMEOUT;
 133 -       else if (intmask & SDHCI_INT_DATA_CRC)
 134 -               host->data->error = MMC_ERR_BADCRC;
 135 -       else if (intmask & SDHCI_INT_DATA_END_BIT)
 136 -               host->data->error = MMC_ERR_FAILED;
 137 +               host->data->error = -ETIMEDOUT;
 138 +       else if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_END_BIT))
 139 +               host->data->error = -EILSEQ;
 140
 141 -       if (host->data->error != MMC_ERR_NONE)
 142 +       if (host->data->error)
 143                 sdhci_finish_data(host);
 144         else {
 145                 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
 146 @@ -1312,7 +1309,7 @@ static int __devinit sdhci_probe_slot(st
 147         mmc->ops = &sdhci_ops;
 148         mmc->f_min = host->max_clk / 256;
 149         mmc->f_max = host->max_clk;
 150 -       mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE | MMC_CAP_BYTEBLOCK;
 151 +       mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_MULTIWRITE;
 152
 153         if (caps & SDHCI_CAN_DO_HISPD)
 154                 mmc->caps |= MMC_CAP_SD_HIGHSPEED;