2 * linux/drivers/mmc/host/sdhci.c - Secure Digital Host Controller Interface driver
4 * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
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.
11 * Thanks to the following companies for their support:
13 * - JMicron (hardware and technical support)
16 #include <linux/delay.h>
17 #include <linux/ktime.h>
18 #include <linux/highmem.h>
20 #include <linux/module.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/slab.h>
23 #include <linux/scatterlist.h>
24 #include <linux/sizes.h>
25 #include <linux/swiotlb.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/pm_runtime.h>
30 #include <linux/leds.h>
32 #include <linux/mmc/mmc.h>
33 #include <linux/mmc/host.h>
34 #include <linux/mmc/card.h>
35 #include <linux/mmc/sdio.h>
36 #include <linux/mmc/slot-gpio.h>
40 #define DRIVER_NAME "sdhci"
42 #define DBG(f, x...) \
43 pr_debug("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
45 #define SDHCI_DUMP(f, x...) \
46 pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
48 #define MAX_TUNING_LOOP 40
50 static unsigned int debug_quirks = 0;
51 static unsigned int debug_quirks2;
53 static void sdhci_finish_data(struct sdhci_host *);
55 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable);
57 void sdhci_dumpregs(struct sdhci_host *host)
59 SDHCI_DUMP("============ SDHCI REGISTER DUMP ===========\n");
61 SDHCI_DUMP("Sys addr: 0x%08x | Version: 0x%08x\n",
62 sdhci_readl(host, SDHCI_DMA_ADDRESS),
63 sdhci_readw(host, SDHCI_HOST_VERSION));
64 SDHCI_DUMP("Blk size: 0x%08x | Blk cnt: 0x%08x\n",
65 sdhci_readw(host, SDHCI_BLOCK_SIZE),
66 sdhci_readw(host, SDHCI_BLOCK_COUNT));
67 SDHCI_DUMP("Argument: 0x%08x | Trn mode: 0x%08x\n",
68 sdhci_readl(host, SDHCI_ARGUMENT),
69 sdhci_readw(host, SDHCI_TRANSFER_MODE));
70 SDHCI_DUMP("Present: 0x%08x | Host ctl: 0x%08x\n",
71 sdhci_readl(host, SDHCI_PRESENT_STATE),
72 sdhci_readb(host, SDHCI_HOST_CONTROL));
73 SDHCI_DUMP("Power: 0x%08x | Blk gap: 0x%08x\n",
74 sdhci_readb(host, SDHCI_POWER_CONTROL),
75 sdhci_readb(host, SDHCI_BLOCK_GAP_CONTROL));
76 SDHCI_DUMP("Wake-up: 0x%08x | Clock: 0x%08x\n",
77 sdhci_readb(host, SDHCI_WAKE_UP_CONTROL),
78 sdhci_readw(host, SDHCI_CLOCK_CONTROL));
79 SDHCI_DUMP("Timeout: 0x%08x | Int stat: 0x%08x\n",
80 sdhci_readb(host, SDHCI_TIMEOUT_CONTROL),
81 sdhci_readl(host, SDHCI_INT_STATUS));
82 SDHCI_DUMP("Int enab: 0x%08x | Sig enab: 0x%08x\n",
83 sdhci_readl(host, SDHCI_INT_ENABLE),
84 sdhci_readl(host, SDHCI_SIGNAL_ENABLE));
85 SDHCI_DUMP("ACmd stat: 0x%08x | Slot int: 0x%08x\n",
86 sdhci_readw(host, SDHCI_AUTO_CMD_STATUS),
87 sdhci_readw(host, SDHCI_SLOT_INT_STATUS));
88 SDHCI_DUMP("Caps: 0x%08x | Caps_1: 0x%08x\n",
89 sdhci_readl(host, SDHCI_CAPABILITIES),
90 sdhci_readl(host, SDHCI_CAPABILITIES_1));
91 SDHCI_DUMP("Cmd: 0x%08x | Max curr: 0x%08x\n",
92 sdhci_readw(host, SDHCI_COMMAND),
93 sdhci_readl(host, SDHCI_MAX_CURRENT));
94 SDHCI_DUMP("Resp[0]: 0x%08x | Resp[1]: 0x%08x\n",
95 sdhci_readl(host, SDHCI_RESPONSE),
96 sdhci_readl(host, SDHCI_RESPONSE + 4));
97 SDHCI_DUMP("Resp[2]: 0x%08x | Resp[3]: 0x%08x\n",
98 sdhci_readl(host, SDHCI_RESPONSE + 8),
99 sdhci_readl(host, SDHCI_RESPONSE + 12));
100 SDHCI_DUMP("Host ctl2: 0x%08x\n",
101 sdhci_readw(host, SDHCI_HOST_CONTROL2));
103 if (host->flags & SDHCI_USE_ADMA) {
104 if (host->flags & SDHCI_USE_64_BIT_DMA) {
105 SDHCI_DUMP("ADMA Err: 0x%08x | ADMA Ptr: 0x%08x%08x\n",
106 sdhci_readl(host, SDHCI_ADMA_ERROR),
107 sdhci_readl(host, SDHCI_ADMA_ADDRESS_HI),
108 sdhci_readl(host, SDHCI_ADMA_ADDRESS));
110 SDHCI_DUMP("ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
111 sdhci_readl(host, SDHCI_ADMA_ERROR),
112 sdhci_readl(host, SDHCI_ADMA_ADDRESS));
116 SDHCI_DUMP("============================================\n");
118 EXPORT_SYMBOL_GPL(sdhci_dumpregs);
120 /*****************************************************************************\
122 * Low level functions *
124 \*****************************************************************************/
126 static void sdhci_do_enable_v4_mode(struct sdhci_host *host)
130 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
131 if (ctrl2 & SDHCI_CTRL_V4_MODE)
134 ctrl2 |= SDHCI_CTRL_V4_MODE;
135 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2);
139 * This can be called before sdhci_add_host() by Vendor's host controller
140 * driver to enable v4 mode if supported.
142 void sdhci_enable_v4_mode(struct sdhci_host *host)
144 host->v4_mode = true;
145 sdhci_do_enable_v4_mode(host);
147 EXPORT_SYMBOL_GPL(sdhci_enable_v4_mode);
149 static inline bool sdhci_data_line_cmd(struct mmc_command *cmd)
151 return cmd->data || cmd->flags & MMC_RSP_BUSY;
154 static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
158 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
159 !mmc_card_is_removable(host->mmc))
163 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
166 host->ier |= present ? SDHCI_INT_CARD_REMOVE :
167 SDHCI_INT_CARD_INSERT;
169 host->ier &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
172 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
173 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
176 static void sdhci_enable_card_detection(struct sdhci_host *host)
178 sdhci_set_card_detection(host, true);
181 static void sdhci_disable_card_detection(struct sdhci_host *host)
183 sdhci_set_card_detection(host, false);
186 static void sdhci_runtime_pm_bus_on(struct sdhci_host *host)
191 pm_runtime_get_noresume(host->mmc->parent);
194 static void sdhci_runtime_pm_bus_off(struct sdhci_host *host)
198 host->bus_on = false;
199 pm_runtime_put_noidle(host->mmc->parent);
202 void sdhci_reset(struct sdhci_host *host, u8 mask)
206 sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
208 if (mask & SDHCI_RESET_ALL) {
210 /* Reset-all turns off SD Bus Power */
211 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
212 sdhci_runtime_pm_bus_off(host);
215 /* Wait max 100 ms */
216 timeout = ktime_add_ms(ktime_get(), 100);
218 /* hw clears the bit when it's done */
220 bool timedout = ktime_after(ktime_get(), timeout);
222 if (!(sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask))
225 pr_err("%s: Reset 0x%x never completed.\n",
226 mmc_hostname(host->mmc), (int)mask);
227 sdhci_dumpregs(host);
233 EXPORT_SYMBOL_GPL(sdhci_reset);
235 static void sdhci_do_reset(struct sdhci_host *host, u8 mask)
237 if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
238 struct mmc_host *mmc = host->mmc;
240 if (!mmc->ops->get_cd(mmc))
244 host->ops->reset(host, mask);
246 if (mask & SDHCI_RESET_ALL) {
247 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
248 if (host->ops->enable_dma)
249 host->ops->enable_dma(host);
252 /* Resetting the controller clears many */
253 host->preset_enabled = false;
257 static void sdhci_set_default_irqs(struct sdhci_host *host)
259 host->ier = SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
260 SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT |
261 SDHCI_INT_INDEX | SDHCI_INT_END_BIT | SDHCI_INT_CRC |
262 SDHCI_INT_TIMEOUT | SDHCI_INT_DATA_END |
265 if (host->tuning_mode == SDHCI_TUNING_MODE_2 ||
266 host->tuning_mode == SDHCI_TUNING_MODE_3)
267 host->ier |= SDHCI_INT_RETUNE;
269 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
270 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
273 static void sdhci_config_dma(struct sdhci_host *host)
278 if (host->version < SDHCI_SPEC_200)
281 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
284 * Always adjust the DMA selection as some controllers
285 * (e.g. JMicron) can't do PIO properly when the selection
288 ctrl &= ~SDHCI_CTRL_DMA_MASK;
289 if (!(host->flags & SDHCI_REQ_USE_DMA))
292 /* Note if DMA Select is zero then SDMA is selected */
293 if (host->flags & SDHCI_USE_ADMA)
294 ctrl |= SDHCI_CTRL_ADMA32;
296 if (host->flags & SDHCI_USE_64_BIT_DMA) {
298 * If v4 mode, all supported DMA can be 64-bit addressing if
299 * controller supports 64-bit system address, otherwise only
300 * ADMA can support 64-bit addressing.
303 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
304 ctrl2 |= SDHCI_CTRL_64BIT_ADDR;
305 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2);
306 } else if (host->flags & SDHCI_USE_ADMA) {
308 * Don't need to undo SDHCI_CTRL_ADMA32 in order to
309 * set SDHCI_CTRL_ADMA64.
311 ctrl |= SDHCI_CTRL_ADMA64;
316 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
319 static void sdhci_init(struct sdhci_host *host, int soft)
321 struct mmc_host *mmc = host->mmc;
324 sdhci_do_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
326 sdhci_do_reset(host, SDHCI_RESET_ALL);
329 sdhci_do_enable_v4_mode(host);
331 sdhci_set_default_irqs(host);
333 host->cqe_on = false;
336 /* force clock reconfiguration */
338 mmc->ops->set_ios(mmc, &mmc->ios);
342 static void sdhci_reinit(struct sdhci_host *host)
345 sdhci_enable_card_detection(host);
348 static void __sdhci_led_activate(struct sdhci_host *host)
352 if (host->quirks & SDHCI_QUIRK_NO_LED)
355 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
356 ctrl |= SDHCI_CTRL_LED;
357 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
360 static void __sdhci_led_deactivate(struct sdhci_host *host)
364 if (host->quirks & SDHCI_QUIRK_NO_LED)
367 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
368 ctrl &= ~SDHCI_CTRL_LED;
369 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
372 #if IS_REACHABLE(CONFIG_LEDS_CLASS)
373 static void sdhci_led_control(struct led_classdev *led,
374 enum led_brightness brightness)
376 struct sdhci_host *host = container_of(led, struct sdhci_host, led);
379 spin_lock_irqsave(&host->lock, flags);
381 if (host->runtime_suspended)
384 if (brightness == LED_OFF)
385 __sdhci_led_deactivate(host);
387 __sdhci_led_activate(host);
389 spin_unlock_irqrestore(&host->lock, flags);
392 static int sdhci_led_register(struct sdhci_host *host)
394 struct mmc_host *mmc = host->mmc;
396 if (host->quirks & SDHCI_QUIRK_NO_LED)
399 snprintf(host->led_name, sizeof(host->led_name),
400 "%s::", mmc_hostname(mmc));
402 host->led.name = host->led_name;
403 host->led.brightness = LED_OFF;
404 host->led.default_trigger = mmc_hostname(mmc);
405 host->led.brightness_set = sdhci_led_control;
407 return led_classdev_register(mmc_dev(mmc), &host->led);
410 static void sdhci_led_unregister(struct sdhci_host *host)
412 if (host->quirks & SDHCI_QUIRK_NO_LED)
415 led_classdev_unregister(&host->led);
418 static inline void sdhci_led_activate(struct sdhci_host *host)
422 static inline void sdhci_led_deactivate(struct sdhci_host *host)
428 static inline int sdhci_led_register(struct sdhci_host *host)
433 static inline void sdhci_led_unregister(struct sdhci_host *host)
437 static inline void sdhci_led_activate(struct sdhci_host *host)
439 __sdhci_led_activate(host);
442 static inline void sdhci_led_deactivate(struct sdhci_host *host)
444 __sdhci_led_deactivate(host);
449 static void sdhci_mod_timer(struct sdhci_host *host, struct mmc_request *mrq,
450 unsigned long timeout)
452 if (sdhci_data_line_cmd(mrq->cmd))
453 mod_timer(&host->data_timer, timeout);
455 mod_timer(&host->timer, timeout);
458 static void sdhci_del_timer(struct sdhci_host *host, struct mmc_request *mrq)
460 if (sdhci_data_line_cmd(mrq->cmd))
461 del_timer(&host->data_timer);
463 del_timer(&host->timer);
466 static inline bool sdhci_has_requests(struct sdhci_host *host)
468 return host->cmd || host->data_cmd;
471 /*****************************************************************************\
475 \*****************************************************************************/
477 static void sdhci_read_block_pio(struct sdhci_host *host)
480 size_t blksize, len, chunk;
481 u32 uninitialized_var(scratch);
484 DBG("PIO reading\n");
486 blksize = host->data->blksz;
489 local_irq_save(flags);
492 BUG_ON(!sg_miter_next(&host->sg_miter));
494 len = min(host->sg_miter.length, blksize);
497 host->sg_miter.consumed = len;
499 buf = host->sg_miter.addr;
503 scratch = sdhci_readl(host, SDHCI_BUFFER);
507 *buf = scratch & 0xFF;
516 sg_miter_stop(&host->sg_miter);
518 local_irq_restore(flags);
521 static void sdhci_write_block_pio(struct sdhci_host *host)
524 size_t blksize, len, chunk;
528 DBG("PIO writing\n");
530 blksize = host->data->blksz;
534 local_irq_save(flags);
537 BUG_ON(!sg_miter_next(&host->sg_miter));
539 len = min(host->sg_miter.length, blksize);
542 host->sg_miter.consumed = len;
544 buf = host->sg_miter.addr;
547 scratch |= (u32)*buf << (chunk * 8);
553 if ((chunk == 4) || ((len == 0) && (blksize == 0))) {
554 sdhci_writel(host, scratch, SDHCI_BUFFER);
561 sg_miter_stop(&host->sg_miter);
563 local_irq_restore(flags);
566 static void sdhci_transfer_pio(struct sdhci_host *host)
570 if (host->blocks == 0)
573 if (host->data->flags & MMC_DATA_READ)
574 mask = SDHCI_DATA_AVAILABLE;
576 mask = SDHCI_SPACE_AVAILABLE;
579 * Some controllers (JMicron JMB38x) mess up the buffer bits
580 * for transfers < 4 bytes. As long as it is just one block,
581 * we can ignore the bits.
583 if ((host->quirks & SDHCI_QUIRK_BROKEN_SMALL_PIO) &&
584 (host->data->blocks == 1))
587 while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
588 if (host->quirks & SDHCI_QUIRK_PIO_NEEDS_DELAY)
591 if (host->data->flags & MMC_DATA_READ)
592 sdhci_read_block_pio(host);
594 sdhci_write_block_pio(host);
597 if (host->blocks == 0)
601 DBG("PIO transfer complete.\n");
604 static int sdhci_pre_dma_transfer(struct sdhci_host *host,
605 struct mmc_data *data, int cookie)
610 * If the data buffers are already mapped, return the previous
611 * dma_map_sg() result.
613 if (data->host_cookie == COOKIE_PRE_MAPPED)
614 return data->sg_count;
616 /* Bounce write requests to the bounce buffer */
617 if (host->bounce_buffer) {
618 unsigned int length = data->blksz * data->blocks;
620 if (length > host->bounce_buffer_size) {
621 pr_err("%s: asked for transfer of %u bytes exceeds bounce buffer %u bytes\n",
622 mmc_hostname(host->mmc), length,
623 host->bounce_buffer_size);
626 if (mmc_get_dma_dir(data) == DMA_TO_DEVICE) {
627 /* Copy the data to the bounce buffer */
628 sg_copy_to_buffer(data->sg, data->sg_len,
632 /* Switch ownership to the DMA */
633 dma_sync_single_for_device(host->mmc->parent,
635 host->bounce_buffer_size,
636 mmc_get_dma_dir(data));
637 /* Just a dummy value */
640 /* Just access the data directly from memory */
641 sg_count = dma_map_sg(mmc_dev(host->mmc),
642 data->sg, data->sg_len,
643 mmc_get_dma_dir(data));
649 data->sg_count = sg_count;
650 data->host_cookie = cookie;
655 static char *sdhci_kmap_atomic(struct scatterlist *sg, unsigned long *flags)
657 local_irq_save(*flags);
658 return kmap_atomic(sg_page(sg)) + sg->offset;
661 static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
663 kunmap_atomic(buffer);
664 local_irq_restore(*flags);
667 void sdhci_adma_write_desc(struct sdhci_host *host, void **desc,
668 dma_addr_t addr, int len, unsigned int cmd)
670 struct sdhci_adma2_64_desc *dma_desc = *desc;
672 /* 32-bit and 64-bit descriptors have these members in same position */
673 dma_desc->cmd = cpu_to_le16(cmd);
674 dma_desc->len = cpu_to_le16(len);
675 dma_desc->addr_lo = cpu_to_le32((u32)addr);
677 if (host->flags & SDHCI_USE_64_BIT_DMA)
678 dma_desc->addr_hi = cpu_to_le32((u64)addr >> 32);
680 *desc += host->desc_sz;
682 EXPORT_SYMBOL_GPL(sdhci_adma_write_desc);
684 static inline void __sdhci_adma_write_desc(struct sdhci_host *host,
685 void **desc, dma_addr_t addr,
686 int len, unsigned int cmd)
688 if (host->ops->adma_write_desc)
689 host->ops->adma_write_desc(host, desc, addr, len, cmd);
691 sdhci_adma_write_desc(host, desc, addr, len, cmd);
694 static void sdhci_adma_mark_end(void *desc)
696 struct sdhci_adma2_64_desc *dma_desc = desc;
698 /* 32-bit and 64-bit descriptors have 'cmd' in same position */
699 dma_desc->cmd |= cpu_to_le16(ADMA2_END);
702 static void sdhci_adma_table_pre(struct sdhci_host *host,
703 struct mmc_data *data, int sg_count)
705 struct scatterlist *sg;
707 dma_addr_t addr, align_addr;
713 * The spec does not specify endianness of descriptor table.
714 * We currently guess that it is LE.
717 host->sg_count = sg_count;
719 desc = host->adma_table;
720 align = host->align_buffer;
722 align_addr = host->align_addr;
724 for_each_sg(data->sg, sg, host->sg_count, i) {
725 addr = sg_dma_address(sg);
726 len = sg_dma_len(sg);
729 * The SDHCI specification states that ADMA addresses must
730 * be 32-bit aligned. If they aren't, then we use a bounce
731 * buffer for the (up to three) bytes that screw up the
734 offset = (SDHCI_ADMA2_ALIGN - (addr & SDHCI_ADMA2_MASK)) &
737 if (data->flags & MMC_DATA_WRITE) {
738 buffer = sdhci_kmap_atomic(sg, &flags);
739 memcpy(align, buffer, offset);
740 sdhci_kunmap_atomic(buffer, &flags);
744 __sdhci_adma_write_desc(host, &desc, align_addr,
745 offset, ADMA2_TRAN_VALID);
747 BUG_ON(offset > 65536);
749 align += SDHCI_ADMA2_ALIGN;
750 align_addr += SDHCI_ADMA2_ALIGN;
760 __sdhci_adma_write_desc(host, &desc, addr, len,
764 * If this triggers then we have a calculation bug
767 WARN_ON((desc - host->adma_table) >= host->adma_table_sz);
770 if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) {
771 /* Mark the last descriptor as the terminating descriptor */
772 if (desc != host->adma_table) {
773 desc -= host->desc_sz;
774 sdhci_adma_mark_end(desc);
777 /* Add a terminating entry - nop, end, valid */
778 __sdhci_adma_write_desc(host, &desc, 0, 0, ADMA2_NOP_END_VALID);
782 static void sdhci_adma_table_post(struct sdhci_host *host,
783 struct mmc_data *data)
785 struct scatterlist *sg;
791 if (data->flags & MMC_DATA_READ) {
792 bool has_unaligned = false;
794 /* Do a quick scan of the SG list for any unaligned mappings */
795 for_each_sg(data->sg, sg, host->sg_count, i)
796 if (sg_dma_address(sg) & SDHCI_ADMA2_MASK) {
797 has_unaligned = true;
802 dma_sync_sg_for_cpu(mmc_dev(host->mmc), data->sg,
803 data->sg_len, DMA_FROM_DEVICE);
805 align = host->align_buffer;
807 for_each_sg(data->sg, sg, host->sg_count, i) {
808 if (sg_dma_address(sg) & SDHCI_ADMA2_MASK) {
809 size = SDHCI_ADMA2_ALIGN -
810 (sg_dma_address(sg) & SDHCI_ADMA2_MASK);
812 buffer = sdhci_kmap_atomic(sg, &flags);
813 memcpy(buffer, align, size);
814 sdhci_kunmap_atomic(buffer, &flags);
816 align += SDHCI_ADMA2_ALIGN;
823 static dma_addr_t sdhci_sdma_address(struct sdhci_host *host)
825 if (host->bounce_buffer)
826 return host->bounce_addr;
828 return sg_dma_address(host->data->sg);
831 static void sdhci_set_sdma_addr(struct sdhci_host *host, dma_addr_t addr)
834 sdhci_writel(host, addr, SDHCI_ADMA_ADDRESS);
835 if (host->flags & SDHCI_USE_64_BIT_DMA)
836 sdhci_writel(host, (u64)addr >> 32, SDHCI_ADMA_ADDRESS_HI);
838 sdhci_writel(host, addr, SDHCI_DMA_ADDRESS);
842 static unsigned int sdhci_target_timeout(struct sdhci_host *host,
843 struct mmc_command *cmd,
844 struct mmc_data *data)
846 unsigned int target_timeout;
850 target_timeout = cmd->busy_timeout * 1000;
852 target_timeout = DIV_ROUND_UP(data->timeout_ns, 1000);
853 if (host->clock && data->timeout_clks) {
854 unsigned long long val;
857 * data->timeout_clks is in units of clock cycles.
858 * host->clock is in Hz. target_timeout is in us.
859 * Hence, us = 1000000 * cycles / Hz. Round up.
861 val = 1000000ULL * data->timeout_clks;
862 if (do_div(val, host->clock))
864 target_timeout += val;
868 return target_timeout;
871 static void sdhci_calc_sw_timeout(struct sdhci_host *host,
872 struct mmc_command *cmd)
874 struct mmc_data *data = cmd->data;
875 struct mmc_host *mmc = host->mmc;
876 struct mmc_ios *ios = &mmc->ios;
877 unsigned char bus_width = 1 << ios->bus_width;
883 target_timeout = sdhci_target_timeout(host, cmd, data);
884 target_timeout *= NSEC_PER_USEC;
888 freq = host->mmc->actual_clock ? : host->clock;
889 transfer_time = (u64)blksz * NSEC_PER_SEC * (8 / bus_width);
890 do_div(transfer_time, freq);
891 /* multiply by '2' to account for any unknowns */
892 transfer_time = transfer_time * 2;
893 /* calculate timeout for the entire data */
894 host->data_timeout = data->blocks * target_timeout +
897 host->data_timeout = target_timeout;
900 if (host->data_timeout)
901 host->data_timeout += MMC_CMD_TRANSFER_TIME;
904 static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd,
908 struct mmc_data *data;
909 unsigned target_timeout, current_timeout;
914 * If the host controller provides us with an incorrect timeout
915 * value, just skip the check and use 0xE. The hardware may take
916 * longer to time out, but that's much better than having a too-short
919 if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL)
922 /* Unspecified command, asume max */
927 /* Unspecified timeout, assume max */
928 if (!data && !cmd->busy_timeout)
932 target_timeout = sdhci_target_timeout(host, cmd, data);
935 * Figure out needed cycles.
936 * We do this in steps in order to fit inside a 32 bit int.
937 * The first step is the minimum timeout, which will have a
938 * minimum resolution of 6 bits:
939 * (1) 2^13*1000 > 2^22,
940 * (2) host->timeout_clk < 2^16
945 current_timeout = (1 << 13) * 1000 / host->timeout_clk;
946 while (current_timeout < target_timeout) {
948 current_timeout <<= 1;
954 if (!(host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT))
955 DBG("Too large timeout 0x%x requested for CMD%d!\n",
965 static void sdhci_set_transfer_irqs(struct sdhci_host *host)
967 u32 pio_irqs = SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL;
968 u32 dma_irqs = SDHCI_INT_DMA_END | SDHCI_INT_ADMA_ERROR;
970 if (host->flags & SDHCI_REQ_USE_DMA)
971 host->ier = (host->ier & ~pio_irqs) | dma_irqs;
973 host->ier = (host->ier & ~dma_irqs) | pio_irqs;
975 if (host->flags & (SDHCI_AUTO_CMD23 | SDHCI_AUTO_CMD12))
976 host->ier |= SDHCI_INT_AUTO_CMD_ERR;
978 host->ier &= ~SDHCI_INT_AUTO_CMD_ERR;
980 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
981 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
984 static void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable)
987 host->ier |= SDHCI_INT_DATA_TIMEOUT;
989 host->ier &= ~SDHCI_INT_DATA_TIMEOUT;
990 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
991 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
994 static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
998 if (host->ops->set_timeout) {
999 host->ops->set_timeout(host, cmd);
1001 bool too_big = false;
1003 count = sdhci_calc_timeout(host, cmd, &too_big);
1006 host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT) {
1007 sdhci_calc_sw_timeout(host, cmd);
1008 sdhci_set_data_timeout_irq(host, false);
1009 } else if (!(host->ier & SDHCI_INT_DATA_TIMEOUT)) {
1010 sdhci_set_data_timeout_irq(host, true);
1013 sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
1017 static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
1019 struct mmc_data *data = cmd->data;
1021 host->data_timeout = 0;
1023 if (sdhci_data_line_cmd(cmd))
1024 sdhci_set_timeout(host, cmd);
1029 WARN_ON(host->data);
1032 BUG_ON(data->blksz * data->blocks > 524288);
1033 BUG_ON(data->blksz > host->mmc->max_blk_size);
1034 BUG_ON(data->blocks > 65535);
1037 host->data_early = 0;
1038 host->data->bytes_xfered = 0;
1040 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
1041 struct scatterlist *sg;
1042 unsigned int length_mask, offset_mask;
1045 host->flags |= SDHCI_REQ_USE_DMA;
1048 * FIXME: This doesn't account for merging when mapping the
1051 * The assumption here being that alignment and lengths are
1052 * the same after DMA mapping to device address space.
1056 if (host->flags & SDHCI_USE_ADMA) {
1057 if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE) {
1060 * As we use up to 3 byte chunks to work
1061 * around alignment problems, we need to
1062 * check the offset as well.
1067 if (host->quirks & SDHCI_QUIRK_32BIT_DMA_SIZE)
1069 if (host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR)
1073 if (unlikely(length_mask | offset_mask)) {
1074 for_each_sg(data->sg, sg, data->sg_len, i) {
1075 if (sg->length & length_mask) {
1076 DBG("Reverting to PIO because of transfer size (%d)\n",
1078 host->flags &= ~SDHCI_REQ_USE_DMA;
1081 if (sg->offset & offset_mask) {
1082 DBG("Reverting to PIO because of bad alignment\n");
1083 host->flags &= ~SDHCI_REQ_USE_DMA;
1090 if (host->flags & SDHCI_REQ_USE_DMA) {
1091 int sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED);
1095 * This only happens when someone fed
1096 * us an invalid request.
1099 host->flags &= ~SDHCI_REQ_USE_DMA;
1100 } else if (host->flags & SDHCI_USE_ADMA) {
1101 sdhci_adma_table_pre(host, data, sg_cnt);
1103 sdhci_writel(host, host->adma_addr, SDHCI_ADMA_ADDRESS);
1104 if (host->flags & SDHCI_USE_64_BIT_DMA)
1106 (u64)host->adma_addr >> 32,
1107 SDHCI_ADMA_ADDRESS_HI);
1109 WARN_ON(sg_cnt != 1);
1110 sdhci_set_sdma_addr(host, sdhci_sdma_address(host));
1114 sdhci_config_dma(host);
1116 if (!(host->flags & SDHCI_REQ_USE_DMA)) {
1119 flags = SG_MITER_ATOMIC;
1120 if (host->data->flags & MMC_DATA_READ)
1121 flags |= SG_MITER_TO_SG;
1123 flags |= SG_MITER_FROM_SG;
1124 sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
1125 host->blocks = data->blocks;
1128 sdhci_set_transfer_irqs(host);
1130 /* Set the DMA boundary value and block size */
1131 sdhci_writew(host, SDHCI_MAKE_BLKSZ(host->sdma_boundary, data->blksz),
1135 * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count
1136 * can be supported, in that case 16-bit block count register must be 0.
1138 if (host->version >= SDHCI_SPEC_410 && host->v4_mode &&
1139 (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) {
1140 if (sdhci_readw(host, SDHCI_BLOCK_COUNT))
1141 sdhci_writew(host, 0, SDHCI_BLOCK_COUNT);
1142 sdhci_writew(host, data->blocks, SDHCI_32BIT_BLK_CNT);
1144 sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
1148 static inline bool sdhci_auto_cmd12(struct sdhci_host *host,
1149 struct mmc_request *mrq)
1151 return !mrq->sbc && (host->flags & SDHCI_AUTO_CMD12) &&
1152 !mrq->cap_cmd_during_tfr;
1155 static inline void sdhci_auto_cmd_select(struct sdhci_host *host,
1156 struct mmc_command *cmd,
1159 bool use_cmd12 = sdhci_auto_cmd12(host, cmd->mrq) &&
1160 (cmd->opcode != SD_IO_RW_EXTENDED);
1161 bool use_cmd23 = cmd->mrq->sbc && (host->flags & SDHCI_AUTO_CMD23);
1165 * In case of Version 4.10 or later, use of 'Auto CMD Auto
1166 * Select' is recommended rather than use of 'Auto CMD12
1167 * Enable' or 'Auto CMD23 Enable'.
1169 if (host->version >= SDHCI_SPEC_410 && (use_cmd12 || use_cmd23)) {
1170 *mode |= SDHCI_TRNS_AUTO_SEL;
1172 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1174 ctrl2 |= SDHCI_CMD23_ENABLE;
1176 ctrl2 &= ~SDHCI_CMD23_ENABLE;
1177 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2);
1183 * If we are sending CMD23, CMD12 never gets sent
1184 * on successful completion (so no Auto-CMD12).
1187 *mode |= SDHCI_TRNS_AUTO_CMD12;
1189 *mode |= SDHCI_TRNS_AUTO_CMD23;
1192 static void sdhci_set_transfer_mode(struct sdhci_host *host,
1193 struct mmc_command *cmd)
1196 struct mmc_data *data = cmd->data;
1200 SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD) {
1201 /* must not clear SDHCI_TRANSFER_MODE when tuning */
1202 if (cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200)
1203 sdhci_writew(host, 0x0, SDHCI_TRANSFER_MODE);
1205 /* clear Auto CMD settings for no data CMDs */
1206 mode = sdhci_readw(host, SDHCI_TRANSFER_MODE);
1207 sdhci_writew(host, mode & ~(SDHCI_TRNS_AUTO_CMD12 |
1208 SDHCI_TRNS_AUTO_CMD23), SDHCI_TRANSFER_MODE);
1213 WARN_ON(!host->data);
1215 if (!(host->quirks2 & SDHCI_QUIRK2_SUPPORT_SINGLE))
1216 mode = SDHCI_TRNS_BLK_CNT_EN;
1218 if (mmc_op_multi(cmd->opcode) || data->blocks > 1) {
1219 mode = SDHCI_TRNS_BLK_CNT_EN | SDHCI_TRNS_MULTI;
1220 sdhci_auto_cmd_select(host, cmd, &mode);
1221 if (cmd->mrq->sbc && (host->flags & SDHCI_AUTO_CMD23))
1222 sdhci_writel(host, cmd->mrq->sbc->arg, SDHCI_ARGUMENT2);
1225 if (data->flags & MMC_DATA_READ)
1226 mode |= SDHCI_TRNS_READ;
1227 if (host->flags & SDHCI_REQ_USE_DMA)
1228 mode |= SDHCI_TRNS_DMA;
1230 sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
1233 static bool sdhci_needs_reset(struct sdhci_host *host, struct mmc_request *mrq)
1235 return (!(host->flags & SDHCI_DEVICE_DEAD) &&
1236 ((mrq->cmd && mrq->cmd->error) ||
1237 (mrq->sbc && mrq->sbc->error) ||
1238 (mrq->data && mrq->data->stop && mrq->data->stop->error) ||
1239 (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST)));
1242 static void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
1246 if (host->cmd && host->cmd->mrq == mrq)
1249 if (host->data_cmd && host->data_cmd->mrq == mrq)
1250 host->data_cmd = NULL;
1252 if (host->data && host->data->mrq == mrq)
1255 if (sdhci_needs_reset(host, mrq))
1256 host->pending_reset = true;
1258 for (i = 0; i < SDHCI_MAX_MRQS; i++) {
1259 if (host->mrqs_done[i] == mrq) {
1265 for (i = 0; i < SDHCI_MAX_MRQS; i++) {
1266 if (!host->mrqs_done[i]) {
1267 host->mrqs_done[i] = mrq;
1272 WARN_ON(i >= SDHCI_MAX_MRQS);
1274 sdhci_del_timer(host, mrq);
1276 if (!sdhci_has_requests(host))
1277 sdhci_led_deactivate(host);
1280 static void sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq)
1282 __sdhci_finish_mrq(host, mrq);
1284 queue_work(host->complete_wq, &host->complete_work);
1287 static void sdhci_finish_data(struct sdhci_host *host)
1289 struct mmc_command *data_cmd = host->data_cmd;
1290 struct mmc_data *data = host->data;
1293 host->data_cmd = NULL;
1296 * The controller needs a reset of internal state machines upon error
1300 if (!host->cmd || host->cmd == data_cmd)
1301 sdhci_do_reset(host, SDHCI_RESET_CMD);
1302 sdhci_do_reset(host, SDHCI_RESET_DATA);
1305 if ((host->flags & (SDHCI_REQ_USE_DMA | SDHCI_USE_ADMA)) ==
1306 (SDHCI_REQ_USE_DMA | SDHCI_USE_ADMA))
1307 sdhci_adma_table_post(host, data);
1310 * The specification states that the block count register must
1311 * be updated, but it does not specify at what point in the
1312 * data flow. That makes the register entirely useless to read
1313 * back so we have to assume that nothing made it to the card
1314 * in the event of an error.
1317 data->bytes_xfered = 0;
1319 data->bytes_xfered = data->blksz * data->blocks;
1322 * Need to send CMD12 if -
1323 * a) open-ended multiblock transfer (no CMD23)
1324 * b) error in multiblock transfer
1330 * 'cap_cmd_during_tfr' request must not use the command line
1331 * after mmc_command_done() has been called. It is upper layer's
1332 * responsibility to send the stop command if required.
1334 if (data->mrq->cap_cmd_during_tfr) {
1335 __sdhci_finish_mrq(host, data->mrq);
1337 /* Avoid triggering warning in sdhci_send_command() */
1339 sdhci_send_command(host, data->stop);
1342 __sdhci_finish_mrq(host, data->mrq);
1346 void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
1350 unsigned long timeout;
1354 /* Initially, a command has no error */
1357 if ((host->quirks2 & SDHCI_QUIRK2_STOP_WITH_TC) &&
1358 cmd->opcode == MMC_STOP_TRANSMISSION)
1359 cmd->flags |= MMC_RSP_BUSY;
1361 /* Wait max 10 ms */
1364 mask = SDHCI_CMD_INHIBIT;
1365 if (sdhci_data_line_cmd(cmd))
1366 mask |= SDHCI_DATA_INHIBIT;
1368 /* We shouldn't wait for data inihibit for stop commands, even
1369 though they might use busy signaling */
1370 if (cmd->mrq->data && (cmd == cmd->mrq->data->stop))
1371 mask &= ~SDHCI_DATA_INHIBIT;
1373 while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
1375 pr_err("%s: Controller never released inhibit bit(s).\n",
1376 mmc_hostname(host->mmc));
1377 sdhci_dumpregs(host);
1379 sdhci_finish_mrq(host, cmd->mrq);
1387 if (sdhci_data_line_cmd(cmd)) {
1388 WARN_ON(host->data_cmd);
1389 host->data_cmd = cmd;
1392 sdhci_prepare_data(host, cmd);
1394 sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
1396 sdhci_set_transfer_mode(host, cmd);
1398 if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
1399 pr_err("%s: Unsupported response type!\n",
1400 mmc_hostname(host->mmc));
1401 cmd->error = -EINVAL;
1402 sdhci_finish_mrq(host, cmd->mrq);
1406 if (!(cmd->flags & MMC_RSP_PRESENT))
1407 flags = SDHCI_CMD_RESP_NONE;
1408 else if (cmd->flags & MMC_RSP_136)
1409 flags = SDHCI_CMD_RESP_LONG;
1410 else if (cmd->flags & MMC_RSP_BUSY)
1411 flags = SDHCI_CMD_RESP_SHORT_BUSY;
1413 flags = SDHCI_CMD_RESP_SHORT;
1415 if (cmd->flags & MMC_RSP_CRC)
1416 flags |= SDHCI_CMD_CRC;
1417 if (cmd->flags & MMC_RSP_OPCODE)
1418 flags |= SDHCI_CMD_INDEX;
1420 /* CMD19 is special in that the Data Present Select should be set */
1421 if (cmd->data || cmd->opcode == MMC_SEND_TUNING_BLOCK ||
1422 cmd->opcode == MMC_SEND_TUNING_BLOCK_HS200)
1423 flags |= SDHCI_CMD_DATA;
1426 if (host->data_timeout)
1427 timeout += nsecs_to_jiffies(host->data_timeout);
1428 else if (!cmd->data && cmd->busy_timeout > 9000)
1429 timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
1432 sdhci_mod_timer(host, cmd->mrq, timeout);
1434 sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
1436 EXPORT_SYMBOL_GPL(sdhci_send_command);
1438 static void sdhci_read_rsp_136(struct sdhci_host *host, struct mmc_command *cmd)
1442 for (i = 0; i < 4; i++) {
1443 reg = SDHCI_RESPONSE + (3 - i) * 4;
1444 cmd->resp[i] = sdhci_readl(host, reg);
1447 if (host->quirks2 & SDHCI_QUIRK2_RSP_136_HAS_CRC)
1450 /* CRC is stripped so we need to do some shifting */
1451 for (i = 0; i < 4; i++) {
1454 cmd->resp[i] |= cmd->resp[i + 1] >> 24;
1458 static void sdhci_finish_command(struct sdhci_host *host)
1460 struct mmc_command *cmd = host->cmd;
1464 if (cmd->flags & MMC_RSP_PRESENT) {
1465 if (cmd->flags & MMC_RSP_136) {
1466 sdhci_read_rsp_136(host, cmd);
1468 cmd->resp[0] = sdhci_readl(host, SDHCI_RESPONSE);
1472 if (cmd->mrq->cap_cmd_during_tfr && cmd == cmd->mrq->cmd)
1473 mmc_command_done(host->mmc, cmd->mrq);
1476 * The host can send and interrupt when the busy state has
1477 * ended, allowing us to wait without wasting CPU cycles.
1478 * The busy signal uses DAT0 so this is similar to waiting
1479 * for data to complete.
1481 * Note: The 1.0 specification is a bit ambiguous about this
1482 * feature so there might be some problems with older
1485 if (cmd->flags & MMC_RSP_BUSY) {
1487 DBG("Cannot wait for busy signal when also doing a data transfer");
1488 } else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ) &&
1489 cmd == host->data_cmd) {
1490 /* Command complete before busy is ended */
1495 /* Finished CMD23, now send actual command. */
1496 if (cmd == cmd->mrq->sbc) {
1497 sdhci_send_command(host, cmd->mrq->cmd);
1500 /* Processed actual command. */
1501 if (host->data && host->data_early)
1502 sdhci_finish_data(host);
1505 __sdhci_finish_mrq(host, cmd->mrq);
1509 static u16 sdhci_get_preset_value(struct sdhci_host *host)
1513 switch (host->timing) {
1514 case MMC_TIMING_UHS_SDR12:
1515 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
1517 case MMC_TIMING_UHS_SDR25:
1518 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR25);
1520 case MMC_TIMING_UHS_SDR50:
1521 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR50);
1523 case MMC_TIMING_UHS_SDR104:
1524 case MMC_TIMING_MMC_HS200:
1525 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR104);
1527 case MMC_TIMING_UHS_DDR50:
1528 case MMC_TIMING_MMC_DDR52:
1529 preset = sdhci_readw(host, SDHCI_PRESET_FOR_DDR50);
1531 case MMC_TIMING_MMC_HS400:
1532 preset = sdhci_readw(host, SDHCI_PRESET_FOR_HS400);
1535 pr_warn("%s: Invalid UHS-I mode selected\n",
1536 mmc_hostname(host->mmc));
1537 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
1543 u16 sdhci_calc_clk(struct sdhci_host *host, unsigned int clock,
1544 unsigned int *actual_clock)
1546 int div = 0; /* Initialized for compiler warning */
1547 int real_div = div, clk_mul = 1;
1549 bool switch_base_clk = false;
1551 if (host->version >= SDHCI_SPEC_300) {
1552 if (host->preset_enabled) {
1555 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1556 pre_val = sdhci_get_preset_value(host);
1557 div = (pre_val & SDHCI_PRESET_SDCLK_FREQ_MASK)
1558 >> SDHCI_PRESET_SDCLK_FREQ_SHIFT;
1559 if (host->clk_mul &&
1560 (pre_val & SDHCI_PRESET_CLKGEN_SEL_MASK)) {
1561 clk = SDHCI_PROG_CLOCK_MODE;
1563 clk_mul = host->clk_mul;
1565 real_div = max_t(int, 1, div << 1);
1571 * Check if the Host Controller supports Programmable Clock
1574 if (host->clk_mul) {
1575 for (div = 1; div <= 1024; div++) {
1576 if ((host->max_clk * host->clk_mul / div)
1580 if ((host->max_clk * host->clk_mul / div) <= clock) {
1582 * Set Programmable Clock Mode in the Clock
1585 clk = SDHCI_PROG_CLOCK_MODE;
1587 clk_mul = host->clk_mul;
1591 * Divisor can be too small to reach clock
1592 * speed requirement. Then use the base clock.
1594 switch_base_clk = true;
1598 if (!host->clk_mul || switch_base_clk) {
1599 /* Version 3.00 divisors must be a multiple of 2. */
1600 if (host->max_clk <= clock)
1603 for (div = 2; div < SDHCI_MAX_DIV_SPEC_300;
1605 if ((host->max_clk / div) <= clock)
1611 if ((host->quirks2 & SDHCI_QUIRK2_CLOCK_DIV_ZERO_BROKEN)
1612 && !div && host->max_clk <= 25000000)
1616 /* Version 2.00 divisors must be a power of 2. */
1617 for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
1618 if ((host->max_clk / div) <= clock)
1627 *actual_clock = (host->max_clk * clk_mul) / real_div;
1628 clk |= (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
1629 clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
1630 << SDHCI_DIVIDER_HI_SHIFT;
1634 EXPORT_SYMBOL_GPL(sdhci_calc_clk);
1636 void sdhci_enable_clk(struct sdhci_host *host, u16 clk)
1640 clk |= SDHCI_CLOCK_INT_EN;
1641 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1643 /* Wait max 20 ms */
1644 timeout = ktime_add_ms(ktime_get(), 20);
1646 bool timedout = ktime_after(ktime_get(), timeout);
1648 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1649 if (clk & SDHCI_CLOCK_INT_STABLE)
1652 pr_err("%s: Internal clock never stabilised.\n",
1653 mmc_hostname(host->mmc));
1654 sdhci_dumpregs(host);
1660 clk |= SDHCI_CLOCK_CARD_EN;
1661 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1663 EXPORT_SYMBOL_GPL(sdhci_enable_clk);
1665 void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
1669 host->mmc->actual_clock = 0;
1671 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
1676 clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock);
1677 sdhci_enable_clk(host, clk);
1679 EXPORT_SYMBOL_GPL(sdhci_set_clock);
1681 static void sdhci_set_power_reg(struct sdhci_host *host, unsigned char mode,
1684 struct mmc_host *mmc = host->mmc;
1686 mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
1688 if (mode != MMC_POWER_OFF)
1689 sdhci_writeb(host, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
1691 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1694 void sdhci_set_power_noreg(struct sdhci_host *host, unsigned char mode,
1699 if (mode != MMC_POWER_OFF) {
1701 case MMC_VDD_165_195:
1703 * Without a regulator, SDHCI does not support 2.0v
1704 * so we only get here if the driver deliberately
1705 * added the 2.0v range to ocr_avail. Map it to 1.8v
1706 * for the purpose of turning on the power.
1709 pwr = SDHCI_POWER_180;
1713 pwr = SDHCI_POWER_300;
1717 pwr = SDHCI_POWER_330;
1720 WARN(1, "%s: Invalid vdd %#x\n",
1721 mmc_hostname(host->mmc), vdd);
1726 if (host->pwr == pwr)
1732 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1733 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
1734 sdhci_runtime_pm_bus_off(host);
1737 * Spec says that we should clear the power reg before setting
1738 * a new value. Some controllers don't seem to like this though.
1740 if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
1741 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1744 * At least the Marvell CaFe chip gets confused if we set the
1745 * voltage and set turn on power at the same time, so set the
1748 if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER)
1749 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1751 pwr |= SDHCI_POWER_ON;
1753 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1755 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
1756 sdhci_runtime_pm_bus_on(host);
1759 * Some controllers need an extra 10ms delay of 10ms before
1760 * they can apply clock after applying power
1762 if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER)
1766 EXPORT_SYMBOL_GPL(sdhci_set_power_noreg);
1768 void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
1771 if (IS_ERR(host->mmc->supply.vmmc))
1772 sdhci_set_power_noreg(host, mode, vdd);
1774 sdhci_set_power_reg(host, mode, vdd);
1776 EXPORT_SYMBOL_GPL(sdhci_set_power);
1778 /*****************************************************************************\
1782 \*****************************************************************************/
1784 void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1786 struct sdhci_host *host;
1788 unsigned long flags;
1790 host = mmc_priv(mmc);
1792 /* Firstly check card presence */
1793 present = mmc->ops->get_cd(mmc);
1795 spin_lock_irqsave(&host->lock, flags);
1797 sdhci_led_activate(host);
1800 * Ensure we don't send the STOP for non-SET_BLOCK_COUNTED
1801 * requests if Auto-CMD12 is enabled.
1803 if (sdhci_auto_cmd12(host, mrq)) {
1805 mrq->data->stop = NULL;
1810 if (!present || host->flags & SDHCI_DEVICE_DEAD) {
1811 mrq->cmd->error = -ENOMEDIUM;
1812 sdhci_finish_mrq(host, mrq);
1814 if (mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23))
1815 sdhci_send_command(host, mrq->sbc);
1817 sdhci_send_command(host, mrq->cmd);
1820 spin_unlock_irqrestore(&host->lock, flags);
1822 EXPORT_SYMBOL_GPL(sdhci_request);
1824 void sdhci_set_bus_width(struct sdhci_host *host, int width)
1828 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1829 if (width == MMC_BUS_WIDTH_8) {
1830 ctrl &= ~SDHCI_CTRL_4BITBUS;
1831 ctrl |= SDHCI_CTRL_8BITBUS;
1833 if (host->mmc->caps & MMC_CAP_8_BIT_DATA)
1834 ctrl &= ~SDHCI_CTRL_8BITBUS;
1835 if (width == MMC_BUS_WIDTH_4)
1836 ctrl |= SDHCI_CTRL_4BITBUS;
1838 ctrl &= ~SDHCI_CTRL_4BITBUS;
1840 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1842 EXPORT_SYMBOL_GPL(sdhci_set_bus_width);
1844 void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing)
1848 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1849 /* Select Bus Speed Mode for host */
1850 ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
1851 if ((timing == MMC_TIMING_MMC_HS200) ||
1852 (timing == MMC_TIMING_UHS_SDR104))
1853 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
1854 else if (timing == MMC_TIMING_UHS_SDR12)
1855 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
1856 else if (timing == MMC_TIMING_UHS_SDR25)
1857 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
1858 else if (timing == MMC_TIMING_UHS_SDR50)
1859 ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
1860 else if ((timing == MMC_TIMING_UHS_DDR50) ||
1861 (timing == MMC_TIMING_MMC_DDR52))
1862 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
1863 else if (timing == MMC_TIMING_MMC_HS400)
1864 ctrl_2 |= SDHCI_CTRL_HS400; /* Non-standard */
1865 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
1867 EXPORT_SYMBOL_GPL(sdhci_set_uhs_signaling);
1869 void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
1871 struct sdhci_host *host = mmc_priv(mmc);
1874 if (ios->power_mode == MMC_POWER_UNDEFINED)
1877 if (host->flags & SDHCI_DEVICE_DEAD) {
1878 if (!IS_ERR(mmc->supply.vmmc) &&
1879 ios->power_mode == MMC_POWER_OFF)
1880 mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, 0);
1885 * Reset the chip on each power off.
1886 * Should clear out any weird states.
1888 if (ios->power_mode == MMC_POWER_OFF) {
1889 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
1893 if (host->version >= SDHCI_SPEC_300 &&
1894 (ios->power_mode == MMC_POWER_UP) &&
1895 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN))
1896 sdhci_enable_preset_value(host, false);
1898 if (!ios->clock || ios->clock != host->clock) {
1899 host->ops->set_clock(host, ios->clock);
1900 host->clock = ios->clock;
1902 if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK &&
1904 host->timeout_clk = host->mmc->actual_clock ?
1905 host->mmc->actual_clock / 1000 :
1907 host->mmc->max_busy_timeout =
1908 host->ops->get_max_timeout_count ?
1909 host->ops->get_max_timeout_count(host) :
1911 host->mmc->max_busy_timeout /= host->timeout_clk;
1915 if (host->ops->set_power)
1916 host->ops->set_power(host, ios->power_mode, ios->vdd);
1918 sdhci_set_power(host, ios->power_mode, ios->vdd);
1920 if (host->ops->platform_send_init_74_clocks)
1921 host->ops->platform_send_init_74_clocks(host, ios->power_mode);
1923 host->ops->set_bus_width(host, ios->bus_width);
1925 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1927 if (!(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT)) {
1928 if (ios->timing == MMC_TIMING_SD_HS ||
1929 ios->timing == MMC_TIMING_MMC_HS ||
1930 ios->timing == MMC_TIMING_MMC_HS400 ||
1931 ios->timing == MMC_TIMING_MMC_HS200 ||
1932 ios->timing == MMC_TIMING_MMC_DDR52 ||
1933 ios->timing == MMC_TIMING_UHS_SDR50 ||
1934 ios->timing == MMC_TIMING_UHS_SDR104 ||
1935 ios->timing == MMC_TIMING_UHS_DDR50 ||
1936 ios->timing == MMC_TIMING_UHS_SDR25)
1937 ctrl |= SDHCI_CTRL_HISPD;
1939 ctrl &= ~SDHCI_CTRL_HISPD;
1942 if (host->version >= SDHCI_SPEC_300) {
1945 if (!host->preset_enabled) {
1946 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1948 * We only need to set Driver Strength if the
1949 * preset value enable is not set.
1951 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1952 ctrl_2 &= ~SDHCI_CTRL_DRV_TYPE_MASK;
1953 if (ios->drv_type == MMC_SET_DRIVER_TYPE_A)
1954 ctrl_2 |= SDHCI_CTRL_DRV_TYPE_A;
1955 else if (ios->drv_type == MMC_SET_DRIVER_TYPE_B)
1956 ctrl_2 |= SDHCI_CTRL_DRV_TYPE_B;
1957 else if (ios->drv_type == MMC_SET_DRIVER_TYPE_C)
1958 ctrl_2 |= SDHCI_CTRL_DRV_TYPE_C;
1959 else if (ios->drv_type == MMC_SET_DRIVER_TYPE_D)
1960 ctrl_2 |= SDHCI_CTRL_DRV_TYPE_D;
1962 pr_warn("%s: invalid driver type, default to driver type B\n",
1964 ctrl_2 |= SDHCI_CTRL_DRV_TYPE_B;
1967 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
1970 * According to SDHC Spec v3.00, if the Preset Value
1971 * Enable in the Host Control 2 register is set, we
1972 * need to reset SD Clock Enable before changing High
1973 * Speed Enable to avoid generating clock gliches.
1976 /* Reset SD Clock Enable */
1977 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1978 clk &= ~SDHCI_CLOCK_CARD_EN;
1979 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1981 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1983 /* Re-enable SD Clock */
1984 host->ops->set_clock(host, host->clock);
1987 /* Reset SD Clock Enable */
1988 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1989 clk &= ~SDHCI_CLOCK_CARD_EN;
1990 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1992 host->ops->set_uhs_signaling(host, ios->timing);
1993 host->timing = ios->timing;
1995 if (!(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN) &&
1996 ((ios->timing == MMC_TIMING_UHS_SDR12) ||
1997 (ios->timing == MMC_TIMING_UHS_SDR25) ||
1998 (ios->timing == MMC_TIMING_UHS_SDR50) ||
1999 (ios->timing == MMC_TIMING_UHS_SDR104) ||
2000 (ios->timing == MMC_TIMING_UHS_DDR50) ||
2001 (ios->timing == MMC_TIMING_MMC_DDR52))) {
2004 sdhci_enable_preset_value(host, true);
2005 preset = sdhci_get_preset_value(host);
2006 ios->drv_type = (preset & SDHCI_PRESET_DRV_MASK)
2007 >> SDHCI_PRESET_DRV_SHIFT;
2010 /* Re-enable SD Clock */
2011 host->ops->set_clock(host, host->clock);
2013 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
2016 * Some (ENE) controllers go apeshit on some ios operation,
2017 * signalling timeout and CRC errors even on CMD0. Resetting
2018 * it on each ios seems to solve the problem.
2020 if (host->quirks & SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS)
2021 sdhci_do_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
2023 EXPORT_SYMBOL_GPL(sdhci_set_ios);
2025 static int sdhci_get_cd(struct mmc_host *mmc)
2027 struct sdhci_host *host = mmc_priv(mmc);
2028 int gpio_cd = mmc_gpio_get_cd(mmc);
2030 if (host->flags & SDHCI_DEVICE_DEAD)
2033 /* If nonremovable, assume that the card is always present. */
2034 if (!mmc_card_is_removable(host->mmc))
2038 * Try slot gpio detect, if defined it take precedence
2039 * over build in controller functionality
2044 /* If polling, assume that the card is always present. */
2045 if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
2048 /* Host native card detect */
2049 return !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT);
2052 static int sdhci_check_ro(struct sdhci_host *host)
2054 unsigned long flags;
2057 spin_lock_irqsave(&host->lock, flags);
2059 if (host->flags & SDHCI_DEVICE_DEAD)
2061 else if (host->ops->get_ro)
2062 is_readonly = host->ops->get_ro(host);
2063 else if (mmc_can_gpio_ro(host->mmc))
2064 is_readonly = mmc_gpio_get_ro(host->mmc);
2066 is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE)
2067 & SDHCI_WRITE_PROTECT);
2069 spin_unlock_irqrestore(&host->lock, flags);
2071 /* This quirk needs to be replaced by a callback-function later */
2072 return host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT ?
2073 !is_readonly : is_readonly;
2076 #define SAMPLE_COUNT 5
2078 static int sdhci_get_ro(struct mmc_host *mmc)
2080 struct sdhci_host *host = mmc_priv(mmc);
2083 if (!(host->quirks & SDHCI_QUIRK_UNSTABLE_RO_DETECT))
2084 return sdhci_check_ro(host);
2087 for (i = 0; i < SAMPLE_COUNT; i++) {
2088 if (sdhci_check_ro(host)) {
2089 if (++ro_count > SAMPLE_COUNT / 2)
2097 static void sdhci_hw_reset(struct mmc_host *mmc)
2099 struct sdhci_host *host = mmc_priv(mmc);
2101 if (host->ops && host->ops->hw_reset)
2102 host->ops->hw_reset(host);
2105 static void sdhci_enable_sdio_irq_nolock(struct sdhci_host *host, int enable)
2107 if (!(host->flags & SDHCI_DEVICE_DEAD)) {
2109 host->ier |= SDHCI_INT_CARD_INT;
2111 host->ier &= ~SDHCI_INT_CARD_INT;
2113 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2114 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2118 void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
2120 struct sdhci_host *host = mmc_priv(mmc);
2121 unsigned long flags;
2124 pm_runtime_get_noresume(host->mmc->parent);
2126 spin_lock_irqsave(&host->lock, flags);
2128 host->flags |= SDHCI_SDIO_IRQ_ENABLED;
2130 host->flags &= ~SDHCI_SDIO_IRQ_ENABLED;
2132 sdhci_enable_sdio_irq_nolock(host, enable);
2133 spin_unlock_irqrestore(&host->lock, flags);
2136 pm_runtime_put_noidle(host->mmc->parent);
2138 EXPORT_SYMBOL_GPL(sdhci_enable_sdio_irq);
2140 int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
2141 struct mmc_ios *ios)
2143 struct sdhci_host *host = mmc_priv(mmc);
2148 * Signal Voltage Switching is only applicable for Host Controllers
2151 if (host->version < SDHCI_SPEC_300)
2154 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2156 switch (ios->signal_voltage) {
2157 case MMC_SIGNAL_VOLTAGE_330:
2158 if (!(host->flags & SDHCI_SIGNALING_330))
2160 /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
2161 ctrl &= ~SDHCI_CTRL_VDD_180;
2162 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2164 if (!IS_ERR(mmc->supply.vqmmc)) {
2165 ret = mmc_regulator_set_vqmmc(mmc, ios);
2167 pr_warn("%s: Switching to 3.3V signalling voltage failed\n",
2173 usleep_range(5000, 5500);
2175 /* 3.3V regulator output should be stable within 5 ms */
2176 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2177 if (!(ctrl & SDHCI_CTRL_VDD_180))
2180 pr_warn("%s: 3.3V regulator output did not became stable\n",
2184 case MMC_SIGNAL_VOLTAGE_180:
2185 if (!(host->flags & SDHCI_SIGNALING_180))
2187 if (!IS_ERR(mmc->supply.vqmmc)) {
2188 ret = mmc_regulator_set_vqmmc(mmc, ios);
2190 pr_warn("%s: Switching to 1.8V signalling voltage failed\n",
2197 * Enable 1.8V Signal Enable in the Host Control2
2200 ctrl |= SDHCI_CTRL_VDD_180;
2201 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2203 /* Some controller need to do more when switching */
2204 if (host->ops->voltage_switch)
2205 host->ops->voltage_switch(host);
2207 /* 1.8V regulator output should be stable within 5 ms */
2208 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2209 if (ctrl & SDHCI_CTRL_VDD_180)
2212 pr_warn("%s: 1.8V regulator output did not became stable\n",
2216 case MMC_SIGNAL_VOLTAGE_120:
2217 if (!(host->flags & SDHCI_SIGNALING_120))
2219 if (!IS_ERR(mmc->supply.vqmmc)) {
2220 ret = mmc_regulator_set_vqmmc(mmc, ios);
2222 pr_warn("%s: Switching to 1.2V signalling voltage failed\n",
2229 /* No signal voltage switch required */
2233 EXPORT_SYMBOL_GPL(sdhci_start_signal_voltage_switch);
2235 static int sdhci_card_busy(struct mmc_host *mmc)
2237 struct sdhci_host *host = mmc_priv(mmc);
2240 /* Check whether DAT[0] is 0 */
2241 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
2243 return !(present_state & SDHCI_DATA_0_LVL_MASK);
2246 static int sdhci_prepare_hs400_tuning(struct mmc_host *mmc, struct mmc_ios *ios)
2248 struct sdhci_host *host = mmc_priv(mmc);
2249 unsigned long flags;
2251 spin_lock_irqsave(&host->lock, flags);
2252 host->flags |= SDHCI_HS400_TUNING;
2253 spin_unlock_irqrestore(&host->lock, flags);
2258 void sdhci_start_tuning(struct sdhci_host *host)
2262 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2263 ctrl |= SDHCI_CTRL_EXEC_TUNING;
2264 if (host->quirks2 & SDHCI_QUIRK2_TUNING_WORK_AROUND)
2265 ctrl |= SDHCI_CTRL_TUNED_CLK;
2266 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2269 * As per the Host Controller spec v3.00, tuning command
2270 * generates Buffer Read Ready interrupt, so enable that.
2272 * Note: The spec clearly says that when tuning sequence
2273 * is being performed, the controller does not generate
2274 * interrupts other than Buffer Read Ready interrupt. But
2275 * to make sure we don't hit a controller bug, we _only_
2276 * enable Buffer Read Ready interrupt here.
2278 sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_INT_ENABLE);
2279 sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_SIGNAL_ENABLE);
2281 EXPORT_SYMBOL_GPL(sdhci_start_tuning);
2283 void sdhci_end_tuning(struct sdhci_host *host)
2285 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2286 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2288 EXPORT_SYMBOL_GPL(sdhci_end_tuning);
2290 void sdhci_reset_tuning(struct sdhci_host *host)
2294 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2295 ctrl &= ~SDHCI_CTRL_TUNED_CLK;
2296 ctrl &= ~SDHCI_CTRL_EXEC_TUNING;
2297 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2299 EXPORT_SYMBOL_GPL(sdhci_reset_tuning);
2301 static void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode)
2303 sdhci_reset_tuning(host);
2305 sdhci_do_reset(host, SDHCI_RESET_CMD);
2306 sdhci_do_reset(host, SDHCI_RESET_DATA);
2308 sdhci_end_tuning(host);
2310 mmc_abort_tuning(host->mmc, opcode);
2314 * We use sdhci_send_tuning() because mmc_send_tuning() is not a good fit. SDHCI
2315 * tuning command does not have a data payload (or rather the hardware does it
2316 * automatically) so mmc_send_tuning() will return -EIO. Also the tuning command
2317 * interrupt setup is different to other commands and there is no timeout
2318 * interrupt so special handling is needed.
2320 void sdhci_send_tuning(struct sdhci_host *host, u32 opcode)
2322 struct mmc_host *mmc = host->mmc;
2323 struct mmc_command cmd = {};
2324 struct mmc_request mrq = {};
2325 unsigned long flags;
2326 u32 b = host->sdma_boundary;
2328 spin_lock_irqsave(&host->lock, flags);
2330 cmd.opcode = opcode;
2331 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
2336 * In response to CMD19, the card sends 64 bytes of tuning
2337 * block to the Host Controller. So we set the block size
2340 if (cmd.opcode == MMC_SEND_TUNING_BLOCK_HS200 &&
2341 mmc->ios.bus_width == MMC_BUS_WIDTH_8)
2342 sdhci_writew(host, SDHCI_MAKE_BLKSZ(b, 128), SDHCI_BLOCK_SIZE);
2344 sdhci_writew(host, SDHCI_MAKE_BLKSZ(b, 64), SDHCI_BLOCK_SIZE);
2347 * The tuning block is sent by the card to the host controller.
2348 * So we set the TRNS_READ bit in the Transfer Mode register.
2349 * This also takes care of setting DMA Enable and Multi Block
2350 * Select in the same register to 0.
2352 sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
2354 sdhci_send_command(host, &cmd);
2358 sdhci_del_timer(host, &mrq);
2360 host->tuning_done = 0;
2362 spin_unlock_irqrestore(&host->lock, flags);
2364 /* Wait for Buffer Read Ready interrupt */
2365 wait_event_timeout(host->buf_ready_int, (host->tuning_done == 1),
2366 msecs_to_jiffies(50));
2369 EXPORT_SYMBOL_GPL(sdhci_send_tuning);
2371 static int __sdhci_execute_tuning(struct sdhci_host *host, u32 opcode)
2376 * Issue opcode repeatedly till Execute Tuning is set to 0 or the number
2377 * of loops reaches tuning loop count.
2379 for (i = 0; i < host->tuning_loop_count; i++) {
2382 sdhci_send_tuning(host, opcode);
2384 if (!host->tuning_done) {
2385 pr_info("%s: Tuning timeout, falling back to fixed sampling clock\n",
2386 mmc_hostname(host->mmc));
2387 sdhci_abort_tuning(host, opcode);
2391 /* Spec does not require a delay between tuning cycles */
2392 if (host->tuning_delay > 0)
2393 mdelay(host->tuning_delay);
2395 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2396 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING)) {
2397 if (ctrl & SDHCI_CTRL_TUNED_CLK)
2398 return 0; /* Success! */
2404 pr_info("%s: Tuning failed, falling back to fixed sampling clock\n",
2405 mmc_hostname(host->mmc));
2406 sdhci_reset_tuning(host);
2410 int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
2412 struct sdhci_host *host = mmc_priv(mmc);
2414 unsigned int tuning_count = 0;
2417 hs400_tuning = host->flags & SDHCI_HS400_TUNING;
2419 if (host->tuning_mode == SDHCI_TUNING_MODE_1)
2420 tuning_count = host->tuning_count;
2423 * The Host Controller needs tuning in case of SDR104 and DDR50
2424 * mode, and for SDR50 mode when Use Tuning for SDR50 is set in
2425 * the Capabilities register.
2426 * If the Host Controller supports the HS200 mode then the
2427 * tuning function has to be executed.
2429 switch (host->timing) {
2430 /* HS400 tuning is done in HS200 mode */
2431 case MMC_TIMING_MMC_HS400:
2435 case MMC_TIMING_MMC_HS200:
2437 * Periodic re-tuning for HS400 is not expected to be needed, so
2444 case MMC_TIMING_UHS_SDR104:
2445 case MMC_TIMING_UHS_DDR50:
2448 case MMC_TIMING_UHS_SDR50:
2449 if (host->flags & SDHCI_SDR50_NEEDS_TUNING)
2457 if (host->ops->platform_execute_tuning) {
2458 err = host->ops->platform_execute_tuning(host, opcode);
2462 host->mmc->retune_period = tuning_count;
2464 if (host->tuning_delay < 0)
2465 host->tuning_delay = opcode == MMC_SEND_TUNING_BLOCK;
2467 sdhci_start_tuning(host);
2469 host->tuning_err = __sdhci_execute_tuning(host, opcode);
2471 sdhci_end_tuning(host);
2473 host->flags &= ~SDHCI_HS400_TUNING;
2477 EXPORT_SYMBOL_GPL(sdhci_execute_tuning);
2479 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable)
2481 /* Host Controller v3.00 defines preset value registers */
2482 if (host->version < SDHCI_SPEC_300)
2486 * We only enable or disable Preset Value if they are not already
2487 * enabled or disabled respectively. Otherwise, we bail out.
2489 if (host->preset_enabled != enable) {
2490 u16 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2493 ctrl |= SDHCI_CTRL_PRESET_VAL_ENABLE;
2495 ctrl &= ~SDHCI_CTRL_PRESET_VAL_ENABLE;
2497 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2500 host->flags |= SDHCI_PV_ENABLED;
2502 host->flags &= ~SDHCI_PV_ENABLED;
2504 host->preset_enabled = enable;
2508 static void sdhci_post_req(struct mmc_host *mmc, struct mmc_request *mrq,
2511 struct sdhci_host *host = mmc_priv(mmc);
2512 struct mmc_data *data = mrq->data;
2514 if (data->host_cookie != COOKIE_UNMAPPED)
2515 dma_unmap_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
2516 mmc_get_dma_dir(data));
2518 data->host_cookie = COOKIE_UNMAPPED;
2521 static void sdhci_pre_req(struct mmc_host *mmc, struct mmc_request *mrq)
2523 struct sdhci_host *host = mmc_priv(mmc);
2525 mrq->data->host_cookie = COOKIE_UNMAPPED;
2528 * No pre-mapping in the pre hook if we're using the bounce buffer,
2529 * for that we would need two bounce buffers since one buffer is
2530 * in flight when this is getting called.
2532 if (host->flags & SDHCI_REQ_USE_DMA && !host->bounce_buffer)
2533 sdhci_pre_dma_transfer(host, mrq->data, COOKIE_PRE_MAPPED);
2536 static void sdhci_error_out_mrqs(struct sdhci_host *host, int err)
2538 if (host->data_cmd) {
2539 host->data_cmd->error = err;
2540 sdhci_finish_mrq(host, host->data_cmd->mrq);
2544 host->cmd->error = err;
2545 sdhci_finish_mrq(host, host->cmd->mrq);
2549 static void sdhci_card_event(struct mmc_host *mmc)
2551 struct sdhci_host *host = mmc_priv(mmc);
2552 unsigned long flags;
2555 /* First check if client has provided their own card event */
2556 if (host->ops->card_event)
2557 host->ops->card_event(host);
2559 present = mmc->ops->get_cd(mmc);
2561 spin_lock_irqsave(&host->lock, flags);
2563 /* Check sdhci_has_requests() first in case we are runtime suspended */
2564 if (sdhci_has_requests(host) && !present) {
2565 pr_err("%s: Card removed during transfer!\n",
2566 mmc_hostname(host->mmc));
2567 pr_err("%s: Resetting controller.\n",
2568 mmc_hostname(host->mmc));
2570 sdhci_do_reset(host, SDHCI_RESET_CMD);
2571 sdhci_do_reset(host, SDHCI_RESET_DATA);
2573 sdhci_error_out_mrqs(host, -ENOMEDIUM);
2576 spin_unlock_irqrestore(&host->lock, flags);
2579 static const struct mmc_host_ops sdhci_ops = {
2580 .request = sdhci_request,
2581 .post_req = sdhci_post_req,
2582 .pre_req = sdhci_pre_req,
2583 .set_ios = sdhci_set_ios,
2584 .get_cd = sdhci_get_cd,
2585 .get_ro = sdhci_get_ro,
2586 .hw_reset = sdhci_hw_reset,
2587 .enable_sdio_irq = sdhci_enable_sdio_irq,
2588 .start_signal_voltage_switch = sdhci_start_signal_voltage_switch,
2589 .prepare_hs400_tuning = sdhci_prepare_hs400_tuning,
2590 .execute_tuning = sdhci_execute_tuning,
2591 .card_event = sdhci_card_event,
2592 .card_busy = sdhci_card_busy,
2595 /*****************************************************************************\
2599 \*****************************************************************************/
2601 static bool sdhci_request_done(struct sdhci_host *host)
2603 unsigned long flags;
2604 struct mmc_request *mrq;
2607 spin_lock_irqsave(&host->lock, flags);
2609 for (i = 0; i < SDHCI_MAX_MRQS; i++) {
2610 mrq = host->mrqs_done[i];
2616 spin_unlock_irqrestore(&host->lock, flags);
2621 * Always unmap the data buffers if they were mapped by
2622 * sdhci_prepare_data() whenever we finish with a request.
2623 * This avoids leaking DMA mappings on error.
2625 if (host->flags & SDHCI_REQ_USE_DMA) {
2626 struct mmc_data *data = mrq->data;
2628 if (data && data->host_cookie == COOKIE_MAPPED) {
2629 if (host->bounce_buffer) {
2631 * On reads, copy the bounced data into the
2634 if (mmc_get_dma_dir(data) == DMA_FROM_DEVICE) {
2635 unsigned int length = data->bytes_xfered;
2637 if (length > host->bounce_buffer_size) {
2638 pr_err("%s: bounce buffer is %u bytes but DMA claims to have transferred %u bytes\n",
2639 mmc_hostname(host->mmc),
2640 host->bounce_buffer_size,
2641 data->bytes_xfered);
2642 /* Cap it down and continue */
2643 length = host->bounce_buffer_size;
2645 dma_sync_single_for_cpu(
2648 host->bounce_buffer_size,
2650 sg_copy_from_buffer(data->sg,
2652 host->bounce_buffer,
2655 /* No copying, just switch ownership */
2656 dma_sync_single_for_cpu(
2659 host->bounce_buffer_size,
2660 mmc_get_dma_dir(data));
2663 /* Unmap the raw data */
2664 dma_unmap_sg(mmc_dev(host->mmc), data->sg,
2666 mmc_get_dma_dir(data));
2668 data->host_cookie = COOKIE_UNMAPPED;
2673 * The controller needs a reset of internal state machines
2674 * upon error conditions.
2676 if (sdhci_needs_reset(host, mrq)) {
2678 * Do not finish until command and data lines are available for
2679 * reset. Note there can only be one other mrq, so it cannot
2680 * also be in mrqs_done, otherwise host->cmd and host->data_cmd
2681 * would both be null.
2683 if (host->cmd || host->data_cmd) {
2684 spin_unlock_irqrestore(&host->lock, flags);
2688 /* Some controllers need this kick or reset won't work here */
2689 if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET)
2690 /* This is to force an update */
2691 host->ops->set_clock(host, host->clock);
2693 /* Spec says we should do both at the same time, but Ricoh
2694 controllers do not like that. */
2695 sdhci_do_reset(host, SDHCI_RESET_CMD);
2696 sdhci_do_reset(host, SDHCI_RESET_DATA);
2698 host->pending_reset = false;
2701 host->mrqs_done[i] = NULL;
2703 spin_unlock_irqrestore(&host->lock, flags);
2705 mmc_request_done(host->mmc, mrq);
2710 static void sdhci_complete_work(struct work_struct *work)
2712 struct sdhci_host *host = container_of(work, struct sdhci_host,
2715 while (!sdhci_request_done(host))
2719 static void sdhci_timeout_timer(struct timer_list *t)
2721 struct sdhci_host *host;
2722 unsigned long flags;
2724 host = from_timer(host, t, timer);
2726 spin_lock_irqsave(&host->lock, flags);
2728 if (host->cmd && !sdhci_data_line_cmd(host->cmd)) {
2729 pr_err("%s: Timeout waiting for hardware cmd interrupt.\n",
2730 mmc_hostname(host->mmc));
2731 sdhci_dumpregs(host);
2733 host->cmd->error = -ETIMEDOUT;
2734 sdhci_finish_mrq(host, host->cmd->mrq);
2737 spin_unlock_irqrestore(&host->lock, flags);
2740 static void sdhci_timeout_data_timer(struct timer_list *t)
2742 struct sdhci_host *host;
2743 unsigned long flags;
2745 host = from_timer(host, t, data_timer);
2747 spin_lock_irqsave(&host->lock, flags);
2749 if (host->data || host->data_cmd ||
2750 (host->cmd && sdhci_data_line_cmd(host->cmd))) {
2751 pr_err("%s: Timeout waiting for hardware interrupt.\n",
2752 mmc_hostname(host->mmc));
2753 sdhci_dumpregs(host);
2756 host->data->error = -ETIMEDOUT;
2757 sdhci_finish_data(host);
2758 queue_work(host->complete_wq, &host->complete_work);
2759 } else if (host->data_cmd) {
2760 host->data_cmd->error = -ETIMEDOUT;
2761 sdhci_finish_mrq(host, host->data_cmd->mrq);
2763 host->cmd->error = -ETIMEDOUT;
2764 sdhci_finish_mrq(host, host->cmd->mrq);
2768 spin_unlock_irqrestore(&host->lock, flags);
2771 /*****************************************************************************\
2773 * Interrupt handling *
2775 \*****************************************************************************/
2777 static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *intmask_p)
2779 /* Handle auto-CMD12 error */
2780 if (intmask & SDHCI_INT_AUTO_CMD_ERR && host->data_cmd) {
2781 struct mmc_request *mrq = host->data_cmd->mrq;
2782 u16 auto_cmd_status = sdhci_readw(host, SDHCI_AUTO_CMD_STATUS);
2783 int data_err_bit = (auto_cmd_status & SDHCI_AUTO_CMD_TIMEOUT) ?
2784 SDHCI_INT_DATA_TIMEOUT :
2787 /* Treat auto-CMD12 error the same as data error */
2788 if (!mrq->sbc && (host->flags & SDHCI_AUTO_CMD12)) {
2789 *intmask_p |= data_err_bit;
2796 * SDHCI recovers from errors by resetting the cmd and data
2797 * circuits. Until that is done, there very well might be more
2798 * interrupts, so ignore them in that case.
2800 if (host->pending_reset)
2802 pr_err("%s: Got command interrupt 0x%08x even though no command operation was in progress.\n",
2803 mmc_hostname(host->mmc), (unsigned)intmask);
2804 sdhci_dumpregs(host);
2808 if (intmask & (SDHCI_INT_TIMEOUT | SDHCI_INT_CRC |
2809 SDHCI_INT_END_BIT | SDHCI_INT_INDEX)) {
2810 if (intmask & SDHCI_INT_TIMEOUT)
2811 host->cmd->error = -ETIMEDOUT;
2813 host->cmd->error = -EILSEQ;
2815 /* Treat data command CRC error the same as data CRC error */
2816 if (host->cmd->data &&
2817 (intmask & (SDHCI_INT_CRC | SDHCI_INT_TIMEOUT)) ==
2820 *intmask_p |= SDHCI_INT_DATA_CRC;
2824 __sdhci_finish_mrq(host, host->cmd->mrq);
2828 /* Handle auto-CMD23 error */
2829 if (intmask & SDHCI_INT_AUTO_CMD_ERR) {
2830 struct mmc_request *mrq = host->cmd->mrq;
2831 u16 auto_cmd_status = sdhci_readw(host, SDHCI_AUTO_CMD_STATUS);
2832 int err = (auto_cmd_status & SDHCI_AUTO_CMD_TIMEOUT) ?
2836 if (mrq->sbc && (host->flags & SDHCI_AUTO_CMD23)) {
2837 mrq->sbc->error = err;
2838 __sdhci_finish_mrq(host, mrq);
2843 if (intmask & SDHCI_INT_RESPONSE)
2844 sdhci_finish_command(host);
2847 static void sdhci_adma_show_error(struct sdhci_host *host)
2849 void *desc = host->adma_table;
2851 sdhci_dumpregs(host);
2854 struct sdhci_adma2_64_desc *dma_desc = desc;
2856 if (host->flags & SDHCI_USE_64_BIT_DMA)
2857 DBG("%p: DMA 0x%08x%08x, LEN 0x%04x, Attr=0x%02x\n",
2858 desc, le32_to_cpu(dma_desc->addr_hi),
2859 le32_to_cpu(dma_desc->addr_lo),
2860 le16_to_cpu(dma_desc->len),
2861 le16_to_cpu(dma_desc->cmd));
2863 DBG("%p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
2864 desc, le32_to_cpu(dma_desc->addr_lo),
2865 le16_to_cpu(dma_desc->len),
2866 le16_to_cpu(dma_desc->cmd));
2868 desc += host->desc_sz;
2870 if (dma_desc->cmd & cpu_to_le16(ADMA2_END))
2875 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2879 /* CMD19 generates _only_ Buffer Read Ready interrupt */
2880 if (intmask & SDHCI_INT_DATA_AVAIL) {
2881 command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
2882 if (command == MMC_SEND_TUNING_BLOCK ||
2883 command == MMC_SEND_TUNING_BLOCK_HS200) {
2884 host->tuning_done = 1;
2885 wake_up(&host->buf_ready_int);
2891 struct mmc_command *data_cmd = host->data_cmd;
2894 * The "data complete" interrupt is also used to
2895 * indicate that a busy state has ended. See comment
2896 * above in sdhci_cmd_irq().
2898 if (data_cmd && (data_cmd->flags & MMC_RSP_BUSY)) {
2899 if (intmask & SDHCI_INT_DATA_TIMEOUT) {
2900 host->data_cmd = NULL;
2901 data_cmd->error = -ETIMEDOUT;
2902 __sdhci_finish_mrq(host, data_cmd->mrq);
2905 if (intmask & SDHCI_INT_DATA_END) {
2906 host->data_cmd = NULL;
2908 * Some cards handle busy-end interrupt
2909 * before the command completed, so make
2910 * sure we do things in the proper order.
2912 if (host->cmd == data_cmd)
2915 __sdhci_finish_mrq(host, data_cmd->mrq);
2921 * SDHCI recovers from errors by resetting the cmd and data
2922 * circuits. Until that is done, there very well might be more
2923 * interrupts, so ignore them in that case.
2925 if (host->pending_reset)
2928 pr_err("%s: Got data interrupt 0x%08x even though no data operation was in progress.\n",
2929 mmc_hostname(host->mmc), (unsigned)intmask);
2930 sdhci_dumpregs(host);
2935 if (intmask & SDHCI_INT_DATA_TIMEOUT)
2936 host->data->error = -ETIMEDOUT;
2937 else if (intmask & SDHCI_INT_DATA_END_BIT)
2938 host->data->error = -EILSEQ;
2939 else if ((intmask & SDHCI_INT_DATA_CRC) &&
2940 SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND))
2942 host->data->error = -EILSEQ;
2943 else if (intmask & SDHCI_INT_ADMA_ERROR) {
2944 pr_err("%s: ADMA error\n", mmc_hostname(host->mmc));
2945 sdhci_adma_show_error(host);
2946 host->data->error = -EIO;
2947 if (host->ops->adma_workaround)
2948 host->ops->adma_workaround(host, intmask);
2951 if (host->data->error)
2952 sdhci_finish_data(host);
2954 if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
2955 sdhci_transfer_pio(host);
2958 * We currently don't do anything fancy with DMA
2959 * boundaries, but as we can't disable the feature
2960 * we need to at least restart the transfer.
2962 * According to the spec sdhci_readl(host, SDHCI_DMA_ADDRESS)
2963 * should return a valid address to continue from, but as
2964 * some controllers are faulty, don't trust them.
2966 if (intmask & SDHCI_INT_DMA_END) {
2967 dma_addr_t dmastart, dmanow;
2969 dmastart = sdhci_sdma_address(host);
2970 dmanow = dmastart + host->data->bytes_xfered;
2972 * Force update to the next DMA block boundary.
2975 ~((dma_addr_t)SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) +
2976 SDHCI_DEFAULT_BOUNDARY_SIZE;
2977 host->data->bytes_xfered = dmanow - dmastart;
2978 DBG("DMA base %pad, transferred 0x%06x bytes, next %pad\n",
2979 &dmastart, host->data->bytes_xfered, &dmanow);
2980 sdhci_set_sdma_addr(host, dmanow);
2983 if (intmask & SDHCI_INT_DATA_END) {
2984 if (host->cmd == host->data_cmd) {
2986 * Data managed to finish before the
2987 * command completed. Make sure we do
2988 * things in the proper order.
2990 host->data_early = 1;
2992 sdhci_finish_data(host);
2998 static inline bool sdhci_defer_done(struct sdhci_host *host,
2999 struct mmc_request *mrq)
3001 struct mmc_data *data = mrq->data;
3003 return host->pending_reset ||
3004 ((host->flags & SDHCI_REQ_USE_DMA) && data &&
3005 data->host_cookie == COOKIE_MAPPED);
3008 static irqreturn_t sdhci_irq(int irq, void *dev_id)
3010 struct mmc_request *mrqs_done[SDHCI_MAX_MRQS] = {0};
3011 irqreturn_t result = IRQ_NONE;
3012 struct sdhci_host *host = dev_id;
3013 u32 intmask, mask, unexpected = 0;
3017 spin_lock(&host->lock);
3019 if (host->runtime_suspended && !sdhci_sdio_irq_enabled(host)) {
3020 spin_unlock(&host->lock);
3024 intmask = sdhci_readl(host, SDHCI_INT_STATUS);
3025 if (!intmask || intmask == 0xffffffff) {
3031 DBG("IRQ status 0x%08x\n", intmask);
3033 if (host->ops->irq) {
3034 intmask = host->ops->irq(host, intmask);
3039 /* Clear selected interrupts. */
3040 mask = intmask & (SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK |
3041 SDHCI_INT_BUS_POWER);
3042 sdhci_writel(host, mask, SDHCI_INT_STATUS);
3044 if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
3045 u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
3049 * There is a observation on i.mx esdhc. INSERT
3050 * bit will be immediately set again when it gets
3051 * cleared, if a card is inserted. We have to mask
3052 * the irq to prevent interrupt storm which will
3053 * freeze the system. And the REMOVE gets the
3056 * More testing are needed here to ensure it works
3057 * for other platforms though.
3059 host->ier &= ~(SDHCI_INT_CARD_INSERT |
3060 SDHCI_INT_CARD_REMOVE);
3061 host->ier |= present ? SDHCI_INT_CARD_REMOVE :
3062 SDHCI_INT_CARD_INSERT;
3063 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
3064 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
3066 sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
3067 SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
3069 host->thread_isr |= intmask & (SDHCI_INT_CARD_INSERT |
3070 SDHCI_INT_CARD_REMOVE);
3071 result = IRQ_WAKE_THREAD;
3074 if (intmask & SDHCI_INT_CMD_MASK)
3075 sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK, &intmask);
3077 if (intmask & SDHCI_INT_DATA_MASK)
3078 sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
3080 if (intmask & SDHCI_INT_BUS_POWER)
3081 pr_err("%s: Card is consuming too much power!\n",
3082 mmc_hostname(host->mmc));
3084 if (intmask & SDHCI_INT_RETUNE)
3085 mmc_retune_needed(host->mmc);
3087 if ((intmask & SDHCI_INT_CARD_INT) &&
3088 (host->ier & SDHCI_INT_CARD_INT)) {
3089 sdhci_enable_sdio_irq_nolock(host, false);
3090 host->thread_isr |= SDHCI_INT_CARD_INT;
3091 result = IRQ_WAKE_THREAD;
3094 intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE |
3095 SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK |
3096 SDHCI_INT_ERROR | SDHCI_INT_BUS_POWER |
3097 SDHCI_INT_RETUNE | SDHCI_INT_CARD_INT);
3100 unexpected |= intmask;
3101 sdhci_writel(host, intmask, SDHCI_INT_STATUS);
3104 if (result == IRQ_NONE)
3105 result = IRQ_HANDLED;
3107 intmask = sdhci_readl(host, SDHCI_INT_STATUS);
3108 } while (intmask && --max_loops);
3110 /* Determine if mrqs can be completed immediately */
3111 for (i = 0; i < SDHCI_MAX_MRQS; i++) {
3112 struct mmc_request *mrq = host->mrqs_done[i];
3117 if (sdhci_defer_done(host, mrq)) {
3118 result = IRQ_WAKE_THREAD;
3121 host->mrqs_done[i] = NULL;
3125 spin_unlock(&host->lock);
3127 /* Process mrqs ready for immediate completion */
3128 for (i = 0; i < SDHCI_MAX_MRQS; i++) {
3130 mmc_request_done(host->mmc, mrqs_done[i]);
3134 pr_err("%s: Unexpected interrupt 0x%08x.\n",
3135 mmc_hostname(host->mmc), unexpected);
3136 sdhci_dumpregs(host);
3142 static irqreturn_t sdhci_thread_irq(int irq, void *dev_id)
3144 struct sdhci_host *host = dev_id;
3145 unsigned long flags;
3148 while (!sdhci_request_done(host))
3151 spin_lock_irqsave(&host->lock, flags);
3152 isr = host->thread_isr;
3153 host->thread_isr = 0;
3154 spin_unlock_irqrestore(&host->lock, flags);
3156 if (isr & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
3157 struct mmc_host *mmc = host->mmc;
3159 mmc->ops->card_event(mmc);
3160 mmc_detect_change(mmc, msecs_to_jiffies(200));
3163 if (isr & SDHCI_INT_CARD_INT) {
3164 sdio_run_irqs(host->mmc);
3166 spin_lock_irqsave(&host->lock, flags);
3167 if (host->flags & SDHCI_SDIO_IRQ_ENABLED)
3168 sdhci_enable_sdio_irq_nolock(host, true);
3169 spin_unlock_irqrestore(&host->lock, flags);
3175 /*****************************************************************************\
3179 \*****************************************************************************/
3183 static bool sdhci_cd_irq_can_wakeup(struct sdhci_host *host)
3185 return mmc_card_is_removable(host->mmc) &&
3186 !(host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
3187 !mmc_can_gpio_cd(host->mmc);
3191 * To enable wakeup events, the corresponding events have to be enabled in
3192 * the Interrupt Status Enable register too. See 'Table 1-6: Wakeup Signal
3193 * Table' in the SD Host Controller Standard Specification.
3194 * It is useless to restore SDHCI_INT_ENABLE state in
3195 * sdhci_disable_irq_wakeups() since it will be set by
3196 * sdhci_enable_card_detection() or sdhci_init().
3198 static bool sdhci_enable_irq_wakeups(struct sdhci_host *host)
3200 u8 mask = SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE |
3206 if (sdhci_cd_irq_can_wakeup(host)) {
3207 wake_val |= SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE;
3208 irq_val |= SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE;
3211 if (mmc_card_wake_sdio_irq(host->mmc)) {
3212 wake_val |= SDHCI_WAKE_ON_INT;
3213 irq_val |= SDHCI_INT_CARD_INT;
3219 val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
3222 sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
3224 sdhci_writel(host, irq_val, SDHCI_INT_ENABLE);
3226 host->irq_wake_enabled = !enable_irq_wake(host->irq);
3228 return host->irq_wake_enabled;
3231 static void sdhci_disable_irq_wakeups(struct sdhci_host *host)
3234 u8 mask = SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE
3235 | SDHCI_WAKE_ON_INT;
3237 val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
3239 sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
3241 disable_irq_wake(host->irq);
3243 host->irq_wake_enabled = false;
3246 int sdhci_suspend_host(struct sdhci_host *host)
3248 sdhci_disable_card_detection(host);
3250 mmc_retune_timer_stop(host->mmc);
3252 if (!device_may_wakeup(mmc_dev(host->mmc)) ||
3253 !sdhci_enable_irq_wakeups(host)) {
3255 sdhci_writel(host, 0, SDHCI_INT_ENABLE);
3256 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
3257 free_irq(host->irq, host);
3263 EXPORT_SYMBOL_GPL(sdhci_suspend_host);
3265 int sdhci_resume_host(struct sdhci_host *host)
3267 struct mmc_host *mmc = host->mmc;
3270 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
3271 if (host->ops->enable_dma)
3272 host->ops->enable_dma(host);
3275 if ((host->mmc->pm_flags & MMC_PM_KEEP_POWER) &&
3276 (host->quirks2 & SDHCI_QUIRK2_HOST_OFF_CARD_ON)) {
3277 /* Card keeps power but host controller does not */
3278 sdhci_init(host, 0);
3281 mmc->ops->set_ios(mmc, &mmc->ios);
3283 sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
3286 if (host->irq_wake_enabled) {
3287 sdhci_disable_irq_wakeups(host);
3289 ret = request_threaded_irq(host->irq, sdhci_irq,
3290 sdhci_thread_irq, IRQF_SHARED,
3291 mmc_hostname(host->mmc), host);
3296 sdhci_enable_card_detection(host);
3301 EXPORT_SYMBOL_GPL(sdhci_resume_host);
3303 int sdhci_runtime_suspend_host(struct sdhci_host *host)
3305 unsigned long flags;
3307 mmc_retune_timer_stop(host->mmc);
3309 spin_lock_irqsave(&host->lock, flags);
3310 host->ier &= SDHCI_INT_CARD_INT;
3311 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
3312 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
3313 spin_unlock_irqrestore(&host->lock, flags);
3315 synchronize_hardirq(host->irq);
3317 spin_lock_irqsave(&host->lock, flags);
3318 host->runtime_suspended = true;
3319 spin_unlock_irqrestore(&host->lock, flags);
3323 EXPORT_SYMBOL_GPL(sdhci_runtime_suspend_host);
3325 int sdhci_runtime_resume_host(struct sdhci_host *host)
3327 struct mmc_host *mmc = host->mmc;
3328 unsigned long flags;
3329 int host_flags = host->flags;
3331 if (host_flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
3332 if (host->ops->enable_dma)
3333 host->ops->enable_dma(host);
3336 sdhci_init(host, 0);
3338 if (mmc->ios.power_mode != MMC_POWER_UNDEFINED &&
3339 mmc->ios.power_mode != MMC_POWER_OFF) {
3340 /* Force clock and power re-program */
3343 mmc->ops->start_signal_voltage_switch(mmc, &mmc->ios);
3344 mmc->ops->set_ios(mmc, &mmc->ios);
3346 if ((host_flags & SDHCI_PV_ENABLED) &&
3347 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) {
3348 spin_lock_irqsave(&host->lock, flags);
3349 sdhci_enable_preset_value(host, true);
3350 spin_unlock_irqrestore(&host->lock, flags);
3353 if ((mmc->caps2 & MMC_CAP2_HS400_ES) &&
3354 mmc->ops->hs400_enhanced_strobe)
3355 mmc->ops->hs400_enhanced_strobe(mmc, &mmc->ios);
3358 spin_lock_irqsave(&host->lock, flags);
3360 host->runtime_suspended = false;
3362 /* Enable SDIO IRQ */
3363 if (host->flags & SDHCI_SDIO_IRQ_ENABLED)
3364 sdhci_enable_sdio_irq_nolock(host, true);
3366 /* Enable Card Detection */
3367 sdhci_enable_card_detection(host);
3369 spin_unlock_irqrestore(&host->lock, flags);
3373 EXPORT_SYMBOL_GPL(sdhci_runtime_resume_host);
3375 #endif /* CONFIG_PM */
3377 /*****************************************************************************\
3379 * Command Queue Engine (CQE) helpers *
3381 \*****************************************************************************/
3383 void sdhci_cqe_enable(struct mmc_host *mmc)
3385 struct sdhci_host *host = mmc_priv(mmc);
3386 unsigned long flags;
3389 spin_lock_irqsave(&host->lock, flags);
3391 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
3392 ctrl &= ~SDHCI_CTRL_DMA_MASK;
3394 * Host from V4.10 supports ADMA3 DMA type.
3395 * ADMA3 performs integrated descriptor which is more suitable
3396 * for cmd queuing to fetch both command and transfer descriptors.
3398 if (host->v4_mode && (host->caps1 & SDHCI_CAN_DO_ADMA3))
3399 ctrl |= SDHCI_CTRL_ADMA3;
3400 else if (host->flags & SDHCI_USE_64_BIT_DMA)
3401 ctrl |= SDHCI_CTRL_ADMA64;
3403 ctrl |= SDHCI_CTRL_ADMA32;
3404 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
3406 sdhci_writew(host, SDHCI_MAKE_BLKSZ(host->sdma_boundary, 512),
3409 /* Set maximum timeout */
3410 sdhci_set_timeout(host, NULL);
3412 host->ier = host->cqe_ier;
3414 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
3415 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
3417 host->cqe_on = true;
3419 pr_debug("%s: sdhci: CQE on, IRQ mask %#x, IRQ status %#x\n",
3420 mmc_hostname(mmc), host->ier,
3421 sdhci_readl(host, SDHCI_INT_STATUS));
3423 spin_unlock_irqrestore(&host->lock, flags);
3425 EXPORT_SYMBOL_GPL(sdhci_cqe_enable);
3427 void sdhci_cqe_disable(struct mmc_host *mmc, bool recovery)
3429 struct sdhci_host *host = mmc_priv(mmc);
3430 unsigned long flags;
3432 spin_lock_irqsave(&host->lock, flags);
3434 sdhci_set_default_irqs(host);
3436 host->cqe_on = false;
3439 sdhci_do_reset(host, SDHCI_RESET_CMD);
3440 sdhci_do_reset(host, SDHCI_RESET_DATA);
3443 pr_debug("%s: sdhci: CQE off, IRQ mask %#x, IRQ status %#x\n",
3444 mmc_hostname(mmc), host->ier,
3445 sdhci_readl(host, SDHCI_INT_STATUS));
3447 spin_unlock_irqrestore(&host->lock, flags);
3449 EXPORT_SYMBOL_GPL(sdhci_cqe_disable);
3451 bool sdhci_cqe_irq(struct sdhci_host *host, u32 intmask, int *cmd_error,
3459 if (intmask & (SDHCI_INT_INDEX | SDHCI_INT_END_BIT | SDHCI_INT_CRC))
3460 *cmd_error = -EILSEQ;
3461 else if (intmask & SDHCI_INT_TIMEOUT)
3462 *cmd_error = -ETIMEDOUT;
3466 if (intmask & (SDHCI_INT_DATA_END_BIT | SDHCI_INT_DATA_CRC))
3467 *data_error = -EILSEQ;
3468 else if (intmask & SDHCI_INT_DATA_TIMEOUT)
3469 *data_error = -ETIMEDOUT;
3470 else if (intmask & SDHCI_INT_ADMA_ERROR)
3475 /* Clear selected interrupts. */
3476 mask = intmask & host->cqe_ier;
3477 sdhci_writel(host, mask, SDHCI_INT_STATUS);
3479 if (intmask & SDHCI_INT_BUS_POWER)
3480 pr_err("%s: Card is consuming too much power!\n",
3481 mmc_hostname(host->mmc));
3483 intmask &= ~(host->cqe_ier | SDHCI_INT_ERROR);
3485 sdhci_writel(host, intmask, SDHCI_INT_STATUS);
3486 pr_err("%s: CQE: Unexpected interrupt 0x%08x.\n",
3487 mmc_hostname(host->mmc), intmask);
3488 sdhci_dumpregs(host);
3493 EXPORT_SYMBOL_GPL(sdhci_cqe_irq);
3495 /*****************************************************************************\
3497 * Device allocation/registration *
3499 \*****************************************************************************/
3501 struct sdhci_host *sdhci_alloc_host(struct device *dev,
3504 struct mmc_host *mmc;
3505 struct sdhci_host *host;
3507 WARN_ON(dev == NULL);
3509 mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev);
3511 return ERR_PTR(-ENOMEM);
3513 host = mmc_priv(mmc);
3515 host->mmc_host_ops = sdhci_ops;
3516 mmc->ops = &host->mmc_host_ops;
3518 host->flags = SDHCI_SIGNALING_330;
3520 host->cqe_ier = SDHCI_CQE_INT_MASK;
3521 host->cqe_err_ier = SDHCI_CQE_INT_ERR_MASK;
3523 host->tuning_delay = -1;
3524 host->tuning_loop_count = MAX_TUNING_LOOP;
3526 host->sdma_boundary = SDHCI_DEFAULT_BOUNDARY_ARG;
3529 * The DMA table descriptor count is calculated as the maximum
3530 * number of segments times 2, to allow for an alignment
3531 * descriptor for each segment, plus 1 for a nop end descriptor.
3533 host->adma_table_cnt = SDHCI_MAX_SEGS * 2 + 1;
3538 EXPORT_SYMBOL_GPL(sdhci_alloc_host);
3540 static int sdhci_set_dma_mask(struct sdhci_host *host)
3542 struct mmc_host *mmc = host->mmc;
3543 struct device *dev = mmc_dev(mmc);
3546 if (host->quirks2 & SDHCI_QUIRK2_BROKEN_64_BIT_DMA)
3547 host->flags &= ~SDHCI_USE_64_BIT_DMA;
3549 /* Try 64-bit mask if hardware is capable of it */
3550 if (host->flags & SDHCI_USE_64_BIT_DMA) {
3551 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
3553 pr_warn("%s: Failed to set 64-bit DMA mask.\n",
3555 host->flags &= ~SDHCI_USE_64_BIT_DMA;
3559 /* 32-bit mask as default & fallback */
3561 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
3563 pr_warn("%s: Failed to set 32-bit DMA mask.\n",
3570 void __sdhci_read_caps(struct sdhci_host *host, u16 *ver, u32 *caps, u32 *caps1)
3573 u64 dt_caps_mask = 0;
3576 if (host->read_caps)
3579 host->read_caps = true;
3582 host->quirks = debug_quirks;
3585 host->quirks2 = debug_quirks2;
3587 sdhci_do_reset(host, SDHCI_RESET_ALL);
3590 sdhci_do_enable_v4_mode(host);
3592 of_property_read_u64(mmc_dev(host->mmc)->of_node,
3593 "sdhci-caps-mask", &dt_caps_mask);
3594 of_property_read_u64(mmc_dev(host->mmc)->of_node,
3595 "sdhci-caps", &dt_caps);
3597 v = ver ? *ver : sdhci_readw(host, SDHCI_HOST_VERSION);
3598 host->version = (v & SDHCI_SPEC_VER_MASK) >> SDHCI_SPEC_VER_SHIFT;
3600 if (host->quirks & SDHCI_QUIRK_MISSING_CAPS)
3606 host->caps = sdhci_readl(host, SDHCI_CAPABILITIES);
3607 host->caps &= ~lower_32_bits(dt_caps_mask);
3608 host->caps |= lower_32_bits(dt_caps);
3611 if (host->version < SDHCI_SPEC_300)
3615 host->caps1 = *caps1;
3617 host->caps1 = sdhci_readl(host, SDHCI_CAPABILITIES_1);
3618 host->caps1 &= ~upper_32_bits(dt_caps_mask);
3619 host->caps1 |= upper_32_bits(dt_caps);
3622 EXPORT_SYMBOL_GPL(__sdhci_read_caps);
3624 static void sdhci_allocate_bounce_buffer(struct sdhci_host *host)
3626 struct mmc_host *mmc = host->mmc;
3627 unsigned int max_blocks;
3628 unsigned int bounce_size;
3632 * Cap the bounce buffer at 64KB. Using a bigger bounce buffer
3633 * has diminishing returns, this is probably because SD/MMC
3634 * cards are usually optimized to handle this size of requests.
3636 bounce_size = SZ_64K;
3638 * Adjust downwards to maximum request size if this is less
3639 * than our segment size, else hammer down the maximum
3640 * request size to the maximum buffer size.
3642 if (mmc->max_req_size < bounce_size)
3643 bounce_size = mmc->max_req_size;
3644 max_blocks = bounce_size / 512;
3647 * When we just support one segment, we can get significant
3648 * speedups by the help of a bounce buffer to group scattered
3649 * reads/writes together.
3651 host->bounce_buffer = devm_kmalloc(mmc->parent,
3654 if (!host->bounce_buffer) {
3655 pr_err("%s: failed to allocate %u bytes for bounce buffer, falling back to single segments\n",
3659 * Exiting with zero here makes sure we proceed with
3660 * mmc->max_segs == 1.
3665 host->bounce_addr = dma_map_single(mmc->parent,
3666 host->bounce_buffer,
3669 ret = dma_mapping_error(mmc->parent, host->bounce_addr);
3671 /* Again fall back to max_segs == 1 */
3673 host->bounce_buffer_size = bounce_size;
3675 /* Lie about this since we're bouncing */
3676 mmc->max_segs = max_blocks;
3677 mmc->max_seg_size = bounce_size;
3678 mmc->max_req_size = bounce_size;
3680 pr_info("%s bounce up to %u segments into one, max segment size %u bytes\n",
3681 mmc_hostname(mmc), max_blocks, bounce_size);
3684 static inline bool sdhci_can_64bit_dma(struct sdhci_host *host)
3687 * According to SD Host Controller spec v4.10, bit[27] added from
3688 * version 4.10 in Capabilities Register is used as 64-bit System
3689 * Address support for V4 mode.
3691 if (host->version >= SDHCI_SPEC_410 && host->v4_mode)
3692 return host->caps & SDHCI_CAN_64BIT_V4;
3694 return host->caps & SDHCI_CAN_64BIT;
3697 int sdhci_setup_host(struct sdhci_host *host)
3699 struct mmc_host *mmc;
3700 u32 max_current_caps;
3701 unsigned int ocr_avail;
3702 unsigned int override_timeout_clk;
3706 WARN_ON(host == NULL);
3713 * If there are external regulators, get them. Note this must be done
3714 * early before resetting the host and reading the capabilities so that
3715 * the host can take the appropriate action if regulators are not
3718 ret = mmc_regulator_get_supply(mmc);
3722 DBG("Version: 0x%08x | Present: 0x%08x\n",
3723 sdhci_readw(host, SDHCI_HOST_VERSION),
3724 sdhci_readl(host, SDHCI_PRESENT_STATE));
3725 DBG("Caps: 0x%08x | Caps_1: 0x%08x\n",
3726 sdhci_readl(host, SDHCI_CAPABILITIES),
3727 sdhci_readl(host, SDHCI_CAPABILITIES_1));
3729 sdhci_read_caps(host);
3731 override_timeout_clk = host->timeout_clk;
3733 if (host->version > SDHCI_SPEC_420) {
3734 pr_err("%s: Unknown controller version (%d). You may experience problems.\n",
3735 mmc_hostname(mmc), host->version);
3738 if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
3739 host->flags |= SDHCI_USE_SDMA;
3740 else if (!(host->caps & SDHCI_CAN_DO_SDMA))
3741 DBG("Controller doesn't have SDMA capability\n");
3743 host->flags |= SDHCI_USE_SDMA;
3745 if ((host->quirks & SDHCI_QUIRK_BROKEN_DMA) &&
3746 (host->flags & SDHCI_USE_SDMA)) {
3747 DBG("Disabling DMA as it is marked broken\n");
3748 host->flags &= ~SDHCI_USE_SDMA;
3751 if ((host->version >= SDHCI_SPEC_200) &&
3752 (host->caps & SDHCI_CAN_DO_ADMA2))
3753 host->flags |= SDHCI_USE_ADMA;
3755 if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
3756 (host->flags & SDHCI_USE_ADMA)) {
3757 DBG("Disabling ADMA as it is marked broken\n");
3758 host->flags &= ~SDHCI_USE_ADMA;
3762 * It is assumed that a 64-bit capable device has set a 64-bit DMA mask
3763 * and *must* do 64-bit DMA. A driver has the opportunity to change
3764 * that during the first call to ->enable_dma(). Similarly
3765 * SDHCI_QUIRK2_BROKEN_64_BIT_DMA must be left to the drivers to
3768 if (sdhci_can_64bit_dma(host))
3769 host->flags |= SDHCI_USE_64_BIT_DMA;
3771 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
3772 ret = sdhci_set_dma_mask(host);
3774 if (!ret && host->ops->enable_dma)
3775 ret = host->ops->enable_dma(host);
3778 pr_warn("%s: No suitable DMA available - falling back to PIO\n",
3780 host->flags &= ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA);
3786 /* SDMA does not support 64-bit DMA if v4 mode not set */
3787 if ((host->flags & SDHCI_USE_64_BIT_DMA) && !host->v4_mode)
3788 host->flags &= ~SDHCI_USE_SDMA;
3790 if (host->flags & SDHCI_USE_ADMA) {
3794 if (host->flags & SDHCI_USE_64_BIT_DMA) {
3795 host->adma_table_sz = host->adma_table_cnt *
3796 SDHCI_ADMA2_64_DESC_SZ(host);
3797 host->desc_sz = SDHCI_ADMA2_64_DESC_SZ(host);
3799 host->adma_table_sz = host->adma_table_cnt *
3800 SDHCI_ADMA2_32_DESC_SZ;
3801 host->desc_sz = SDHCI_ADMA2_32_DESC_SZ;
3804 host->align_buffer_sz = SDHCI_MAX_SEGS * SDHCI_ADMA2_ALIGN;
3806 * Use zalloc to zero the reserved high 32-bits of 128-bit
3807 * descriptors so that they never need to be written.
3809 buf = dma_alloc_coherent(mmc_dev(mmc),
3810 host->align_buffer_sz + host->adma_table_sz,
3813 pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n",
3815 host->flags &= ~SDHCI_USE_ADMA;
3816 } else if ((dma + host->align_buffer_sz) &
3817 (SDHCI_ADMA2_DESC_ALIGN - 1)) {
3818 pr_warn("%s: unable to allocate aligned ADMA descriptor\n",
3820 host->flags &= ~SDHCI_USE_ADMA;
3821 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz +
3822 host->adma_table_sz, buf, dma);
3824 host->align_buffer = buf;
3825 host->align_addr = dma;
3827 host->adma_table = buf + host->align_buffer_sz;
3828 host->adma_addr = dma + host->align_buffer_sz;
3833 * If we use DMA, then it's up to the caller to set the DMA
3834 * mask, but PIO does not need the hw shim so we set a new
3835 * mask here in that case.
3837 if (!(host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))) {
3838 host->dma_mask = DMA_BIT_MASK(64);
3839 mmc_dev(mmc)->dma_mask = &host->dma_mask;
3842 if (host->version >= SDHCI_SPEC_300)
3843 host->max_clk = (host->caps & SDHCI_CLOCK_V3_BASE_MASK)
3844 >> SDHCI_CLOCK_BASE_SHIFT;
3846 host->max_clk = (host->caps & SDHCI_CLOCK_BASE_MASK)
3847 >> SDHCI_CLOCK_BASE_SHIFT;
3849 host->max_clk *= 1000000;
3850 if (host->max_clk == 0 || host->quirks &
3851 SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN) {
3852 if (!host->ops->get_max_clock) {
3853 pr_err("%s: Hardware doesn't specify base clock frequency.\n",
3858 host->max_clk = host->ops->get_max_clock(host);
3862 * In case of Host Controller v3.00, find out whether clock
3863 * multiplier is supported.
3865 host->clk_mul = (host->caps1 & SDHCI_CLOCK_MUL_MASK) >>
3866 SDHCI_CLOCK_MUL_SHIFT;
3869 * In case the value in Clock Multiplier is 0, then programmable
3870 * clock mode is not supported, otherwise the actual clock
3871 * multiplier is one more than the value of Clock Multiplier
3872 * in the Capabilities Register.
3878 * Set host parameters.
3880 max_clk = host->max_clk;
3882 if (host->ops->get_min_clock)
3883 mmc->f_min = host->ops->get_min_clock(host);
3884 else if (host->version >= SDHCI_SPEC_300) {
3885 if (host->clk_mul) {
3886 mmc->f_min = (host->max_clk * host->clk_mul) / 1024;
3887 max_clk = host->max_clk * host->clk_mul;
3889 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300;
3891 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
3893 if (!mmc->f_max || mmc->f_max > max_clk)
3894 mmc->f_max = max_clk;
3896 if (!(host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
3897 host->timeout_clk = (host->caps & SDHCI_TIMEOUT_CLK_MASK) >>
3898 SDHCI_TIMEOUT_CLK_SHIFT;
3900 if (host->caps & SDHCI_TIMEOUT_CLK_UNIT)
3901 host->timeout_clk *= 1000;
3903 if (host->timeout_clk == 0) {
3904 if (!host->ops->get_timeout_clock) {
3905 pr_err("%s: Hardware doesn't specify timeout clock frequency.\n",
3912 DIV_ROUND_UP(host->ops->get_timeout_clock(host),
3916 if (override_timeout_clk)
3917 host->timeout_clk = override_timeout_clk;
3919 mmc->max_busy_timeout = host->ops->get_max_timeout_count ?
3920 host->ops->get_max_timeout_count(host) : 1 << 27;
3921 mmc->max_busy_timeout /= host->timeout_clk;
3924 if (host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT &&
3925 !host->ops->get_max_timeout_count)
3926 mmc->max_busy_timeout = 0;
3928 mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
3929 mmc->caps2 |= MMC_CAP2_SDIO_IRQ_NOTHREAD;
3931 if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12)
3932 host->flags |= SDHCI_AUTO_CMD12;
3935 * For v3 mode, Auto-CMD23 stuff only works in ADMA or PIO.
3936 * For v4 mode, SDMA may use Auto-CMD23 as well.
3938 if ((host->version >= SDHCI_SPEC_300) &&
3939 ((host->flags & SDHCI_USE_ADMA) ||
3940 !(host->flags & SDHCI_USE_SDMA) || host->v4_mode) &&
3941 !(host->quirks2 & SDHCI_QUIRK2_ACMD23_BROKEN)) {
3942 host->flags |= SDHCI_AUTO_CMD23;
3943 DBG("Auto-CMD23 available\n");
3945 DBG("Auto-CMD23 unavailable\n");
3949 * A controller may support 8-bit width, but the board itself
3950 * might not have the pins brought out. Boards that support
3951 * 8-bit width must set "mmc->caps |= MMC_CAP_8_BIT_DATA;" in
3952 * their platform code before calling sdhci_add_host(), and we
3953 * won't assume 8-bit width for hosts without that CAP.
3955 if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA))
3956 mmc->caps |= MMC_CAP_4_BIT_DATA;
3958 if (host->quirks2 & SDHCI_QUIRK2_HOST_NO_CMD23)
3959 mmc->caps &= ~MMC_CAP_CMD23;
3961 if (host->caps & SDHCI_CAN_DO_HISPD)
3962 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
3964 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
3965 mmc_card_is_removable(mmc) &&
3966 mmc_gpio_get_cd(host->mmc) < 0)
3967 mmc->caps |= MMC_CAP_NEEDS_POLL;
3969 if (!IS_ERR(mmc->supply.vqmmc)) {
3970 ret = regulator_enable(mmc->supply.vqmmc);
3972 /* If vqmmc provides no 1.8V signalling, then there's no UHS */
3973 if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
3975 host->caps1 &= ~(SDHCI_SUPPORT_SDR104 |
3976 SDHCI_SUPPORT_SDR50 |
3977 SDHCI_SUPPORT_DDR50);
3979 /* In eMMC case vqmmc might be a fixed 1.8V regulator */
3980 if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000,
3982 host->flags &= ~SDHCI_SIGNALING_330;
3985 pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
3986 mmc_hostname(mmc), ret);
3987 mmc->supply.vqmmc = ERR_PTR(-EINVAL);
3991 if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) {
3992 host->caps1 &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
3993 SDHCI_SUPPORT_DDR50);
3995 * The SDHCI controller in a SoC might support HS200/HS400
3996 * (indicated using mmc-hs200-1_8v/mmc-hs400-1_8v dt property),
3997 * but if the board is modeled such that the IO lines are not
3998 * connected to 1.8v then HS200/HS400 cannot be supported.
3999 * Disable HS200/HS400 if the board does not have 1.8v connected
4000 * to the IO lines. (Applicable for other modes in 1.8v)
4002 mmc->caps2 &= ~(MMC_CAP2_HSX00_1_8V | MMC_CAP2_HS400_ES);
4003 mmc->caps &= ~(MMC_CAP_1_8V_DDR | MMC_CAP_UHS);
4006 /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
4007 if (host->caps1 & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
4008 SDHCI_SUPPORT_DDR50))
4009 mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25;
4011 /* SDR104 supports also implies SDR50 support */
4012 if (host->caps1 & SDHCI_SUPPORT_SDR104) {
4013 mmc->caps |= MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_SDR50;
4014 /* SD3.0: SDR104 is supported so (for eMMC) the caps2
4015 * field can be promoted to support HS200.
4017 if (!(host->quirks2 & SDHCI_QUIRK2_BROKEN_HS200))
4018 mmc->caps2 |= MMC_CAP2_HS200;
4019 } else if (host->caps1 & SDHCI_SUPPORT_SDR50) {
4020 mmc->caps |= MMC_CAP_UHS_SDR50;
4023 if (host->quirks2 & SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400 &&
4024 (host->caps1 & SDHCI_SUPPORT_HS400))
4025 mmc->caps2 |= MMC_CAP2_HS400;
4027 if ((mmc->caps2 & MMC_CAP2_HSX00_1_2V) &&
4028 (IS_ERR(mmc->supply.vqmmc) ||
4029 !regulator_is_supported_voltage(mmc->supply.vqmmc, 1100000,
4031 mmc->caps2 &= ~MMC_CAP2_HSX00_1_2V;
4033 if ((host->caps1 & SDHCI_SUPPORT_DDR50) &&
4034 !(host->quirks2 & SDHCI_QUIRK2_BROKEN_DDR50))
4035 mmc->caps |= MMC_CAP_UHS_DDR50;
4037 /* Does the host need tuning for SDR50? */
4038 if (host->caps1 & SDHCI_USE_SDR50_TUNING)
4039 host->flags |= SDHCI_SDR50_NEEDS_TUNING;
4041 /* Driver Type(s) (A, C, D) supported by the host */
4042 if (host->caps1 & SDHCI_DRIVER_TYPE_A)
4043 mmc->caps |= MMC_CAP_DRIVER_TYPE_A;
4044 if (host->caps1 & SDHCI_DRIVER_TYPE_C)
4045 mmc->caps |= MMC_CAP_DRIVER_TYPE_C;
4046 if (host->caps1 & SDHCI_DRIVER_TYPE_D)
4047 mmc->caps |= MMC_CAP_DRIVER_TYPE_D;
4049 /* Initial value for re-tuning timer count */
4050 host->tuning_count = (host->caps1 & SDHCI_RETUNING_TIMER_COUNT_MASK) >>
4051 SDHCI_RETUNING_TIMER_COUNT_SHIFT;
4054 * In case Re-tuning Timer is not disabled, the actual value of
4055 * re-tuning timer will be 2 ^ (n - 1).
4057 if (host->tuning_count)
4058 host->tuning_count = 1 << (host->tuning_count - 1);
4060 /* Re-tuning mode supported by the Host Controller */
4061 host->tuning_mode = (host->caps1 & SDHCI_RETUNING_MODE_MASK) >>
4062 SDHCI_RETUNING_MODE_SHIFT;
4067 * According to SD Host Controller spec v3.00, if the Host System
4068 * can afford more than 150mA, Host Driver should set XPC to 1. Also
4069 * the value is meaningful only if Voltage Support in the Capabilities
4070 * register is set. The actual current value is 4 times the register
4073 max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
4074 if (!max_current_caps && !IS_ERR(mmc->supply.vmmc)) {
4075 int curr = regulator_get_current_limit(mmc->supply.vmmc);
4078 /* convert to SDHCI_MAX_CURRENT format */
4079 curr = curr/1000; /* convert to mA */
4080 curr = curr/SDHCI_MAX_CURRENT_MULTIPLIER;
4082 curr = min_t(u32, curr, SDHCI_MAX_CURRENT_LIMIT);
4084 (curr << SDHCI_MAX_CURRENT_330_SHIFT) |
4085 (curr << SDHCI_MAX_CURRENT_300_SHIFT) |
4086 (curr << SDHCI_MAX_CURRENT_180_SHIFT);
4090 if (host->caps & SDHCI_CAN_VDD_330) {
4091 ocr_avail |= MMC_VDD_32_33 | MMC_VDD_33_34;
4093 mmc->max_current_330 = ((max_current_caps &
4094 SDHCI_MAX_CURRENT_330_MASK) >>
4095 SDHCI_MAX_CURRENT_330_SHIFT) *
4096 SDHCI_MAX_CURRENT_MULTIPLIER;
4098 if (host->caps & SDHCI_CAN_VDD_300) {
4099 ocr_avail |= MMC_VDD_29_30 | MMC_VDD_30_31;
4101 mmc->max_current_300 = ((max_current_caps &
4102 SDHCI_MAX_CURRENT_300_MASK) >>
4103 SDHCI_MAX_CURRENT_300_SHIFT) *
4104 SDHCI_MAX_CURRENT_MULTIPLIER;
4106 if (host->caps & SDHCI_CAN_VDD_180) {
4107 ocr_avail |= MMC_VDD_165_195;
4109 mmc->max_current_180 = ((max_current_caps &
4110 SDHCI_MAX_CURRENT_180_MASK) >>
4111 SDHCI_MAX_CURRENT_180_SHIFT) *
4112 SDHCI_MAX_CURRENT_MULTIPLIER;
4115 /* If OCR set by host, use it instead. */
4117 ocr_avail = host->ocr_mask;
4119 /* If OCR set by external regulators, give it highest prio. */
4121 ocr_avail = mmc->ocr_avail;
4123 mmc->ocr_avail = ocr_avail;
4124 mmc->ocr_avail_sdio = ocr_avail;
4125 if (host->ocr_avail_sdio)
4126 mmc->ocr_avail_sdio &= host->ocr_avail_sdio;
4127 mmc->ocr_avail_sd = ocr_avail;
4128 if (host->ocr_avail_sd)
4129 mmc->ocr_avail_sd &= host->ocr_avail_sd;
4130 else /* normal SD controllers don't support 1.8V */
4131 mmc->ocr_avail_sd &= ~MMC_VDD_165_195;
4132 mmc->ocr_avail_mmc = ocr_avail;
4133 if (host->ocr_avail_mmc)
4134 mmc->ocr_avail_mmc &= host->ocr_avail_mmc;
4136 if (mmc->ocr_avail == 0) {
4137 pr_err("%s: Hardware doesn't report any support voltages.\n",
4143 if ((mmc->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
4144 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
4145 MMC_CAP_UHS_DDR50 | MMC_CAP_1_8V_DDR)) ||
4146 (mmc->caps2 & (MMC_CAP2_HS200_1_8V_SDR | MMC_CAP2_HS400_1_8V)))
4147 host->flags |= SDHCI_SIGNALING_180;
4149 if (mmc->caps2 & MMC_CAP2_HSX00_1_2V)
4150 host->flags |= SDHCI_SIGNALING_120;
4152 spin_lock_init(&host->lock);
4155 * Maximum number of sectors in one transfer. Limited by SDMA boundary
4156 * size (512KiB). Note some tuning modes impose a 4MiB limit, but this
4159 mmc->max_req_size = 524288;
4162 * Maximum number of segments. Depends on if the hardware
4163 * can do scatter/gather or not.
4165 if (host->flags & SDHCI_USE_ADMA) {
4166 mmc->max_segs = SDHCI_MAX_SEGS;
4167 } else if (host->flags & SDHCI_USE_SDMA) {
4169 if (swiotlb_max_segment()) {
4170 unsigned int max_req_size = (1 << IO_TLB_SHIFT) *
4172 mmc->max_req_size = min(mmc->max_req_size,
4176 mmc->max_segs = SDHCI_MAX_SEGS;
4180 * Maximum segment size. Could be one segment with the maximum number
4181 * of bytes. When doing hardware scatter/gather, each entry cannot
4182 * be larger than 64 KiB though.
4184 if (host->flags & SDHCI_USE_ADMA) {
4185 if (host->quirks & SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC)
4186 mmc->max_seg_size = 65535;
4188 mmc->max_seg_size = 65536;
4190 mmc->max_seg_size = mmc->max_req_size;
4194 * Maximum block size. This varies from controller to controller and
4195 * is specified in the capabilities register.
4197 if (host->quirks & SDHCI_QUIRK_FORCE_BLK_SZ_2048) {
4198 mmc->max_blk_size = 2;
4200 mmc->max_blk_size = (host->caps & SDHCI_MAX_BLOCK_MASK) >>
4201 SDHCI_MAX_BLOCK_SHIFT;
4202 if (mmc->max_blk_size >= 3) {
4203 pr_warn("%s: Invalid maximum block size, assuming 512 bytes\n",
4205 mmc->max_blk_size = 0;
4209 mmc->max_blk_size = 512 << mmc->max_blk_size;
4212 * Maximum block count.
4214 mmc->max_blk_count = (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
4216 if (mmc->max_segs == 1)
4217 /* This may alter mmc->*_blk_* parameters */
4218 sdhci_allocate_bounce_buffer(host);
4223 if (!IS_ERR(mmc->supply.vqmmc))
4224 regulator_disable(mmc->supply.vqmmc);
4226 if (host->align_buffer)
4227 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz +
4228 host->adma_table_sz, host->align_buffer,
4230 host->adma_table = NULL;
4231 host->align_buffer = NULL;
4235 EXPORT_SYMBOL_GPL(sdhci_setup_host);
4237 void sdhci_cleanup_host(struct sdhci_host *host)
4239 struct mmc_host *mmc = host->mmc;
4241 if (!IS_ERR(mmc->supply.vqmmc))
4242 regulator_disable(mmc->supply.vqmmc);
4244 if (host->align_buffer)
4245 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz +
4246 host->adma_table_sz, host->align_buffer,
4248 host->adma_table = NULL;
4249 host->align_buffer = NULL;
4251 EXPORT_SYMBOL_GPL(sdhci_cleanup_host);
4253 int __sdhci_add_host(struct sdhci_host *host)
4255 unsigned int flags = WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_HIGHPRI;
4256 struct mmc_host *mmc = host->mmc;
4259 host->complete_wq = alloc_workqueue("sdhci", flags, 0);
4260 if (!host->complete_wq)
4263 INIT_WORK(&host->complete_work, sdhci_complete_work);
4265 timer_setup(&host->timer, sdhci_timeout_timer, 0);
4266 timer_setup(&host->data_timer, sdhci_timeout_data_timer, 0);
4268 init_waitqueue_head(&host->buf_ready_int);
4270 sdhci_init(host, 0);
4272 ret = request_threaded_irq(host->irq, sdhci_irq, sdhci_thread_irq,
4273 IRQF_SHARED, mmc_hostname(mmc), host);
4275 pr_err("%s: Failed to request IRQ %d: %d\n",
4276 mmc_hostname(mmc), host->irq, ret);
4280 ret = sdhci_led_register(host);
4282 pr_err("%s: Failed to register LED device: %d\n",
4283 mmc_hostname(mmc), ret);
4287 ret = mmc_add_host(mmc);
4291 pr_info("%s: SDHCI controller on %s [%s] using %s\n",
4292 mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
4293 (host->flags & SDHCI_USE_ADMA) ?
4294 (host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" :
4295 (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
4297 sdhci_enable_card_detection(host);
4302 sdhci_led_unregister(host);
4304 sdhci_do_reset(host, SDHCI_RESET_ALL);
4305 sdhci_writel(host, 0, SDHCI_INT_ENABLE);
4306 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
4307 free_irq(host->irq, host);
4309 destroy_workqueue(host->complete_wq);
4313 EXPORT_SYMBOL_GPL(__sdhci_add_host);
4315 int sdhci_add_host(struct sdhci_host *host)
4319 ret = sdhci_setup_host(host);
4323 ret = __sdhci_add_host(host);
4330 sdhci_cleanup_host(host);
4334 EXPORT_SYMBOL_GPL(sdhci_add_host);
4336 void sdhci_remove_host(struct sdhci_host *host, int dead)
4338 struct mmc_host *mmc = host->mmc;
4339 unsigned long flags;
4342 spin_lock_irqsave(&host->lock, flags);
4344 host->flags |= SDHCI_DEVICE_DEAD;
4346 if (sdhci_has_requests(host)) {
4347 pr_err("%s: Controller removed during "
4348 " transfer!\n", mmc_hostname(mmc));
4349 sdhci_error_out_mrqs(host, -ENOMEDIUM);
4352 spin_unlock_irqrestore(&host->lock, flags);
4355 sdhci_disable_card_detection(host);
4357 mmc_remove_host(mmc);
4359 sdhci_led_unregister(host);
4362 sdhci_do_reset(host, SDHCI_RESET_ALL);
4364 sdhci_writel(host, 0, SDHCI_INT_ENABLE);
4365 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
4366 free_irq(host->irq, host);
4368 del_timer_sync(&host->timer);
4369 del_timer_sync(&host->data_timer);
4371 destroy_workqueue(host->complete_wq);
4373 if (!IS_ERR(mmc->supply.vqmmc))
4374 regulator_disable(mmc->supply.vqmmc);
4376 if (host->align_buffer)
4377 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz +
4378 host->adma_table_sz, host->align_buffer,
4381 host->adma_table = NULL;
4382 host->align_buffer = NULL;
4385 EXPORT_SYMBOL_GPL(sdhci_remove_host);
4387 void sdhci_free_host(struct sdhci_host *host)
4389 mmc_free_host(host->mmc);
4392 EXPORT_SYMBOL_GPL(sdhci_free_host);
4394 /*****************************************************************************\
4396 * Driver init/exit *
4398 \*****************************************************************************/
4400 static int __init sdhci_drv_init(void)
4403 ": Secure Digital Host Controller Interface driver\n");
4404 pr_info(DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
4409 static void __exit sdhci_drv_exit(void)
4413 module_init(sdhci_drv_init);
4414 module_exit(sdhci_drv_exit);
4416 module_param(debug_quirks, uint, 0444);
4417 module_param(debug_quirks2, uint, 0444);
4419 MODULE_AUTHOR("Pierre Ossman <pierre@ossman.eu>");
4420 MODULE_DESCRIPTION("Secure Digital Host Controller Interface core driver");
4421 MODULE_LICENSE("GPL");
4423 MODULE_PARM_DESC(debug_quirks, "Force certain quirks.");
4424 MODULE_PARM_DESC(debug_quirks2, "Force certain other quirks.");