Lines Matching +full:mmc +full:- +full:host
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * linux/drivers/mmc/host/sdhci.c - Secure Digital Host Controller Interface driver
5 * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
9 * - JMicron (hardware and technical support)
19 #include <linux/dma-mapping.h>
29 #include <linux/mmc/mmc.h>
30 #include <linux/mmc/host.h>
31 #include <linux/mmc/card.h>
32 #include <linux/mmc/sdio.h>
33 #include <linux/mmc/slot-gpio.h>
40 pr_debug("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
43 pr_err("%s: " DRIVER_NAME ": " f, mmc_hostname(host->mmc), ## x)
50 static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd);
52 void sdhci_dumpregs(struct sdhci_host *host) in sdhci_dumpregs() argument
57 sdhci_readl(host, SDHCI_DMA_ADDRESS), in sdhci_dumpregs()
58 sdhci_readw(host, SDHCI_HOST_VERSION)); in sdhci_dumpregs()
60 sdhci_readw(host, SDHCI_BLOCK_SIZE), in sdhci_dumpregs()
61 sdhci_readw(host, SDHCI_BLOCK_COUNT)); in sdhci_dumpregs()
63 sdhci_readl(host, SDHCI_ARGUMENT), in sdhci_dumpregs()
64 sdhci_readw(host, SDHCI_TRANSFER_MODE)); in sdhci_dumpregs()
65 SDHCI_DUMP("Present: 0x%08x | Host ctl: 0x%08x\n", in sdhci_dumpregs()
66 sdhci_readl(host, SDHCI_PRESENT_STATE), in sdhci_dumpregs()
67 sdhci_readb(host, SDHCI_HOST_CONTROL)); in sdhci_dumpregs()
69 sdhci_readb(host, SDHCI_POWER_CONTROL), in sdhci_dumpregs()
70 sdhci_readb(host, SDHCI_BLOCK_GAP_CONTROL)); in sdhci_dumpregs()
71 SDHCI_DUMP("Wake-up: 0x%08x | Clock: 0x%08x\n", in sdhci_dumpregs()
72 sdhci_readb(host, SDHCI_WAKE_UP_CONTROL), in sdhci_dumpregs()
73 sdhci_readw(host, SDHCI_CLOCK_CONTROL)); in sdhci_dumpregs()
75 sdhci_readb(host, SDHCI_TIMEOUT_CONTROL), in sdhci_dumpregs()
76 sdhci_readl(host, SDHCI_INT_STATUS)); in sdhci_dumpregs()
78 sdhci_readl(host, SDHCI_INT_ENABLE), in sdhci_dumpregs()
79 sdhci_readl(host, SDHCI_SIGNAL_ENABLE)); in sdhci_dumpregs()
81 sdhci_readw(host, SDHCI_AUTO_CMD_STATUS), in sdhci_dumpregs()
82 sdhci_readw(host, SDHCI_SLOT_INT_STATUS)); in sdhci_dumpregs()
84 sdhci_readl(host, SDHCI_CAPABILITIES), in sdhci_dumpregs()
85 sdhci_readl(host, SDHCI_CAPABILITIES_1)); in sdhci_dumpregs()
87 sdhci_readw(host, SDHCI_COMMAND), in sdhci_dumpregs()
88 sdhci_readl(host, SDHCI_MAX_CURRENT)); in sdhci_dumpregs()
90 sdhci_readl(host, SDHCI_RESPONSE), in sdhci_dumpregs()
91 sdhci_readl(host, SDHCI_RESPONSE + 4)); in sdhci_dumpregs()
93 sdhci_readl(host, SDHCI_RESPONSE + 8), in sdhci_dumpregs()
94 sdhci_readl(host, SDHCI_RESPONSE + 12)); in sdhci_dumpregs()
95 SDHCI_DUMP("Host ctl2: 0x%08x\n", in sdhci_dumpregs()
96 sdhci_readw(host, SDHCI_HOST_CONTROL2)); in sdhci_dumpregs()
98 if (host->flags & SDHCI_USE_ADMA) { in sdhci_dumpregs()
99 if (host->flags & SDHCI_USE_64_BIT_DMA) { in sdhci_dumpregs()
101 sdhci_readl(host, SDHCI_ADMA_ERROR), in sdhci_dumpregs()
102 sdhci_readl(host, SDHCI_ADMA_ADDRESS_HI), in sdhci_dumpregs()
103 sdhci_readl(host, SDHCI_ADMA_ADDRESS)); in sdhci_dumpregs()
106 sdhci_readl(host, SDHCI_ADMA_ERROR), in sdhci_dumpregs()
107 sdhci_readl(host, SDHCI_ADMA_ADDRESS)); in sdhci_dumpregs()
111 if (host->ops->dump_uhs2_regs) in sdhci_dumpregs()
112 host->ops->dump_uhs2_regs(host); in sdhci_dumpregs()
114 if (host->ops->dump_vendor_regs) in sdhci_dumpregs()
115 host->ops->dump_vendor_regs(host); in sdhci_dumpregs()
127 static void sdhci_do_enable_v4_mode(struct sdhci_host *host) in sdhci_do_enable_v4_mode() argument
131 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_do_enable_v4_mode()
136 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2); in sdhci_do_enable_v4_mode()
140 * This can be called before sdhci_add_host() by Vendor's host controller
143 void sdhci_enable_v4_mode(struct sdhci_host *host) in sdhci_enable_v4_mode() argument
145 host->v4_mode = true; in sdhci_enable_v4_mode()
146 sdhci_do_enable_v4_mode(host); in sdhci_enable_v4_mode()
152 return cmd->data || cmd->flags & MMC_RSP_BUSY; in sdhci_data_line_cmd()
156 static void sdhci_set_card_detection(struct sdhci_host *host, bool enable) in sdhci_set_card_detection() argument
160 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) || in sdhci_set_card_detection()
161 !mmc_card_is_removable(host->mmc) || mmc_can_gpio_cd(host->mmc)) in sdhci_set_card_detection()
165 present = sdhci_readl(host, SDHCI_PRESENT_STATE) & in sdhci_set_card_detection()
168 host->ier |= present ? SDHCI_INT_CARD_REMOVE : in sdhci_set_card_detection()
171 host->ier &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT); in sdhci_set_card_detection()
174 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_set_card_detection()
175 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_set_card_detection()
178 static void sdhci_enable_card_detection(struct sdhci_host *host) in sdhci_enable_card_detection() argument
180 sdhci_set_card_detection(host, true); in sdhci_enable_card_detection()
183 static void sdhci_disable_card_detection(struct sdhci_host *host) in sdhci_disable_card_detection() argument
185 sdhci_set_card_detection(host, false); in sdhci_disable_card_detection()
188 static void sdhci_runtime_pm_bus_on(struct sdhci_host *host) in sdhci_runtime_pm_bus_on() argument
190 if (host->bus_on) in sdhci_runtime_pm_bus_on()
192 host->bus_on = true; in sdhci_runtime_pm_bus_on()
193 pm_runtime_get_noresume(mmc_dev(host->mmc)); in sdhci_runtime_pm_bus_on()
196 static void sdhci_runtime_pm_bus_off(struct sdhci_host *host) in sdhci_runtime_pm_bus_off() argument
198 if (!host->bus_on) in sdhci_runtime_pm_bus_off()
200 host->bus_on = false; in sdhci_runtime_pm_bus_off()
201 pm_runtime_put_noidle(mmc_dev(host->mmc)); in sdhci_runtime_pm_bus_off()
204 void sdhci_reset(struct sdhci_host *host, u8 mask) in sdhci_reset() argument
208 sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET); in sdhci_reset()
211 host->clock = 0; in sdhci_reset()
212 /* Reset-all turns off SD Bus Power */ in sdhci_reset()
213 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON) in sdhci_reset()
214 sdhci_runtime_pm_bus_off(host); in sdhci_reset()
224 if (!(sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask)) in sdhci_reset()
228 mmc_hostname(host->mmc), (int)mask); in sdhci_reset()
229 sdhci_err_stats_inc(host, CTRL_TIMEOUT); in sdhci_reset()
230 sdhci_dumpregs(host); in sdhci_reset()
238 bool sdhci_do_reset(struct sdhci_host *host, u8 mask) in sdhci_do_reset() argument
240 if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) { in sdhci_do_reset()
241 struct mmc_host *mmc = host->mmc; in sdhci_do_reset() local
243 if (!mmc->ops->get_cd(mmc)) in sdhci_do_reset()
247 host->ops->reset(host, mask); in sdhci_do_reset()
253 static void sdhci_reset_for_all(struct sdhci_host *host) in sdhci_reset_for_all() argument
255 if (sdhci_do_reset(host, SDHCI_RESET_ALL)) { in sdhci_reset_for_all()
256 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) { in sdhci_reset_for_all()
257 if (host->ops->enable_dma) in sdhci_reset_for_all()
258 host->ops->enable_dma(host); in sdhci_reset_for_all()
261 host->preset_enabled = false; in sdhci_reset_for_all()
274 static void sdhci_reset_for_reason(struct sdhci_host *host, enum sdhci_reset_reason reason) in sdhci_reset_for_reason() argument
276 if (host->quirks2 & SDHCI_QUIRK2_ISSUE_CMD_DAT_RESET_TOGETHER) { in sdhci_reset_for_reason()
277 sdhci_do_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA); in sdhci_reset_for_reason()
283 sdhci_do_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA); in sdhci_reset_for_reason()
289 sdhci_do_reset(host, SDHCI_RESET_CMD); in sdhci_reset_for_reason()
290 sdhci_do_reset(host, SDHCI_RESET_DATA); in sdhci_reset_for_reason()
293 sdhci_do_reset(host, SDHCI_RESET_DATA); in sdhci_reset_for_reason()
300 static void sdhci_set_default_irqs(struct sdhci_host *host) in sdhci_set_default_irqs() argument
302 host->ier = SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT | in sdhci_set_default_irqs()
308 if (host->tuning_mode == SDHCI_TUNING_MODE_2 || in sdhci_set_default_irqs()
309 host->tuning_mode == SDHCI_TUNING_MODE_3) in sdhci_set_default_irqs()
310 host->ier |= SDHCI_INT_RETUNE; in sdhci_set_default_irqs()
312 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_set_default_irqs()
313 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_set_default_irqs()
316 static void sdhci_config_dma(struct sdhci_host *host) in sdhci_config_dma() argument
321 if (host->version < SDHCI_SPEC_200) in sdhci_config_dma()
324 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); in sdhci_config_dma()
332 if (!(host->flags & SDHCI_REQ_USE_DMA)) in sdhci_config_dma()
336 if (host->flags & SDHCI_USE_ADMA) in sdhci_config_dma()
339 if (host->flags & SDHCI_USE_64_BIT_DMA) { in sdhci_config_dma()
341 * If v4 mode, all supported DMA can be 64-bit addressing if in sdhci_config_dma()
342 * controller supports 64-bit system address, otherwise only in sdhci_config_dma()
343 * ADMA can support 64-bit addressing. in sdhci_config_dma()
345 if (host->v4_mode) { in sdhci_config_dma()
346 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_config_dma()
348 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2); in sdhci_config_dma()
349 } else if (host->flags & SDHCI_USE_ADMA) { in sdhci_config_dma()
359 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in sdhci_config_dma()
362 static void sdhci_init(struct sdhci_host *host, int soft) in sdhci_init() argument
364 struct mmc_host *mmc = host->mmc; in sdhci_init() local
368 sdhci_reset_for(host, INIT); in sdhci_init()
370 sdhci_reset_for_all(host); in sdhci_init()
372 if (host->v4_mode) in sdhci_init()
373 sdhci_do_enable_v4_mode(host); in sdhci_init()
375 spin_lock_irqsave(&host->lock, flags); in sdhci_init()
376 sdhci_set_default_irqs(host); in sdhci_init()
377 spin_unlock_irqrestore(&host->lock, flags); in sdhci_init()
379 host->cqe_on = false; in sdhci_init()
383 host->clock = 0; in sdhci_init()
384 host->reinit_uhs = true; in sdhci_init()
385 mmc->ops->set_ios(mmc, &mmc->ios); in sdhci_init()
389 static void sdhci_reinit(struct sdhci_host *host) in sdhci_reinit() argument
391 u32 cd = host->ier & (SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT); in sdhci_reinit()
393 sdhci_init(host, 0); in sdhci_reinit()
394 sdhci_enable_card_detection(host); in sdhci_reinit()
399 * been missed while the host controller was being reset, so trigger a in sdhci_reinit()
402 if (cd != (host->ier & (SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT))) in sdhci_reinit()
403 mmc_detect_change(host->mmc, msecs_to_jiffies(200)); in sdhci_reinit()
406 static void __sdhci_led_activate(struct sdhci_host *host) in __sdhci_led_activate() argument
410 if (host->quirks & SDHCI_QUIRK_NO_LED) in __sdhci_led_activate()
413 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); in __sdhci_led_activate()
415 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in __sdhci_led_activate()
418 static void __sdhci_led_deactivate(struct sdhci_host *host) in __sdhci_led_deactivate() argument
422 if (host->quirks & SDHCI_QUIRK_NO_LED) in __sdhci_led_deactivate()
425 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); in __sdhci_led_deactivate()
427 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in __sdhci_led_deactivate()
434 struct sdhci_host *host = container_of(led, struct sdhci_host, led); in sdhci_led_control() local
437 spin_lock_irqsave(&host->lock, flags); in sdhci_led_control()
439 if (host->runtime_suspended) in sdhci_led_control()
443 __sdhci_led_deactivate(host); in sdhci_led_control()
445 __sdhci_led_activate(host); in sdhci_led_control()
447 spin_unlock_irqrestore(&host->lock, flags); in sdhci_led_control()
450 static int sdhci_led_register(struct sdhci_host *host) in sdhci_led_register() argument
452 struct mmc_host *mmc = host->mmc; in sdhci_led_register() local
454 if (host->quirks & SDHCI_QUIRK_NO_LED) in sdhci_led_register()
457 snprintf(host->led_name, sizeof(host->led_name), in sdhci_led_register()
458 "%s::", mmc_hostname(mmc)); in sdhci_led_register()
460 host->led.name = host->led_name; in sdhci_led_register()
461 host->led.brightness = LED_OFF; in sdhci_led_register()
462 host->led.default_trigger = mmc_hostname(mmc); in sdhci_led_register()
463 host->led.brightness_set = sdhci_led_control; in sdhci_led_register()
465 return led_classdev_register(mmc_dev(mmc), &host->led); in sdhci_led_register()
468 static void sdhci_led_unregister(struct sdhci_host *host) in sdhci_led_unregister() argument
470 if (host->quirks & SDHCI_QUIRK_NO_LED) in sdhci_led_unregister()
473 led_classdev_unregister(&host->led); in sdhci_led_unregister()
476 static inline void sdhci_led_activate(struct sdhci_host *host) in sdhci_led_activate() argument
480 static inline void sdhci_led_deactivate(struct sdhci_host *host) in sdhci_led_deactivate() argument
486 static inline int sdhci_led_register(struct sdhci_host *host) in sdhci_led_register() argument
491 static inline void sdhci_led_unregister(struct sdhci_host *host) in sdhci_led_unregister() argument
495 static inline void sdhci_led_activate(struct sdhci_host *host) in sdhci_led_activate() argument
497 __sdhci_led_activate(host); in sdhci_led_activate()
500 static inline void sdhci_led_deactivate(struct sdhci_host *host) in sdhci_led_deactivate() argument
502 __sdhci_led_deactivate(host); in sdhci_led_deactivate()
507 void sdhci_mod_timer(struct sdhci_host *host, struct mmc_request *mrq, in sdhci_mod_timer() argument
510 if (sdhci_data_line_cmd(mrq->cmd)) in sdhci_mod_timer()
511 mod_timer(&host->data_timer, timeout); in sdhci_mod_timer()
513 mod_timer(&host->timer, timeout); in sdhci_mod_timer()
517 static void sdhci_del_timer(struct sdhci_host *host, struct mmc_request *mrq) in sdhci_del_timer() argument
519 if (sdhci_data_line_cmd(mrq->cmd)) in sdhci_del_timer()
520 timer_delete(&host->data_timer); in sdhci_del_timer()
522 timer_delete(&host->timer); in sdhci_del_timer()
525 static inline bool sdhci_has_requests(struct sdhci_host *host) in sdhci_has_requests() argument
527 return host->cmd || host->data_cmd; in sdhci_has_requests()
536 static void sdhci_read_block_pio(struct sdhci_host *host) in sdhci_read_block_pio() argument
544 blksize = host->data->blksz; in sdhci_read_block_pio()
548 BUG_ON(!sg_miter_next(&host->sg_miter)); in sdhci_read_block_pio()
550 len = min(host->sg_miter.length, blksize); in sdhci_read_block_pio()
552 blksize -= len; in sdhci_read_block_pio()
553 host->sg_miter.consumed = len; in sdhci_read_block_pio()
555 buf = host->sg_miter.addr; in sdhci_read_block_pio()
559 scratch = sdhci_readl(host, SDHCI_BUFFER); in sdhci_read_block_pio()
567 chunk--; in sdhci_read_block_pio()
568 len--; in sdhci_read_block_pio()
572 sg_miter_stop(&host->sg_miter); in sdhci_read_block_pio()
575 static void sdhci_write_block_pio(struct sdhci_host *host) in sdhci_write_block_pio() argument
583 blksize = host->data->blksz; in sdhci_write_block_pio()
588 BUG_ON(!sg_miter_next(&host->sg_miter)); in sdhci_write_block_pio()
590 len = min(host->sg_miter.length, blksize); in sdhci_write_block_pio()
592 blksize -= len; in sdhci_write_block_pio()
593 host->sg_miter.consumed = len; in sdhci_write_block_pio()
595 buf = host->sg_miter.addr; in sdhci_write_block_pio()
602 len--; in sdhci_write_block_pio()
605 sdhci_writel(host, scratch, SDHCI_BUFFER); in sdhci_write_block_pio()
612 sg_miter_stop(&host->sg_miter); in sdhci_write_block_pio()
615 static void sdhci_transfer_pio(struct sdhci_host *host) in sdhci_transfer_pio() argument
619 if (host->blocks == 0) in sdhci_transfer_pio()
622 if (host->data->flags & MMC_DATA_READ) in sdhci_transfer_pio()
632 if ((host->quirks & SDHCI_QUIRK_BROKEN_SMALL_PIO) && in sdhci_transfer_pio()
633 (host->data->blocks == 1)) in sdhci_transfer_pio()
636 while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) { in sdhci_transfer_pio()
637 if (host->quirks & SDHCI_QUIRK_PIO_NEEDS_DELAY) in sdhci_transfer_pio()
640 if (host->data->flags & MMC_DATA_READ) in sdhci_transfer_pio()
641 sdhci_read_block_pio(host); in sdhci_transfer_pio()
643 sdhci_write_block_pio(host); in sdhci_transfer_pio()
645 host->blocks--; in sdhci_transfer_pio()
646 if (host->blocks == 0) in sdhci_transfer_pio()
653 static int sdhci_pre_dma_transfer(struct sdhci_host *host, in sdhci_pre_dma_transfer() argument
662 if (data->host_cookie == COOKIE_PRE_MAPPED) in sdhci_pre_dma_transfer()
663 return data->sg_count; in sdhci_pre_dma_transfer()
666 if (host->bounce_buffer) { in sdhci_pre_dma_transfer()
667 unsigned int length = data->blksz * data->blocks; in sdhci_pre_dma_transfer()
669 if (length > host->bounce_buffer_size) { in sdhci_pre_dma_transfer()
671 mmc_hostname(host->mmc), length, in sdhci_pre_dma_transfer()
672 host->bounce_buffer_size); in sdhci_pre_dma_transfer()
673 return -EIO; in sdhci_pre_dma_transfer()
677 if (host->ops->copy_to_bounce_buffer) { in sdhci_pre_dma_transfer()
678 host->ops->copy_to_bounce_buffer(host, in sdhci_pre_dma_transfer()
681 sg_copy_to_buffer(data->sg, data->sg_len, in sdhci_pre_dma_transfer()
682 host->bounce_buffer, length); in sdhci_pre_dma_transfer()
686 dma_sync_single_for_device(mmc_dev(host->mmc), in sdhci_pre_dma_transfer()
687 host->bounce_addr, in sdhci_pre_dma_transfer()
688 host->bounce_buffer_size, in sdhci_pre_dma_transfer()
694 sg_count = dma_map_sg(mmc_dev(host->mmc), in sdhci_pre_dma_transfer()
695 data->sg, data->sg_len, in sdhci_pre_dma_transfer()
700 return -ENOSPC; in sdhci_pre_dma_transfer()
702 data->sg_count = sg_count; in sdhci_pre_dma_transfer()
703 data->host_cookie = cookie; in sdhci_pre_dma_transfer()
710 return kmap_local_page(sg_page(sg)) + sg->offset; in sdhci_kmap_atomic()
718 void sdhci_adma_write_desc(struct sdhci_host *host, void **desc, in sdhci_adma_write_desc() argument
723 /* 32-bit and 64-bit descriptors have these members in same position */ in sdhci_adma_write_desc()
724 dma_desc->cmd = cpu_to_le16(cmd); in sdhci_adma_write_desc()
725 dma_desc->len = cpu_to_le16(len); in sdhci_adma_write_desc()
726 dma_desc->addr_lo = cpu_to_le32(lower_32_bits(addr)); in sdhci_adma_write_desc()
728 if (host->flags & SDHCI_USE_64_BIT_DMA) in sdhci_adma_write_desc()
729 dma_desc->addr_hi = cpu_to_le32(upper_32_bits(addr)); in sdhci_adma_write_desc()
731 *desc += host->desc_sz; in sdhci_adma_write_desc()
735 static inline void __sdhci_adma_write_desc(struct sdhci_host *host, in __sdhci_adma_write_desc() argument
739 if (host->ops->adma_write_desc) in __sdhci_adma_write_desc()
740 host->ops->adma_write_desc(host, desc, addr, len, cmd); in __sdhci_adma_write_desc()
742 sdhci_adma_write_desc(host, desc, addr, len, cmd); in __sdhci_adma_write_desc()
749 /* 32-bit and 64-bit descriptors have 'cmd' in same position */ in sdhci_adma_mark_end()
750 dma_desc->cmd |= cpu_to_le16(ADMA2_END); in sdhci_adma_mark_end()
753 static void sdhci_adma_table_pre(struct sdhci_host *host, in sdhci_adma_table_pre() argument
767 host->sg_count = sg_count; in sdhci_adma_table_pre()
769 desc = host->adma_table; in sdhci_adma_table_pre()
770 align = host->align_buffer; in sdhci_adma_table_pre()
772 align_addr = host->align_addr; in sdhci_adma_table_pre()
774 for_each_sg(data->sg, sg, host->sg_count, i) { in sdhci_adma_table_pre()
780 * be 32-bit aligned. If they aren't, then we use a bounce in sdhci_adma_table_pre()
784 offset = (SDHCI_ADMA2_ALIGN - (addr & SDHCI_ADMA2_MASK)) & in sdhci_adma_table_pre()
787 if (data->flags & MMC_DATA_WRITE) { in sdhci_adma_table_pre()
794 __sdhci_adma_write_desc(host, &desc, align_addr, in sdhci_adma_table_pre()
803 len -= offset; in sdhci_adma_table_pre()
812 while (len > host->max_adma) { in sdhci_adma_table_pre()
815 __sdhci_adma_write_desc(host, &desc, addr, n, ADMA2_TRAN_VALID); in sdhci_adma_table_pre()
817 len -= n; in sdhci_adma_table_pre()
822 __sdhci_adma_write_desc(host, &desc, addr, len, in sdhci_adma_table_pre()
829 WARN_ON((desc - host->adma_table) >= host->adma_table_sz); in sdhci_adma_table_pre()
832 if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) { in sdhci_adma_table_pre()
834 if (desc != host->adma_table) { in sdhci_adma_table_pre()
835 desc -= host->desc_sz; in sdhci_adma_table_pre()
839 /* Add a terminating entry - nop, end, valid */ in sdhci_adma_table_pre()
840 __sdhci_adma_write_desc(host, &desc, 0, 0, ADMA2_NOP_END_VALID); in sdhci_adma_table_pre()
844 static void sdhci_adma_table_post(struct sdhci_host *host, in sdhci_adma_table_post() argument
852 if (data->flags & MMC_DATA_READ) { in sdhci_adma_table_post()
856 for_each_sg(data->sg, sg, host->sg_count, i) in sdhci_adma_table_post()
863 dma_sync_sg_for_cpu(mmc_dev(host->mmc), data->sg, in sdhci_adma_table_post()
864 data->sg_len, DMA_FROM_DEVICE); in sdhci_adma_table_post()
866 align = host->align_buffer; in sdhci_adma_table_post()
868 for_each_sg(data->sg, sg, host->sg_count, i) { in sdhci_adma_table_post()
870 size = SDHCI_ADMA2_ALIGN - in sdhci_adma_table_post()
884 static void sdhci_set_adma_addr(struct sdhci_host *host, dma_addr_t addr) in sdhci_set_adma_addr() argument
886 sdhci_writel(host, lower_32_bits(addr), SDHCI_ADMA_ADDRESS); in sdhci_set_adma_addr()
887 if (host->flags & SDHCI_USE_64_BIT_DMA) in sdhci_set_adma_addr()
888 sdhci_writel(host, upper_32_bits(addr), SDHCI_ADMA_ADDRESS_HI); in sdhci_set_adma_addr()
891 static dma_addr_t sdhci_sdma_address(struct sdhci_host *host) in sdhci_sdma_address() argument
893 if (host->bounce_buffer) in sdhci_sdma_address()
894 return host->bounce_addr; in sdhci_sdma_address()
896 return sg_dma_address(host->data->sg); in sdhci_sdma_address()
899 static void sdhci_set_sdma_addr(struct sdhci_host *host, dma_addr_t addr) in sdhci_set_sdma_addr() argument
901 if (host->v4_mode) in sdhci_set_sdma_addr()
902 sdhci_set_adma_addr(host, addr); in sdhci_set_sdma_addr()
904 sdhci_writel(host, addr, SDHCI_DMA_ADDRESS); in sdhci_set_sdma_addr()
907 static unsigned int sdhci_target_timeout(struct sdhci_host *host, in sdhci_target_timeout() argument
915 target_timeout = cmd->busy_timeout * 1000; in sdhci_target_timeout()
917 target_timeout = DIV_ROUND_UP(data->timeout_ns, 1000); in sdhci_target_timeout()
918 if (host->clock && data->timeout_clks) { in sdhci_target_timeout()
922 * data->timeout_clks is in units of clock cycles. in sdhci_target_timeout()
923 * host->clock is in Hz. target_timeout is in us. in sdhci_target_timeout()
926 val = 1000000ULL * data->timeout_clks; in sdhci_target_timeout()
927 if (do_div(val, host->clock)) in sdhci_target_timeout()
936 static void sdhci_calc_sw_timeout(struct sdhci_host *host, in sdhci_calc_sw_timeout() argument
939 struct mmc_data *data = cmd->data; in sdhci_calc_sw_timeout()
940 struct mmc_host *mmc = host->mmc; in sdhci_calc_sw_timeout() local
941 struct mmc_ios *ios = &mmc->ios; in sdhci_calc_sw_timeout()
942 unsigned char bus_width = 1 << ios->bus_width; in sdhci_calc_sw_timeout()
948 target_timeout = sdhci_target_timeout(host, cmd, data); in sdhci_calc_sw_timeout()
952 blksz = data->blksz; in sdhci_calc_sw_timeout()
953 freq = mmc->actual_clock ? : host->clock; in sdhci_calc_sw_timeout()
959 host->data_timeout = data->blocks * target_timeout + in sdhci_calc_sw_timeout()
962 host->data_timeout = target_timeout; in sdhci_calc_sw_timeout()
965 if (host->data_timeout) in sdhci_calc_sw_timeout()
966 host->data_timeout += MMC_CMD_TRANSFER_TIME; in sdhci_calc_sw_timeout()
969 static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd, in sdhci_calc_timeout() argument
979 * If the host controller provides us with an incorrect timeout in sdhci_calc_timeout()
981 * longer to time out, but that's much better than having a too-short in sdhci_calc_timeout()
984 if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL) in sdhci_calc_timeout()
985 return host->max_timeout_count; in sdhci_calc_timeout()
989 return host->max_timeout_count; in sdhci_calc_timeout()
991 data = cmd->data; in sdhci_calc_timeout()
993 if (!data && !cmd->busy_timeout) in sdhci_calc_timeout()
994 return host->max_timeout_count; in sdhci_calc_timeout()
997 target_timeout = sdhci_target_timeout(host, cmd, data); in sdhci_calc_timeout()
1005 * (2) host->timeout_clk < 2^16 in sdhci_calc_timeout()
1010 current_timeout = (1 << 13) * 1000 / host->timeout_clk; in sdhci_calc_timeout()
1014 if (count > host->max_timeout_count) { in sdhci_calc_timeout()
1015 if (!(host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT)) in sdhci_calc_timeout()
1017 count, cmd->opcode); in sdhci_calc_timeout()
1018 count = host->max_timeout_count; in sdhci_calc_timeout()
1027 static void sdhci_set_transfer_irqs(struct sdhci_host *host) in sdhci_set_transfer_irqs() argument
1032 if (host->flags & SDHCI_REQ_USE_DMA) in sdhci_set_transfer_irqs()
1033 host->ier = (host->ier & ~pio_irqs) | dma_irqs; in sdhci_set_transfer_irqs()
1035 host->ier = (host->ier & ~dma_irqs) | pio_irqs; in sdhci_set_transfer_irqs()
1037 if (host->flags & (SDHCI_AUTO_CMD23 | SDHCI_AUTO_CMD12)) in sdhci_set_transfer_irqs()
1038 host->ier |= SDHCI_INT_AUTO_CMD_ERR; in sdhci_set_transfer_irqs()
1040 host->ier &= ~SDHCI_INT_AUTO_CMD_ERR; in sdhci_set_transfer_irqs()
1042 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_set_transfer_irqs()
1043 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_set_transfer_irqs()
1046 void sdhci_set_data_timeout_irq(struct sdhci_host *host, bool enable) in sdhci_set_data_timeout_irq() argument
1049 host->ier |= SDHCI_INT_DATA_TIMEOUT; in sdhci_set_data_timeout_irq()
1051 host->ier &= ~SDHCI_INT_DATA_TIMEOUT; in sdhci_set_data_timeout_irq()
1052 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_set_data_timeout_irq()
1053 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_set_data_timeout_irq()
1057 void __sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd) in __sdhci_set_timeout() argument
1060 u8 count = sdhci_calc_timeout(host, cmd, &too_big); in __sdhci_set_timeout()
1063 host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT) { in __sdhci_set_timeout()
1064 sdhci_calc_sw_timeout(host, cmd); in __sdhci_set_timeout()
1065 sdhci_set_data_timeout_irq(host, false); in __sdhci_set_timeout()
1066 } else if (!(host->ier & SDHCI_INT_DATA_TIMEOUT)) { in __sdhci_set_timeout()
1067 sdhci_set_data_timeout_irq(host, true); in __sdhci_set_timeout()
1070 sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL); in __sdhci_set_timeout()
1074 static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd) in sdhci_set_timeout() argument
1076 if (host->ops->set_timeout) in sdhci_set_timeout()
1077 host->ops->set_timeout(host, cmd); in sdhci_set_timeout()
1079 __sdhci_set_timeout(host, cmd); in sdhci_set_timeout()
1082 void sdhci_initialize_data(struct sdhci_host *host, struct mmc_data *data) in sdhci_initialize_data() argument
1084 WARN_ON(host->data); in sdhci_initialize_data()
1087 BUG_ON(data->blksz * data->blocks > 524288); in sdhci_initialize_data()
1088 BUG_ON(data->blksz > host->mmc->max_blk_size); in sdhci_initialize_data()
1089 BUG_ON(data->blocks > 65535); in sdhci_initialize_data()
1091 host->data = data; in sdhci_initialize_data()
1092 host->data_early = 0; in sdhci_initialize_data()
1093 host->data->bytes_xfered = 0; in sdhci_initialize_data()
1097 static inline void sdhci_set_block_info(struct sdhci_host *host, in sdhci_set_block_info() argument
1101 sdhci_writew(host, in sdhci_set_block_info()
1102 SDHCI_MAKE_BLKSZ(host->sdma_boundary, data->blksz), in sdhci_set_block_info()
1105 * For Version 4.10 onwards, if v4 mode is enabled, 32-bit Block Count in sdhci_set_block_info()
1106 * can be supported, in that case 16-bit block count register must be 0. in sdhci_set_block_info()
1108 if (host->version >= SDHCI_SPEC_410 && host->v4_mode && in sdhci_set_block_info()
1109 (host->quirks2 & SDHCI_QUIRK2_USE_32BIT_BLK_CNT)) { in sdhci_set_block_info()
1110 if (sdhci_readw(host, SDHCI_BLOCK_COUNT)) in sdhci_set_block_info()
1111 sdhci_writew(host, 0, SDHCI_BLOCK_COUNT); in sdhci_set_block_info()
1112 sdhci_writew(host, data->blocks, SDHCI_32BIT_BLK_CNT); in sdhci_set_block_info()
1114 sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT); in sdhci_set_block_info()
1118 void sdhci_prepare_dma(struct sdhci_host *host, struct mmc_data *data) in sdhci_prepare_dma() argument
1120 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) { in sdhci_prepare_dma()
1125 host->flags |= SDHCI_REQ_USE_DMA; in sdhci_prepare_dma()
1136 if (host->flags & SDHCI_USE_ADMA) { in sdhci_prepare_dma()
1137 if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE) { in sdhci_prepare_dma()
1147 if (host->quirks & SDHCI_QUIRK_32BIT_DMA_SIZE) in sdhci_prepare_dma()
1149 if (host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) in sdhci_prepare_dma()
1154 for_each_sg(data->sg, sg, data->sg_len, i) { in sdhci_prepare_dma()
1155 if (sg->length & length_mask) { in sdhci_prepare_dma()
1157 sg->length); in sdhci_prepare_dma()
1158 host->flags &= ~SDHCI_REQ_USE_DMA; in sdhci_prepare_dma()
1161 if (sg->offset & offset_mask) { in sdhci_prepare_dma()
1163 host->flags &= ~SDHCI_REQ_USE_DMA; in sdhci_prepare_dma()
1170 sdhci_config_dma(host); in sdhci_prepare_dma()
1172 if (host->flags & SDHCI_REQ_USE_DMA) { in sdhci_prepare_dma()
1173 int sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED); in sdhci_prepare_dma()
1181 host->flags &= ~SDHCI_REQ_USE_DMA; in sdhci_prepare_dma()
1182 } else if (host->flags & SDHCI_USE_ADMA) { in sdhci_prepare_dma()
1183 sdhci_adma_table_pre(host, data, sg_cnt); in sdhci_prepare_dma()
1184 sdhci_set_adma_addr(host, host->adma_addr); in sdhci_prepare_dma()
1187 sdhci_set_sdma_addr(host, sdhci_sdma_address(host)); in sdhci_prepare_dma()
1191 if (!(host->flags & SDHCI_REQ_USE_DMA)) { in sdhci_prepare_dma()
1195 if (host->data->flags & MMC_DATA_READ) in sdhci_prepare_dma()
1199 sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags); in sdhci_prepare_dma()
1200 host->blocks = data->blocks; in sdhci_prepare_dma()
1203 sdhci_set_transfer_irqs(host); in sdhci_prepare_dma()
1207 static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd) in sdhci_prepare_data() argument
1209 struct mmc_data *data = cmd->data; in sdhci_prepare_data()
1211 sdhci_initialize_data(host, data); in sdhci_prepare_data()
1213 sdhci_prepare_dma(host, data); in sdhci_prepare_data()
1215 sdhci_set_block_info(host, data); in sdhci_prepare_data()
1220 static int sdhci_external_dma_init(struct sdhci_host *host) in sdhci_external_dma_init() argument
1223 struct mmc_host *mmc = host->mmc; in sdhci_external_dma_init() local
1225 host->tx_chan = dma_request_chan(mmc_dev(mmc), "tx"); in sdhci_external_dma_init()
1226 if (IS_ERR(host->tx_chan)) { in sdhci_external_dma_init()
1227 ret = PTR_ERR(host->tx_chan); in sdhci_external_dma_init()
1228 if (ret != -EPROBE_DEFER) in sdhci_external_dma_init()
1230 host->tx_chan = NULL; in sdhci_external_dma_init()
1234 host->rx_chan = dma_request_chan(mmc_dev(mmc), "rx"); in sdhci_external_dma_init()
1235 if (IS_ERR(host->rx_chan)) { in sdhci_external_dma_init()
1236 if (host->tx_chan) { in sdhci_external_dma_init()
1237 dma_release_channel(host->tx_chan); in sdhci_external_dma_init()
1238 host->tx_chan = NULL; in sdhci_external_dma_init()
1241 ret = PTR_ERR(host->rx_chan); in sdhci_external_dma_init()
1242 if (ret != -EPROBE_DEFER) in sdhci_external_dma_init()
1244 host->rx_chan = NULL; in sdhci_external_dma_init()
1250 static struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host, in sdhci_external_dma_channel() argument
1253 return data->flags & MMC_DATA_WRITE ? host->tx_chan : host->rx_chan; in sdhci_external_dma_channel()
1256 static int sdhci_external_dma_setup(struct sdhci_host *host, in sdhci_external_dma_setup() argument
1262 struct mmc_data *data = cmd->data; in sdhci_external_dma_setup()
1268 if (!host->mapbase) in sdhci_external_dma_setup()
1269 return -EINVAL; in sdhci_external_dma_setup()
1272 cfg.src_addr = host->mapbase + SDHCI_BUFFER; in sdhci_external_dma_setup()
1273 cfg.dst_addr = host->mapbase + SDHCI_BUFFER; in sdhci_external_dma_setup()
1276 cfg.src_maxburst = data->blksz / 4; in sdhci_external_dma_setup()
1277 cfg.dst_maxburst = data->blksz / 4; in sdhci_external_dma_setup()
1280 for (i = 0; i < data->sg_len; i++) { in sdhci_external_dma_setup()
1281 if ((data->sg + i)->length % data->blksz) in sdhci_external_dma_setup()
1282 return -EINVAL; in sdhci_external_dma_setup()
1285 chan = sdhci_external_dma_channel(host, data); in sdhci_external_dma_setup()
1291 sg_cnt = sdhci_pre_dma_transfer(host, data, COOKIE_MAPPED); in sdhci_external_dma_setup()
1293 return -EINVAL; in sdhci_external_dma_setup()
1295 dir = data->flags & MMC_DATA_WRITE ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM; in sdhci_external_dma_setup()
1296 desc = dmaengine_prep_slave_sg(chan, data->sg, data->sg_len, dir, in sdhci_external_dma_setup()
1299 return -EINVAL; in sdhci_external_dma_setup()
1301 desc->callback = NULL; in sdhci_external_dma_setup()
1302 desc->callback_param = NULL; in sdhci_external_dma_setup()
1311 static void sdhci_external_dma_release(struct sdhci_host *host) in sdhci_external_dma_release() argument
1313 if (host->tx_chan) { in sdhci_external_dma_release()
1314 dma_release_channel(host->tx_chan); in sdhci_external_dma_release()
1315 host->tx_chan = NULL; in sdhci_external_dma_release()
1318 if (host->rx_chan) { in sdhci_external_dma_release()
1319 dma_release_channel(host->rx_chan); in sdhci_external_dma_release()
1320 host->rx_chan = NULL; in sdhci_external_dma_release()
1323 sdhci_switch_external_dma(host, false); in sdhci_external_dma_release()
1326 static void __sdhci_external_dma_prepare_data(struct sdhci_host *host, in __sdhci_external_dma_prepare_data() argument
1329 struct mmc_data *data = cmd->data; in __sdhci_external_dma_prepare_data()
1331 sdhci_initialize_data(host, data); in __sdhci_external_dma_prepare_data()
1333 host->flags |= SDHCI_REQ_USE_DMA; in __sdhci_external_dma_prepare_data()
1334 sdhci_set_transfer_irqs(host); in __sdhci_external_dma_prepare_data()
1336 sdhci_set_block_info(host, data); in __sdhci_external_dma_prepare_data()
1339 static void sdhci_external_dma_prepare_data(struct sdhci_host *host, in sdhci_external_dma_prepare_data() argument
1342 if (!sdhci_external_dma_setup(host, cmd)) { in sdhci_external_dma_prepare_data()
1343 __sdhci_external_dma_prepare_data(host, cmd); in sdhci_external_dma_prepare_data()
1345 sdhci_external_dma_release(host); in sdhci_external_dma_prepare_data()
1347 mmc_hostname(host->mmc)); in sdhci_external_dma_prepare_data()
1348 sdhci_prepare_data(host, cmd); in sdhci_external_dma_prepare_data()
1352 static void sdhci_external_dma_pre_transfer(struct sdhci_host *host, in sdhci_external_dma_pre_transfer() argument
1357 if (!cmd->data) in sdhci_external_dma_pre_transfer()
1360 chan = sdhci_external_dma_channel(host, cmd->data); in sdhci_external_dma_pre_transfer()
1367 static inline int sdhci_external_dma_init(struct sdhci_host *host) in sdhci_external_dma_init() argument
1369 return -EOPNOTSUPP; in sdhci_external_dma_init()
1372 static inline void sdhci_external_dma_release(struct sdhci_host *host) in sdhci_external_dma_release() argument
1376 static inline void sdhci_external_dma_prepare_data(struct sdhci_host *host, in sdhci_external_dma_prepare_data() argument
1383 static inline void sdhci_external_dma_pre_transfer(struct sdhci_host *host, in sdhci_external_dma_pre_transfer() argument
1388 static inline struct dma_chan *sdhci_external_dma_channel(struct sdhci_host *host, in sdhci_external_dma_channel() argument
1396 void sdhci_switch_external_dma(struct sdhci_host *host, bool en) in sdhci_switch_external_dma() argument
1398 host->use_external_dma = en; in sdhci_switch_external_dma()
1402 static inline bool sdhci_auto_cmd12(struct sdhci_host *host, in sdhci_auto_cmd12() argument
1405 return !mrq->sbc && (host->flags & SDHCI_AUTO_CMD12) && in sdhci_auto_cmd12()
1406 !mrq->cap_cmd_during_tfr; in sdhci_auto_cmd12()
1409 static inline bool sdhci_auto_cmd23(struct sdhci_host *host, in sdhci_auto_cmd23() argument
1412 return mrq->sbc && (host->flags & SDHCI_AUTO_CMD23); in sdhci_auto_cmd23()
1415 static inline bool sdhci_manual_cmd23(struct sdhci_host *host, in sdhci_manual_cmd23() argument
1418 return mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23); in sdhci_manual_cmd23()
1421 static inline void sdhci_auto_cmd_select(struct sdhci_host *host, in sdhci_auto_cmd_select() argument
1425 bool use_cmd12 = sdhci_auto_cmd12(host, cmd->mrq) && in sdhci_auto_cmd_select()
1426 (cmd->opcode != SD_IO_RW_EXTENDED); in sdhci_auto_cmd_select()
1427 bool use_cmd23 = sdhci_auto_cmd23(host, cmd->mrq); in sdhci_auto_cmd_select()
1434 * here because some controllers (e.g sdhci-of-dwmshc) expect it. in sdhci_auto_cmd_select()
1436 if (host->version >= SDHCI_SPEC_410 && host->v4_mode && in sdhci_auto_cmd_select()
1440 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_auto_cmd_select()
1445 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2); in sdhci_auto_cmd_select()
1452 * on successful completion (so no Auto-CMD12). in sdhci_auto_cmd_select()
1460 static void sdhci_set_transfer_mode(struct sdhci_host *host, in sdhci_set_transfer_mode() argument
1464 struct mmc_data *data = cmd->data; in sdhci_set_transfer_mode()
1467 if (host->quirks2 & in sdhci_set_transfer_mode()
1470 if (!mmc_op_tuning(cmd->opcode)) in sdhci_set_transfer_mode()
1471 sdhci_writew(host, 0x0, SDHCI_TRANSFER_MODE); in sdhci_set_transfer_mode()
1474 mode = sdhci_readw(host, SDHCI_TRANSFER_MODE); in sdhci_set_transfer_mode()
1475 sdhci_writew(host, mode & ~(SDHCI_TRNS_AUTO_CMD12 | in sdhci_set_transfer_mode()
1481 WARN_ON(!host->data); in sdhci_set_transfer_mode()
1483 if (!(host->quirks2 & SDHCI_QUIRK2_SUPPORT_SINGLE)) in sdhci_set_transfer_mode()
1486 if (mmc_op_multi(cmd->opcode) || data->blocks > 1) { in sdhci_set_transfer_mode()
1488 sdhci_auto_cmd_select(host, cmd, &mode); in sdhci_set_transfer_mode()
1489 if (sdhci_auto_cmd23(host, cmd->mrq)) in sdhci_set_transfer_mode()
1490 sdhci_writel(host, cmd->mrq->sbc->arg, SDHCI_ARGUMENT2); in sdhci_set_transfer_mode()
1493 if (data->flags & MMC_DATA_READ) in sdhci_set_transfer_mode()
1495 if (host->flags & SDHCI_REQ_USE_DMA) in sdhci_set_transfer_mode()
1498 sdhci_writew(host, mode, SDHCI_TRANSFER_MODE); in sdhci_set_transfer_mode()
1501 bool sdhci_needs_reset(struct sdhci_host *host, struct mmc_request *mrq) in sdhci_needs_reset() argument
1503 return (!(host->flags & SDHCI_DEVICE_DEAD) && in sdhci_needs_reset()
1504 ((mrq->cmd && mrq->cmd->error) || in sdhci_needs_reset()
1505 (mrq->sbc && mrq->sbc->error) || in sdhci_needs_reset()
1506 (mrq->data && mrq->data->stop && mrq->data->stop->error) || in sdhci_needs_reset()
1507 (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))); in sdhci_needs_reset()
1511 static void sdhci_set_mrq_done(struct sdhci_host *host, struct mmc_request *mrq) in sdhci_set_mrq_done() argument
1516 if (host->mrqs_done[i] == mrq) { in sdhci_set_mrq_done()
1523 if (!host->mrqs_done[i]) { in sdhci_set_mrq_done()
1524 host->mrqs_done[i] = mrq; in sdhci_set_mrq_done()
1532 void __sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq) in __sdhci_finish_mrq() argument
1534 if (host->cmd && host->cmd->mrq == mrq) in __sdhci_finish_mrq()
1535 host->cmd = NULL; in __sdhci_finish_mrq()
1537 if (host->data_cmd && host->data_cmd->mrq == mrq) in __sdhci_finish_mrq()
1538 host->data_cmd = NULL; in __sdhci_finish_mrq()
1540 if (host->deferred_cmd && host->deferred_cmd->mrq == mrq) in __sdhci_finish_mrq()
1541 host->deferred_cmd = NULL; in __sdhci_finish_mrq()
1543 if (host->data && host->data->mrq == mrq) in __sdhci_finish_mrq()
1544 host->data = NULL; in __sdhci_finish_mrq()
1546 if (sdhci_needs_reset(host, mrq)) in __sdhci_finish_mrq()
1547 host->pending_reset = true; in __sdhci_finish_mrq()
1549 sdhci_set_mrq_done(host, mrq); in __sdhci_finish_mrq()
1551 sdhci_del_timer(host, mrq); in __sdhci_finish_mrq()
1553 if (!sdhci_has_requests(host)) in __sdhci_finish_mrq()
1554 sdhci_led_deactivate(host); in __sdhci_finish_mrq()
1558 void sdhci_finish_mrq(struct sdhci_host *host, struct mmc_request *mrq) in sdhci_finish_mrq() argument
1560 __sdhci_finish_mrq(host, mrq); in sdhci_finish_mrq()
1562 queue_work(host->complete_wq, &host->complete_work); in sdhci_finish_mrq()
1566 void __sdhci_finish_data_common(struct sdhci_host *host, bool defer_reset) in __sdhci_finish_data_common() argument
1568 struct mmc_command *data_cmd = host->data_cmd; in __sdhci_finish_data_common()
1569 struct mmc_data *data = host->data; in __sdhci_finish_data_common()
1571 host->data = NULL; in __sdhci_finish_data_common()
1572 host->data_cmd = NULL; in __sdhci_finish_data_common()
1578 if (data->error) { in __sdhci_finish_data_common()
1580 host->pending_reset = true; in __sdhci_finish_data_common()
1581 else if (!host->cmd || host->cmd == data_cmd) in __sdhci_finish_data_common()
1582 sdhci_reset_for(host, REQUEST_ERROR); in __sdhci_finish_data_common()
1584 sdhci_reset_for(host, REQUEST_ERROR_DATA_ONLY); in __sdhci_finish_data_common()
1587 if ((host->flags & (SDHCI_REQ_USE_DMA | SDHCI_USE_ADMA)) == in __sdhci_finish_data_common()
1589 sdhci_adma_table_post(host, data); in __sdhci_finish_data_common()
1598 if (data->error) in __sdhci_finish_data_common()
1599 data->bytes_xfered = 0; in __sdhci_finish_data_common()
1601 data->bytes_xfered = data->blksz * data->blocks; in __sdhci_finish_data_common()
1605 static void __sdhci_finish_data(struct sdhci_host *host, bool sw_data_timeout) in __sdhci_finish_data() argument
1607 struct mmc_data *data = host->data; in __sdhci_finish_data()
1609 __sdhci_finish_data_common(host, false); in __sdhci_finish_data()
1612 * Need to send CMD12 if - in __sdhci_finish_data()
1613 * a) open-ended multiblock transfer not using auto CMD12 (no CMD23) in __sdhci_finish_data()
1616 if (data->stop && in __sdhci_finish_data()
1617 ((!data->mrq->sbc && !sdhci_auto_cmd12(host, data->mrq)) || in __sdhci_finish_data()
1618 data->error)) { in __sdhci_finish_data()
1624 if (data->mrq->cap_cmd_during_tfr) { in __sdhci_finish_data()
1625 __sdhci_finish_mrq(host, data->mrq); in __sdhci_finish_data()
1628 host->cmd = NULL; in __sdhci_finish_data()
1629 if (!sdhci_send_command(host, data->stop)) { in __sdhci_finish_data()
1635 data->stop->error = -EIO; in __sdhci_finish_data()
1636 __sdhci_finish_mrq(host, data->mrq); in __sdhci_finish_data()
1638 WARN_ON(host->deferred_cmd); in __sdhci_finish_data()
1639 host->deferred_cmd = data->stop; in __sdhci_finish_data()
1644 __sdhci_finish_mrq(host, data->mrq); in __sdhci_finish_data()
1648 static void sdhci_finish_data(struct sdhci_host *host) in sdhci_finish_data() argument
1650 __sdhci_finish_data(host, false); in sdhci_finish_data()
1653 static bool sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd) in sdhci_send_command() argument
1659 WARN_ON(host->cmd); in sdhci_send_command()
1662 cmd->error = 0; in sdhci_send_command()
1664 if ((host->quirks2 & SDHCI_QUIRK2_STOP_WITH_TC) && in sdhci_send_command()
1665 cmd->opcode == MMC_STOP_TRANSMISSION) in sdhci_send_command()
1666 cmd->flags |= MMC_RSP_BUSY; in sdhci_send_command()
1674 if (cmd->mrq->data && (cmd == cmd->mrq->data->stop)) in sdhci_send_command()
1677 if (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) in sdhci_send_command()
1680 host->cmd = cmd; in sdhci_send_command()
1681 host->data_timeout = 0; in sdhci_send_command()
1683 WARN_ON(host->data_cmd); in sdhci_send_command()
1684 host->data_cmd = cmd; in sdhci_send_command()
1685 sdhci_set_timeout(host, cmd); in sdhci_send_command()
1688 if (cmd->data) { in sdhci_send_command()
1689 if (host->use_external_dma) in sdhci_send_command()
1690 sdhci_external_dma_prepare_data(host, cmd); in sdhci_send_command()
1692 sdhci_prepare_data(host, cmd); in sdhci_send_command()
1695 sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT); in sdhci_send_command()
1697 sdhci_set_transfer_mode(host, cmd); in sdhci_send_command()
1699 if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) { in sdhci_send_command()
1702 * This does not happen in practice because 136-bit response in sdhci_send_command()
1706 cmd->flags &= ~MMC_RSP_BUSY; in sdhci_send_command()
1709 if (!(cmd->flags & MMC_RSP_PRESENT)) in sdhci_send_command()
1711 else if (cmd->flags & MMC_RSP_136) in sdhci_send_command()
1713 else if (cmd->flags & MMC_RSP_BUSY) in sdhci_send_command()
1718 if (cmd->flags & MMC_RSP_CRC) in sdhci_send_command()
1720 if (cmd->flags & MMC_RSP_OPCODE) in sdhci_send_command()
1724 if (cmd->data || mmc_op_tuning(cmd->opcode)) in sdhci_send_command()
1728 if (host->data_timeout) in sdhci_send_command()
1729 timeout += nsecs_to_jiffies(host->data_timeout); in sdhci_send_command()
1730 else if (!cmd->data && cmd->busy_timeout > 9000) in sdhci_send_command()
1731 timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ; in sdhci_send_command()
1734 sdhci_mod_timer(host, cmd->mrq, timeout); in sdhci_send_command()
1736 if (host->use_external_dma) in sdhci_send_command()
1737 sdhci_external_dma_pre_transfer(host, cmd); in sdhci_send_command()
1739 sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND); in sdhci_send_command()
1744 bool sdhci_present_error(struct sdhci_host *host, in sdhci_present_error() argument
1747 if (!present || host->flags & SDHCI_DEVICE_DEAD) { in sdhci_present_error()
1748 cmd->error = -ENOMEDIUM; in sdhci_present_error()
1756 static bool sdhci_send_command_retry(struct sdhci_host *host, in sdhci_send_command_retry() argument
1759 __releases(host->lock) in sdhci_send_command_retry()
1760 __acquires(host->lock) in sdhci_send_command_retry()
1762 struct mmc_command *deferred_cmd = host->deferred_cmd; in sdhci_send_command_retry()
1766 while (!sdhci_send_command(host, cmd)) { in sdhci_send_command_retry()
1767 if (!timeout--) { in sdhci_send_command_retry()
1769 mmc_hostname(host->mmc)); in sdhci_send_command_retry()
1770 sdhci_err_stats_inc(host, CTRL_TIMEOUT); in sdhci_send_command_retry()
1771 sdhci_dumpregs(host); in sdhci_send_command_retry()
1772 cmd->error = -EIO; in sdhci_send_command_retry()
1776 spin_unlock_irqrestore(&host->lock, flags); in sdhci_send_command_retry()
1780 present = host->mmc->ops->get_cd(host->mmc); in sdhci_send_command_retry()
1782 spin_lock_irqsave(&host->lock, flags); in sdhci_send_command_retry()
1785 if (cmd == deferred_cmd && cmd != host->deferred_cmd) in sdhci_send_command_retry()
1788 if (sdhci_present_error(host, cmd, present)) in sdhci_send_command_retry()
1792 if (cmd == host->deferred_cmd) in sdhci_send_command_retry()
1793 host->deferred_cmd = NULL; in sdhci_send_command_retry()
1798 static void sdhci_read_rsp_136(struct sdhci_host *host, struct mmc_command *cmd) in sdhci_read_rsp_136() argument
1803 reg = SDHCI_RESPONSE + (3 - i) * 4; in sdhci_read_rsp_136()
1804 cmd->resp[i] = sdhci_readl(host, reg); in sdhci_read_rsp_136()
1807 if (host->quirks2 & SDHCI_QUIRK2_RSP_136_HAS_CRC) in sdhci_read_rsp_136()
1812 cmd->resp[i] <<= 8; in sdhci_read_rsp_136()
1814 cmd->resp[i] |= cmd->resp[i + 1] >> 24; in sdhci_read_rsp_136()
1818 static void sdhci_finish_command(struct sdhci_host *host) in sdhci_finish_command() argument
1820 struct mmc_command *cmd = host->cmd; in sdhci_finish_command()
1822 host->cmd = NULL; in sdhci_finish_command()
1824 if (cmd->flags & MMC_RSP_PRESENT) { in sdhci_finish_command()
1825 if (cmd->flags & MMC_RSP_136) { in sdhci_finish_command()
1826 sdhci_read_rsp_136(host, cmd); in sdhci_finish_command()
1828 cmd->resp[0] = sdhci_readl(host, SDHCI_RESPONSE); in sdhci_finish_command()
1832 if (cmd->mrq->cap_cmd_during_tfr && cmd == cmd->mrq->cmd) in sdhci_finish_command()
1833 mmc_command_done(host->mmc, cmd->mrq); in sdhci_finish_command()
1836 * The host can send and interrupt when the busy state has in sdhci_finish_command()
1845 if (cmd->flags & MMC_RSP_BUSY) { in sdhci_finish_command()
1846 if (cmd->data) { in sdhci_finish_command()
1848 } else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ) && in sdhci_finish_command()
1849 cmd == host->data_cmd) { in sdhci_finish_command()
1856 if (cmd == cmd->mrq->sbc) { in sdhci_finish_command()
1857 if (!sdhci_send_command(host, cmd->mrq->cmd)) { in sdhci_finish_command()
1858 WARN_ON(host->deferred_cmd); in sdhci_finish_command()
1859 host->deferred_cmd = cmd->mrq->cmd; in sdhci_finish_command()
1864 if (host->data && host->data_early) in sdhci_finish_command()
1865 sdhci_finish_data(host); in sdhci_finish_command()
1867 if (!cmd->data) in sdhci_finish_command()
1868 __sdhci_finish_mrq(host, cmd->mrq); in sdhci_finish_command()
1872 static u16 sdhci_get_preset_value(struct sdhci_host *host) in sdhci_get_preset_value() argument
1876 switch (host->timing) { in sdhci_get_preset_value()
1879 preset = sdhci_readw(host, SDHCI_PRESET_FOR_HIGH_SPEED); in sdhci_get_preset_value()
1882 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12); in sdhci_get_preset_value()
1885 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR25); in sdhci_get_preset_value()
1888 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR50); in sdhci_get_preset_value()
1892 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR104); in sdhci_get_preset_value()
1896 preset = sdhci_readw(host, SDHCI_PRESET_FOR_DDR50); in sdhci_get_preset_value()
1899 preset = sdhci_readw(host, SDHCI_PRESET_FOR_HS400); in sdhci_get_preset_value()
1905 preset = sdhci_readw(host, SDHCI_PRESET_FOR_UHS2); in sdhci_get_preset_value()
1908 pr_warn("%s: Invalid UHS-I mode selected\n", in sdhci_get_preset_value()
1909 mmc_hostname(host->mmc)); in sdhci_get_preset_value()
1910 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12); in sdhci_get_preset_value()
1916 u16 sdhci_calc_clk(struct sdhci_host *host, unsigned int clock, in sdhci_calc_clk() argument
1924 if (host->version >= SDHCI_SPEC_300) { in sdhci_calc_clk()
1925 if (host->preset_enabled) { in sdhci_calc_clk()
1928 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL); in sdhci_calc_clk()
1929 pre_val = sdhci_get_preset_value(host); in sdhci_calc_clk()
1931 if (host->clk_mul && in sdhci_calc_clk()
1935 clk_mul = host->clk_mul; in sdhci_calc_clk()
1943 * Check if the Host Controller supports Programmable Clock in sdhci_calc_clk()
1946 if (host->clk_mul) { in sdhci_calc_clk()
1948 if ((host->max_clk * host->clk_mul / div) in sdhci_calc_clk()
1952 if ((host->max_clk * host->clk_mul / div) <= clock) { in sdhci_calc_clk()
1959 clk_mul = host->clk_mul; in sdhci_calc_clk()
1960 div--; in sdhci_calc_clk()
1970 if (!host->clk_mul || switch_base_clk) { in sdhci_calc_clk()
1972 if (host->max_clk <= clock) in sdhci_calc_clk()
1977 if ((host->max_clk / div) <= clock) in sdhci_calc_clk()
1983 if ((host->quirks2 & SDHCI_QUIRK2_CLOCK_DIV_ZERO_BROKEN) in sdhci_calc_clk()
1984 && !div && host->max_clk <= 25000000) in sdhci_calc_clk()
1990 if ((host->max_clk / div) <= clock) in sdhci_calc_clk()
1999 *actual_clock = (host->max_clk * clk_mul) / real_div; in sdhci_calc_clk()
2008 void sdhci_enable_clk(struct sdhci_host *host, u16 clk) in sdhci_enable_clk() argument
2013 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); in sdhci_enable_clk()
2020 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL); in sdhci_enable_clk()
2025 mmc_hostname(host->mmc)); in sdhci_enable_clk()
2026 sdhci_err_stats_inc(host, CTRL_TIMEOUT); in sdhci_enable_clk()
2027 sdhci_dumpregs(host); in sdhci_enable_clk()
2033 if (host->version >= SDHCI_SPEC_410 && host->v4_mode) { in sdhci_enable_clk()
2036 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); in sdhci_enable_clk()
2043 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL); in sdhci_enable_clk()
2048 mmc_hostname(host->mmc)); in sdhci_enable_clk()
2049 sdhci_err_stats_inc(host, CTRL_TIMEOUT); in sdhci_enable_clk()
2050 sdhci_dumpregs(host); in sdhci_enable_clk()
2058 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); in sdhci_enable_clk()
2062 void sdhci_set_clock(struct sdhci_host *host, unsigned int clock) in sdhci_set_clock() argument
2066 host->mmc->actual_clock = 0; in sdhci_set_clock()
2068 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL); in sdhci_set_clock()
2070 sdhci_writew(host, clk & ~SDHCI_CLOCK_CARD_EN, in sdhci_set_clock()
2074 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); in sdhci_set_clock()
2078 clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock); in sdhci_set_clock()
2079 sdhci_enable_clk(host, clk); in sdhci_set_clock()
2083 static void sdhci_set_power_reg(struct sdhci_host *host, unsigned char mode, in sdhci_set_power_reg() argument
2086 struct mmc_host *mmc = host->mmc; in sdhci_set_power_reg() local
2088 mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd); in sdhci_set_power_reg()
2091 sdhci_writeb(host, SDHCI_POWER_ON, SDHCI_POWER_CONTROL); in sdhci_set_power_reg()
2093 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL); in sdhci_set_power_reg()
2126 void sdhci_set_power_noreg(struct sdhci_host *host, unsigned char mode, in sdhci_set_power_noreg() argument
2135 mmc_hostname(host->mmc), vdd); in sdhci_set_power_noreg()
2139 if (host->pwr == pwr) in sdhci_set_power_noreg()
2142 host->pwr = pwr; in sdhci_set_power_noreg()
2145 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL); in sdhci_set_power_noreg()
2146 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON) in sdhci_set_power_noreg()
2147 sdhci_runtime_pm_bus_off(host); in sdhci_set_power_noreg()
2153 if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE)) in sdhci_set_power_noreg()
2154 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL); in sdhci_set_power_noreg()
2161 if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER) in sdhci_set_power_noreg()
2162 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL); in sdhci_set_power_noreg()
2166 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL); in sdhci_set_power_noreg()
2168 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON) in sdhci_set_power_noreg()
2169 sdhci_runtime_pm_bus_on(host); in sdhci_set_power_noreg()
2175 if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER) in sdhci_set_power_noreg()
2181 void sdhci_set_power(struct sdhci_host *host, unsigned char mode, in sdhci_set_power() argument
2184 if (IS_ERR(host->mmc->supply.vmmc)) in sdhci_set_power()
2185 sdhci_set_power_noreg(host, mode, vdd); in sdhci_set_power()
2187 sdhci_set_power_reg(host, mode, vdd); in sdhci_set_power()
2197 void sdhci_set_power_and_bus_voltage(struct sdhci_host *host, in sdhci_set_power_and_bus_voltage() argument
2201 if (!IS_ERR(host->mmc->supply.vmmc)) { in sdhci_set_power_and_bus_voltage()
2202 struct mmc_host *mmc = host->mmc; in sdhci_set_power_and_bus_voltage() local
2204 mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd); in sdhci_set_power_and_bus_voltage()
2206 sdhci_set_power_noreg(host, mode, vdd); in sdhci_set_power_and_bus_voltage()
2212 * MMC callbacks *
2216 void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq) in sdhci_request() argument
2218 struct sdhci_host *host = mmc_priv(mmc); in sdhci_request() local
2224 present = mmc->ops->get_cd(mmc); in sdhci_request()
2226 spin_lock_irqsave(&host->lock, flags); in sdhci_request()
2228 sdhci_led_activate(host); in sdhci_request()
2230 if (sdhci_present_error(host, mrq->cmd, present)) in sdhci_request()
2233 cmd = sdhci_manual_cmd23(host, mrq) ? mrq->sbc : mrq->cmd; in sdhci_request()
2235 if (!sdhci_send_command_retry(host, cmd, flags)) in sdhci_request()
2238 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request()
2243 sdhci_finish_mrq(host, mrq); in sdhci_request()
2244 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request()
2248 int sdhci_request_atomic(struct mmc_host *mmc, struct mmc_request *mrq) in sdhci_request_atomic() argument
2250 struct sdhci_host *host = mmc_priv(mmc); in sdhci_request_atomic() local
2255 spin_lock_irqsave(&host->lock, flags); in sdhci_request_atomic()
2257 if (sdhci_present_error(host, mrq->cmd, true)) { in sdhci_request_atomic()
2258 sdhci_finish_mrq(host, mrq); in sdhci_request_atomic()
2262 cmd = sdhci_manual_cmd23(host, mrq) ? mrq->sbc : mrq->cmd; in sdhci_request_atomic()
2268 * again in non-atomic context. So we should not finish this request in sdhci_request_atomic()
2271 if (!sdhci_send_command(host, cmd)) in sdhci_request_atomic()
2272 ret = -EBUSY; in sdhci_request_atomic()
2274 sdhci_led_activate(host); in sdhci_request_atomic()
2277 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request_atomic()
2282 void sdhci_set_bus_width(struct sdhci_host *host, int width) in sdhci_set_bus_width() argument
2286 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); in sdhci_set_bus_width()
2291 if (host->mmc->caps & MMC_CAP_8_BIT_DATA) in sdhci_set_bus_width()
2298 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in sdhci_set_bus_width()
2302 void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing) in sdhci_set_uhs_signaling() argument
2306 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_set_uhs_signaling()
2307 /* Select Bus Speed Mode for host */ in sdhci_set_uhs_signaling()
2322 ctrl_2 |= SDHCI_CTRL_HS400; /* Non-standard */ in sdhci_set_uhs_signaling()
2323 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2); in sdhci_set_uhs_signaling()
2341 static bool sdhci_preset_needed(struct sdhci_host *host, unsigned char timing) in sdhci_preset_needed() argument
2343 return !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN) && in sdhci_preset_needed()
2347 static bool sdhci_presetable_values_change(struct sdhci_host *host, struct mmc_ios *ios) in sdhci_presetable_values_change() argument
2354 return !host->preset_enabled && in sdhci_presetable_values_change()
2355 (sdhci_preset_needed(host, ios->timing) || host->drv_type != ios->drv_type); in sdhci_presetable_values_change()
2358 void sdhci_set_ios_common(struct mmc_host *mmc, struct mmc_ios *ios) in sdhci_set_ios_common() argument
2360 struct sdhci_host *host = mmc_priv(mmc); in sdhci_set_ios_common() local
2366 if (ios->power_mode == MMC_POWER_OFF) { in sdhci_set_ios_common()
2367 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE); in sdhci_set_ios_common()
2368 sdhci_reinit(host); in sdhci_set_ios_common()
2371 if (host->version >= SDHCI_SPEC_300 && in sdhci_set_ios_common()
2372 (ios->power_mode == MMC_POWER_UP) && in sdhci_set_ios_common()
2373 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) in sdhci_set_ios_common()
2374 sdhci_enable_preset_value(host, false); in sdhci_set_ios_common()
2376 if (!ios->clock || ios->clock != host->clock) { in sdhci_set_ios_common()
2377 host->ops->set_clock(host, ios->clock); in sdhci_set_ios_common()
2378 host->clock = ios->clock; in sdhci_set_ios_common()
2380 if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK && in sdhci_set_ios_common()
2381 host->clock) { in sdhci_set_ios_common()
2382 host->timeout_clk = mmc->actual_clock ? in sdhci_set_ios_common()
2383 mmc->actual_clock / 1000 : in sdhci_set_ios_common()
2384 host->clock / 1000; in sdhci_set_ios_common()
2385 mmc->max_busy_timeout = in sdhci_set_ios_common()
2386 host->ops->get_max_timeout_count ? in sdhci_set_ios_common()
2387 host->ops->get_max_timeout_count(host) : in sdhci_set_ios_common()
2389 mmc->max_busy_timeout /= host->timeout_clk; in sdhci_set_ios_common()
2395 void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) in sdhci_set_ios() argument
2397 struct sdhci_host *host = mmc_priv(mmc); in sdhci_set_ios() local
2398 bool reinit_uhs = host->reinit_uhs; in sdhci_set_ios()
2402 host->reinit_uhs = false; in sdhci_set_ios()
2404 if (ios->power_mode == MMC_POWER_UNDEFINED) in sdhci_set_ios()
2407 if (host->flags & SDHCI_DEVICE_DEAD) { in sdhci_set_ios()
2408 if (!IS_ERR(mmc->supply.vmmc) && in sdhci_set_ios()
2409 ios->power_mode == MMC_POWER_OFF) in sdhci_set_ios()
2410 mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, 0); in sdhci_set_ios()
2414 turning_on_clk = ios->clock != host->clock && ios->clock && !host->clock; in sdhci_set_ios()
2416 sdhci_set_ios_common(mmc, ios); in sdhci_set_ios()
2418 if (host->ops->set_power) in sdhci_set_ios()
2419 host->ops->set_power(host, ios->power_mode, ios->vdd); in sdhci_set_ios()
2421 sdhci_set_power(host, ios->power_mode, ios->vdd); in sdhci_set_ios()
2423 if (host->ops->platform_send_init_74_clocks) in sdhci_set_ios()
2424 host->ops->platform_send_init_74_clocks(host, ios->power_mode); in sdhci_set_ios()
2426 host->ops->set_bus_width(host, ios->bus_width); in sdhci_set_ios()
2434 host->timing == ios->timing && in sdhci_set_ios()
2435 host->version >= SDHCI_SPEC_300 && in sdhci_set_ios()
2436 !sdhci_presetable_values_change(host, ios)) in sdhci_set_ios()
2439 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); in sdhci_set_ios()
2441 if (!(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT)) { in sdhci_set_ios()
2442 if (ios->timing == MMC_TIMING_SD_HS || in sdhci_set_ios()
2443 ios->timing == MMC_TIMING_MMC_HS || in sdhci_set_ios()
2444 ios->timing == MMC_TIMING_MMC_HS400 || in sdhci_set_ios()
2445 ios->timing == MMC_TIMING_MMC_HS200 || in sdhci_set_ios()
2446 ios->timing == MMC_TIMING_MMC_DDR52 || in sdhci_set_ios()
2447 ios->timing == MMC_TIMING_UHS_SDR50 || in sdhci_set_ios()
2448 ios->timing == MMC_TIMING_UHS_SDR104 || in sdhci_set_ios()
2449 ios->timing == MMC_TIMING_UHS_DDR50 || in sdhci_set_ios()
2450 ios->timing == MMC_TIMING_UHS_SDR25) in sdhci_set_ios()
2456 if (host->version >= SDHCI_SPEC_300) { in sdhci_set_ios()
2461 * Enable in the Host Control 2 register is set, we in sdhci_set_ios()
2465 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL); in sdhci_set_ios()
2468 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL); in sdhci_set_ios()
2471 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in sdhci_set_ios()
2473 if (!host->preset_enabled) { in sdhci_set_ios()
2478 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_set_ios()
2480 if (ios->drv_type == MMC_SET_DRIVER_TYPE_A) in sdhci_set_ios()
2482 else if (ios->drv_type == MMC_SET_DRIVER_TYPE_B) in sdhci_set_ios()
2484 else if (ios->drv_type == MMC_SET_DRIVER_TYPE_C) in sdhci_set_ios()
2486 else if (ios->drv_type == MMC_SET_DRIVER_TYPE_D) in sdhci_set_ios()
2490 mmc_hostname(mmc)); in sdhci_set_ios()
2494 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2); in sdhci_set_ios()
2495 host->drv_type = ios->drv_type; in sdhci_set_ios()
2498 host->ops->set_uhs_signaling(host, ios->timing); in sdhci_set_ios()
2499 host->timing = ios->timing; in sdhci_set_ios()
2501 if (sdhci_preset_needed(host, ios->timing)) { in sdhci_set_ios()
2504 sdhci_enable_preset_value(host, true); in sdhci_set_ios()
2505 preset = sdhci_get_preset_value(host); in sdhci_set_ios()
2506 ios->drv_type = FIELD_GET(SDHCI_PRESET_DRV_MASK, in sdhci_set_ios()
2508 host->drv_type = ios->drv_type; in sdhci_set_ios()
2511 /* Re-enable SD Clock */ in sdhci_set_ios()
2512 host->ops->set_clock(host, host->clock); in sdhci_set_ios()
2514 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in sdhci_set_ios()
2518 static int sdhci_get_cd(struct mmc_host *mmc) in sdhci_get_cd() argument
2520 struct sdhci_host *host = mmc_priv(mmc); in sdhci_get_cd() local
2521 int gpio_cd = mmc_gpio_get_cd(mmc); in sdhci_get_cd()
2523 if (host->flags & SDHCI_DEVICE_DEAD) in sdhci_get_cd()
2527 if (!mmc_card_is_removable(mmc)) in sdhci_get_cd()
2538 if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) in sdhci_get_cd()
2541 /* Host native card detect */ in sdhci_get_cd()
2542 return !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT); in sdhci_get_cd()
2545 int sdhci_get_cd_nogpio(struct mmc_host *mmc) in sdhci_get_cd_nogpio() argument
2547 struct sdhci_host *host = mmc_priv(mmc); in sdhci_get_cd_nogpio() local
2551 spin_lock_irqsave(&host->lock, flags); in sdhci_get_cd_nogpio()
2553 if (host->flags & SDHCI_DEVICE_DEAD) in sdhci_get_cd_nogpio()
2556 ret = !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT); in sdhci_get_cd_nogpio()
2558 spin_unlock_irqrestore(&host->lock, flags); in sdhci_get_cd_nogpio()
2564 int sdhci_get_ro(struct mmc_host *mmc) in sdhci_get_ro() argument
2566 struct sdhci_host *host = mmc_priv(mmc); in sdhci_get_ro() local
2570 if (host->flags & SDHCI_DEVICE_DEAD) { in sdhci_get_ro()
2572 } else if (host->ops->get_ro) { in sdhci_get_ro()
2573 is_readonly = host->ops->get_ro(host); in sdhci_get_ro()
2574 } else if (mmc_can_gpio_ro(mmc)) { in sdhci_get_ro()
2575 is_readonly = mmc_gpio_get_ro(mmc); in sdhci_get_ro()
2577 allow_invert = !(mmc->caps2 & MMC_CAP2_RO_ACTIVE_HIGH); in sdhci_get_ro()
2579 is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE) in sdhci_get_ro()
2586 (host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT)) in sdhci_get_ro()
2593 static void sdhci_hw_reset(struct mmc_host *mmc) in sdhci_hw_reset() argument
2595 struct sdhci_host *host = mmc_priv(mmc); in sdhci_hw_reset() local
2597 if (host->ops && host->ops->hw_reset) in sdhci_hw_reset()
2598 host->ops->hw_reset(host); in sdhci_hw_reset()
2601 static void sdhci_enable_sdio_irq_nolock(struct sdhci_host *host, int enable) in sdhci_enable_sdio_irq_nolock() argument
2603 if (!(host->flags & SDHCI_DEVICE_DEAD)) { in sdhci_enable_sdio_irq_nolock()
2605 host->ier |= SDHCI_INT_CARD_INT; in sdhci_enable_sdio_irq_nolock()
2607 host->ier &= ~SDHCI_INT_CARD_INT; in sdhci_enable_sdio_irq_nolock()
2609 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_enable_sdio_irq_nolock()
2610 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_enable_sdio_irq_nolock()
2614 void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable) in sdhci_enable_sdio_irq() argument
2616 struct sdhci_host *host = mmc_priv(mmc); in sdhci_enable_sdio_irq() local
2620 pm_runtime_get_noresume(mmc_dev(mmc)); in sdhci_enable_sdio_irq()
2622 spin_lock_irqsave(&host->lock, flags); in sdhci_enable_sdio_irq()
2623 sdhci_enable_sdio_irq_nolock(host, enable); in sdhci_enable_sdio_irq()
2624 spin_unlock_irqrestore(&host->lock, flags); in sdhci_enable_sdio_irq()
2627 pm_runtime_put_noidle(mmc_dev(mmc)); in sdhci_enable_sdio_irq()
2631 static void sdhci_ack_sdio_irq(struct mmc_host *mmc) in sdhci_ack_sdio_irq() argument
2633 struct sdhci_host *host = mmc_priv(mmc); in sdhci_ack_sdio_irq() local
2636 spin_lock_irqsave(&host->lock, flags); in sdhci_ack_sdio_irq()
2637 sdhci_enable_sdio_irq_nolock(host, true); in sdhci_ack_sdio_irq()
2638 spin_unlock_irqrestore(&host->lock, flags); in sdhci_ack_sdio_irq()
2641 int sdhci_start_signal_voltage_switch(struct mmc_host *mmc, in sdhci_start_signal_voltage_switch() argument
2644 struct sdhci_host *host = mmc_priv(mmc); in sdhci_start_signal_voltage_switch() local
2649 * Signal Voltage Switching is only applicable for Host Controllers in sdhci_start_signal_voltage_switch()
2652 if (host->version < SDHCI_SPEC_300) in sdhci_start_signal_voltage_switch()
2655 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_start_signal_voltage_switch()
2657 switch (ios->signal_voltage) { in sdhci_start_signal_voltage_switch()
2659 if (!(host->flags & SDHCI_SIGNALING_330)) in sdhci_start_signal_voltage_switch()
2660 return -EINVAL; in sdhci_start_signal_voltage_switch()
2661 /* Set 1.8V Signal Enable in the Host Control2 register to 0 */ in sdhci_start_signal_voltage_switch()
2663 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2); in sdhci_start_signal_voltage_switch()
2665 if (!IS_ERR(mmc->supply.vqmmc)) { in sdhci_start_signal_voltage_switch()
2666 ret = mmc_regulator_set_vqmmc(mmc, ios); in sdhci_start_signal_voltage_switch()
2669 mmc_hostname(mmc)); in sdhci_start_signal_voltage_switch()
2670 return -EIO; in sdhci_start_signal_voltage_switch()
2677 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_start_signal_voltage_switch()
2682 mmc_hostname(mmc)); in sdhci_start_signal_voltage_switch()
2684 return -EAGAIN; in sdhci_start_signal_voltage_switch()
2686 if (!(host->flags & SDHCI_SIGNALING_180)) in sdhci_start_signal_voltage_switch()
2687 return -EINVAL; in sdhci_start_signal_voltage_switch()
2688 if (!IS_ERR(mmc->supply.vqmmc)) { in sdhci_start_signal_voltage_switch()
2689 ret = mmc_regulator_set_vqmmc(mmc, ios); in sdhci_start_signal_voltage_switch()
2692 mmc_hostname(mmc)); in sdhci_start_signal_voltage_switch()
2693 return -EIO; in sdhci_start_signal_voltage_switch()
2698 * Enable 1.8V Signal Enable in the Host Control2 in sdhci_start_signal_voltage_switch()
2702 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2); in sdhci_start_signal_voltage_switch()
2705 if (host->ops->voltage_switch) in sdhci_start_signal_voltage_switch()
2706 host->ops->voltage_switch(host); in sdhci_start_signal_voltage_switch()
2709 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_start_signal_voltage_switch()
2714 mmc_hostname(mmc)); in sdhci_start_signal_voltage_switch()
2716 return -EAGAIN; in sdhci_start_signal_voltage_switch()
2718 if (!(host->flags & SDHCI_SIGNALING_120)) in sdhci_start_signal_voltage_switch()
2719 return -EINVAL; in sdhci_start_signal_voltage_switch()
2720 if (!IS_ERR(mmc->supply.vqmmc)) { in sdhci_start_signal_voltage_switch()
2721 ret = mmc_regulator_set_vqmmc(mmc, ios); in sdhci_start_signal_voltage_switch()
2724 mmc_hostname(mmc)); in sdhci_start_signal_voltage_switch()
2725 return -EIO; in sdhci_start_signal_voltage_switch()
2736 static int sdhci_card_busy(struct mmc_host *mmc) in sdhci_card_busy() argument
2738 struct sdhci_host *host = mmc_priv(mmc); in sdhci_card_busy() local
2742 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE); in sdhci_card_busy()
2747 static int sdhci_prepare_hs400_tuning(struct mmc_host *mmc, struct mmc_ios *ios) in sdhci_prepare_hs400_tuning() argument
2749 struct sdhci_host *host = mmc_priv(mmc); in sdhci_prepare_hs400_tuning() local
2752 spin_lock_irqsave(&host->lock, flags); in sdhci_prepare_hs400_tuning()
2753 host->flags |= SDHCI_HS400_TUNING; in sdhci_prepare_hs400_tuning()
2754 spin_unlock_irqrestore(&host->lock, flags); in sdhci_prepare_hs400_tuning()
2759 void sdhci_start_tuning(struct sdhci_host *host) in sdhci_start_tuning() argument
2763 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_start_tuning()
2765 if (host->quirks2 & SDHCI_QUIRK2_TUNING_WORK_AROUND) in sdhci_start_tuning()
2767 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2); in sdhci_start_tuning()
2770 * As per the Host Controller spec v3.00, tuning command in sdhci_start_tuning()
2779 sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_INT_ENABLE); in sdhci_start_tuning()
2780 sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_SIGNAL_ENABLE); in sdhci_start_tuning()
2784 void sdhci_end_tuning(struct sdhci_host *host) in sdhci_end_tuning() argument
2786 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_end_tuning()
2787 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_end_tuning()
2791 void sdhci_reset_tuning(struct sdhci_host *host) in sdhci_reset_tuning() argument
2795 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_reset_tuning()
2798 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2); in sdhci_reset_tuning()
2802 void sdhci_abort_tuning(struct sdhci_host *host, u32 opcode) in sdhci_abort_tuning() argument
2804 sdhci_reset_tuning(host); in sdhci_abort_tuning()
2806 sdhci_reset_for(host, TUNING_ABORT); in sdhci_abort_tuning()
2808 sdhci_end_tuning(host); in sdhci_abort_tuning()
2810 mmc_send_abort_tuning(host->mmc, opcode); in sdhci_abort_tuning()
2817 * automatically) so mmc_send_tuning() will return -EIO. Also the tuning command
2821 void sdhci_send_tuning(struct sdhci_host *host, u32 opcode) in sdhci_send_tuning() argument
2823 struct mmc_host *mmc = host->mmc; in sdhci_send_tuning() local
2827 u32 b = host->sdma_boundary; in sdhci_send_tuning()
2829 spin_lock_irqsave(&host->lock, flags); in sdhci_send_tuning()
2838 * block to the Host Controller. So we set the block size in sdhci_send_tuning()
2842 mmc->ios.bus_width == MMC_BUS_WIDTH_8) in sdhci_send_tuning()
2843 sdhci_writew(host, SDHCI_MAKE_BLKSZ(b, 128), SDHCI_BLOCK_SIZE); in sdhci_send_tuning()
2845 sdhci_writew(host, SDHCI_MAKE_BLKSZ(b, 64), SDHCI_BLOCK_SIZE); in sdhci_send_tuning()
2848 * The tuning block is sent by the card to the host controller. in sdhci_send_tuning()
2853 sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE); in sdhci_send_tuning()
2855 if (!sdhci_send_command_retry(host, &cmd, flags)) { in sdhci_send_tuning()
2856 spin_unlock_irqrestore(&host->lock, flags); in sdhci_send_tuning()
2857 host->tuning_done = 0; in sdhci_send_tuning()
2861 host->cmd = NULL; in sdhci_send_tuning()
2863 sdhci_del_timer(host, &mrq); in sdhci_send_tuning()
2865 host->tuning_done = 0; in sdhci_send_tuning()
2867 spin_unlock_irqrestore(&host->lock, flags); in sdhci_send_tuning()
2870 wait_event_timeout(host->buf_ready_int, (host->tuning_done == 1), in sdhci_send_tuning()
2876 int __sdhci_execute_tuning(struct sdhci_host *host, u32 opcode) in __sdhci_execute_tuning() argument
2884 for (i = 0; i < host->tuning_loop_count; i++) { in __sdhci_execute_tuning()
2887 sdhci_send_tuning(host, opcode); in __sdhci_execute_tuning()
2889 if (!host->tuning_done) { in __sdhci_execute_tuning()
2891 mmc_hostname(host->mmc)); in __sdhci_execute_tuning()
2892 sdhci_abort_tuning(host, opcode); in __sdhci_execute_tuning()
2893 return -ETIMEDOUT; in __sdhci_execute_tuning()
2897 if (host->tuning_delay > 0) in __sdhci_execute_tuning()
2898 mdelay(host->tuning_delay); in __sdhci_execute_tuning()
2900 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in __sdhci_execute_tuning()
2910 mmc_hostname(host->mmc)); in __sdhci_execute_tuning()
2911 sdhci_reset_tuning(host); in __sdhci_execute_tuning()
2912 return -EAGAIN; in __sdhci_execute_tuning()
2916 int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode) in sdhci_execute_tuning() argument
2918 struct sdhci_host *host = mmc_priv(mmc); in sdhci_execute_tuning() local
2923 hs400_tuning = host->flags & SDHCI_HS400_TUNING; in sdhci_execute_tuning()
2925 if (host->tuning_mode == SDHCI_TUNING_MODE_1) in sdhci_execute_tuning()
2926 tuning_count = host->tuning_count; in sdhci_execute_tuning()
2929 * The Host Controller needs tuning in case of SDR104 and DDR50 in sdhci_execute_tuning()
2932 * If the Host Controller supports the HS200 mode then the in sdhci_execute_tuning()
2935 switch (host->timing) { in sdhci_execute_tuning()
2938 err = -EINVAL; in sdhci_execute_tuning()
2943 * Periodic re-tuning for HS400 is not expected to be needed, so in sdhci_execute_tuning()
2955 if (host->flags & SDHCI_SDR50_NEEDS_TUNING) in sdhci_execute_tuning()
2963 if (host->ops->platform_execute_tuning) { in sdhci_execute_tuning()
2964 err = host->ops->platform_execute_tuning(host, opcode); in sdhci_execute_tuning()
2968 mmc->retune_period = tuning_count; in sdhci_execute_tuning()
2970 if (host->tuning_delay < 0) in sdhci_execute_tuning()
2971 host->tuning_delay = opcode == MMC_SEND_TUNING_BLOCK; in sdhci_execute_tuning()
2973 sdhci_start_tuning(host); in sdhci_execute_tuning()
2975 host->tuning_err = __sdhci_execute_tuning(host, opcode); in sdhci_execute_tuning()
2977 sdhci_end_tuning(host); in sdhci_execute_tuning()
2979 host->flags &= ~SDHCI_HS400_TUNING; in sdhci_execute_tuning()
2985 void sdhci_enable_preset_value(struct sdhci_host *host, bool enable) in sdhci_enable_preset_value() argument
2987 /* Host Controller v3.00 defines preset value registers */ in sdhci_enable_preset_value()
2988 if (host->version < SDHCI_SPEC_300) in sdhci_enable_preset_value()
2995 if (host->preset_enabled != enable) { in sdhci_enable_preset_value()
2996 u16 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_enable_preset_value()
3003 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2); in sdhci_enable_preset_value()
3006 host->flags |= SDHCI_PV_ENABLED; in sdhci_enable_preset_value()
3008 host->flags &= ~SDHCI_PV_ENABLED; in sdhci_enable_preset_value()
3010 host->preset_enabled = enable; in sdhci_enable_preset_value()
3015 static void sdhci_post_req(struct mmc_host *mmc, struct mmc_request *mrq, in sdhci_post_req() argument
3018 struct mmc_data *data = mrq->data; in sdhci_post_req()
3020 if (data->host_cookie != COOKIE_UNMAPPED) in sdhci_post_req()
3021 dma_unmap_sg(mmc_dev(mmc), data->sg, data->sg_len, in sdhci_post_req()
3024 data->host_cookie = COOKIE_UNMAPPED; in sdhci_post_req()
3027 static void sdhci_pre_req(struct mmc_host *mmc, struct mmc_request *mrq) in sdhci_pre_req() argument
3029 struct sdhci_host *host = mmc_priv(mmc); in sdhci_pre_req() local
3031 mrq->data->host_cookie = COOKIE_UNMAPPED; in sdhci_pre_req()
3034 * No pre-mapping in the pre hook if we're using the bounce buffer, in sdhci_pre_req()
3038 if (host->flags & SDHCI_REQ_USE_DMA && !host->bounce_buffer) in sdhci_pre_req()
3039 sdhci_pre_dma_transfer(host, mrq->data, COOKIE_PRE_MAPPED); in sdhci_pre_req()
3042 static void sdhci_error_out_mrqs(struct sdhci_host *host, int err) in sdhci_error_out_mrqs() argument
3044 if (host->data_cmd) { in sdhci_error_out_mrqs()
3045 host->data_cmd->error = err; in sdhci_error_out_mrqs()
3046 sdhci_finish_mrq(host, host->data_cmd->mrq); in sdhci_error_out_mrqs()
3049 if (host->cmd) { in sdhci_error_out_mrqs()
3050 host->cmd->error = err; in sdhci_error_out_mrqs()
3051 sdhci_finish_mrq(host, host->cmd->mrq); in sdhci_error_out_mrqs()
3055 static void sdhci_card_event(struct mmc_host *mmc) in sdhci_card_event() argument
3057 struct sdhci_host *host = mmc_priv(mmc); in sdhci_card_event() local
3062 if (host->ops->card_event) in sdhci_card_event()
3063 host->ops->card_event(host); in sdhci_card_event()
3065 present = mmc->ops->get_cd(mmc); in sdhci_card_event()
3067 spin_lock_irqsave(&host->lock, flags); in sdhci_card_event()
3070 if (sdhci_has_requests(host) && !present) { in sdhci_card_event()
3072 mmc_hostname(mmc)); in sdhci_card_event()
3074 mmc_hostname(mmc)); in sdhci_card_event()
3076 sdhci_reset_for(host, CARD_REMOVED); in sdhci_card_event()
3078 sdhci_error_out_mrqs(host, -ENOMEDIUM); in sdhci_card_event()
3081 spin_unlock_irqrestore(&host->lock, flags); in sdhci_card_event()
3107 void sdhci_request_done_dma(struct sdhci_host *host, struct mmc_request *mrq) in sdhci_request_done_dma() argument
3109 struct mmc_data *data = mrq->data; in sdhci_request_done_dma()
3111 if (data && data->host_cookie == COOKIE_MAPPED) { in sdhci_request_done_dma()
3112 if (host->bounce_buffer) { in sdhci_request_done_dma()
3118 unsigned int length = data->bytes_xfered; in sdhci_request_done_dma()
3120 if (length > host->bounce_buffer_size) { in sdhci_request_done_dma()
3122 mmc_hostname(host->mmc), in sdhci_request_done_dma()
3123 host->bounce_buffer_size, in sdhci_request_done_dma()
3124 data->bytes_xfered); in sdhci_request_done_dma()
3126 length = host->bounce_buffer_size; in sdhci_request_done_dma()
3128 dma_sync_single_for_cpu(mmc_dev(host->mmc), in sdhci_request_done_dma()
3129 host->bounce_addr, in sdhci_request_done_dma()
3130 host->bounce_buffer_size, in sdhci_request_done_dma()
3132 sg_copy_from_buffer(data->sg, in sdhci_request_done_dma()
3133 data->sg_len, in sdhci_request_done_dma()
3134 host->bounce_buffer, in sdhci_request_done_dma()
3138 dma_sync_single_for_cpu(mmc_dev(host->mmc), in sdhci_request_done_dma()
3139 host->bounce_addr, in sdhci_request_done_dma()
3140 host->bounce_buffer_size, in sdhci_request_done_dma()
3145 dma_unmap_sg(mmc_dev(host->mmc), data->sg, in sdhci_request_done_dma()
3146 data->sg_len, in sdhci_request_done_dma()
3149 data->host_cookie = COOKIE_UNMAPPED; in sdhci_request_done_dma()
3154 static bool sdhci_request_done(struct sdhci_host *host) in sdhci_request_done() argument
3160 spin_lock_irqsave(&host->lock, flags); in sdhci_request_done()
3163 mrq = host->mrqs_done[i]; in sdhci_request_done()
3169 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request_done()
3177 if (sdhci_needs_reset(host, mrq)) { in sdhci_request_done()
3181 * also be in mrqs_done, otherwise host->cmd and host->data_cmd in sdhci_request_done()
3184 if (host->cmd || host->data_cmd) { in sdhci_request_done()
3185 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request_done()
3190 if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET) in sdhci_request_done()
3192 host->ops->set_clock(host, host->clock); in sdhci_request_done()
3194 sdhci_reset_for(host, REQUEST_ERROR); in sdhci_request_done()
3196 host->pending_reset = false; in sdhci_request_done()
3204 if (host->flags & SDHCI_REQ_USE_DMA) { in sdhci_request_done()
3205 struct mmc_data *data = mrq->data; in sdhci_request_done()
3207 if (host->use_external_dma && data && in sdhci_request_done()
3208 (mrq->cmd->error || data->error)) { in sdhci_request_done()
3209 struct dma_chan *chan = sdhci_external_dma_channel(host, data); in sdhci_request_done()
3211 host->mrqs_done[i] = NULL; in sdhci_request_done()
3212 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request_done()
3214 spin_lock_irqsave(&host->lock, flags); in sdhci_request_done()
3215 sdhci_set_mrq_done(host, mrq); in sdhci_request_done()
3218 sdhci_request_done_dma(host, mrq); in sdhci_request_done()
3221 host->mrqs_done[i] = NULL; in sdhci_request_done()
3223 spin_unlock_irqrestore(&host->lock, flags); in sdhci_request_done()
3225 if (host->ops->request_done) in sdhci_request_done()
3226 host->ops->request_done(host, mrq); in sdhci_request_done()
3228 mmc_request_done(host->mmc, mrq); in sdhci_request_done()
3235 struct sdhci_host *host = container_of(work, struct sdhci_host, in sdhci_complete_work() local
3238 while (!sdhci_request_done(host)) in sdhci_complete_work()
3245 struct sdhci_host *host; in sdhci_timeout_timer() local
3248 host = from_timer(host, t, timer); in sdhci_timeout_timer()
3250 spin_lock_irqsave(&host->lock, flags); in sdhci_timeout_timer()
3252 if (host->cmd && !sdhci_data_line_cmd(host->cmd)) { in sdhci_timeout_timer()
3254 mmc_hostname(host->mmc)); in sdhci_timeout_timer()
3255 sdhci_err_stats_inc(host, REQ_TIMEOUT); in sdhci_timeout_timer()
3256 sdhci_dumpregs(host); in sdhci_timeout_timer()
3258 host->cmd->error = -ETIMEDOUT; in sdhci_timeout_timer()
3259 sdhci_finish_mrq(host, host->cmd->mrq); in sdhci_timeout_timer()
3262 spin_unlock_irqrestore(&host->lock, flags); in sdhci_timeout_timer()
3267 struct sdhci_host *host; in sdhci_timeout_data_timer() local
3270 host = from_timer(host, t, data_timer); in sdhci_timeout_data_timer()
3272 spin_lock_irqsave(&host->lock, flags); in sdhci_timeout_data_timer()
3274 if (host->data || host->data_cmd || in sdhci_timeout_data_timer()
3275 (host->cmd && sdhci_data_line_cmd(host->cmd))) { in sdhci_timeout_data_timer()
3277 mmc_hostname(host->mmc)); in sdhci_timeout_data_timer()
3278 sdhci_err_stats_inc(host, REQ_TIMEOUT); in sdhci_timeout_data_timer()
3279 sdhci_dumpregs(host); in sdhci_timeout_data_timer()
3281 if (host->data) { in sdhci_timeout_data_timer()
3282 host->data->error = -ETIMEDOUT; in sdhci_timeout_data_timer()
3283 __sdhci_finish_data(host, true); in sdhci_timeout_data_timer()
3284 queue_work(host->complete_wq, &host->complete_work); in sdhci_timeout_data_timer()
3285 } else if (host->data_cmd) { in sdhci_timeout_data_timer()
3286 host->data_cmd->error = -ETIMEDOUT; in sdhci_timeout_data_timer()
3287 sdhci_finish_mrq(host, host->data_cmd->mrq); in sdhci_timeout_data_timer()
3289 host->cmd->error = -ETIMEDOUT; in sdhci_timeout_data_timer()
3290 sdhci_finish_mrq(host, host->cmd->mrq); in sdhci_timeout_data_timer()
3294 spin_unlock_irqrestore(&host->lock, flags); in sdhci_timeout_data_timer()
3303 static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *intmask_p) in sdhci_cmd_irq() argument
3305 /* Handle auto-CMD12 error */ in sdhci_cmd_irq()
3306 if (intmask & SDHCI_INT_AUTO_CMD_ERR && host->data_cmd) { in sdhci_cmd_irq()
3307 struct mmc_request *mrq = host->data_cmd->mrq; in sdhci_cmd_irq()
3308 u16 auto_cmd_status = sdhci_readw(host, SDHCI_AUTO_CMD_STATUS); in sdhci_cmd_irq()
3313 /* Treat auto-CMD12 error the same as data error */ in sdhci_cmd_irq()
3314 if (!mrq->sbc && (host->flags & SDHCI_AUTO_CMD12)) { in sdhci_cmd_irq()
3320 if (!host->cmd) { in sdhci_cmd_irq()
3326 if (host->pending_reset) in sdhci_cmd_irq()
3329 mmc_hostname(host->mmc), (unsigned)intmask); in sdhci_cmd_irq()
3330 sdhci_err_stats_inc(host, UNEXPECTED_IRQ); in sdhci_cmd_irq()
3331 sdhci_dumpregs(host); in sdhci_cmd_irq()
3338 host->cmd->error = -ETIMEDOUT; in sdhci_cmd_irq()
3339 sdhci_err_stats_inc(host, CMD_TIMEOUT); in sdhci_cmd_irq()
3341 host->cmd->error = -EILSEQ; in sdhci_cmd_irq()
3342 if (!mmc_op_tuning(host->cmd->opcode)) in sdhci_cmd_irq()
3343 sdhci_err_stats_inc(host, CMD_CRC); in sdhci_cmd_irq()
3346 if (host->cmd->data && in sdhci_cmd_irq()
3349 host->cmd = NULL; in sdhci_cmd_irq()
3354 __sdhci_finish_mrq(host, host->cmd->mrq); in sdhci_cmd_irq()
3358 /* Handle auto-CMD23 error */ in sdhci_cmd_irq()
3360 struct mmc_request *mrq = host->cmd->mrq; in sdhci_cmd_irq()
3361 u16 auto_cmd_status = sdhci_readw(host, SDHCI_AUTO_CMD_STATUS); in sdhci_cmd_irq()
3363 -ETIMEDOUT : in sdhci_cmd_irq()
3364 -EILSEQ; in sdhci_cmd_irq()
3366 sdhci_err_stats_inc(host, AUTO_CMD); in sdhci_cmd_irq()
3368 if (sdhci_auto_cmd23(host, mrq)) { in sdhci_cmd_irq()
3369 mrq->sbc->error = err; in sdhci_cmd_irq()
3370 __sdhci_finish_mrq(host, mrq); in sdhci_cmd_irq()
3376 sdhci_finish_command(host); in sdhci_cmd_irq()
3379 static void sdhci_adma_show_error(struct sdhci_host *host) in sdhci_adma_show_error() argument
3381 void *desc = host->adma_table; in sdhci_adma_show_error()
3382 dma_addr_t dma = host->adma_addr; in sdhci_adma_show_error()
3384 sdhci_dumpregs(host); in sdhci_adma_show_error()
3389 if (host->flags & SDHCI_USE_64_BIT_DMA) in sdhci_adma_show_error()
3392 le32_to_cpu(dma_desc->addr_hi), in sdhci_adma_show_error()
3393 le32_to_cpu(dma_desc->addr_lo), in sdhci_adma_show_error()
3394 le16_to_cpu(dma_desc->len), in sdhci_adma_show_error()
3395 le16_to_cpu(dma_desc->cmd)); in sdhci_adma_show_error()
3399 le32_to_cpu(dma_desc->addr_lo), in sdhci_adma_show_error()
3400 le16_to_cpu(dma_desc->len), in sdhci_adma_show_error()
3401 le16_to_cpu(dma_desc->cmd)); in sdhci_adma_show_error()
3403 desc += host->desc_sz; in sdhci_adma_show_error()
3404 dma += host->desc_sz; in sdhci_adma_show_error()
3406 if (dma_desc->cmd & cpu_to_le16(ADMA2_END)) in sdhci_adma_show_error()
3411 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask) in sdhci_data_irq() argument
3420 if (intmask & SDHCI_INT_DATA_AVAIL && !host->data) { in sdhci_data_irq()
3421 if (mmc_op_tuning(SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)))) { in sdhci_data_irq()
3422 host->tuning_done = 1; in sdhci_data_irq()
3423 wake_up(&host->buf_ready_int); in sdhci_data_irq()
3428 if (!host->data) { in sdhci_data_irq()
3429 struct mmc_command *data_cmd = host->data_cmd; in sdhci_data_irq()
3436 if (data_cmd && (data_cmd->flags & MMC_RSP_BUSY)) { in sdhci_data_irq()
3438 host->data_cmd = NULL; in sdhci_data_irq()
3439 data_cmd->error = -ETIMEDOUT; in sdhci_data_irq()
3440 sdhci_err_stats_inc(host, CMD_TIMEOUT); in sdhci_data_irq()
3441 __sdhci_finish_mrq(host, data_cmd->mrq); in sdhci_data_irq()
3445 host->data_cmd = NULL; in sdhci_data_irq()
3447 * Some cards handle busy-end interrupt in sdhci_data_irq()
3451 if (host->cmd == data_cmd) in sdhci_data_irq()
3454 __sdhci_finish_mrq(host, data_cmd->mrq); in sdhci_data_irq()
3464 if (host->pending_reset) in sdhci_data_irq()
3468 mmc_hostname(host->mmc), (unsigned)intmask); in sdhci_data_irq()
3469 sdhci_err_stats_inc(host, UNEXPECTED_IRQ); in sdhci_data_irq()
3470 sdhci_dumpregs(host); in sdhci_data_irq()
3476 host->data->error = -ETIMEDOUT; in sdhci_data_irq()
3477 sdhci_err_stats_inc(host, DAT_TIMEOUT); in sdhci_data_irq()
3479 host->data->error = -EILSEQ; in sdhci_data_irq()
3480 if (!mmc_op_tuning(SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)))) in sdhci_data_irq()
3481 sdhci_err_stats_inc(host, DAT_CRC); in sdhci_data_irq()
3483 SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)) in sdhci_data_irq()
3485 host->data->error = -EILSEQ; in sdhci_data_irq()
3486 if (!mmc_op_tuning(SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)))) in sdhci_data_irq()
3487 sdhci_err_stats_inc(host, DAT_CRC); in sdhci_data_irq()
3489 u16 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); in sdhci_data_irq()
3492 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2); in sdhci_data_irq()
3495 pr_err("%s: ADMA error: 0x%08x\n", mmc_hostname(host->mmc), in sdhci_data_irq()
3497 sdhci_adma_show_error(host); in sdhci_data_irq()
3498 sdhci_err_stats_inc(host, ADMA); in sdhci_data_irq()
3499 host->data->error = -EIO; in sdhci_data_irq()
3500 if (host->ops->adma_workaround) in sdhci_data_irq()
3501 host->ops->adma_workaround(host, intmask); in sdhci_data_irq()
3504 if (host->data->error) in sdhci_data_irq()
3505 sdhci_finish_data(host); in sdhci_data_irq()
3508 sdhci_transfer_pio(host); in sdhci_data_irq()
3515 * According to the spec sdhci_readl(host, SDHCI_DMA_ADDRESS) in sdhci_data_irq()
3522 dmastart = sdhci_sdma_address(host); in sdhci_data_irq()
3523 dmanow = dmastart + host->data->bytes_xfered; in sdhci_data_irq()
3528 ~((dma_addr_t)SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) + in sdhci_data_irq()
3530 host->data->bytes_xfered = dmanow - dmastart; in sdhci_data_irq()
3532 &dmastart, host->data->bytes_xfered, &dmanow); in sdhci_data_irq()
3533 sdhci_set_sdma_addr(host, dmanow); in sdhci_data_irq()
3537 if (host->cmd == host->data_cmd) { in sdhci_data_irq()
3543 host->data_early = 1; in sdhci_data_irq()
3545 sdhci_finish_data(host); in sdhci_data_irq()
3551 static inline bool sdhci_defer_done(struct sdhci_host *host, in sdhci_defer_done() argument
3554 struct mmc_data *data = mrq->data; in sdhci_defer_done()
3556 return host->pending_reset || host->always_defer_done || in sdhci_defer_done()
3557 ((host->flags & SDHCI_REQ_USE_DMA) && data && in sdhci_defer_done()
3558 data->host_cookie == COOKIE_MAPPED); in sdhci_defer_done()
3565 struct sdhci_host *host = dev_id; in sdhci_irq() local
3570 spin_lock(&host->lock); in sdhci_irq()
3572 if (host->runtime_suspended) { in sdhci_irq()
3573 spin_unlock(&host->lock); in sdhci_irq()
3577 intmask = sdhci_readl(host, SDHCI_INT_STATUS); in sdhci_irq()
3586 if (host->ops->irq) { in sdhci_irq()
3587 intmask = host->ops->irq(host, intmask); in sdhci_irq()
3595 sdhci_writel(host, mask, SDHCI_INT_STATUS); in sdhci_irq()
3598 u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) & in sdhci_irq()
3612 host->ier &= ~(SDHCI_INT_CARD_INSERT | in sdhci_irq()
3614 host->ier |= present ? SDHCI_INT_CARD_REMOVE : in sdhci_irq()
3616 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_irq()
3617 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_irq()
3619 sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT | in sdhci_irq()
3622 host->thread_isr |= intmask & (SDHCI_INT_CARD_INSERT | in sdhci_irq()
3628 sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK, &intmask); in sdhci_irq()
3631 sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK); in sdhci_irq()
3635 mmc_hostname(host->mmc)); in sdhci_irq()
3638 mmc_retune_needed(host->mmc); in sdhci_irq()
3641 (host->ier & SDHCI_INT_CARD_INT)) { in sdhci_irq()
3642 sdhci_enable_sdio_irq_nolock(host, false); in sdhci_irq()
3643 sdio_signal_irq(host->mmc); in sdhci_irq()
3653 sdhci_writel(host, intmask, SDHCI_INT_STATUS); in sdhci_irq()
3659 intmask = sdhci_readl(host, SDHCI_INT_STATUS); in sdhci_irq()
3660 } while (intmask && --max_loops); in sdhci_irq()
3664 struct mmc_request *mrq = host->mrqs_done[i]; in sdhci_irq()
3669 if (sdhci_defer_done(host, mrq)) { in sdhci_irq()
3673 host->mrqs_done[i] = NULL; in sdhci_irq()
3677 if (host->deferred_cmd) in sdhci_irq()
3680 spin_unlock(&host->lock); in sdhci_irq()
3687 if (host->ops->request_done) in sdhci_irq()
3688 host->ops->request_done(host, mrqs_done[i]); in sdhci_irq()
3690 mmc_request_done(host->mmc, mrqs_done[i]); in sdhci_irq()
3695 mmc_hostname(host->mmc), unexpected); in sdhci_irq()
3696 sdhci_err_stats_inc(host, UNEXPECTED_IRQ); in sdhci_irq()
3697 sdhci_dumpregs(host); in sdhci_irq()
3705 struct sdhci_host *host = dev_id; in sdhci_thread_irq() local
3710 while (!sdhci_request_done(host)) in sdhci_thread_irq()
3713 spin_lock_irqsave(&host->lock, flags); in sdhci_thread_irq()
3715 isr = host->thread_isr; in sdhci_thread_irq()
3716 host->thread_isr = 0; in sdhci_thread_irq()
3718 cmd = host->deferred_cmd; in sdhci_thread_irq()
3719 if (cmd && !sdhci_send_command_retry(host, cmd, flags)) in sdhci_thread_irq()
3720 sdhci_finish_mrq(host, cmd->mrq); in sdhci_thread_irq()
3722 spin_unlock_irqrestore(&host->lock, flags); in sdhci_thread_irq()
3725 struct mmc_host *mmc = host->mmc; in sdhci_thread_irq() local
3727 mmc->ops->card_event(mmc); in sdhci_thread_irq()
3728 mmc_detect_change(mmc, msecs_to_jiffies(200)); in sdhci_thread_irq()
3743 static bool sdhci_cd_irq_can_wakeup(struct sdhci_host *host) in sdhci_cd_irq_can_wakeup() argument
3745 return mmc_card_is_removable(host->mmc) && in sdhci_cd_irq_can_wakeup()
3746 !(host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) && in sdhci_cd_irq_can_wakeup()
3747 !mmc_can_gpio_cd(host->mmc); in sdhci_cd_irq_can_wakeup()
3752 * the Interrupt Status Enable register too. See 'Table 1-6: Wakeup Signal
3753 * Table' in the SD Host Controller Standard Specification.
3758 static bool sdhci_enable_irq_wakeups(struct sdhci_host *host) in sdhci_enable_irq_wakeups() argument
3766 if (sdhci_cd_irq_can_wakeup(host)) { in sdhci_enable_irq_wakeups()
3771 if (mmc_card_wake_sdio_irq(host->mmc)) { in sdhci_enable_irq_wakeups()
3779 val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL); in sdhci_enable_irq_wakeups()
3782 sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL); in sdhci_enable_irq_wakeups()
3784 sdhci_writel(host, irq_val, SDHCI_INT_ENABLE); in sdhci_enable_irq_wakeups()
3786 host->irq_wake_enabled = !enable_irq_wake(host->irq); in sdhci_enable_irq_wakeups()
3788 return host->irq_wake_enabled; in sdhci_enable_irq_wakeups()
3791 static void sdhci_disable_irq_wakeups(struct sdhci_host *host) in sdhci_disable_irq_wakeups() argument
3797 val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL); in sdhci_disable_irq_wakeups()
3799 sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL); in sdhci_disable_irq_wakeups()
3801 disable_irq_wake(host->irq); in sdhci_disable_irq_wakeups()
3803 host->irq_wake_enabled = false; in sdhci_disable_irq_wakeups()
3806 int sdhci_suspend_host(struct sdhci_host *host) in sdhci_suspend_host() argument
3808 sdhci_disable_card_detection(host); in sdhci_suspend_host()
3810 mmc_retune_timer_stop(host->mmc); in sdhci_suspend_host()
3812 if (!device_may_wakeup(mmc_dev(host->mmc)) || in sdhci_suspend_host()
3813 !sdhci_enable_irq_wakeups(host)) { in sdhci_suspend_host()
3814 host->ier = 0; in sdhci_suspend_host()
3815 sdhci_writel(host, 0, SDHCI_INT_ENABLE); in sdhci_suspend_host()
3816 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE); in sdhci_suspend_host()
3817 free_irq(host->irq, host); in sdhci_suspend_host()
3825 int sdhci_resume_host(struct sdhci_host *host) in sdhci_resume_host() argument
3827 struct mmc_host *mmc = host->mmc; in sdhci_resume_host() local
3830 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) { in sdhci_resume_host()
3831 if (host->ops->enable_dma) in sdhci_resume_host()
3832 host->ops->enable_dma(host); in sdhci_resume_host()
3835 if ((mmc->pm_flags & MMC_PM_KEEP_POWER) && in sdhci_resume_host()
3836 (host->quirks2 & SDHCI_QUIRK2_HOST_OFF_CARD_ON)) { in sdhci_resume_host()
3837 /* Card keeps power but host controller does not */ in sdhci_resume_host()
3838 sdhci_init(host, 0); in sdhci_resume_host()
3839 host->pwr = 0; in sdhci_resume_host()
3840 host->clock = 0; in sdhci_resume_host()
3841 host->reinit_uhs = true; in sdhci_resume_host()
3842 mmc->ops->set_ios(mmc, &mmc->ios); in sdhci_resume_host()
3844 sdhci_init(host, (mmc->pm_flags & MMC_PM_KEEP_POWER)); in sdhci_resume_host()
3847 if (host->irq_wake_enabled) { in sdhci_resume_host()
3848 sdhci_disable_irq_wakeups(host); in sdhci_resume_host()
3850 ret = request_threaded_irq(host->irq, sdhci_irq, in sdhci_resume_host()
3852 mmc_hostname(mmc), host); in sdhci_resume_host()
3857 sdhci_enable_card_detection(host); in sdhci_resume_host()
3864 int sdhci_runtime_suspend_host(struct sdhci_host *host) in sdhci_runtime_suspend_host() argument
3868 mmc_retune_timer_stop(host->mmc); in sdhci_runtime_suspend_host()
3870 spin_lock_irqsave(&host->lock, flags); in sdhci_runtime_suspend_host()
3871 host->ier &= SDHCI_INT_CARD_INT; in sdhci_runtime_suspend_host()
3872 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_runtime_suspend_host()
3873 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_runtime_suspend_host()
3874 spin_unlock_irqrestore(&host->lock, flags); in sdhci_runtime_suspend_host()
3876 synchronize_hardirq(host->irq); in sdhci_runtime_suspend_host()
3878 spin_lock_irqsave(&host->lock, flags); in sdhci_runtime_suspend_host()
3879 host->runtime_suspended = true; in sdhci_runtime_suspend_host()
3880 spin_unlock_irqrestore(&host->lock, flags); in sdhci_runtime_suspend_host()
3886 int sdhci_runtime_resume_host(struct sdhci_host *host, int soft_reset) in sdhci_runtime_resume_host() argument
3888 struct mmc_host *mmc = host->mmc; in sdhci_runtime_resume_host() local
3890 int host_flags = host->flags; in sdhci_runtime_resume_host()
3893 if (host->ops->enable_dma) in sdhci_runtime_resume_host()
3894 host->ops->enable_dma(host); in sdhci_runtime_resume_host()
3897 sdhci_init(host, soft_reset); in sdhci_runtime_resume_host()
3899 if (mmc->ios.power_mode != MMC_POWER_UNDEFINED && in sdhci_runtime_resume_host()
3900 mmc->ios.power_mode != MMC_POWER_OFF) { in sdhci_runtime_resume_host()
3901 /* Force clock and power re-program */ in sdhci_runtime_resume_host()
3902 host->pwr = 0; in sdhci_runtime_resume_host()
3903 host->clock = 0; in sdhci_runtime_resume_host()
3904 host->reinit_uhs = true; in sdhci_runtime_resume_host()
3905 mmc->ops->start_signal_voltage_switch(mmc, &mmc->ios); in sdhci_runtime_resume_host()
3906 mmc->ops->set_ios(mmc, &mmc->ios); in sdhci_runtime_resume_host()
3909 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) { in sdhci_runtime_resume_host()
3910 spin_lock_irqsave(&host->lock, flags); in sdhci_runtime_resume_host()
3911 sdhci_enable_preset_value(host, true); in sdhci_runtime_resume_host()
3912 spin_unlock_irqrestore(&host->lock, flags); in sdhci_runtime_resume_host()
3915 if ((mmc->caps2 & MMC_CAP2_HS400_ES) && in sdhci_runtime_resume_host()
3916 mmc->ops->hs400_enhanced_strobe) in sdhci_runtime_resume_host()
3917 mmc->ops->hs400_enhanced_strobe(mmc, &mmc->ios); in sdhci_runtime_resume_host()
3920 spin_lock_irqsave(&host->lock, flags); in sdhci_runtime_resume_host()
3922 host->runtime_suspended = false; in sdhci_runtime_resume_host()
3925 if (sdio_irq_claimed(mmc)) in sdhci_runtime_resume_host()
3926 sdhci_enable_sdio_irq_nolock(host, true); in sdhci_runtime_resume_host()
3929 sdhci_enable_card_detection(host); in sdhci_runtime_resume_host()
3931 spin_unlock_irqrestore(&host->lock, flags); in sdhci_runtime_resume_host()
3945 void sdhci_cqe_enable(struct mmc_host *mmc) in sdhci_cqe_enable() argument
3947 struct sdhci_host *host = mmc_priv(mmc); in sdhci_cqe_enable() local
3951 spin_lock_irqsave(&host->lock, flags); in sdhci_cqe_enable()
3953 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); in sdhci_cqe_enable()
3956 * Host from V4.10 supports ADMA3 DMA type. in sdhci_cqe_enable()
3960 if (host->v4_mode && (host->caps1 & SDHCI_CAN_DO_ADMA3)) in sdhci_cqe_enable()
3962 else if (host->flags & SDHCI_USE_64_BIT_DMA) in sdhci_cqe_enable()
3966 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); in sdhci_cqe_enable()
3968 sdhci_writew(host, SDHCI_MAKE_BLKSZ(host->sdma_boundary, 512), in sdhci_cqe_enable()
3972 sdhci_set_timeout(host, NULL); in sdhci_cqe_enable()
3974 host->ier = host->cqe_ier; in sdhci_cqe_enable()
3976 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE); in sdhci_cqe_enable()
3977 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE); in sdhci_cqe_enable()
3979 host->cqe_on = true; in sdhci_cqe_enable()
3982 mmc_hostname(mmc), host->ier, in sdhci_cqe_enable()
3983 sdhci_readl(host, SDHCI_INT_STATUS)); in sdhci_cqe_enable()
3985 spin_unlock_irqrestore(&host->lock, flags); in sdhci_cqe_enable()
3989 void sdhci_cqe_disable(struct mmc_host *mmc, bool recovery) in sdhci_cqe_disable() argument
3991 struct sdhci_host *host = mmc_priv(mmc); in sdhci_cqe_disable() local
3994 spin_lock_irqsave(&host->lock, flags); in sdhci_cqe_disable()
3996 sdhci_set_default_irqs(host); in sdhci_cqe_disable()
3998 host->cqe_on = false; in sdhci_cqe_disable()
4001 sdhci_reset_for(host, CQE_RECOVERY); in sdhci_cqe_disable()
4004 mmc_hostname(mmc), host->ier, in sdhci_cqe_disable()
4005 sdhci_readl(host, SDHCI_INT_STATUS)); in sdhci_cqe_disable()
4007 spin_unlock_irqrestore(&host->lock, flags); in sdhci_cqe_disable()
4011 bool sdhci_cqe_irq(struct sdhci_host *host, u32 intmask, int *cmd_error, in sdhci_cqe_irq() argument
4016 if (!host->cqe_on) in sdhci_cqe_irq()
4020 *cmd_error = -EILSEQ; in sdhci_cqe_irq()
4021 if (!mmc_op_tuning(SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)))) in sdhci_cqe_irq()
4022 sdhci_err_stats_inc(host, CMD_CRC); in sdhci_cqe_irq()
4024 *cmd_error = -ETIMEDOUT; in sdhci_cqe_irq()
4025 sdhci_err_stats_inc(host, CMD_TIMEOUT); in sdhci_cqe_irq()
4030 *data_error = -EILSEQ; in sdhci_cqe_irq()
4031 if (!mmc_op_tuning(SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND)))) in sdhci_cqe_irq()
4032 sdhci_err_stats_inc(host, DAT_CRC); in sdhci_cqe_irq()
4034 *data_error = -ETIMEDOUT; in sdhci_cqe_irq()
4035 sdhci_err_stats_inc(host, DAT_TIMEOUT); in sdhci_cqe_irq()
4037 *data_error = -EIO; in sdhci_cqe_irq()
4038 sdhci_err_stats_inc(host, ADMA); in sdhci_cqe_irq()
4043 mask = intmask & host->cqe_ier; in sdhci_cqe_irq()
4044 sdhci_writel(host, mask, SDHCI_INT_STATUS); in sdhci_cqe_irq()
4048 mmc_hostname(host->mmc)); in sdhci_cqe_irq()
4050 intmask &= ~(host->cqe_ier | SDHCI_INT_ERROR); in sdhci_cqe_irq()
4052 sdhci_writel(host, intmask, SDHCI_INT_STATUS); in sdhci_cqe_irq()
4054 mmc_hostname(host->mmc), intmask); in sdhci_cqe_irq()
4055 sdhci_err_stats_inc(host, UNEXPECTED_IRQ); in sdhci_cqe_irq()
4056 sdhci_dumpregs(host); in sdhci_cqe_irq()
4072 struct mmc_host *mmc; in sdhci_alloc_host() local
4073 struct sdhci_host *host; in sdhci_alloc_host() local
4077 mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev); in sdhci_alloc_host()
4078 if (!mmc) in sdhci_alloc_host()
4079 return ERR_PTR(-ENOMEM); in sdhci_alloc_host()
4081 host = mmc_priv(mmc); in sdhci_alloc_host()
4082 host->mmc = mmc; in sdhci_alloc_host()
4083 host->mmc_host_ops = sdhci_ops; in sdhci_alloc_host()
4084 mmc->ops = &host->mmc_host_ops; in sdhci_alloc_host()
4086 host->flags = SDHCI_SIGNALING_330; in sdhci_alloc_host()
4088 host->cqe_ier = SDHCI_CQE_INT_MASK; in sdhci_alloc_host()
4089 host->cqe_err_ier = SDHCI_CQE_INT_ERR_MASK; in sdhci_alloc_host()
4091 host->tuning_delay = -1; in sdhci_alloc_host()
4092 host->tuning_loop_count = MAX_TUNING_LOOP; in sdhci_alloc_host()
4094 host->sdma_boundary = SDHCI_DEFAULT_BOUNDARY_ARG; in sdhci_alloc_host()
4101 host->adma_table_cnt = SDHCI_MAX_SEGS * 2 + 1; in sdhci_alloc_host()
4102 host->max_adma = 65536; in sdhci_alloc_host()
4104 host->max_timeout_count = 0xE; in sdhci_alloc_host()
4106 host->complete_work_fn = sdhci_complete_work; in sdhci_alloc_host()
4107 host->thread_irq_fn = sdhci_thread_irq; in sdhci_alloc_host()
4109 return host; in sdhci_alloc_host()
4114 static int sdhci_set_dma_mask(struct sdhci_host *host) in sdhci_set_dma_mask() argument
4116 struct mmc_host *mmc = host->mmc; in sdhci_set_dma_mask() local
4117 struct device *dev = mmc_dev(mmc); in sdhci_set_dma_mask()
4118 int ret = -EINVAL; in sdhci_set_dma_mask()
4120 if (host->quirks2 & SDHCI_QUIRK2_BROKEN_64_BIT_DMA) in sdhci_set_dma_mask()
4121 host->flags &= ~SDHCI_USE_64_BIT_DMA; in sdhci_set_dma_mask()
4123 /* Try 64-bit mask if hardware is capable of it */ in sdhci_set_dma_mask()
4124 if (host->flags & SDHCI_USE_64_BIT_DMA) { in sdhci_set_dma_mask()
4127 pr_warn("%s: Failed to set 64-bit DMA mask.\n", in sdhci_set_dma_mask()
4128 mmc_hostname(mmc)); in sdhci_set_dma_mask()
4129 host->flags &= ~SDHCI_USE_64_BIT_DMA; in sdhci_set_dma_mask()
4133 /* 32-bit mask as default & fallback */ in sdhci_set_dma_mask()
4137 pr_warn("%s: Failed to set 32-bit DMA mask.\n", in sdhci_set_dma_mask()
4138 mmc_hostname(mmc)); in sdhci_set_dma_mask()
4144 void __sdhci_read_caps(struct sdhci_host *host, const u16 *ver, in __sdhci_read_caps() argument
4151 if (host->read_caps) in __sdhci_read_caps()
4154 host->read_caps = true; in __sdhci_read_caps()
4157 host->quirks = debug_quirks; in __sdhci_read_caps()
4160 host->quirks2 = debug_quirks2; in __sdhci_read_caps()
4162 sdhci_reset_for_all(host); in __sdhci_read_caps()
4164 if (host->v4_mode) in __sdhci_read_caps()
4165 sdhci_do_enable_v4_mode(host); in __sdhci_read_caps()
4167 device_property_read_u64(mmc_dev(host->mmc), in __sdhci_read_caps()
4168 "sdhci-caps-mask", &dt_caps_mask); in __sdhci_read_caps()
4169 device_property_read_u64(mmc_dev(host->mmc), in __sdhci_read_caps()
4170 "sdhci-caps", &dt_caps); in __sdhci_read_caps()
4172 v = ver ? *ver : sdhci_readw(host, SDHCI_HOST_VERSION); in __sdhci_read_caps()
4173 host->version = (v & SDHCI_SPEC_VER_MASK) >> SDHCI_SPEC_VER_SHIFT; in __sdhci_read_caps()
4176 host->caps = *caps; in __sdhci_read_caps()
4178 host->caps = sdhci_readl(host, SDHCI_CAPABILITIES); in __sdhci_read_caps()
4179 host->caps &= ~lower_32_bits(dt_caps_mask); in __sdhci_read_caps()
4180 host->caps |= lower_32_bits(dt_caps); in __sdhci_read_caps()
4183 if (host->version < SDHCI_SPEC_300) in __sdhci_read_caps()
4187 host->caps1 = *caps1; in __sdhci_read_caps()
4189 host->caps1 = sdhci_readl(host, SDHCI_CAPABILITIES_1); in __sdhci_read_caps()
4190 host->caps1 &= ~upper_32_bits(dt_caps_mask); in __sdhci_read_caps()
4191 host->caps1 |= upper_32_bits(dt_caps); in __sdhci_read_caps()
4196 static void sdhci_allocate_bounce_buffer(struct sdhci_host *host) in sdhci_allocate_bounce_buffer() argument
4198 struct mmc_host *mmc = host->mmc; in sdhci_allocate_bounce_buffer() local
4205 * has diminishing returns, this is probably because SD/MMC in sdhci_allocate_bounce_buffer()
4214 if (mmc->max_req_size < bounce_size) in sdhci_allocate_bounce_buffer()
4215 bounce_size = mmc->max_req_size; in sdhci_allocate_bounce_buffer()
4223 host->bounce_buffer = devm_kmalloc(mmc_dev(mmc), in sdhci_allocate_bounce_buffer()
4226 if (!host->bounce_buffer) { in sdhci_allocate_bounce_buffer()
4228 mmc_hostname(mmc), in sdhci_allocate_bounce_buffer()
4232 * mmc->max_segs == 1. in sdhci_allocate_bounce_buffer()
4237 host->bounce_addr = dma_map_single(mmc_dev(mmc), in sdhci_allocate_bounce_buffer()
4238 host->bounce_buffer, in sdhci_allocate_bounce_buffer()
4241 ret = dma_mapping_error(mmc_dev(mmc), host->bounce_addr); in sdhci_allocate_bounce_buffer()
4243 devm_kfree(mmc_dev(mmc), host->bounce_buffer); in sdhci_allocate_bounce_buffer()
4244 host->bounce_buffer = NULL; in sdhci_allocate_bounce_buffer()
4249 host->bounce_buffer_size = bounce_size; in sdhci_allocate_bounce_buffer()
4252 mmc->max_segs = max_blocks; in sdhci_allocate_bounce_buffer()
4253 mmc->max_seg_size = bounce_size; in sdhci_allocate_bounce_buffer()
4254 mmc->max_req_size = bounce_size; in sdhci_allocate_bounce_buffer()
4257 mmc_hostname(mmc), max_blocks, bounce_size); in sdhci_allocate_bounce_buffer()
4260 static inline bool sdhci_can_64bit_dma(struct sdhci_host *host) in sdhci_can_64bit_dma() argument
4263 * According to SD Host Controller spec v4.10, bit[27] added from in sdhci_can_64bit_dma()
4264 * version 4.10 in Capabilities Register is used as 64-bit System in sdhci_can_64bit_dma()
4267 if (host->version >= SDHCI_SPEC_410 && host->v4_mode) in sdhci_can_64bit_dma()
4268 return host->caps & SDHCI_CAN_64BIT_V4; in sdhci_can_64bit_dma()
4270 return host->caps & SDHCI_CAN_64BIT; in sdhci_can_64bit_dma()
4273 int sdhci_setup_host(struct sdhci_host *host) in sdhci_setup_host() argument
4275 struct mmc_host *mmc; in sdhci_setup_host() local
4283 WARN_ON(host == NULL); in sdhci_setup_host()
4284 if (host == NULL) in sdhci_setup_host()
4285 return -EINVAL; in sdhci_setup_host()
4287 mmc = host->mmc; in sdhci_setup_host()
4291 * early before resetting the host and reading the capabilities so that in sdhci_setup_host()
4292 * the host can take the appropriate action if regulators are not in sdhci_setup_host()
4295 if (!mmc->supply.vqmmc) { in sdhci_setup_host()
4296 ret = mmc_regulator_get_supply(mmc); in sdhci_setup_host()
4303 sdhci_readw(host, SDHCI_HOST_VERSION), in sdhci_setup_host()
4304 sdhci_readl(host, SDHCI_PRESENT_STATE)); in sdhci_setup_host()
4306 sdhci_readl(host, SDHCI_CAPABILITIES), in sdhci_setup_host()
4307 sdhci_readl(host, SDHCI_CAPABILITIES_1)); in sdhci_setup_host()
4309 sdhci_read_caps(host); in sdhci_setup_host()
4311 override_timeout_clk = host->timeout_clk; in sdhci_setup_host()
4313 if (host->version > SDHCI_SPEC_420) { in sdhci_setup_host()
4315 mmc_hostname(mmc), host->version); in sdhci_setup_host()
4318 if (host->quirks & SDHCI_QUIRK_FORCE_DMA) in sdhci_setup_host()
4319 host->flags |= SDHCI_USE_SDMA; in sdhci_setup_host()
4320 else if (!(host->caps & SDHCI_CAN_DO_SDMA)) in sdhci_setup_host()
4323 host->flags |= SDHCI_USE_SDMA; in sdhci_setup_host()
4325 if ((host->quirks & SDHCI_QUIRK_BROKEN_DMA) && in sdhci_setup_host()
4326 (host->flags & SDHCI_USE_SDMA)) { in sdhci_setup_host()
4328 host->flags &= ~SDHCI_USE_SDMA; in sdhci_setup_host()
4331 if ((host->version >= SDHCI_SPEC_200) && in sdhci_setup_host()
4332 (host->caps & SDHCI_CAN_DO_ADMA2)) in sdhci_setup_host()
4333 host->flags |= SDHCI_USE_ADMA; in sdhci_setup_host()
4335 if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) && in sdhci_setup_host()
4336 (host->flags & SDHCI_USE_ADMA)) { in sdhci_setup_host()
4338 host->flags &= ~SDHCI_USE_ADMA; in sdhci_setup_host()
4341 if (sdhci_can_64bit_dma(host)) in sdhci_setup_host()
4342 host->flags |= SDHCI_USE_64_BIT_DMA; in sdhci_setup_host()
4344 if (host->use_external_dma) { in sdhci_setup_host()
4345 ret = sdhci_external_dma_init(host); in sdhci_setup_host()
4346 if (ret == -EPROBE_DEFER) in sdhci_setup_host()
4353 sdhci_switch_external_dma(host, false); in sdhci_setup_host()
4356 host->flags &= ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA); in sdhci_setup_host()
4359 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) { in sdhci_setup_host()
4360 if (host->ops->set_dma_mask) in sdhci_setup_host()
4361 ret = host->ops->set_dma_mask(host); in sdhci_setup_host()
4363 ret = sdhci_set_dma_mask(host); in sdhci_setup_host()
4365 if (!ret && host->ops->enable_dma) in sdhci_setup_host()
4366 ret = host->ops->enable_dma(host); in sdhci_setup_host()
4369 pr_warn("%s: No suitable DMA available - falling back to PIO\n", in sdhci_setup_host()
4370 mmc_hostname(mmc)); in sdhci_setup_host()
4371 host->flags &= ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA); in sdhci_setup_host()
4377 /* SDMA does not support 64-bit DMA if v4 mode not set */ in sdhci_setup_host()
4378 if ((host->flags & SDHCI_USE_64_BIT_DMA) && !host->v4_mode) in sdhci_setup_host()
4379 host->flags &= ~SDHCI_USE_SDMA; in sdhci_setup_host()
4381 if (host->flags & SDHCI_USE_ADMA) { in sdhci_setup_host()
4385 if (!(host->flags & SDHCI_USE_64_BIT_DMA)) in sdhci_setup_host()
4386 host->alloc_desc_sz = SDHCI_ADMA2_32_DESC_SZ; in sdhci_setup_host()
4387 else if (!host->alloc_desc_sz) in sdhci_setup_host()
4388 host->alloc_desc_sz = SDHCI_ADMA2_64_DESC_SZ(host); in sdhci_setup_host()
4390 host->desc_sz = host->alloc_desc_sz; in sdhci_setup_host()
4391 host->adma_table_sz = host->adma_table_cnt * host->desc_sz; in sdhci_setup_host()
4393 host->align_buffer_sz = SDHCI_MAX_SEGS * SDHCI_ADMA2_ALIGN; in sdhci_setup_host()
4395 * Use zalloc to zero the reserved high 32-bits of 128-bit in sdhci_setup_host()
4398 buf = dma_alloc_coherent(mmc_dev(mmc), in sdhci_setup_host()
4399 host->align_buffer_sz + host->adma_table_sz, in sdhci_setup_host()
4402 pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n", in sdhci_setup_host()
4403 mmc_hostname(mmc)); in sdhci_setup_host()
4404 host->flags &= ~SDHCI_USE_ADMA; in sdhci_setup_host()
4405 } else if ((dma + host->align_buffer_sz) & in sdhci_setup_host()
4406 (SDHCI_ADMA2_DESC_ALIGN - 1)) { in sdhci_setup_host()
4408 mmc_hostname(mmc)); in sdhci_setup_host()
4409 host->flags &= ~SDHCI_USE_ADMA; in sdhci_setup_host()
4410 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz + in sdhci_setup_host()
4411 host->adma_table_sz, buf, dma); in sdhci_setup_host()
4413 host->align_buffer = buf; in sdhci_setup_host()
4414 host->align_addr = dma; in sdhci_setup_host()
4416 host->adma_table = buf + host->align_buffer_sz; in sdhci_setup_host()
4417 host->adma_addr = dma + host->align_buffer_sz; in sdhci_setup_host()
4426 if (!(host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))) { in sdhci_setup_host()
4427 host->dma_mask = DMA_BIT_MASK(64); in sdhci_setup_host()
4428 mmc_dev(mmc)->dma_mask = &host->dma_mask; in sdhci_setup_host()
4431 if (host->version >= SDHCI_SPEC_300) in sdhci_setup_host()
4432 host->max_clk = FIELD_GET(SDHCI_CLOCK_V3_BASE_MASK, host->caps); in sdhci_setup_host()
4434 host->max_clk = FIELD_GET(SDHCI_CLOCK_BASE_MASK, host->caps); in sdhci_setup_host()
4436 host->max_clk *= 1000000; in sdhci_setup_host()
4437 if (host->max_clk == 0 || host->quirks & in sdhci_setup_host()
4439 if (!host->ops->get_max_clock) { in sdhci_setup_host()
4441 mmc_hostname(mmc)); in sdhci_setup_host()
4442 ret = -ENODEV; in sdhci_setup_host()
4445 host->max_clk = host->ops->get_max_clock(host); in sdhci_setup_host()
4449 * In case of Host Controller v3.00, find out whether clock in sdhci_setup_host()
4452 host->clk_mul = FIELD_GET(SDHCI_CLOCK_MUL_MASK, host->caps1); in sdhci_setup_host()
4460 if (host->clk_mul) in sdhci_setup_host()
4461 host->clk_mul += 1; in sdhci_setup_host()
4464 * Set host parameters. in sdhci_setup_host()
4466 max_clk = host->max_clk; in sdhci_setup_host()
4468 if (host->ops->get_min_clock) in sdhci_setup_host()
4469 mmc->f_min = host->ops->get_min_clock(host); in sdhci_setup_host()
4470 else if (host->version >= SDHCI_SPEC_300) { in sdhci_setup_host()
4471 if (host->clk_mul) in sdhci_setup_host()
4472 max_clk = host->max_clk * host->clk_mul; in sdhci_setup_host()
4477 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300; in sdhci_setup_host()
4479 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200; in sdhci_setup_host()
4481 if (!mmc->f_max || mmc->f_max > max_clk) in sdhci_setup_host()
4482 mmc->f_max = max_clk; in sdhci_setup_host()
4484 if (!(host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) { in sdhci_setup_host()
4485 host->timeout_clk = FIELD_GET(SDHCI_TIMEOUT_CLK_MASK, host->caps); in sdhci_setup_host()
4487 if (host->caps & SDHCI_TIMEOUT_CLK_UNIT) in sdhci_setup_host()
4488 host->timeout_clk *= 1000; in sdhci_setup_host()
4490 if (host->timeout_clk == 0) { in sdhci_setup_host()
4491 if (!host->ops->get_timeout_clock) { in sdhci_setup_host()
4493 mmc_hostname(mmc)); in sdhci_setup_host()
4494 ret = -ENODEV; in sdhci_setup_host()
4498 host->timeout_clk = in sdhci_setup_host()
4499 DIV_ROUND_UP(host->ops->get_timeout_clock(host), in sdhci_setup_host()
4504 host->timeout_clk = override_timeout_clk; in sdhci_setup_host()
4506 mmc->max_busy_timeout = host->ops->get_max_timeout_count ? in sdhci_setup_host()
4507 host->ops->get_max_timeout_count(host) : 1 << 27; in sdhci_setup_host()
4508 mmc->max_busy_timeout /= host->timeout_clk; in sdhci_setup_host()
4511 if (host->quirks2 & SDHCI_QUIRK2_DISABLE_HW_TIMEOUT && in sdhci_setup_host()
4512 !host->ops->get_max_timeout_count) in sdhci_setup_host()
4513 mmc->max_busy_timeout = 0; in sdhci_setup_host()
4515 mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_CMD23; in sdhci_setup_host()
4516 mmc->caps2 |= MMC_CAP2_SDIO_IRQ_NOTHREAD; in sdhci_setup_host()
4518 if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12) in sdhci_setup_host()
4519 host->flags |= SDHCI_AUTO_CMD12; in sdhci_setup_host()
4522 * For v3 mode, Auto-CMD23 stuff only works in ADMA or PIO. in sdhci_setup_host()
4523 * For v4 mode, SDMA may use Auto-CMD23 as well. in sdhci_setup_host()
4525 if ((host->version >= SDHCI_SPEC_300) && in sdhci_setup_host()
4526 ((host->flags & SDHCI_USE_ADMA) || in sdhci_setup_host()
4527 !(host->flags & SDHCI_USE_SDMA) || host->v4_mode) && in sdhci_setup_host()
4528 !(host->quirks2 & SDHCI_QUIRK2_ACMD23_BROKEN)) { in sdhci_setup_host()
4529 host->flags |= SDHCI_AUTO_CMD23; in sdhci_setup_host()
4530 DBG("Auto-CMD23 available\n"); in sdhci_setup_host()
4532 DBG("Auto-CMD23 unavailable\n"); in sdhci_setup_host()
4536 * A controller may support 8-bit width, but the board itself in sdhci_setup_host()
4538 * 8-bit width must set "mmc->caps |= MMC_CAP_8_BIT_DATA;" in in sdhci_setup_host()
4540 * won't assume 8-bit width for hosts without that CAP. in sdhci_setup_host()
4542 if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA)) in sdhci_setup_host()
4543 mmc->caps |= MMC_CAP_4_BIT_DATA; in sdhci_setup_host()
4545 if (host->quirks2 & SDHCI_QUIRK2_HOST_NO_CMD23) in sdhci_setup_host()
4546 mmc->caps &= ~MMC_CAP_CMD23; in sdhci_setup_host()
4548 if (host->caps & SDHCI_CAN_DO_HISPD) in sdhci_setup_host()
4549 mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED; in sdhci_setup_host()
4551 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) && in sdhci_setup_host()
4552 mmc_card_is_removable(mmc) && in sdhci_setup_host()
4553 mmc_gpio_get_cd(mmc) < 0) in sdhci_setup_host()
4554 mmc->caps |= MMC_CAP_NEEDS_POLL; in sdhci_setup_host()
4556 if (!IS_ERR(mmc->supply.vqmmc)) { in sdhci_setup_host()
4558 ret = regulator_enable(mmc->supply.vqmmc); in sdhci_setup_host()
4559 host->sdhci_core_to_disable_vqmmc = !ret; in sdhci_setup_host()
4563 if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000, in sdhci_setup_host()
4565 host->caps1 &= ~(SDHCI_SUPPORT_SDR104 | in sdhci_setup_host()
4570 if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 2700000, in sdhci_setup_host()
4572 host->flags &= ~SDHCI_SIGNALING_330; in sdhci_setup_host()
4576 mmc_hostname(mmc), ret); in sdhci_setup_host()
4577 mmc->supply.vqmmc = ERR_PTR(-EINVAL); in sdhci_setup_host()
4582 if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V) { in sdhci_setup_host()
4583 host->caps1 &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 | in sdhci_setup_host()
4587 * (indicated using mmc-hs200-1_8v/mmc-hs400-1_8v dt property), in sdhci_setup_host()
4593 mmc->caps2 &= ~(MMC_CAP2_HSX00_1_8V | MMC_CAP2_HS400_ES); in sdhci_setup_host()
4594 mmc->caps &= ~(MMC_CAP_1_8V_DDR | MMC_CAP_UHS); in sdhci_setup_host()
4597 /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */ in sdhci_setup_host()
4598 if (host->caps1 & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 | in sdhci_setup_host()
4600 mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25; in sdhci_setup_host()
4603 if (host->caps1 & SDHCI_SUPPORT_SDR104) { in sdhci_setup_host()
4604 mmc->caps |= MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_SDR50; in sdhci_setup_host()
4608 if (!(host->quirks2 & SDHCI_QUIRK2_BROKEN_HS200)) in sdhci_setup_host()
4609 mmc->caps2 |= MMC_CAP2_HS200; in sdhci_setup_host()
4610 } else if (host->caps1 & SDHCI_SUPPORT_SDR50) { in sdhci_setup_host()
4611 mmc->caps |= MMC_CAP_UHS_SDR50; in sdhci_setup_host()
4614 if (host->quirks2 & SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400 && in sdhci_setup_host()
4615 (host->caps1 & SDHCI_SUPPORT_HS400)) in sdhci_setup_host()
4616 mmc->caps2 |= MMC_CAP2_HS400; in sdhci_setup_host()
4618 if ((mmc->caps2 & MMC_CAP2_HSX00_1_2V) && in sdhci_setup_host()
4619 (IS_ERR(mmc->supply.vqmmc) || in sdhci_setup_host()
4620 !regulator_is_supported_voltage(mmc->supply.vqmmc, 1100000, in sdhci_setup_host()
4622 mmc->caps2 &= ~MMC_CAP2_HSX00_1_2V; in sdhci_setup_host()
4624 if ((host->caps1 & SDHCI_SUPPORT_DDR50) && in sdhci_setup_host()
4625 !(host->quirks2 & SDHCI_QUIRK2_BROKEN_DDR50)) in sdhci_setup_host()
4626 mmc->caps |= MMC_CAP_UHS_DDR50; in sdhci_setup_host()
4628 /* Does the host need tuning for SDR50? */ in sdhci_setup_host()
4629 if (host->caps1 & SDHCI_USE_SDR50_TUNING) in sdhci_setup_host()
4630 host->flags |= SDHCI_SDR50_NEEDS_TUNING; in sdhci_setup_host()
4632 /* Driver Type(s) (A, C, D) supported by the host */ in sdhci_setup_host()
4633 if (host->caps1 & SDHCI_DRIVER_TYPE_A) in sdhci_setup_host()
4634 mmc->caps |= MMC_CAP_DRIVER_TYPE_A; in sdhci_setup_host()
4635 if (host->caps1 & SDHCI_DRIVER_TYPE_C) in sdhci_setup_host()
4636 mmc->caps |= MMC_CAP_DRIVER_TYPE_C; in sdhci_setup_host()
4637 if (host->caps1 & SDHCI_DRIVER_TYPE_D) in sdhci_setup_host()
4638 mmc->caps |= MMC_CAP_DRIVER_TYPE_D; in sdhci_setup_host()
4640 /* Initial value for re-tuning timer count */ in sdhci_setup_host()
4641 host->tuning_count = FIELD_GET(SDHCI_RETUNING_TIMER_COUNT_MASK, in sdhci_setup_host()
4642 host->caps1); in sdhci_setup_host()
4645 * In case Re-tuning Timer is not disabled, the actual value of in sdhci_setup_host()
4646 * re-tuning timer will be 2 ^ (n - 1). in sdhci_setup_host()
4648 if (host->tuning_count) in sdhci_setup_host()
4649 host->tuning_count = 1 << (host->tuning_count - 1); in sdhci_setup_host()
4651 /* Re-tuning mode supported by the Host Controller */ in sdhci_setup_host()
4652 host->tuning_mode = FIELD_GET(SDHCI_RETUNING_MODE_MASK, host->caps1); in sdhci_setup_host()
4657 * According to SD Host Controller spec v3.00, if the Host System in sdhci_setup_host()
4658 * can afford more than 150mA, Host Driver should set XPC to 1. Also in sdhci_setup_host()
4663 max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT); in sdhci_setup_host()
4664 if (!max_current_caps && !IS_ERR(mmc->supply.vmmc)) { in sdhci_setup_host()
4665 int curr = regulator_get_current_limit(mmc->supply.vmmc); in sdhci_setup_host()
4680 if (host->caps & SDHCI_CAN_VDD_330) { in sdhci_setup_host()
4683 mmc->max_current_330 = FIELD_GET(SDHCI_MAX_CURRENT_330_MASK, in sdhci_setup_host()
4687 if (host->caps & SDHCI_CAN_VDD_300) { in sdhci_setup_host()
4690 mmc->max_current_300 = FIELD_GET(SDHCI_MAX_CURRENT_300_MASK, in sdhci_setup_host()
4694 if (host->caps & SDHCI_CAN_VDD_180) { in sdhci_setup_host()
4697 mmc->max_current_180 = FIELD_GET(SDHCI_MAX_CURRENT_180_MASK, in sdhci_setup_host()
4702 /* If OCR set by host, use it instead. */ in sdhci_setup_host()
4703 if (host->ocr_mask) in sdhci_setup_host()
4704 ocr_avail = host->ocr_mask; in sdhci_setup_host()
4707 if (mmc->ocr_avail) in sdhci_setup_host()
4708 ocr_avail = mmc->ocr_avail; in sdhci_setup_host()
4710 mmc->ocr_avail = ocr_avail; in sdhci_setup_host()
4711 mmc->ocr_avail_sdio = ocr_avail; in sdhci_setup_host()
4712 if (host->ocr_avail_sdio) in sdhci_setup_host()
4713 mmc->ocr_avail_sdio &= host->ocr_avail_sdio; in sdhci_setup_host()
4714 mmc->ocr_avail_sd = ocr_avail; in sdhci_setup_host()
4715 if (host->ocr_avail_sd) in sdhci_setup_host()
4716 mmc->ocr_avail_sd &= host->ocr_avail_sd; in sdhci_setup_host()
4718 mmc->ocr_avail_sd &= ~MMC_VDD_165_195; in sdhci_setup_host()
4719 mmc->ocr_avail_mmc = ocr_avail; in sdhci_setup_host()
4720 if (host->ocr_avail_mmc) in sdhci_setup_host()
4721 mmc->ocr_avail_mmc &= host->ocr_avail_mmc; in sdhci_setup_host()
4723 if (mmc->ocr_avail == 0) { in sdhci_setup_host()
4725 mmc_hostname(mmc)); in sdhci_setup_host()
4726 ret = -ENODEV; in sdhci_setup_host()
4730 if ((mmc->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | in sdhci_setup_host()
4733 (mmc->caps2 & (MMC_CAP2_HS200_1_8V_SDR | MMC_CAP2_HS400_1_8V))) in sdhci_setup_host()
4734 host->flags |= SDHCI_SIGNALING_180; in sdhci_setup_host()
4736 if (mmc->caps2 & MMC_CAP2_HSX00_1_2V) in sdhci_setup_host()
4737 host->flags |= SDHCI_SIGNALING_120; in sdhci_setup_host()
4739 spin_lock_init(&host->lock); in sdhci_setup_host()
4746 mmc->max_req_size = 524288; in sdhci_setup_host()
4752 if (host->flags & SDHCI_USE_ADMA) { in sdhci_setup_host()
4753 mmc->max_segs = SDHCI_MAX_SEGS; in sdhci_setup_host()
4754 } else if (host->flags & SDHCI_USE_SDMA) { in sdhci_setup_host()
4755 mmc->max_segs = 1; in sdhci_setup_host()
4756 mmc->max_req_size = min_t(size_t, mmc->max_req_size, in sdhci_setup_host()
4757 dma_max_mapping_size(mmc_dev(mmc))); in sdhci_setup_host()
4759 mmc->max_segs = SDHCI_MAX_SEGS; in sdhci_setup_host()
4767 if (host->flags & SDHCI_USE_ADMA) { in sdhci_setup_host()
4768 if (host->quirks & SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC) { in sdhci_setup_host()
4769 host->max_adma = 65532; /* 32-bit alignment */ in sdhci_setup_host()
4770 mmc->max_seg_size = 65535; in sdhci_setup_host()
4775 * descriptor (16-bit field), but some controllers do in sdhci_setup_host()
4784 if (mmc->max_seg_size < PAGE_SIZE) in sdhci_setup_host()
4785 mmc->max_seg_size = PAGE_SIZE; in sdhci_setup_host()
4787 mmc->max_seg_size = 65536; in sdhci_setup_host()
4790 mmc->max_seg_size = mmc->max_req_size; in sdhci_setup_host()
4797 if (host->quirks & SDHCI_QUIRK_FORCE_BLK_SZ_2048) { in sdhci_setup_host()
4798 mmc->max_blk_size = 2; in sdhci_setup_host()
4800 mmc->max_blk_size = (host->caps & SDHCI_MAX_BLOCK_MASK) >> in sdhci_setup_host()
4802 if (mmc->max_blk_size >= 3) { in sdhci_setup_host()
4804 mmc_hostname(mmc)); in sdhci_setup_host()
4805 mmc->max_blk_size = 0; in sdhci_setup_host()
4809 mmc->max_blk_size = 512 << mmc->max_blk_size; in sdhci_setup_host()
4814 mmc->max_blk_count = (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535; in sdhci_setup_host()
4816 if (mmc->max_segs == 1) in sdhci_setup_host()
4817 /* This may alter mmc->*_blk_* parameters */ in sdhci_setup_host()
4818 sdhci_allocate_bounce_buffer(host); in sdhci_setup_host()
4823 if (host->sdhci_core_to_disable_vqmmc) in sdhci_setup_host()
4824 regulator_disable(mmc->supply.vqmmc); in sdhci_setup_host()
4826 if (host->align_buffer) in sdhci_setup_host()
4827 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz + in sdhci_setup_host()
4828 host->adma_table_sz, host->align_buffer, in sdhci_setup_host()
4829 host->align_addr); in sdhci_setup_host()
4830 host->adma_table = NULL; in sdhci_setup_host()
4831 host->align_buffer = NULL; in sdhci_setup_host()
4837 void sdhci_cleanup_host(struct sdhci_host *host) in sdhci_cleanup_host() argument
4839 struct mmc_host *mmc = host->mmc; in sdhci_cleanup_host() local
4841 if (host->sdhci_core_to_disable_vqmmc) in sdhci_cleanup_host()
4842 regulator_disable(mmc->supply.vqmmc); in sdhci_cleanup_host()
4844 if (host->align_buffer) in sdhci_cleanup_host()
4845 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz + in sdhci_cleanup_host()
4846 host->adma_table_sz, host->align_buffer, in sdhci_cleanup_host()
4847 host->align_addr); in sdhci_cleanup_host()
4849 if (host->use_external_dma) in sdhci_cleanup_host()
4850 sdhci_external_dma_release(host); in sdhci_cleanup_host()
4852 host->adma_table = NULL; in sdhci_cleanup_host()
4853 host->align_buffer = NULL; in sdhci_cleanup_host()
4857 int __sdhci_add_host(struct sdhci_host *host) in __sdhci_add_host() argument
4860 struct mmc_host *mmc = host->mmc; in __sdhci_add_host() local
4863 if ((mmc->caps2 & MMC_CAP2_CQE) && in __sdhci_add_host()
4864 (host->quirks & SDHCI_QUIRK_BROKEN_CQE)) { in __sdhci_add_host()
4865 mmc->caps2 &= ~MMC_CAP2_CQE; in __sdhci_add_host()
4866 mmc->cqe_ops = NULL; in __sdhci_add_host()
4869 host->complete_wq = alloc_workqueue("sdhci", flags, 0); in __sdhci_add_host()
4870 if (!host->complete_wq) in __sdhci_add_host()
4871 return -ENOMEM; in __sdhci_add_host()
4873 INIT_WORK(&host->complete_work, host->complete_work_fn); in __sdhci_add_host()
4875 timer_setup(&host->timer, sdhci_timeout_timer, 0); in __sdhci_add_host()
4876 timer_setup(&host->data_timer, sdhci_timeout_data_timer, 0); in __sdhci_add_host()
4878 init_waitqueue_head(&host->buf_ready_int); in __sdhci_add_host()
4880 sdhci_init(host, 0); in __sdhci_add_host()
4882 ret = request_threaded_irq(host->irq, sdhci_irq, host->thread_irq_fn, in __sdhci_add_host()
4883 IRQF_SHARED, mmc_hostname(mmc), host); in __sdhci_add_host()
4886 mmc_hostname(mmc), host->irq, ret); in __sdhci_add_host()
4890 ret = sdhci_led_register(host); in __sdhci_add_host()
4893 mmc_hostname(mmc), ret); in __sdhci_add_host()
4897 ret = mmc_add_host(mmc); in __sdhci_add_host()
4902 mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)), in __sdhci_add_host()
4903 host->use_external_dma ? "External DMA" : in __sdhci_add_host()
4904 (host->flags & SDHCI_USE_ADMA) ? in __sdhci_add_host()
4905 (host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" : in __sdhci_add_host()
4906 (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO"); in __sdhci_add_host()
4908 sdhci_enable_card_detection(host); in __sdhci_add_host()
4913 sdhci_led_unregister(host); in __sdhci_add_host()
4915 sdhci_reset_for_all(host); in __sdhci_add_host()
4916 sdhci_writel(host, 0, SDHCI_INT_ENABLE); in __sdhci_add_host()
4917 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE); in __sdhci_add_host()
4918 free_irq(host->irq, host); in __sdhci_add_host()
4920 destroy_workqueue(host->complete_wq); in __sdhci_add_host()
4926 int sdhci_add_host(struct sdhci_host *host) in sdhci_add_host() argument
4930 ret = sdhci_setup_host(host); in sdhci_add_host()
4934 ret = __sdhci_add_host(host); in sdhci_add_host()
4941 sdhci_cleanup_host(host); in sdhci_add_host()
4947 void sdhci_remove_host(struct sdhci_host *host, int dead) in sdhci_remove_host() argument
4949 struct mmc_host *mmc = host->mmc; in sdhci_remove_host() local
4953 spin_lock_irqsave(&host->lock, flags); in sdhci_remove_host()
4955 host->flags |= SDHCI_DEVICE_DEAD; in sdhci_remove_host()
4957 if (sdhci_has_requests(host)) { in sdhci_remove_host()
4959 " transfer!\n", mmc_hostname(mmc)); in sdhci_remove_host()
4960 sdhci_error_out_mrqs(host, -ENOMEDIUM); in sdhci_remove_host()
4963 spin_unlock_irqrestore(&host->lock, flags); in sdhci_remove_host()
4966 sdhci_disable_card_detection(host); in sdhci_remove_host()
4968 mmc_remove_host(mmc); in sdhci_remove_host()
4970 sdhci_led_unregister(host); in sdhci_remove_host()
4973 sdhci_reset_for_all(host); in sdhci_remove_host()
4975 sdhci_writel(host, 0, SDHCI_INT_ENABLE); in sdhci_remove_host()
4976 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE); in sdhci_remove_host()
4977 free_irq(host->irq, host); in sdhci_remove_host()
4979 timer_delete_sync(&host->timer); in sdhci_remove_host()
4980 timer_delete_sync(&host->data_timer); in sdhci_remove_host()
4982 destroy_workqueue(host->complete_wq); in sdhci_remove_host()
4984 if (host->sdhci_core_to_disable_vqmmc) in sdhci_remove_host()
4985 regulator_disable(mmc->supply.vqmmc); in sdhci_remove_host()
4987 if (host->align_buffer) in sdhci_remove_host()
4988 dma_free_coherent(mmc_dev(mmc), host->align_buffer_sz + in sdhci_remove_host()
4989 host->adma_table_sz, host->align_buffer, in sdhci_remove_host()
4990 host->align_addr); in sdhci_remove_host()
4992 if (host->use_external_dma) in sdhci_remove_host()
4993 sdhci_external_dma_release(host); in sdhci_remove_host()
4995 host->adma_table = NULL; in sdhci_remove_host()
4996 host->align_buffer = NULL; in sdhci_remove_host()
5001 void sdhci_free_host(struct sdhci_host *host) in sdhci_free_host() argument
5003 mmc_free_host(host->mmc); in sdhci_free_host()
5017 ": Secure Digital Host Controller Interface driver\n"); in sdhci_drv_init()
5034 MODULE_DESCRIPTION("Secure Digital Host Controller Interface core driver");