drivers/mmc/host/sdhci.c

   1 /*
   2  *  linux/drivers/mmc/host/sdhci.c - Secure Digital Host Controller Interface driver
   3  *
   4  *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or (at
   9  * your option) any later version.
  10  *
  11  * Thanks to the following companies for their support:
  12  *
  13  *     - JMicron (hardware and technical support)
  14  */
  15
  16 #include <linux/delay.h>
  17 #include <linux/highmem.h>
  18 #include <linux/io.h>
  19 #include <linux/dma-mapping.h>
  20 #include <linux/scatterlist.h>
  21
  22 #include <linux/leds.h>
  23
  24 #include <linux/mmc/host.h>
  25
  26 #include "sdhci.h"
  27
  28 #define DRIVER_NAME "sdhci"
  29
  30 #define DBG(f, x...) \
  31         pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x)
  32
  33 #if defined(CONFIG_LEDS_CLASS) || (defined(CONFIG_LEDS_CLASS_MODULE) && \
  34         defined(CONFIG_MMC_SDHCI_MODULE))
  35 #define SDHCI_USE_LEDS_CLASS
  36 #endif
  37
  38 static unsigned int debug_quirks = 0;
  39
  40 static void sdhci_prepare_data(struct sdhci_host *, struct mmc_data *);
  41 static void sdhci_finish_data(struct sdhci_host *);
  42
  43 static void sdhci_send_command(struct sdhci_host *, struct mmc_command *);
  44 static void sdhci_finish_command(struct sdhci_host *);
  45
  46 static void sdhci_dumpregs(struct sdhci_host *host)
  47 {
  48         printk(KERN_DEBUG DRIVER_NAME ": ============== REGISTER DUMP ==============\n");
  49
  50         printk(KERN_DEBUG DRIVER_NAME ": Sys addr: 0x%08x | Version:  0x%08x\n",
  51                 sdhci_readl(host, SDHCI_DMA_ADDRESS),
  52                 sdhci_readw(host, SDHCI_HOST_VERSION));
  53         printk(KERN_DEBUG DRIVER_NAME ": Blk size: 0x%08x | Blk cnt:  0x%08x\n",
  54                 sdhci_readw(host, SDHCI_BLOCK_SIZE),
  55                 sdhci_readw(host, SDHCI_BLOCK_COUNT));
  56         printk(KERN_DEBUG DRIVER_NAME ": Argument: 0x%08x | Trn mode: 0x%08x\n",
  57                 sdhci_readl(host, SDHCI_ARGUMENT),
  58                 sdhci_readw(host, SDHCI_TRANSFER_MODE));
  59         printk(KERN_DEBUG DRIVER_NAME ": Present:  0x%08x | Host ctl: 0x%08x\n",
  60                 sdhci_readl(host, SDHCI_PRESENT_STATE),
  61                 sdhci_readb(host, SDHCI_HOST_CONTROL));
  62         printk(KERN_DEBUG DRIVER_NAME ": Power:    0x%08x | Blk gap:  0x%08x\n",
  63                 sdhci_readb(host, SDHCI_POWER_CONTROL),
  64                 sdhci_readb(host, SDHCI_BLOCK_GAP_CONTROL));
  65         printk(KERN_DEBUG DRIVER_NAME ": Wake-up:  0x%08x | Clock:    0x%08x\n",
  66                 sdhci_readb(host, SDHCI_WAKE_UP_CONTROL),
  67                 sdhci_readw(host, SDHCI_CLOCK_CONTROL));
  68         printk(KERN_DEBUG DRIVER_NAME ": Timeout:  0x%08x | Int stat: 0x%08x\n",
  69                 sdhci_readb(host, SDHCI_TIMEOUT_CONTROL),
  70                 sdhci_readl(host, SDHCI_INT_STATUS));
  71         printk(KERN_DEBUG DRIVER_NAME ": Int enab: 0x%08x | Sig enab: 0x%08x\n",
  72                 sdhci_readl(host, SDHCI_INT_ENABLE),
  73                 sdhci_readl(host, SDHCI_SIGNAL_ENABLE));
  74         printk(KERN_DEBUG DRIVER_NAME ": AC12 err: 0x%08x | Slot int: 0x%08x\n",
  75                 sdhci_readw(host, SDHCI_ACMD12_ERR),
  76                 sdhci_readw(host, SDHCI_SLOT_INT_STATUS));
  77         printk(KERN_DEBUG DRIVER_NAME ": Caps:     0x%08x | Max curr: 0x%08x\n",
  78                 sdhci_readl(host, SDHCI_CAPABILITIES),
  79                 sdhci_readl(host, SDHCI_MAX_CURRENT));
  80
  81         printk(KERN_DEBUG DRIVER_NAME ": ===========================================\n");
  82 }
  83
  84 /*****************************************************************************\
  85  *                                                                           *
  86  * Low level functions                                                       *
  87  *                                                                           *
  88 \*****************************************************************************/
  89
  90 static void sdhci_clear_set_irqs(struct sdhci_host *host, u32 clear, u32 set)
  91 {
  92         u32 ier;
  93
  94         ier = sdhci_readl(host, SDHCI_INT_ENABLE);
  95         ier &= ~clear;
  96         ier |= set;
  97         sdhci_writel(host, ier, SDHCI_INT_ENABLE);
  98         sdhci_writel(host, ier, SDHCI_SIGNAL_ENABLE);
  99 }
 100
 101 static void sdhci_unmask_irqs(struct sdhci_host *host, u32 irqs)
 102 {
 103         sdhci_clear_set_irqs(host, 0, irqs);
 104 }
 105
 106 static void sdhci_mask_irqs(struct sdhci_host *host, u32 irqs)
 107 {
 108         sdhci_clear_set_irqs(host, irqs, 0);
 109 }
 110
 111 static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
 112 {
 113         u32 irqs = SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT;
 114
 115         if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
 116                 return;
 117
 118         if (enable)
 119                 sdhci_unmask_irqs(host, irqs);
 120         else
 121                 sdhci_mask_irqs(host, irqs);
 122 }
 123
 124 static void sdhci_enable_card_detection(struct sdhci_host *host)
 125 {
 126         sdhci_set_card_detection(host, true);
 127 }
 128
 129 static void sdhci_disable_card_detection(struct sdhci_host *host)
 130 {
 131         sdhci_set_card_detection(host, false);
 132 }
 133
 134 static void sdhci_reset(struct sdhci_host *host, u8 mask)
 135 {
 136         unsigned long timeout;
 137
 138         if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
 139                 if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) &
 140                         SDHCI_CARD_PRESENT))
 141                         return;
 142         }
 143
 144         sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
 145
 146         if (mask & SDHCI_RESET_ALL)
 147                 host->clock = 0;
 148
 149         /* Wait max 100 ms */
 150         timeout = 100;
 151
 152         /* hw clears the bit when it's done */
 153         while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
 154                 if (timeout == 0) {
 155                         printk(KERN_ERR "%s: Reset 0x%x never completed.\n",
 156                                 mmc_hostname(host->mmc), (int)mask);
 157                         sdhci_dumpregs(host);
 158                         return;
 159                 }
 160                 timeout--;
 161                 mdelay(1);
 162         }
 163 }
 164
 165 static void sdhci_init(struct sdhci_host *host)
 166 {
 167         sdhci_reset(host, SDHCI_RESET_ALL);
 168
 169         sdhci_clear_set_irqs(host, SDHCI_INT_ALL_MASK,
 170                 SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
 171                 SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_INDEX |
 172                 SDHCI_INT_END_BIT | SDHCI_INT_CRC | SDHCI_INT_TIMEOUT |
 173                 SDHCI_INT_DATA_END | SDHCI_INT_RESPONSE);
 174 }
 175
 176 static void sdhci_reinit(struct sdhci_host *host)
 177 {
 178         sdhci_init(host);
 179         sdhci_enable_card_detection(host);
 180 }
 181
 182 static void sdhci_activate_led(struct sdhci_host *host)
 183 {
 184         u8 ctrl;
 185
 186         ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
 187         ctrl |= SDHCI_CTRL_LED;
 188         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 189 }
 190
 191 static void sdhci_deactivate_led(struct sdhci_host *host)
 192 {
 193         u8 ctrl;
 194
 195         ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
 196         ctrl &= ~SDHCI_CTRL_LED;
 197         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 198 }
 199
 200 #ifdef SDHCI_USE_LEDS_CLASS
 201 static void sdhci_led_control(struct led_classdev *led,
 202         enum led_brightness brightness)
 203 {
 204         struct sdhci_host *host = container_of(led, struct sdhci_host, led);
 205         unsigned long flags;
 206
 207         spin_lock_irqsave(&host->lock, flags);
 208
 209         if (brightness == LED_OFF)
 210                 sdhci_deactivate_led(host);
 211         else
 212                 sdhci_activate_led(host);
 213
 214         spin_unlock_irqrestore(&host->lock, flags);
 215 }
 216 #endif
 217
 218 /*****************************************************************************\
 219  *                                                                           *
 220  * Core functions                                                            *
 221  *                                                                           *
 222 \*****************************************************************************/
 223
 224 static void sdhci_read_block_pio(struct sdhci_host *host)
 225 {
 226         unsigned long flags;
 227         size_t blksize, len, chunk;
 228         u32 uninitialized_var(scratch);
 229         u8 *buf;
 230
 231         DBG("PIO reading\n");
 232
 233         blksize = host->data->blksz;
 234         chunk = 0;
 235
 236         local_irq_save(flags);
 237
 238         while (blksize) {
 239                 if (!sg_miter_next(&host->sg_miter))
 240                         BUG();
 241
 242                 len = min(host->sg_miter.length, blksize);
 243
 244                 blksize -= len;
 245                 host->sg_miter.consumed = len;
 246
 247                 buf = host->sg_miter.addr;
 248
 249                 while (len) {
 250                         if (chunk == 0) {
 251                                 scratch = sdhci_readl(host, SDHCI_BUFFER);
 252                                 chunk = 4;
 253                         }
 254
 255                         *buf = scratch & 0xFF;
 256
 257                         buf++;
 258                         scratch >>= 8;
 259                         chunk--;
 260                         len--;
 261                 }
 262         }
 263
 264         sg_miter_stop(&host->sg_miter);
 265
 266         local_irq_restore(flags);
 267 }
 268
 269 static void sdhci_write_block_pio(struct sdhci_host *host)
 270 {
 271         unsigned long flags;
 272         size_t blksize, len, chunk;
 273         u32 scratch;
 274         u8 *buf;
 275
 276         DBG("PIO writing\n");
 277
 278         blksize = host->data->blksz;
 279         chunk = 0;
 280         scratch = 0;
 281
 282         local_irq_save(flags);
 283
 284         while (blksize) {
 285                 if (!sg_miter_next(&host->sg_miter))
 286                         BUG();
 287
 288                 len = min(host->sg_miter.length, blksize);
 289
 290                 blksize -= len;
 291                 host->sg_miter.consumed = len;
 292
 293                 buf = host->sg_miter.addr;
 294
 295                 while (len) {
 296                         scratch |= (u32)*buf << (chunk * 8);
 297
 298                         buf++;
 299                         chunk++;
 300                         len--;
 301
 302                         if ((chunk == 4) || ((len == 0) && (blksize == 0))) {
 303                                 sdhci_writel(host, scratch, SDHCI_BUFFER);
 304                                 chunk = 0;
 305                                 scratch = 0;
 306                         }
 307                 }
 308         }
 309
 310         sg_miter_stop(&host->sg_miter);
 311
 312         local_irq_restore(flags);
 313 }
 314
 315 static void sdhci_transfer_pio(struct sdhci_host *host)
 316 {
 317         u32 mask;
 318
 319         BUG_ON(!host->data);
 320
 321         if (host->blocks == 0)
 322                 return;
 323
 324         if (host->data->flags & MMC_DATA_READ)
 325                 mask = SDHCI_DATA_AVAILABLE;
 326         else
 327                 mask = SDHCI_SPACE_AVAILABLE;
 328
 329         /*
 330          * Some controllers (JMicron JMB38x) mess up the buffer bits
 331          * for transfers < 4 bytes. As long as it is just one block,
 332          * we can ignore the bits.
 333          */
 334         if ((host->quirks & SDHCI_QUIRK_BROKEN_SMALL_PIO) &&
 335                 (host->data->blocks == 1))
 336                 mask = ~0;
 337
 338         while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
 339                 if (host->data->flags & MMC_DATA_READ)
 340                         sdhci_read_block_pio(host);
 341                 else
 342                         sdhci_write_block_pio(host);
 343
 344                 host->blocks--;
 345                 if (host->blocks == 0)
 346                         break;
 347         }
 348
 349         DBG("PIO transfer complete.\n");
 350 }
 351
 352 static char *sdhci_kmap_atomic(struct scatterlist *sg, unsigned long *flags)
 353 {
 354         local_irq_save(*flags);
 355         return kmap_atomic(sg_page(sg), KM_BIO_SRC_IRQ) + sg->offset;
 356 }
 357
 358 static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
 359 {
 360         kunmap_atomic(buffer, KM_BIO_SRC_IRQ);
 361         local_irq_restore(*flags);
 362 }
 363
 364 static int sdhci_adma_table_pre(struct sdhci_host *host,
 365         struct mmc_data *data)
 366 {
 367         int direction;
 368
 369         u8 *desc;
 370         u8 *align;
 371         dma_addr_t addr;
 372         dma_addr_t align_addr;
 373         int len, offset;
 374
 375         struct scatterlist *sg;
 376         int i;
 377         char *buffer;
 378         unsigned long flags;
 379
 380         /*
 381          * The spec does not specify endianness of descriptor table.
 382          * We currently guess that it is LE.
 383          */
 384
 385         if (data->flags & MMC_DATA_READ)
 386                 direction = DMA_FROM_DEVICE;
 387         else
 388                 direction = DMA_TO_DEVICE;
 389
 390         /*
 391          * The ADMA descriptor table is mapped further down as we
 392          * need to fill it with data first.
 393          */
 394
 395         host->align_addr = dma_map_single(mmc_dev(host->mmc),
 396                 host->align_buffer, 128 * 4, direction);
 397         if (dma_mapping_error(mmc_dev(host->mmc), host->align_addr))
 398                 goto fail;
 399         BUG_ON(host->align_addr & 0x3);
 400
 401         host->sg_count = dma_map_sg(mmc_dev(host->mmc),
 402                 data->sg, data->sg_len, direction);
 403         if (host->sg_count == 0)
 404                 goto unmap_align;
 405
 406         desc = host->adma_desc;
 407         align = host->align_buffer;
 408
 409         align_addr = host->align_addr;
 410
 411         for_each_sg(data->sg, sg, host->sg_count, i) {
 412                 addr = sg_dma_address(sg);
 413                 len = sg_dma_len(sg);
 414
 415                 /*
 416                  * The SDHCI specification states that ADMA
 417                  * addresses must be 32-bit aligned. If they
 418                  * aren't, then we use a bounce buffer for
 419                  * the (up to three) bytes that screw up the
 420                  * alignment.
 421                  */
 422                 offset = (4 - (addr & 0x3)) & 0x3;
 423                 if (offset) {
 424                         if (data->flags & MMC_DATA_WRITE) {
 425                                 buffer = sdhci_kmap_atomic(sg, &flags);
 426                                 WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
 427                                 memcpy(align, buffer, offset);
 428                                 sdhci_kunmap_atomic(buffer, &flags);
 429                         }
 430
 431                         desc[7] = (align_addr >> 24) & 0xff;
 432                         desc[6] = (align_addr >> 16) & 0xff;
 433                         desc[5] = (align_addr >> 8) & 0xff;
 434                         desc[4] = (align_addr >> 0) & 0xff;
 435
 436                         BUG_ON(offset > 65536);
 437
 438                         desc[3] = (offset >> 8) & 0xff;
 439                         desc[2] = (offset >> 0) & 0xff;
 440
 441                         desc[1] = 0x00;
 442                         desc[0] = 0x21; /* tran, valid */
 443
 444                         align += 4;
 445                         align_addr += 4;
 446
 447                         desc += 8;
 448
 449                         addr += offset;
 450                         len -= offset;
 451                 }
 452
 453                 desc[7] = (addr >> 24) & 0xff;
 454                 desc[6] = (addr >> 16) & 0xff;
 455                 desc[5] = (addr >> 8) & 0xff;
 456                 desc[4] = (addr >> 0) & 0xff;
 457
 458                 BUG_ON(len > 65536);
 459
 460                 desc[3] = (len >> 8) & 0xff;
 461                 desc[2] = (len >> 0) & 0xff;
 462
 463                 desc[1] = 0x00;
 464                 desc[0] = 0x21; /* tran, valid */
 465
 466                 desc += 8;
 467
 468                 /*
 469                  * If this triggers then we have a calculation bug
 470                  * somewhere. :/
 471                  */
 472                 WARN_ON((desc - host->adma_desc) > (128 * 2 + 1) * 4);
 473         }
 474
 475         /*
 476          * Add a terminating entry.
 477          */
 478         desc[7] = 0;
 479         desc[6] = 0;
 480         desc[5] = 0;
 481         desc[4] = 0;
 482
 483         desc[3] = 0;
 484         desc[2] = 0;
 485
 486         desc[1] = 0x00;
 487         desc[0] = 0x03; /* nop, end, valid */
 488
 489         /*
 490          * Resync align buffer as we might have changed it.
 491          */
 492         if (data->flags & MMC_DATA_WRITE) {
 493                 dma_sync_single_for_device(mmc_dev(host->mmc),
 494                         host->align_addr, 128 * 4, direction);
 495         }
 496
 497         host->adma_addr = dma_map_single(mmc_dev(host->mmc),
 498                 host->adma_desc, (128 * 2 + 1) * 4, DMA_TO_DEVICE);
 499         if (dma_mapping_error(mmc_dev(host->mmc), host->adma_addr))
 500                 goto unmap_entries;
 501         BUG_ON(host->adma_addr & 0x3);
 502
 503         return 0;
 504
 505 unmap_entries:
 506         dma_unmap_sg(mmc_dev(host->mmc), data->sg,
 507                 data->sg_len, direction);
 508 unmap_align:
 509         dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
 510                 128 * 4, direction);
 511 fail:
 512         return -EINVAL;
 513 }
 514
 515 static void sdhci_adma_table_post(struct sdhci_host *host,
 516         struct mmc_data *data)
 517 {
 518         int direction;
 519
 520         struct scatterlist *sg;
 521         int i, size;
 522         u8 *align;
 523         char *buffer;
 524         unsigned long flags;
 525
 526         if (data->flags & MMC_DATA_READ)
 527                 direction = DMA_FROM_DEVICE;
 528         else
 529                 direction = DMA_TO_DEVICE;
 530
 531         dma_unmap_single(mmc_dev(host->mmc), host->adma_addr,
 532                 (128 * 2 + 1) * 4, DMA_TO_DEVICE);
 533
 534         dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
 535                 128 * 4, direction);
 536
 537         if (data->flags & MMC_DATA_READ) {
 538                 dma_sync_sg_for_cpu(mmc_dev(host->mmc), data->sg,
 539                         data->sg_len, direction);
 540
 541                 align = host->align_buffer;
 542
 543                 for_each_sg(data->sg, sg, host->sg_count, i) {
 544                         if (sg_dma_address(sg) & 0x3) {
 545                                 size = 4 - (sg_dma_address(sg) & 0x3);
 546
 547                                 buffer = sdhci_kmap_atomic(sg, &flags);
 548                                 WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
 549                                 memcpy(buffer, align, size);
 550                                 sdhci_kunmap_atomic(buffer, &flags);
 551
 552                                 align += 4;
 553                         }
 554                 }
 555         }
 556
 557         dma_unmap_sg(mmc_dev(host->mmc), data->sg,
 558                 data->sg_len, direction);
 559 }
 560
 561 static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_data *data)
 562 {
 563         u8 count;
 564         unsigned target_timeout, current_timeout;
 565
 566         /*
 567          * If the host controller provides us with an incorrect timeout
 568          * value, just skip the check and use 0xE.  The hardware may take
 569          * longer to time out, but that's much better than having a too-short
 570          * timeout value.
 571          */
 572         if ((host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL))
 573                 return 0xE;
 574
 575         /* timeout in us */
 576         target_timeout = data->timeout_ns / 1000 +
 577                 data->timeout_clks / host->clock;
 578
 579         /*
 580          * Figure out needed cycles.
 581          * We do this in steps in order to fit inside a 32 bit int.
 582          * The first step is the minimum timeout, which will have a
 583          * minimum resolution of 6 bits:
 584          * (1) 2^13*1000 > 2^22,
 585          * (2) host->timeout_clk < 2^16
 586          *     =>
 587          *     (1) / (2) > 2^6
 588          */
 589         count = 0;
 590         current_timeout = (1 << 13) * 1000 / host->timeout_clk;
 591         while (current_timeout < target_timeout) {
 592                 count++;
 593                 current_timeout <<= 1;
 594                 if (count >= 0xF)
 595                         break;
 596         }
 597
 598         if (count >= 0xF) {
 599                 printk(KERN_WARNING "%s: Too large timeout requested!\n",
 600                         mmc_hostname(host->mmc));
 601                 count = 0xE;
 602         }
 603
 604         return count;
 605 }
 606
 607 static void sdhci_set_transfer_irqs(struct sdhci_host *host)
 608 {
 609         u32 pio_irqs = SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL;
 610         u32 dma_irqs = SDHCI_INT_DMA_END | SDHCI_INT_ADMA_ERROR;
 611
 612         if (host->flags & SDHCI_REQ_USE_DMA)
 613                 sdhci_clear_set_irqs(host, pio_irqs, dma_irqs);
 614         else
 615                 sdhci_clear_set_irqs(host, dma_irqs, pio_irqs);
 616 }
 617
 618 static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_data *data)
 619 {
 620         u8 count;
 621         u8 ctrl;
 622         int ret;
 623
 624         WARN_ON(host->data);
 625
 626         if (data == NULL)
 627                 return;
 628
 629         /* Sanity checks */
 630         BUG_ON(data->blksz * data->blocks > 524288);
 631         BUG_ON(data->blksz > host->mmc->max_blk_size);
 632         BUG_ON(data->blocks > 65535);
 633
 634         host->data = data;
 635         host->data_early = 0;
 636
 637         count = sdhci_calc_timeout(host, data);
 638         sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
 639
 640         if (host->flags & SDHCI_USE_DMA)
 641                 host->flags |= SDHCI_REQ_USE_DMA;
 642
 643         /*
 644          * FIXME: This doesn't account for merging when mapping the
 645          * scatterlist.
 646          */
 647         if (host->flags & SDHCI_REQ_USE_DMA) {
 648                 int broken, i;
 649                 struct scatterlist *sg;
 650
 651                 broken = 0;
 652                 if (host->flags & SDHCI_USE_ADMA) {
 653                         if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE)
 654                                 broken = 1;
 655                 } else {
 656                         if (host->quirks & SDHCI_QUIRK_32BIT_DMA_SIZE)
 657                                 broken = 1;
 658                 }
 659
 660                 if (unlikely(broken)) {
 661                         for_each_sg(data->sg, sg, data->sg_len, i) {
 662                                 if (sg->length & 0x3) {
 663                                         DBG("Reverting to PIO because of "
 664                                                 "transfer size (%d)\n",
 665                                                 sg->length);
 666                                         host->flags &= ~SDHCI_REQ_USE_DMA;
 667                                         break;
 668                                 }
 669                         }
 670                 }
 671         }
 672
 673         /*
 674          * The assumption here being that alignment is the same after
 675          * translation to device address space.
 676          */
 677         if (host->flags & SDHCI_REQ_USE_DMA) {
 678                 int broken, i;
 679                 struct scatterlist *sg;
 680
 681                 broken = 0;
 682                 if (host->flags & SDHCI_USE_ADMA) {
 683                         /*
 684                          * As we use 3 byte chunks to work around
 685                          * alignment problems, we need to check this
 686                          * quirk.
 687                          */
 688                         if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE)
 689                                 broken = 1;
 690                 } else {
 691                         if (host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR)
 692                                 broken = 1;
 693                 }
 694
 695                 if (unlikely(broken)) {
 696                         for_each_sg(data->sg, sg, data->sg_len, i) {
 697                                 if (sg->offset & 0x3) {
 698                                         DBG("Reverting to PIO because of "
 699                                                 "bad alignment\n");
 700                                         host->flags &= ~SDHCI_REQ_USE_DMA;
 701                                         break;
 702                                 }
 703                         }
 704                 }
 705         }
 706
 707         if (host->flags & SDHCI_REQ_USE_DMA) {
 708                 if (host->flags & SDHCI_USE_ADMA) {
 709                         ret = sdhci_adma_table_pre(host, data);
 710                         if (ret) {
 711                                 /*
 712                                  * This only happens when someone fed
 713                                  * us an invalid request.
 714                                  */
 715                                 WARN_ON(1);
 716                                 host->flags &= ~SDHCI_REQ_USE_DMA;
 717                         } else {
 718                                 sdhci_writel(host, host->adma_addr,
 719                                         SDHCI_ADMA_ADDRESS);
 720                         }
 721                 } else {
 722                         int sg_cnt;
 723
 724                         sg_cnt = dma_map_sg(mmc_dev(host->mmc),
 725                                         data->sg, data->sg_len,
 726                                         (data->flags & MMC_DATA_READ) ?
 727                                                 DMA_FROM_DEVICE :
 728                                                 DMA_TO_DEVICE);
 729                         if (sg_cnt == 0) {
 730                                 /*
 731                                  * This only happens when someone fed
 732                                  * us an invalid request.
 733                                  */
 734                                 WARN_ON(1);
 735                                 host->flags &= ~SDHCI_REQ_USE_DMA;
 736                         } else {
 737                                 WARN_ON(sg_cnt != 1);
 738                                 sdhci_writel(host, sg_dma_address(data->sg),
 739                                         SDHCI_DMA_ADDRESS);
 740                         }
 741                 }
 742         }
 743
 744         /*
 745          * Always adjust the DMA selection as some controllers
 746          * (e.g. JMicron) can't do PIO properly when the selection
 747          * is ADMA.
 748          */
 749         if (host->version >= SDHCI_SPEC_200) {
 750                 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
 751                 ctrl &= ~SDHCI_CTRL_DMA_MASK;
 752                 if ((host->flags & SDHCI_REQ_USE_DMA) &&
 753                         (host->flags & SDHCI_USE_ADMA))
 754                         ctrl |= SDHCI_CTRL_ADMA32;
 755                 else
 756                         ctrl |= SDHCI_CTRL_SDMA;
 757                 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
 758         }
 759
 760         if (!(host->flags & SDHCI_REQ_USE_DMA)) {
 761                 sg_miter_start(&host->sg_miter,
 762                         data->sg, data->sg_len, SG_MITER_ATOMIC);
 763                 host->blocks = data->blocks;
 764         }
 765
 766         sdhci_set_transfer_irqs(host);
 767
 768         /* We do not handle DMA boundaries, so set it to max (512 KiB) */
 769         sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, data->blksz), SDHCI_BLOCK_SIZE);
 770         sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
 771 }
 772
 773 static void sdhci_set_transfer_mode(struct sdhci_host *host,
 774         struct mmc_data *data)
 775 {
 776         u16 mode;
 777
 778         if (data == NULL)
 779                 return;
 780
 781         WARN_ON(!host->data);
 782
 783         mode = SDHCI_TRNS_BLK_CNT_EN;
 784         if (data->blocks > 1)
 785                 mode |= SDHCI_TRNS_MULTI;
 786         if (data->flags & MMC_DATA_READ)
 787                 mode |= SDHCI_TRNS_READ;
 788         if (host->flags & SDHCI_REQ_USE_DMA)
 789                 mode |= SDHCI_TRNS_DMA;
 790
 791         sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
 792 }
 793
 794 static void sdhci_finish_data(struct sdhci_host *host)
 795 {
 796         struct mmc_data *data;
 797
 798         BUG_ON(!host->data);
 799
 800         data = host->data;
 801         host->data = NULL;
 802
 803         if (host->flags & SDHCI_REQ_USE_DMA) {
 804                 if (host->flags & SDHCI_USE_ADMA)
 805                         sdhci_adma_table_post(host, data);
 806                 else {
 807                         dma_unmap_sg(mmc_dev(host->mmc), data->sg,
 808                                 data->sg_len, (data->flags & MMC_DATA_READ) ?
 809                                         DMA_FROM_DEVICE : DMA_TO_DEVICE);
 810                 }
 811         }
 812
 813         /*
 814          * The specification states that the block count register must
 815          * be updated, but it does not specify at what point in the
 816          * data flow. That makes the register entirely useless to read
 817          * back so we have to assume that nothing made it to the card
 818          * in the event of an error.
 819          */
 820         if (data->error)
 821                 data->bytes_xfered = 0;
 822         else
 823                 data->bytes_xfered = data->blksz * data->blocks;
 824
 825         if (data->stop) {
 826                 /*
 827                  * The controller needs a reset of internal state machines
 828                  * upon error conditions.
 829                  */
 830                 if (data->error) {
 831                         sdhci_reset(host, SDHCI_RESET_CMD);
 832                         sdhci_reset(host, SDHCI_RESET_DATA);
 833                 }
 834
 835                 sdhci_send_command(host, data->stop);
 836         } else
 837                 tasklet_schedule(&host->finish_tasklet);
 838 }
 839
 840 static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
 841 {
 842         int flags;
 843         u32 mask;
 844         unsigned long timeout;
 845
 846         WARN_ON(host->cmd);
 847
 848         /* Wait max 10 ms */
 849         timeout = 10;
 850
 851         mask = SDHCI_CMD_INHIBIT;
 852         if ((cmd->data != NULL) || (cmd->flags & MMC_RSP_BUSY))
 853                 mask |= SDHCI_DATA_INHIBIT;
 854
 855         /* We shouldn't wait for data inihibit for stop commands, even
 856            though they might use busy signaling */
 857         if (host->mrq->data && (cmd == host->mrq->data->stop))
 858                 mask &= ~SDHCI_DATA_INHIBIT;
 859
 860         while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
 861                 if (timeout == 0) {
 862                         printk(KERN_ERR "%s: Controller never released "
 863                                 "inhibit bit(s).\n", mmc_hostname(host->mmc));
 864                         sdhci_dumpregs(host);
 865                         cmd->error = -EIO;
 866                         tasklet_schedule(&host->finish_tasklet);
 867                         return;
 868                 }
 869                 timeout--;
 870                 mdelay(1);
 871         }
 872
 873         mod_timer(&host->timer, jiffies + 10 * HZ);
 874
 875         host->cmd = cmd;
 876
 877         sdhci_prepare_data(host, cmd->data);
 878
 879         sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
 880
 881         sdhci_set_transfer_mode(host, cmd->data);
 882
 883         if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
 884                 printk(KERN_ERR "%s: Unsupported response type!\n",
 885                         mmc_hostname(host->mmc));
 886                 cmd->error = -EINVAL;
 887                 tasklet_schedule(&host->finish_tasklet);
 888                 return;
 889         }
 890
 891         if (!(cmd->flags & MMC_RSP_PRESENT))
 892                 flags = SDHCI_CMD_RESP_NONE;
 893         else if (cmd->flags & MMC_RSP_136)
 894                 flags = SDHCI_CMD_RESP_LONG;
 895         else if (cmd->flags & MMC_RSP_BUSY)
 896                 flags = SDHCI_CMD_RESP_SHORT_BUSY;
 897         else
 898                 flags = SDHCI_CMD_RESP_SHORT;
 899
 900         if (cmd->flags & MMC_RSP_CRC)
 901                 flags |= SDHCI_CMD_CRC;
 902         if (cmd->flags & MMC_RSP_OPCODE)
 903                 flags |= SDHCI_CMD_INDEX;
 904         if (cmd->data)
 905                 flags |= SDHCI_CMD_DATA;
 906
 907         sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
 908 }
 909
 910 static void sdhci_finish_command(struct sdhci_host *host)
 911 {
 912         int i;
 913
 914         BUG_ON(host->cmd == NULL);
 915
 916         if (host->cmd->flags & MMC_RSP_PRESENT) {
 917                 if (host->cmd->flags & MMC_RSP_136) {
 918                         /* CRC is stripped so we need to do some shifting. */
 919                         for (i = 0;i < 4;i++) {
 920                                 host->cmd->resp[i] = sdhci_readl(host,
 921                                         SDHCI_RESPONSE + (3-i)*4) << 8;
 922                                 if (i != 3)
 923                                         host->cmd->resp[i] |=
 924                                                 sdhci_readb(host,
 925                                                 SDHCI_RESPONSE + (3-i)*4-1);
 926                         }
 927                 } else {
 928                         host->cmd->resp[0] = sdhci_readl(host, SDHCI_RESPONSE);
 929                 }
 930         }
 931
 932         host->cmd->error = 0;
 933
 934         if (host->data && host->data_early)
 935                 sdhci_finish_data(host);
 936
 937         if (!host->cmd->data)
 938                 tasklet_schedule(&host->finish_tasklet);
 939
 940         host->cmd = NULL;
 941 }
 942
 943 static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
 944 {
 945         int div;
 946         u16 clk;
 947         unsigned long timeout;
 948
 949         if (clock == host->clock)
 950                 return;
 951
 952         sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
 953
 954         if (clock == 0)
 955                 goto out;
 956
 957         for (div = 1;div < 256;div *= 2) {
 958                 if ((host->max_clk / div) <= clock)
 959                         break;
 960         }
 961         div >>= 1;
 962
 963         clk = div << SDHCI_DIVIDER_SHIFT;
 964         clk |= SDHCI_CLOCK_INT_EN;
 965         sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
 966
 967         /* Wait max 10 ms */
 968         timeout = 10;
 969         while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
 970                 & SDHCI_CLOCK_INT_STABLE)) {
 971                 if (timeout == 0) {
 972                         printk(KERN_ERR "%s: Internal clock never "
 973                                 "stabilised.\n", mmc_hostname(host->mmc));
 974                         sdhci_dumpregs(host);
 975                         return;
 976                 }
 977                 timeout--;
 978                 mdelay(1);
 979         }
 980
 981         clk |= SDHCI_CLOCK_CARD_EN;
 982         sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
 983
 984 out:
 985         host->clock = clock;
 986 }
 987
 988 static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
 989 {
 990         u8 pwr;
 991
 992         if (host->power == power)
 993                 return;
 994
 995         if (power == (unsigned short)-1) {
 996                 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
 997                 goto out;
 998         }
 999
1000         /*
1001          * Spec says that we should clear the power reg before setting
1002          * a new value. Some controllers don't seem to like this though.
1003          */
1004         if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
1005                 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1006
1007         pwr = SDHCI_POWER_ON;
1008
1009         switch (1 << power) {
1010         case MMC_VDD_165_195:
1011                 pwr |= SDHCI_POWER_180;
1012                 break;
1013         case MMC_VDD_29_30:
1014         case MMC_VDD_30_31:
1015                 pwr |= SDHCI_POWER_300;
1016                 break;
1017         case MMC_VDD_32_33:
1018         case MMC_VDD_33_34:
1019                 pwr |= SDHCI_POWER_330;
1020                 break;
1021         default:
1022                 BUG();
1023         }
1024
1025         /*
1026          * At least the Marvell CaFe chip gets confused if we set the voltage
1027          * and set turn on power at the same time, so set the voltage first.
1028          */
1029         if ((host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER))
1030                 sdhci_writeb(host, pwr & ~SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
1031
1032         sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1033
1034 out:
1035         host->power = power;
1036 }
1037
1038 /*****************************************************************************\
1039  *                                                                           *
1040  * MMC callbacks                                                             *
1041  *                                                                           *
1042 \*****************************************************************************/
1043
1044 static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1045 {
1046         struct sdhci_host *host;
1047         bool present;
1048         unsigned long flags;
1049
1050         host = mmc_priv(mmc);
1051
1052         spin_lock_irqsave(&host->lock, flags);
1053
1054         WARN_ON(host->mrq != NULL);
1055
1056 #ifndef SDHCI_USE_LEDS_CLASS
1057         sdhci_activate_led(host);
1058 #endif
1059
1060         host->mrq = mrq;
1061
1062         /* If polling, assume that the card is always present. */
1063         if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1064                 present = true;
1065         else
1066                 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
1067                                 SDHCI_CARD_PRESENT;
1068
1069         if (!present || host->flags & SDHCI_DEVICE_DEAD) {
1070                 host->mrq->cmd->error = -ENOMEDIUM;
1071                 tasklet_schedule(&host->finish_tasklet);
1072         } else
1073                 sdhci_send_command(host, mrq->cmd);
1074
1075         mmiowb();
1076         spin_unlock_irqrestore(&host->lock, flags);
1077 }
1078
1079 static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
1080 {
1081         struct sdhci_host *host;
1082         unsigned long flags;
1083         u8 ctrl;
1084
1085         host = mmc_priv(mmc);
1086
1087         spin_lock_irqsave(&host->lock, flags);
1088
1089         if (host->flags & SDHCI_DEVICE_DEAD)
1090                 goto out;
1091
1092         /*
1093          * Reset the chip on each power off.
1094          * Should clear out any weird states.
1095          */
1096         if (ios->power_mode == MMC_POWER_OFF) {
1097                 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
1098                 sdhci_reinit(host);
1099         }
1100
1101         sdhci_set_clock(host, ios->clock);
1102
1103         if (ios->power_mode == MMC_POWER_OFF)
1104                 sdhci_set_power(host, -1);
1105         else
1106                 sdhci_set_power(host, ios->vdd);
1107
1108         ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1109
1110         if (ios->bus_width == MMC_BUS_WIDTH_4)
1111                 ctrl |= SDHCI_CTRL_4BITBUS;
1112         else
1113                 ctrl &= ~SDHCI_CTRL_4BITBUS;
1114
1115         if (ios->timing == MMC_TIMING_SD_HS)
1116                 ctrl |= SDHCI_CTRL_HISPD;
1117         else
1118                 ctrl &= ~SDHCI_CTRL_HISPD;
1119
1120         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1121
1122         /*
1123          * Some (ENE) controllers go apeshit on some ios operation,
1124          * signalling timeout and CRC errors even on CMD0. Resetting
1125          * it on each ios seems to solve the problem.
1126          */
1127         if(host->quirks & SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS)
1128                 sdhci_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
1129
1130 out:
1131         mmiowb();
1132         spin_unlock_irqrestore(&host->lock, flags);
1133 }
1134
1135 static int sdhci_get_ro(struct mmc_host *mmc)
1136 {
1137         struct sdhci_host *host;
1138         unsigned long flags;
1139         int present;
1140
1141         host = mmc_priv(mmc);
1142
1143         spin_lock_irqsave(&host->lock, flags);
1144
1145         if (host->flags & SDHCI_DEVICE_DEAD)
1146                 present = 0;
1147         else
1148                 present = sdhci_readl(host, SDHCI_PRESENT_STATE);
1149
1150         spin_unlock_irqrestore(&host->lock, flags);
1151
1152         return !(present & SDHCI_WRITE_PROTECT);
1153 }
1154
1155 static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
1156 {
1157         struct sdhci_host *host;
1158         unsigned long flags;
1159
1160         host = mmc_priv(mmc);
1161
1162         spin_lock_irqsave(&host->lock, flags);
1163
1164         if (host->flags & SDHCI_DEVICE_DEAD)
1165                 goto out;
1166
1167         if (enable)
1168                 sdhci_unmask_irqs(host, SDHCI_INT_CARD_INT);
1169         else
1170                 sdhci_mask_irqs(host, SDHCI_INT_CARD_INT);
1171 out:
1172         mmiowb();
1173
1174         spin_unlock_irqrestore(&host->lock, flags);
1175 }
1176
1177 static const struct mmc_host_ops sdhci_ops = {
1178         .request        = sdhci_request,
1179         .set_ios        = sdhci_set_ios,
1180         .get_ro         = sdhci_get_ro,
1181         .enable_sdio_irq = sdhci_enable_sdio_irq,
1182 };
1183
1184 /*****************************************************************************\
1185  *                                                                           *
1186  * Tasklets                                                                  *
1187  *                                                                           *
1188 \*****************************************************************************/
1189
1190 static void sdhci_tasklet_card(unsigned long param)
1191 {
1192         struct sdhci_host *host;
1193         unsigned long flags;
1194
1195         host = (struct sdhci_host*)param;
1196
1197         spin_lock_irqsave(&host->lock, flags);
1198
1199         if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
1200                 if (host->mrq) {
1201                         printk(KERN_ERR "%s: Card removed during transfer!\n",
1202                                 mmc_hostname(host->mmc));
1203                         printk(KERN_ERR "%s: Resetting controller.\n",
1204                                 mmc_hostname(host->mmc));
1205
1206                         sdhci_reset(host, SDHCI_RESET_CMD);
1207                         sdhci_reset(host, SDHCI_RESET_DATA);
1208
1209                         host->mrq->cmd->error = -ENOMEDIUM;
1210                         tasklet_schedule(&host->finish_tasklet);
1211                 }
1212         }
1213
1214         spin_unlock_irqrestore(&host->lock, flags);
1215
1216         mmc_detect_change(host->mmc, msecs_to_jiffies(200));
1217 }
1218
1219 static void sdhci_tasklet_finish(unsigned long param)
1220 {
1221         struct sdhci_host *host;
1222         unsigned long flags;
1223         struct mmc_request *mrq;
1224
1225         host = (struct sdhci_host*)param;
1226
1227         spin_lock_irqsave(&host->lock, flags);
1228
1229         del_timer(&host->timer);
1230
1231         mrq = host->mrq;
1232
1233         /*
1234          * The controller needs a reset of internal state machines
1235          * upon error conditions.
1236          */
1237         if (!(host->flags & SDHCI_DEVICE_DEAD) &&
1238                 (mrq->cmd->error ||
1239                  (mrq->data && (mrq->data->error ||
1240                   (mrq->data->stop && mrq->data->stop->error))) ||
1241                    (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
1242
1243                 /* Some controllers need this kick or reset won't work here */
1244                 if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) {
1245                         unsigned int clock;
1246
1247                         /* This is to force an update */
1248                         clock = host->clock;
1249                         host->clock = 0;
1250                         sdhci_set_clock(host, clock);
1251                 }
1252
1253                 /* Spec says we should do both at the same time, but Ricoh
1254                    controllers do not like that. */
1255                 sdhci_reset(host, SDHCI_RESET_CMD);
1256                 sdhci_reset(host, SDHCI_RESET_DATA);
1257         }
1258
1259         host->mrq = NULL;
1260         host->cmd = NULL;
1261         host->data = NULL;
1262
1263 #ifndef SDHCI_USE_LEDS_CLASS
1264         sdhci_deactivate_led(host);
1265 #endif
1266
1267         mmiowb();
1268         spin_unlock_irqrestore(&host->lock, flags);
1269
1270         mmc_request_done(host->mmc, mrq);
1271 }
1272
1273 static void sdhci_timeout_timer(unsigned long data)
1274 {
1275         struct sdhci_host *host;
1276         unsigned long flags;
1277
1278         host = (struct sdhci_host*)data;
1279
1280         spin_lock_irqsave(&host->lock, flags);
1281
1282         if (host->mrq) {
1283                 printk(KERN_ERR "%s: Timeout waiting for hardware "
1284                         "interrupt.\n", mmc_hostname(host->mmc));
1285                 sdhci_dumpregs(host);
1286
1287                 if (host->data) {
1288                         host->data->error = -ETIMEDOUT;
1289                         sdhci_finish_data(host);
1290                 } else {
1291                         if (host->cmd)
1292                                 host->cmd->error = -ETIMEDOUT;
1293                         else
1294                                 host->mrq->cmd->error = -ETIMEDOUT;
1295
1296                         tasklet_schedule(&host->finish_tasklet);
1297                 }
1298         }
1299
1300         mmiowb();
1301         spin_unlock_irqrestore(&host->lock, flags);
1302 }
1303
1304 /*****************************************************************************\
1305  *                                                                           *
1306  * Interrupt handling                                                        *
1307  *                                                                           *
1308 \*****************************************************************************/
1309
1310 static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
1311 {
1312         BUG_ON(intmask == 0);
1313
1314         if (!host->cmd) {
1315                 printk(KERN_ERR "%s: Got command interrupt 0x%08x even "
1316                         "though no command operation was in progress.\n",
1317                         mmc_hostname(host->mmc), (unsigned)intmask);
1318                 sdhci_dumpregs(host);
1319                 return;
1320         }
1321
1322         if (intmask & SDHCI_INT_TIMEOUT)
1323                 host->cmd->error = -ETIMEDOUT;
1324         else if (intmask & (SDHCI_INT_CRC | SDHCI_INT_END_BIT |
1325                         SDHCI_INT_INDEX))
1326                 host->cmd->error = -EILSEQ;
1327
1328         if (host->cmd->error) {
1329                 tasklet_schedule(&host->finish_tasklet);
1330                 return;
1331         }
1332
1333         /*
1334          * The host can send and interrupt when the busy state has
1335          * ended, allowing us to wait without wasting CPU cycles.
1336          * Unfortunately this is overloaded on the "data complete"
1337          * interrupt, so we need to take some care when handling
1338          * it.
1339          *
1340          * Note: The 1.0 specification is a bit ambiguous about this
1341          *       feature so there might be some problems with older
1342          *       controllers.
1343          */
1344         if (host->cmd->flags & MMC_RSP_BUSY) {
1345                 if (host->cmd->data)
1346                         DBG("Cannot wait for busy signal when also "
1347                                 "doing a data transfer");
1348                 else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ))
1349                         return;
1350
1351                 /* The controller does not support the end-of-busy IRQ,
1352                  * fall through and take the SDHCI_INT_RESPONSE */
1353         }
1354
1355         if (intmask & SDHCI_INT_RESPONSE)
1356                 sdhci_finish_command(host);
1357 }
1358
1359 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
1360 {
1361         BUG_ON(intmask == 0);
1362
1363         if (!host->data) {
1364                 /*
1365                  * The "data complete" interrupt is also used to
1366                  * indicate that a busy state has ended. See comment
1367                  * above in sdhci_cmd_irq().
1368                  */
1369                 if (host->cmd && (host->cmd->flags & MMC_RSP_BUSY)) {
1370                         if (intmask & SDHCI_INT_DATA_END) {
1371                                 sdhci_finish_command(host);
1372                                 return;
1373                         }
1374                 }
1375
1376                 printk(KERN_ERR "%s: Got data interrupt 0x%08x even "
1377                         "though no data operation was in progress.\n",
1378                         mmc_hostname(host->mmc), (unsigned)intmask);
1379                 sdhci_dumpregs(host);
1380
1381                 return;
1382         }
1383
1384         if (intmask & SDHCI_INT_DATA_TIMEOUT)
1385                 host->data->error = -ETIMEDOUT;
1386         else if (intmask & (SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_END_BIT))
1387                 host->data->error = -EILSEQ;
1388         else if (intmask & SDHCI_INT_ADMA_ERROR)
1389                 host->data->error = -EIO;
1390
1391         if (host->data->error)
1392                 sdhci_finish_data(host);
1393         else {
1394                 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
1395                         sdhci_transfer_pio(host);
1396
1397                 /*
1398                  * We currently don't do anything fancy with DMA
1399                  * boundaries, but as we can't disable the feature
1400                  * we need to at least restart the transfer.
1401                  */
1402                 if (intmask & SDHCI_INT_DMA_END)
1403                         sdhci_writel(host, sdhci_readl(host, SDHCI_DMA_ADDRESS),
1404                                 SDHCI_DMA_ADDRESS);
1405
1406                 if (intmask & SDHCI_INT_DATA_END) {
1407                         if (host->cmd) {
1408                                 /*
1409                                  * Data managed to finish before the
1410                                  * command completed. Make sure we do
1411                                  * things in the proper order.
1412                                  */
1413                                 host->data_early = 1;
1414                         } else {
1415                                 sdhci_finish_data(host);
1416                         }
1417                 }
1418         }
1419 }
1420
1421 static irqreturn_t sdhci_irq(int irq, void *dev_id)
1422 {
1423         irqreturn_t result;
1424         struct sdhci_host* host = dev_id;
1425         u32 intmask;
1426         int cardint = 0;
1427
1428         spin_lock(&host->lock);
1429
1430         intmask = sdhci_readl(host, SDHCI_INT_STATUS);
1431
1432         if (!intmask || intmask == 0xffffffff) {
1433                 result = IRQ_NONE;
1434                 goto out;
1435         }
1436
1437         DBG("*** %s got interrupt: 0x%08x\n",
1438                 mmc_hostname(host->mmc), intmask);
1439
1440         if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
1441                 sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
1442                         SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
1443                 tasklet_schedule(&host->card_tasklet);
1444         }
1445
1446         intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE);
1447
1448         if (intmask & SDHCI_INT_CMD_MASK) {
1449                 sdhci_writel(host, intmask & SDHCI_INT_CMD_MASK,
1450                         SDHCI_INT_STATUS);
1451                 sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK);
1452         }
1453
1454         if (intmask & SDHCI_INT_DATA_MASK) {
1455                 sdhci_writel(host, intmask & SDHCI_INT_DATA_MASK,
1456                         SDHCI_INT_STATUS);
1457                 sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
1458         }
1459
1460         intmask &= ~(SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK);
1461
1462         intmask &= ~SDHCI_INT_ERROR;
1463
1464         if (intmask & SDHCI_INT_BUS_POWER) {
1465                 printk(KERN_ERR "%s: Card is consuming too much power!\n",
1466                         mmc_hostname(host->mmc));
1467                 sdhci_writel(host, SDHCI_INT_BUS_POWER, SDHCI_INT_STATUS);
1468         }
1469
1470         intmask &= ~SDHCI_INT_BUS_POWER;
1471
1472         if (intmask & SDHCI_INT_CARD_INT)
1473                 cardint = 1;
1474
1475         intmask &= ~SDHCI_INT_CARD_INT;
1476
1477         if (intmask) {
1478                 printk(KERN_ERR "%s: Unexpected interrupt 0x%08x.\n",
1479                         mmc_hostname(host->mmc), intmask);
1480                 sdhci_dumpregs(host);
1481
1482                 sdhci_writel(host, intmask, SDHCI_INT_STATUS);
1483         }
1484
1485         result = IRQ_HANDLED;
1486
1487         mmiowb();
1488 out:
1489         spin_unlock(&host->lock);
1490
1491         /*
1492          * We have to delay this as it calls back into the driver.
1493          */
1494         if (cardint)
1495                 mmc_signal_sdio_irq(host->mmc);
1496
1497         return result;
1498 }
1499
1500 /*****************************************************************************\
1501  *                                                                           *
1502  * Suspend/resume                                                            *
1503  *                                                                           *
1504 \*****************************************************************************/
1505
1506 #ifdef CONFIG_PM
1507
1508 int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state)
1509 {
1510         int ret;
1511
1512         sdhci_disable_card_detection(host);
1513
1514         ret = mmc_suspend_host(host->mmc, state);
1515         if (ret)
1516                 return ret;
1517
1518         free_irq(host->irq, host);
1519
1520         return 0;
1521 }
1522
1523 EXPORT_SYMBOL_GPL(sdhci_suspend_host);
1524
1525 int sdhci_resume_host(struct sdhci_host *host)
1526 {
1527         int ret;
1528
1529         if (host->flags & SDHCI_USE_DMA) {
1530                 if (host->ops->enable_dma)
1531                         host->ops->enable_dma(host);
1532         }
1533
1534         ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
1535                           mmc_hostname(host->mmc), host);
1536         if (ret)
1537                 return ret;
1538
1539         sdhci_init(host);
1540         mmiowb();
1541
1542         ret = mmc_resume_host(host->mmc);
1543         if (ret)
1544                 return ret;
1545
1546         sdhci_enable_card_detection(host);
1547
1548         return 0;
1549 }
1550
1551 EXPORT_SYMBOL_GPL(sdhci_resume_host);
1552
1553 #endif /* CONFIG_PM */
1554
1555 /*****************************************************************************\
1556  *                                                                           *
1557  * Device allocation/registration                                            *
1558  *                                                                           *
1559 \*****************************************************************************/
1560
1561 struct sdhci_host *sdhci_alloc_host(struct device *dev,
1562         size_t priv_size)
1563 {
1564         struct mmc_host *mmc;
1565         struct sdhci_host *host;
1566
1567         WARN_ON(dev == NULL);
1568
1569         mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev);
1570         if (!mmc)
1571                 return ERR_PTR(-ENOMEM);
1572
1573         host = mmc_priv(mmc);
1574         host->mmc = mmc;
1575
1576         return host;
1577 }
1578
1579 EXPORT_SYMBOL_GPL(sdhci_alloc_host);
1580
1581 int sdhci_add_host(struct sdhci_host *host)
1582 {
1583         struct mmc_host *mmc;
1584         unsigned int caps;
1585         int ret;
1586
1587         WARN_ON(host == NULL);
1588         if (host == NULL)
1589                 return -EINVAL;
1590
1591         mmc = host->mmc;
1592
1593         if (debug_quirks)
1594                 host->quirks = debug_quirks;
1595
1596         sdhci_reset(host, SDHCI_RESET_ALL);
1597
1598         host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
1599         host->version = (host->version & SDHCI_SPEC_VER_MASK)
1600                                 >> SDHCI_SPEC_VER_SHIFT;
1601         if (host->version > SDHCI_SPEC_200) {
1602                 printk(KERN_ERR "%s: Unknown controller version (%d). "
1603                         "You may experience problems.\n", mmc_hostname(mmc),
1604                         host->version);
1605         }
1606
1607         caps = sdhci_readl(host, SDHCI_CAPABILITIES);
1608
1609         if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
1610                 host->flags |= SDHCI_USE_DMA;
1611         else if (!(caps & SDHCI_CAN_DO_DMA))
1612                 DBG("Controller doesn't have DMA capability\n");
1613         else
1614                 host->flags |= SDHCI_USE_DMA;
1615
1616         if ((host->quirks & SDHCI_QUIRK_BROKEN_DMA) &&
1617                 (host->flags & SDHCI_USE_DMA)) {
1618                 DBG("Disabling DMA as it is marked broken\n");
1619                 host->flags &= ~SDHCI_USE_DMA;
1620         }
1621
1622         if (host->flags & SDHCI_USE_DMA) {
1623                 if ((host->version >= SDHCI_SPEC_200) &&
1624                                 (caps & SDHCI_CAN_DO_ADMA2))
1625                         host->flags |= SDHCI_USE_ADMA;
1626         }
1627
1628         if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
1629                 (host->flags & SDHCI_USE_ADMA)) {
1630                 DBG("Disabling ADMA as it is marked broken\n");
1631                 host->flags &= ~SDHCI_USE_ADMA;
1632         }
1633
1634         if (host->flags & SDHCI_USE_DMA) {
1635                 if (host->ops->enable_dma) {
1636                         if (host->ops->enable_dma(host)) {
1637                                 printk(KERN_WARNING "%s: No suitable DMA "
1638                                         "available. Falling back to PIO.\n",
1639                                         mmc_hostname(mmc));
1640                                 host->flags &= ~(SDHCI_USE_DMA | SDHCI_USE_ADMA);
1641                         }
1642                 }
1643         }
1644
1645         if (host->flags & SDHCI_USE_ADMA) {
1646                 /*
1647                  * We need to allocate descriptors for all sg entries
1648                  * (128) and potentially one alignment transfer for
1649                  * each of those entries.
1650                  */
1651                 host->adma_desc = kmalloc((128 * 2 + 1) * 4, GFP_KERNEL);
1652                 host->align_buffer = kmalloc(128 * 4, GFP_KERNEL);
1653                 if (!host->adma_desc || !host->align_buffer) {
1654                         kfree(host->adma_desc);
1655                         kfree(host->align_buffer);
1656                         printk(KERN_WARNING "%s: Unable to allocate ADMA "
1657                                 "buffers. Falling back to standard DMA.\n",
1658                                 mmc_hostname(mmc));
1659                         host->flags &= ~SDHCI_USE_ADMA;
1660                 }
1661         }
1662
1663         /*
1664          * If we use DMA, then it's up to the caller to set the DMA
1665          * mask, but PIO does not need the hw shim so we set a new
1666          * mask here in that case.
1667          */
1668         if (!(host->flags & SDHCI_USE_DMA)) {
1669                 host->dma_mask = DMA_BIT_MASK(64);
1670                 mmc_dev(host->mmc)->dma_mask = &host->dma_mask;
1671         }
1672
1673         host->max_clk =
1674                 (caps & SDHCI_CLOCK_BASE_MASK) >> SDHCI_CLOCK_BASE_SHIFT;
1675         if (host->max_clk == 0) {
1676                 printk(KERN_ERR "%s: Hardware doesn't specify base clock "
1677                         "frequency.\n", mmc_hostname(mmc));
1678                 return -ENODEV;
1679         }
1680         host->max_clk *= 1000000;
1681
1682         host->timeout_clk =
1683                 (caps & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
1684         if (host->timeout_clk == 0) {
1685                 printk(KERN_ERR "%s: Hardware doesn't specify timeout clock "
1686                         "frequency.\n", mmc_hostname(mmc));
1687                 return -ENODEV;
1688         }
1689         if (caps & SDHCI_TIMEOUT_CLK_UNIT)
1690                 host->timeout_clk *= 1000;
1691
1692         /*
1693          * Set host parameters.
1694          */
1695         mmc->ops = &sdhci_ops;
1696         mmc->f_min = host->max_clk / 256;
1697         mmc->f_max = host->max_clk;
1698         mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SDIO_IRQ;
1699
1700         if (caps & SDHCI_CAN_DO_HISPD)
1701                 mmc->caps |= MMC_CAP_SD_HIGHSPEED;
1702
1703         if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1704                 mmc->caps |= MMC_CAP_NEEDS_POLL;
1705
1706         mmc->ocr_avail = 0;
1707         if (caps & SDHCI_CAN_VDD_330)
1708                 mmc->ocr_avail |= MMC_VDD_32_33|MMC_VDD_33_34;
1709         if (caps & SDHCI_CAN_VDD_300)
1710                 mmc->ocr_avail |= MMC_VDD_29_30|MMC_VDD_30_31;
1711         if (caps & SDHCI_CAN_VDD_180)
1712                 mmc->ocr_avail |= MMC_VDD_165_195;
1713
1714         if (mmc->ocr_avail == 0) {
1715                 printk(KERN_ERR "%s: Hardware doesn't report any "
1716                         "support voltages.\n", mmc_hostname(mmc));
1717                 return -ENODEV;
1718         }
1719
1720         spin_lock_init(&host->lock);
1721
1722         /*
1723          * Maximum number of segments. Depends on if the hardware
1724          * can do scatter/gather or not.
1725          */
1726         if (host->flags & SDHCI_USE_ADMA)
1727                 mmc->max_hw_segs = 128;
1728         else if (host->flags & SDHCI_USE_DMA)
1729                 mmc->max_hw_segs = 1;
1730         else /* PIO */
1731                 mmc->max_hw_segs = 128;
1732         mmc->max_phys_segs = 128;
1733
1734         /*
1735          * Maximum number of sectors in one transfer. Limited by DMA boundary
1736          * size (512KiB).
1737          */
1738         mmc->max_req_size = 524288;
1739
1740         /*
1741          * Maximum segment size. Could be one segment with the maximum number
1742          * of bytes. When doing hardware scatter/gather, each entry cannot
1743          * be larger than 64 KiB though.
1744          */
1745         if (host->flags & SDHCI_USE_ADMA)
1746                 mmc->max_seg_size = 65536;
1747         else
1748                 mmc->max_seg_size = mmc->max_req_size;
1749
1750         /*
1751          * Maximum block size. This varies from controller to controller and
1752          * is specified in the capabilities register.
1753          */
1754         mmc->max_blk_size = (caps & SDHCI_MAX_BLOCK_MASK) >> SDHCI_MAX_BLOCK_SHIFT;
1755         if (mmc->max_blk_size >= 3) {
1756                 printk(KERN_WARNING "%s: Invalid maximum block size, "
1757                         "assuming 512 bytes\n", mmc_hostname(mmc));
1758                 mmc->max_blk_size = 512;
1759         } else
1760                 mmc->max_blk_size = 512 << mmc->max_blk_size;
1761
1762         /*
1763          * Maximum block count.
1764          */
1765         mmc->max_blk_count = 65535;
1766
1767         /*
1768          * Init tasklets.
1769          */
1770         tasklet_init(&host->card_tasklet,
1771                 sdhci_tasklet_card, (unsigned long)host);
1772         tasklet_init(&host->finish_tasklet,
1773                 sdhci_tasklet_finish, (unsigned long)host);
1774
1775         setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host);
1776
1777         ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,
1778                 mmc_hostname(mmc), host);
1779         if (ret)
1780                 goto untasklet;
1781
1782         sdhci_init(host);
1783
1784 #ifdef CONFIG_MMC_DEBUG
1785         sdhci_dumpregs(host);
1786 #endif
1787
1788 #ifdef SDHCI_USE_LEDS_CLASS
1789         snprintf(host->led_name, sizeof(host->led_name),
1790                 "%s::", mmc_hostname(mmc));
1791         host->led.name = host->led_name;
1792         host->led.brightness = LED_OFF;
1793         host->led.default_trigger = mmc_hostname(mmc);
1794         host->led.brightness_set = sdhci_led_control;
1795
1796         ret = led_classdev_register(mmc_dev(mmc), &host->led);
1797         if (ret)
1798                 goto reset;
1799 #endif
1800
1801         mmiowb();
1802
1803         mmc_add_host(mmc);
1804
1805         printk(KERN_INFO "%s: SDHCI controller on %s [%s] using %s%s\n",
1806                 mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
1807                 (host->flags & SDHCI_USE_ADMA)?"A":"",
1808                 (host->flags & SDHCI_USE_DMA)?"DMA":"PIO");
1809
1810         sdhci_enable_card_detection(host);
1811
1812         return 0;
1813
1814 #ifdef SDHCI_USE_LEDS_CLASS
1815 reset:
1816         sdhci_reset(host, SDHCI_RESET_ALL);
1817         free_irq(host->irq, host);
1818 #endif
1819 untasklet:
1820         tasklet_kill(&host->card_tasklet);
1821         tasklet_kill(&host->finish_tasklet);
1822
1823         return ret;
1824 }
1825
1826 EXPORT_SYMBOL_GPL(sdhci_add_host);
1827
1828 void sdhci_remove_host(struct sdhci_host *host, int dead)
1829 {
1830         unsigned long flags;
1831
1832         if (dead) {
1833                 spin_lock_irqsave(&host->lock, flags);
1834
1835                 host->flags |= SDHCI_DEVICE_DEAD;
1836
1837                 if (host->mrq) {
1838                         printk(KERN_ERR "%s: Controller removed during "
1839                                 " transfer!\n", mmc_hostname(host->mmc));
1840
1841                         host->mrq->cmd->error = -ENOMEDIUM;
1842                         tasklet_schedule(&host->finish_tasklet);
1843                 }
1844
1845                 spin_unlock_irqrestore(&host->lock, flags);
1846         }
1847
1848         sdhci_disable_card_detection(host);
1849
1850         mmc_remove_host(host->mmc);
1851
1852 #ifdef SDHCI_USE_LEDS_CLASS
1853         led_classdev_unregister(&host->led);
1854 #endif
1855
1856         if (!dead)
1857                 sdhci_reset(host, SDHCI_RESET_ALL);
1858
1859         free_irq(host->irq, host);
1860
1861         del_timer_sync(&host->timer);
1862
1863         tasklet_kill(&host->card_tasklet);
1864         tasklet_kill(&host->finish_tasklet);
1865
1866         kfree(host->adma_desc);
1867         kfree(host->align_buffer);
1868
1869         host->adma_desc = NULL;
1870         host->align_buffer = NULL;
1871 }
1872
1873 EXPORT_SYMBOL_GPL(sdhci_remove_host);
1874
1875 void sdhci_free_host(struct sdhci_host *host)
1876 {
1877         mmc_free_host(host->mmc);
1878 }
1879
1880 EXPORT_SYMBOL_GPL(sdhci_free_host);
1881
1882 /*****************************************************************************\
1883  *                                                                           *
1884  * Driver init/exit                                                          *
1885  *                                                                           *
1886 \*****************************************************************************/
1887
1888 static int __init sdhci_drv_init(void)
1889 {
1890         printk(KERN_INFO DRIVER_NAME
1891                 ": Secure Digital Host Controller Interface driver\n");
1892         printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
1893
1894         return 0;
1895 }
1896
1897 static void __exit sdhci_drv_exit(void)
1898 {
1899 }
1900
1901 module_init(sdhci_drv_init);
1902 module_exit(sdhci_drv_exit);
1903
1904 module_param(debug_quirks, uint, 0444);
1905
1906 MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
1907 MODULE_DESCRIPTION("Secure Digital Host Controller Interface core driver");
1908 MODULE_LICENSE("GPL");
1909
1910 MODULE_PARM_DESC(debug_quirks, "Force certain quirks.");