Lines Matching refs:host
2 * linux/drivers/mmc/host/sdhci.c - Secure Digital Host Controller Interface driver
29 #include <linux/mmc/host.h>
57 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable);
60 static int sdhci_runtime_pm_get(struct sdhci_host *host);
61 static int sdhci_runtime_pm_put(struct sdhci_host *host);
62 static void sdhci_runtime_pm_bus_on(struct sdhci_host *host);
63 static void sdhci_runtime_pm_bus_off(struct sdhci_host *host);
65 static inline int sdhci_runtime_pm_get(struct sdhci_host *host)
69 static inline int sdhci_runtime_pm_put(struct sdhci_host *host)
73 static void sdhci_runtime_pm_bus_on(struct sdhci_host *host)
76 static void sdhci_runtime_pm_bus_off(struct sdhci_host *host)
81 static void sdhci_dumpregs(struct sdhci_host *host)
84 mmc_hostname(host->mmc));
87 sdhci_readl(host, SDHCI_DMA_ADDRESS),
88 sdhci_readw(host, SDHCI_HOST_VERSION));
90 sdhci_readw(host, SDHCI_BLOCK_SIZE),
91 sdhci_readw(host, SDHCI_BLOCK_COUNT));
93 sdhci_readl(host, SDHCI_ARGUMENT),
94 sdhci_readw(host, SDHCI_TRANSFER_MODE));
96 sdhci_readl(host, SDHCI_PRESENT_STATE),
97 sdhci_readb(host, SDHCI_HOST_CONTROL));
99 sdhci_readb(host, SDHCI_POWER_CONTROL),
100 sdhci_readb(host, SDHCI_BLOCK_GAP_CONTROL));
102 sdhci_readb(host, SDHCI_WAKE_UP_CONTROL),
103 sdhci_readw(host, SDHCI_CLOCK_CONTROL));
105 sdhci_readb(host, SDHCI_TIMEOUT_CONTROL),
106 sdhci_readl(host, SDHCI_INT_STATUS));
108 sdhci_readl(host, SDHCI_INT_ENABLE),
109 sdhci_readl(host, SDHCI_SIGNAL_ENABLE));
111 sdhci_readw(host, SDHCI_ACMD12_ERR),
112 sdhci_readw(host, SDHCI_SLOT_INT_STATUS));
114 sdhci_readl(host, SDHCI_CAPABILITIES),
115 sdhci_readl(host, SDHCI_CAPABILITIES_1));
117 sdhci_readw(host, SDHCI_COMMAND),
118 sdhci_readl(host, SDHCI_MAX_CURRENT));
120 sdhci_readw(host, SDHCI_HOST_CONTROL2));
122 if (host->flags & SDHCI_USE_ADMA)
124 readl(host->ioaddr + SDHCI_ADMA_ERROR),
125 readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
136 static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
140 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
141 (host->mmc->caps & MMC_CAP_NONREMOVABLE))
145 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
148 host->ier |= present ? SDHCI_INT_CARD_REMOVE :
151 host->ier &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
154 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
155 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
158 static void sdhci_enable_card_detection(struct sdhci_host *host)
160 sdhci_set_card_detection(host, true);
163 static void sdhci_disable_card_detection(struct sdhci_host *host)
165 sdhci_set_card_detection(host, false);
168 void sdhci_reset(struct sdhci_host *host, u8 mask)
172 sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
175 host->clock = 0;
177 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
178 sdhci_runtime_pm_bus_off(host);
185 while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
188 mmc_hostname(host->mmc), (int)mask);
189 sdhci_dumpregs(host);
198 static void sdhci_do_reset(struct sdhci_host *host, u8 mask)
200 if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
201 if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) &
206 host->ops->reset(host, mask);
209 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
210 if (host->ops->enable_dma)
211 host->ops->enable_dma(host);
215 host->preset_enabled = false;
221 static void sdhci_init(struct sdhci_host *host, int soft)
224 sdhci_do_reset(host, SDHCI_RESET_CMD|SDHCI_RESET_DATA);
226 sdhci_do_reset(host, SDHCI_RESET_ALL);
228 host->ier = SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
234 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
235 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
239 host->clock = 0;
240 sdhci_set_ios(host->mmc, &host->mmc->ios);
244 static void sdhci_reinit(struct sdhci_host *host)
246 sdhci_init(host, 0);
252 if (host->flags & SDHCI_USING_RETUNING_TIMER) {
253 host->flags &= ~SDHCI_USING_RETUNING_TIMER;
255 del_timer_sync(&host->tuning_timer);
256 host->flags &= ~SDHCI_NEEDS_RETUNING;
257 host->mmc->max_blk_count =
258 (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
260 sdhci_enable_card_detection(host);
263 static void sdhci_activate_led(struct sdhci_host *host)
267 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
269 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
272 static void sdhci_deactivate_led(struct sdhci_host *host)
276 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
278 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
285 struct sdhci_host *host = container_of(led, struct sdhci_host, led);
288 spin_lock_irqsave(&host->lock, flags);
290 if (host->runtime_suspended)
294 sdhci_deactivate_led(host);
296 sdhci_activate_led(host);
298 spin_unlock_irqrestore(&host->lock, flags);
308 static void sdhci_read_block_pio(struct sdhci_host *host)
317 blksize = host->data->blksz;
323 if (!sg_miter_next(&host->sg_miter))
326 len = min(host->sg_miter.length, blksize);
329 host->sg_miter.consumed = len;
331 buf = host->sg_miter.addr;
335 scratch = sdhci_readl(host, SDHCI_BUFFER);
348 sg_miter_stop(&host->sg_miter);
353 static void sdhci_write_block_pio(struct sdhci_host *host)
362 blksize = host->data->blksz;
369 if (!sg_miter_next(&host->sg_miter))
372 len = min(host->sg_miter.length, blksize);
375 host->sg_miter.consumed = len;
377 buf = host->sg_miter.addr;
387 sdhci_writel(host, scratch, SDHCI_BUFFER);
394 sg_miter_stop(&host->sg_miter);
399 static void sdhci_transfer_pio(struct sdhci_host *host)
403 BUG_ON(!host->data);
405 if (host->blocks == 0)
408 if (host->data->flags & MMC_DATA_READ)
418 if ((host->quirks & SDHCI_QUIRK_BROKEN_SMALL_PIO) &&
419 (host->data->blocks == 1))
422 while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
423 if (host->quirks & SDHCI_QUIRK_PIO_NEEDS_DELAY)
426 if (host->data->flags & MMC_DATA_READ)
427 sdhci_read_block_pio(host);
429 sdhci_write_block_pio(host);
431 host->blocks--;
432 if (host->blocks == 0)
465 static int sdhci_adma_table_pre(struct sdhci_host *host,
491 host->align_addr = dma_map_single(mmc_dev(host->mmc),
492 host->align_buffer, 128 * 4, direction);
493 if (dma_mapping_error(mmc_dev(host->mmc), host->align_addr))
495 BUG_ON(host->align_addr & 0x3);
497 host->sg_count = dma_map_sg(mmc_dev(host->mmc),
499 if (host->sg_count == 0)
502 desc = host->adma_desc;
503 align = host->align_buffer;
505 align_addr = host->align_addr;
507 for_each_sg(data->sg, sg, host->sg_count, i) {
551 WARN_ON((desc - host->adma_desc) > ADMA_SIZE);
554 if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) {
558 if (desc != host->adma_desc) {
575 dma_sync_single_for_device(mmc_dev(host->mmc),
576 host->align_addr, 128 * 4, direction);
582 dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
588 static void sdhci_adma_table_post(struct sdhci_host *host,
605 dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
610 for_each_sg(data->sg, sg, host->sg_count, i)
617 dma_sync_sg_for_cpu(mmc_dev(host->mmc), data->sg,
620 align = host->align_buffer;
622 for_each_sg(data->sg, sg, host->sg_count, i) {
636 dma_unmap_sg(mmc_dev(host->mmc), data->sg,
640 static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
647 * If the host controller provides us with an incorrect timeout
652 if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL)
664 if (host->clock)
665 target_timeout += data->timeout_clks / host->clock;
674 * (2) host->timeout_clk < 2^16
679 current_timeout = (1 << 13) * 1000 / host->timeout_clk;
689 mmc_hostname(host->mmc), count, cmd->opcode);
696 static void sdhci_set_transfer_irqs(struct sdhci_host *host)
701 if (host->flags & SDHCI_REQ_USE_DMA)
702 host->ier = (host->ier & ~pio_irqs) | dma_irqs;
704 host->ier = (host->ier & ~dma_irqs) | pio_irqs;
706 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
707 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
710 static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
714 if (host->ops->set_timeout) {
715 host->ops->set_timeout(host, cmd);
717 count = sdhci_calc_timeout(host, cmd);
718 sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
722 static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
728 WARN_ON(host->data);
731 sdhci_set_timeout(host, cmd);
738 BUG_ON(data->blksz > host->mmc->max_blk_size);
741 host->data = data;
742 host->data_early = 0;
743 host->data->bytes_xfered = 0;
745 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))
746 host->flags |= SDHCI_REQ_USE_DMA;
752 if (host->flags & SDHCI_REQ_USE_DMA) {
757 if (host->flags & SDHCI_USE_ADMA) {
758 if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE)
761 if (host->quirks & SDHCI_QUIRK_32BIT_DMA_SIZE)
771 host->flags &= ~SDHCI_REQ_USE_DMA;
782 if (host->flags & SDHCI_REQ_USE_DMA) {
787 if (host->flags & SDHCI_USE_ADMA) {
793 if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE)
796 if (host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR)
805 host->flags &= ~SDHCI_REQ_USE_DMA;
812 if (host->flags & SDHCI_REQ_USE_DMA) {
813 if (host->flags & SDHCI_USE_ADMA) {
814 ret = sdhci_adma_table_pre(host, data);
821 host->flags &= ~SDHCI_REQ_USE_DMA;
823 sdhci_writel(host, host->adma_addr,
829 sg_cnt = dma_map_sg(mmc_dev(host->mmc),
840 host->flags &= ~SDHCI_REQ_USE_DMA;
843 sdhci_writel(host, sg_dma_address(data->sg),
854 if (host->version >= SDHCI_SPEC_200) {
855 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
857 if ((host->flags & SDHCI_REQ_USE_DMA) &&
858 (host->flags & SDHCI_USE_ADMA))
862 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
865 if (!(host->flags & SDHCI_REQ_USE_DMA)) {
869 if (host->data->flags & MMC_DATA_READ)
873 sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
874 host->blocks = data->blocks;
877 sdhci_set_transfer_irqs(host);
880 sdhci_writew(host, SDHCI_MAKE_BLKSZ(SDHCI_DEFAULT_BOUNDARY_ARG,
882 sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
885 static void sdhci_set_transfer_mode(struct sdhci_host *host,
893 mode = sdhci_readw(host, SDHCI_TRANSFER_MODE);
894 sdhci_writew(host, mode & ~(SDHCI_TRNS_AUTO_CMD12 |
899 WARN_ON(!host->data);
908 if (!host->mrq->sbc && (host->flags & SDHCI_AUTO_CMD12))
910 else if (host->mrq->sbc && (host->flags & SDHCI_AUTO_CMD23)) {
912 sdhci_writel(host, host->mrq->sbc->arg, SDHCI_ARGUMENT2);
918 if (host->flags & SDHCI_REQ_USE_DMA)
921 sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
924 static void sdhci_finish_data(struct sdhci_host *host)
928 BUG_ON(!host->data);
930 data = host->data;
931 host->data = NULL;
933 if (host->flags & SDHCI_REQ_USE_DMA) {
934 if (host->flags & SDHCI_USE_ADMA)
935 sdhci_adma_table_post(host, data);
937 dma_unmap_sg(mmc_dev(host->mmc), data->sg,
962 !host->mrq->sbc)) {
969 sdhci_do_reset(host, SDHCI_RESET_CMD);
970 sdhci_do_reset(host, SDHCI_RESET_DATA);
973 sdhci_send_command(host, data->stop);
975 tasklet_schedule(&host->finish_tasklet);
978 void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
984 WARN_ON(host->cmd);
995 if (host->mrq->data && (cmd == host->mrq->data->stop))
998 while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
1001 "inhibit bit(s).\n", mmc_hostname(host->mmc));
1002 sdhci_dumpregs(host);
1004 tasklet_schedule(&host->finish_tasklet);
1016 mod_timer(&host->timer, timeout);
1018 host->cmd = cmd;
1019 host->busy_handle = 0;
1021 sdhci_prepare_data(host, cmd);
1023 sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
1025 sdhci_set_transfer_mode(host, cmd);
1029 mmc_hostname(host->mmc));
1031 tasklet_schedule(&host->finish_tasklet);
1054 sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
1058 static void sdhci_finish_command(struct sdhci_host *host)
1062 BUG_ON(host->cmd == NULL);
1064 if (host->cmd->flags & MMC_RSP_PRESENT) {
1065 if (host->cmd->flags & MMC_RSP_136) {
1068 host->cmd->resp[i] = sdhci_readl(host,
1071 host->cmd->resp[i] |=
1072 sdhci_readb(host,
1076 host->cmd->resp[0] = sdhci_readl(host, SDHCI_RESPONSE);
1080 host->cmd->error = 0;
1083 if (host->cmd == host->mrq->sbc) {
1084 host->cmd = NULL;
1085 sdhci_send_command(host, host->mrq->cmd);
1089 if (host->data && host->data_early)
1090 sdhci_finish_data(host);
1092 if (!host->cmd->data)
1093 tasklet_schedule(&host->finish_tasklet);
1095 host->cmd = NULL;
1099 static u16 sdhci_get_preset_value(struct sdhci_host *host)
1103 switch (host->timing) {
1105 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
1108 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR25);
1111 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR50);
1115 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR104);
1118 preset = sdhci_readw(host, SDHCI_PRESET_FOR_DDR50);
1122 mmc_hostname(host->mmc));
1123 preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
1129 void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
1136 host->mmc->actual_clock = 0;
1138 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
1143 if (host->version >= SDHCI_SPEC_300) {
1144 if (host->preset_enabled) {
1147 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1148 pre_val = sdhci_get_preset_value(host);
1151 if (host->clk_mul &&
1155 clk_mul = host->clk_mul;
1166 if (host->clk_mul) {
1168 if ((host->max_clk * host->clk_mul / div)
1178 clk_mul = host->clk_mul;
1182 if (host->max_clk <= clock)
1187 if ((host->max_clk / div) <= clock)
1197 if ((host->max_clk / div) <= clock)
1206 host->mmc->actual_clock = (host->max_clk * clk_mul) / real_div;
1211 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1215 while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
1219 "stabilised.\n", mmc_hostname(host->mmc));
1220 sdhci_dumpregs(host);
1228 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1232 static void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
1235 struct mmc_host *mmc = host->mmc;
1239 spin_unlock_irq(&host->lock);
1241 spin_lock_irq(&host->lock);
1263 if (host->pwr == pwr)
1266 host->pwr = pwr;
1269 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1270 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
1271 sdhci_runtime_pm_bus_off(host);
1278 if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
1279 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1286 if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER)
1287 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1291 sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1293 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
1294 sdhci_runtime_pm_bus_on(host);
1300 if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER)
1313 struct sdhci_host *host;
1318 host = mmc_priv(mmc);
1320 sdhci_runtime_pm_get(host);
1322 spin_lock_irqsave(&host->lock, flags);
1324 WARN_ON(host->mrq != NULL);
1327 sdhci_activate_led(host);
1334 if (!mrq->sbc && (host->flags & SDHCI_AUTO_CMD12)) {
1341 host->mrq = mrq;
1350 present = mmc_gpio_get_cd(host->mmc);
1353 if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1356 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
1360 if (!present || host->flags & SDHCI_DEVICE_DEAD) {
1361 host->mrq->cmd->error = -ENOMEDIUM;
1362 tasklet_schedule(&host->finish_tasklet);
1366 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
1372 if ((host->flags & SDHCI_NEEDS_RETUNING) &&
1382 /* Here we need to set the host->mrq to NULL,
1386 host->mrq = NULL;
1388 spin_unlock_irqrestore(&host->lock, flags);
1390 spin_lock_irqsave(&host->lock, flags);
1393 host->mrq = mrq;
1397 if (mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23))
1398 sdhci_send_command(host, mrq->sbc);
1400 sdhci_send_command(host, mrq->cmd);
1404 spin_unlock_irqrestore(&host->lock, flags);
1407 void sdhci_set_bus_width(struct sdhci_host *host, int width)
1411 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1414 if (host->version >= SDHCI_SPEC_300)
1417 if (host->version >= SDHCI_SPEC_300)
1424 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1428 void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing)
1432 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1433 /* Select Bus Speed Mode for host */
1447 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
1451 static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1455 struct mmc_host *mmc = host->mmc;
1457 spin_lock_irqsave(&host->lock, flags);
1459 if (host->flags & SDHCI_DEVICE_DEAD) {
1460 spin_unlock_irqrestore(&host->lock, flags);
1472 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
1473 sdhci_reinit(host);
1476 if (host->version >= SDHCI_SPEC_300 &&
1478 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN))
1479 sdhci_enable_preset_value(host, false);
1481 if (!ios->clock || ios->clock != host->clock) {
1482 host->ops->set_clock(host, ios->clock);
1483 host->clock = ios->clock;
1485 if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK &&
1486 host->clock) {
1487 host->timeout_clk = host->mmc->actual_clock ?
1488 host->mmc->actual_clock / 1000 :
1489 host->clock / 1000;
1490 host->mmc->max_busy_timeout =
1491 host->ops->get_max_timeout_count ?
1492 host->ops->get_max_timeout_count(host) :
1494 host->mmc->max_busy_timeout /= host->timeout_clk;
1498 sdhci_set_power(host, ios->power_mode, ios->vdd);
1500 if (host->ops->platform_send_init_74_clocks)
1501 host->ops->platform_send_init_74_clocks(host, ios->power_mode);
1503 host->ops->set_bus_width(host, ios->bus_width);
1505 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1509 && !(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT))
1514 if (host->version >= SDHCI_SPEC_300) {
1526 if (!host->preset_enabled) {
1527 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1532 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1539 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
1549 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1551 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1553 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1556 host->ops->set_clock(host, host->clock);
1560 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1562 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1564 host->ops->set_uhs_signaling(host, ios->timing);
1565 host->timing = ios->timing;
1567 if (!(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN) &&
1575 sdhci_enable_preset_value(host, true);
1576 preset = sdhci_get_preset_value(host);
1582 host->ops->set_clock(host, host->clock);
1584 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1591 if(host->quirks & SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS)
1592 sdhci_do_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
1595 spin_unlock_irqrestore(&host->lock, flags);
1600 struct sdhci_host *host = mmc_priv(mmc);
1602 sdhci_runtime_pm_get(host);
1603 sdhci_do_set_ios(host, ios);
1604 sdhci_runtime_pm_put(host);
1607 static int sdhci_do_get_cd(struct sdhci_host *host)
1609 int gpio_cd = mmc_gpio_get_cd(host->mmc);
1611 if (host->flags & SDHCI_DEVICE_DEAD)
1615 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
1616 (host->mmc->caps & MMC_CAP_NONREMOVABLE))
1624 return !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT);
1629 struct sdhci_host *host = mmc_priv(mmc);
1632 sdhci_runtime_pm_get(host);
1633 ret = sdhci_do_get_cd(host);
1634 sdhci_runtime_pm_put(host);
1638 static int sdhci_check_ro(struct sdhci_host *host)
1643 spin_lock_irqsave(&host->lock, flags);
1645 if (host->flags & SDHCI_DEVICE_DEAD)
1647 else if (host->ops->get_ro)
1648 is_readonly = host->ops->get_ro(host);
1650 is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE)
1653 spin_unlock_irqrestore(&host->lock, flags);
1656 return host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT ?
1662 static int sdhci_do_get_ro(struct sdhci_host *host)
1666 if (!(host->quirks & SDHCI_QUIRK_UNSTABLE_RO_DETECT))
1667 return sdhci_check_ro(host);
1671 if (sdhci_check_ro(host)) {
1682 struct sdhci_host *host = mmc_priv(mmc);
1684 if (host->ops && host->ops->hw_reset)
1685 host->ops->hw_reset(host);
1690 struct sdhci_host *host = mmc_priv(mmc);
1693 sdhci_runtime_pm_get(host);
1694 ret = sdhci_do_get_ro(host);
1695 sdhci_runtime_pm_put(host);
1699 static void sdhci_enable_sdio_irq_nolock(struct sdhci_host *host, int enable)
1701 if (!(host->flags & SDHCI_DEVICE_DEAD)) {
1703 host->ier |= SDHCI_INT_CARD_INT;
1705 host->ier &= ~SDHCI_INT_CARD_INT;
1707 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
1708 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
1715 struct sdhci_host *host = mmc_priv(mmc);
1718 sdhci_runtime_pm_get(host);
1720 spin_lock_irqsave(&host->lock, flags);
1722 host->flags |= SDHCI_SDIO_IRQ_ENABLED;
1724 host->flags &= ~SDHCI_SDIO_IRQ_ENABLED;
1726 sdhci_enable_sdio_irq_nolock(host, enable);
1727 spin_unlock_irqrestore(&host->lock, flags);
1729 sdhci_runtime_pm_put(host);
1732 static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
1735 struct mmc_host *mmc = host->mmc;
1743 if (host->version < SDHCI_SPEC_300)
1746 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1752 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1767 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1791 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1794 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1822 struct sdhci_host *host = mmc_priv(mmc);
1825 if (host->version < SDHCI_SPEC_300)
1827 sdhci_runtime_pm_get(host);
1828 err = sdhci_do_start_signal_voltage_switch(host, ios);
1829 sdhci_runtime_pm_put(host);
1835 struct sdhci_host *host = mmc_priv(mmc);
1838 sdhci_runtime_pm_get(host);
1840 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
1841 sdhci_runtime_pm_put(host);
1848 struct sdhci_host *host = mmc_priv(mmc);
1854 sdhci_runtime_pm_get(host);
1855 spin_lock_irqsave(&host->lock, flags);
1864 switch (host->timing) {
1870 if (host->flags & SDHCI_SDR50_NEEDS_TUNING ||
1871 host->flags & SDHCI_SDR104_NEEDS_TUNING)
1876 spin_unlock_irqrestore(&host->lock, flags);
1877 sdhci_runtime_pm_put(host);
1881 if (host->ops->platform_execute_tuning) {
1882 spin_unlock_irqrestore(&host->lock, flags);
1883 err = host->ops->platform_execute_tuning(host, opcode);
1884 sdhci_runtime_pm_put(host);
1888 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1890 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1902 sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_INT_ENABLE);
1903 sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_SIGNAL_ENABLE);
1924 host->mrq = &mrq;
1933 sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 128),
1936 sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
1939 sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
1944 * The tuning block is sent by the card to the host controller.
1949 sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
1951 sdhci_send_command(host, &cmd);
1953 host->cmd = NULL;
1954 host->mrq = NULL;
1956 spin_unlock_irqrestore(&host->lock, flags);
1958 wait_event_interruptible_timeout(host->buf_ready_int,
1959 (host->tuning_done == 1),
1961 spin_lock_irqsave(&host->lock, flags);
1963 if (!host->tuning_done) {
1968 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1971 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1977 host->tuning_done = 0;
1979 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1992 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2008 if (!(host->flags & SDHCI_NEEDS_RETUNING) && host->tuning_count &&
2009 (host->tuning_mode == SDHCI_TUNING_MODE_1)) {
2010 host->flags |= SDHCI_USING_RETUNING_TIMER;
2011 mod_timer(&host->tuning_timer, jiffies +
2012 host->tuning_count * HZ);
2015 } else if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2016 host->flags &= ~SDHCI_NEEDS_RETUNING;
2018 mod_timer(&host->tuning_timer, jiffies +
2019 host->tuning_count * HZ);
2023 * In case tuning fails, host controllers which support re-tuning can
2027 * them. SDHCI_USING_RETUNING_TIMER means the host is currently using
2030 if (err && (host->flags & SDHCI_USING_RETUNING_TIMER))
2033 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2034 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2035 spin_unlock_irqrestore(&host->lock, flags);
2036 sdhci_runtime_pm_put(host);
2042 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable)
2045 if (host->version < SDHCI_SPEC_300)
2052 if (host->preset_enabled != enable) {
2053 u16 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2060 sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2063 host->flags |= SDHCI_PV_ENABLED;
2065 host->flags &= ~SDHCI_PV_ENABLED;
2067 host->preset_enabled = enable;
2073 struct sdhci_host *host = mmc_priv(mmc);
2077 if (host->ops->card_event)
2078 host->ops->card_event(host);
2080 spin_lock_irqsave(&host->lock, flags);
2082 /* Check host->mrq first in case we are runtime suspended */
2083 if (host->mrq && !sdhci_do_get_cd(host)) {
2085 mmc_hostname(host->mmc));
2087 mmc_hostname(host->mmc));
2089 sdhci_do_reset(host, SDHCI_RESET_CMD);
2090 sdhci_do_reset(host, SDHCI_RESET_DATA);
2092 host->mrq->cmd->error = -ENOMEDIUM;
2093 tasklet_schedule(&host->finish_tasklet);
2096 spin_unlock_irqrestore(&host->lock, flags);
2120 struct sdhci_host *host;
2124 host = (struct sdhci_host*)param;
2126 spin_lock_irqsave(&host->lock, flags);
2132 if (!host->mrq) {
2133 spin_unlock_irqrestore(&host->lock, flags);
2137 del_timer(&host->timer);
2139 mrq = host->mrq;
2145 if (!(host->flags & SDHCI_DEVICE_DEAD) &&
2149 (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
2152 if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET)
2154 host->ops->set_clock(host, host->clock);
2158 sdhci_do_reset(host, SDHCI_RESET_CMD);
2159 sdhci_do_reset(host, SDHCI_RESET_DATA);
2162 host->mrq = NULL;
2163 host->cmd = NULL;
2164 host->data = NULL;
2167 sdhci_deactivate_led(host);
2171 spin_unlock_irqrestore(&host->lock, flags);
2173 mmc_request_done(host->mmc, mrq);
2174 sdhci_runtime_pm_put(host);
2179 struct sdhci_host *host;
2182 host = (struct sdhci_host*)data;
2184 spin_lock_irqsave(&host->lock, flags);
2186 if (host->mrq) {
2188 "interrupt.\n", mmc_hostname(host->mmc));
2189 sdhci_dumpregs(host);
2191 if (host->data) {
2192 host->data->error = -ETIMEDOUT;
2193 sdhci_finish_data(host);
2195 if (host->cmd)
2196 host->cmd->error = -ETIMEDOUT;
2198 host->mrq->cmd->error = -ETIMEDOUT;
2200 tasklet_schedule(&host->finish_tasklet);
2205 spin_unlock_irqrestore(&host->lock, flags);
2210 struct sdhci_host *host;
2213 host = (struct sdhci_host *)data;
2215 spin_lock_irqsave(&host->lock, flags);
2217 host->flags |= SDHCI_NEEDS_RETUNING;
2219 spin_unlock_irqrestore(&host->lock, flags);
2228 static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *mask)
2232 if (!host->cmd) {
2235 mmc_hostname(host->mmc), (unsigned)intmask);
2236 sdhci_dumpregs(host);
2241 host->cmd->error = -ETIMEDOUT;
2244 host->cmd->error = -EILSEQ;
2246 if (host->cmd->error) {
2247 tasklet_schedule(&host->finish_tasklet);
2252 * The host can send and interrupt when the busy state has
2262 if (host->cmd->flags & MMC_RSP_BUSY) {
2263 if (host->cmd->data)
2266 else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ)
2267 && !host->busy_handle) {
2269 host->busy_handle = 1;
2275 } else if ((host->quirks2 & SDHCI_QUIRK2_STOP_WITH_TC) &&
2276 host->cmd->opcode == MMC_STOP_TRANSMISSION && !host->data) {
2281 sdhci_finish_command(host);
2285 static void sdhci_show_adma_error(struct sdhci_host *host)
2287 const char *name = mmc_hostname(host->mmc);
2288 u8 *desc = host->adma_desc;
2293 sdhci_dumpregs(host);
2310 static void sdhci_show_adma_error(struct sdhci_host *host) { }
2313 static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2320 command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
2323 host->tuning_done = 1;
2324 wake_up(&host->buf_ready_int);
2329 if (!host->data) {
2335 if (host->cmd && (host->cmd->flags & MMC_RSP_BUSY)) {
2337 host->cmd->error = -ETIMEDOUT;
2338 tasklet_schedule(&host->finish_tasklet);
2347 if (host->busy_handle)
2348 sdhci_finish_command(host);
2350 host->busy_handle = 1;
2357 mmc_hostname(host->mmc), (unsigned)intmask);
2358 sdhci_dumpregs(host);
2364 host->data->error = -ETIMEDOUT;
2366 host->data->error = -EILSEQ;
2368 SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND))
2370 host->data->error = -EILSEQ;
2372 pr_err("%s: ADMA error\n", mmc_hostname(host->mmc));
2373 sdhci_show_adma_error(host);
2374 host->data->error = -EIO;
2375 if (host->ops->adma_workaround)
2376 host->ops->adma_workaround(host, intmask);
2379 if (host->data->error)
2380 sdhci_finish_data(host);
2383 sdhci_transfer_pio(host);
2390 * According to the spec sdhci_readl(host, SDHCI_DMA_ADDRESS)
2396 dmastart = sg_dma_address(host->data->sg);
2397 dmanow = dmastart + host->data->bytes_xfered;
2404 host->data->bytes_xfered = dmanow - dmastart;
2407 mmc_hostname(host->mmc), dmastart,
2408 host->data->bytes_xfered, dmanow);
2409 sdhci_writel(host, dmanow, SDHCI_DMA_ADDRESS);
2413 if (host->cmd) {
2419 host->data_early = 1;
2421 sdhci_finish_data(host);
2430 struct sdhci_host *host = dev_id;
2434 spin_lock(&host->lock);
2436 if (host->runtime_suspended && !sdhci_sdio_irq_enabled(host)) {
2437 spin_unlock(&host->lock);
2441 intmask = sdhci_readl(host, SDHCI_INT_STATUS);
2451 sdhci_writel(host, mask, SDHCI_INT_STATUS);
2454 mmc_hostname(host->mmc), intmask);
2457 u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
2471 host->ier &= ~(SDHCI_INT_CARD_INSERT |
2473 host->ier |= present ? SDHCI_INT_CARD_REMOVE :
2475 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2476 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2478 sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
2481 host->thread_isr |= intmask & (SDHCI_INT_CARD_INSERT |
2487 sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK,
2491 sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
2495 mmc_hostname(host->mmc));
2498 sdhci_enable_sdio_irq_nolock(host, false);
2499 host->thread_isr |= SDHCI_INT_CARD_INT;
2510 sdhci_writel(host, intmask, SDHCI_INT_STATUS);
2516 intmask = sdhci_readl(host, SDHCI_INT_STATUS);
2519 spin_unlock(&host->lock);
2523 mmc_hostname(host->mmc), unexpected);
2524 sdhci_dumpregs(host);
2532 struct sdhci_host *host = dev_id;
2536 spin_lock_irqsave(&host->lock, flags);
2537 isr = host->thread_isr;
2538 host->thread_isr = 0;
2539 spin_unlock_irqrestore(&host->lock, flags);
2542 sdhci_card_event(host->mmc);
2543 mmc_detect_change(host->mmc, msecs_to_jiffies(200));
2547 sdio_run_irqs(host->mmc);
2549 spin_lock_irqsave(&host->lock, flags);
2550 if (host->flags & SDHCI_SDIO_IRQ_ENABLED)
2551 sdhci_enable_sdio_irq_nolock(host, true);
2552 spin_unlock_irqrestore(&host->lock, flags);
2565 void sdhci_enable_irq_wakeups(struct sdhci_host *host)
2571 val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
2574 if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
2576 sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
2580 static void sdhci_disable_irq_wakeups(struct sdhci_host *host)
2586 val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
2588 sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
2591 int sdhci_suspend_host(struct sdhci_host *host)
2593 sdhci_disable_card_detection(host);
2596 if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2597 del_timer_sync(&host->tuning_timer);
2598 host->flags &= ~SDHCI_NEEDS_RETUNING;
2601 if (!device_may_wakeup(mmc_dev(host->mmc))) {
2602 host->ier = 0;
2603 sdhci_writel(host, 0, SDHCI_INT_ENABLE);
2604 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
2605 free_irq(host->irq, host);
2607 sdhci_enable_irq_wakeups(host);
2608 enable_irq_wake(host->irq);
2615 int sdhci_resume_host(struct sdhci_host *host)
2619 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
2620 if (host->ops->enable_dma)
2621 host->ops->enable_dma(host);
2624 if (!device_may_wakeup(mmc_dev(host->mmc))) {
2625 ret = request_threaded_irq(host->irq, sdhci_irq,
2627 mmc_hostname(host->mmc), host);
2631 sdhci_disable_irq_wakeups(host);
2632 disable_irq_wake(host->irq);
2635 if ((host->mmc->pm_flags & MMC_PM_KEEP_POWER) &&
2636 (host->quirks2 & SDHCI_QUIRK2_HOST_OFF_CARD_ON)) {
2637 /* Card keeps power but host controller does not */
2638 sdhci_init(host, 0);
2639 host->pwr = 0;
2640 host->clock = 0;
2641 sdhci_do_set_ios(host, &host->mmc->ios);
2643 sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
2647 sdhci_enable_card_detection(host);
2650 if (host->flags & SDHCI_USING_RETUNING_TIMER)
2651 host->flags |= SDHCI_NEEDS_RETUNING;
2661 static int sdhci_runtime_pm_get(struct sdhci_host *host)
2663 return pm_runtime_get_sync(host->mmc->parent);
2666 static int sdhci_runtime_pm_put(struct sdhci_host *host)
2668 pm_runtime_mark_last_busy(host->mmc->parent);
2669 return pm_runtime_put_autosuspend(host->mmc->parent);
2672 static void sdhci_runtime_pm_bus_on(struct sdhci_host *host)
2674 if (host->runtime_suspended || host->bus_on)
2676 host->bus_on = true;
2677 pm_runtime_get_noresume(host->mmc->parent);
2680 static void sdhci_runtime_pm_bus_off(struct sdhci_host *host)
2682 if (host->runtime_suspended || !host->bus_on)
2684 host->bus_on = false;
2685 pm_runtime_put_noidle(host->mmc->parent);
2688 int sdhci_runtime_suspend_host(struct sdhci_host *host)
2693 if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2694 del_timer_sync(&host->tuning_timer);
2695 host->flags &= ~SDHCI_NEEDS_RETUNING;
2698 spin_lock_irqsave(&host->lock, flags);
2699 host->ier &= SDHCI_INT_CARD_INT;
2700 sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2701 sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2702 spin_unlock_irqrestore(&host->lock, flags);
2704 synchronize_hardirq(host->irq);
2706 spin_lock_irqsave(&host->lock, flags);
2707 host->runtime_suspended = true;
2708 spin_unlock_irqrestore(&host->lock, flags);
2714 int sdhci_runtime_resume_host(struct sdhci_host *host)
2717 int host_flags = host->flags;
2720 if (host->ops->enable_dma)
2721 host->ops->enable_dma(host);
2724 sdhci_init(host, 0);
2727 host->pwr = 0;
2728 host->clock = 0;
2729 sdhci_do_set_ios(host, &host->mmc->ios);
2731 sdhci_do_start_signal_voltage_switch(host, &host->mmc->ios);
2733 !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) {
2734 spin_lock_irqsave(&host->lock, flags);
2735 sdhci_enable_preset_value(host, true);
2736 spin_unlock_irqrestore(&host->lock, flags);
2740 if (host->flags & SDHCI_USING_RETUNING_TIMER)
2741 host->flags |= SDHCI_NEEDS_RETUNING;
2743 spin_lock_irqsave(&host->lock, flags);
2745 host->runtime_suspended = false;
2748 if (host->flags & SDHCI_SDIO_IRQ_ENABLED)
2749 sdhci_enable_sdio_irq_nolock(host, true);
2752 sdhci_enable_card_detection(host);
2754 spin_unlock_irqrestore(&host->lock, flags);
2772 struct sdhci_host *host;
2780 host = mmc_priv(mmc);
2781 host->mmc = mmc;
2783 return host;
2788 int sdhci_add_host(struct sdhci_host *host)
2797 WARN_ON(host == NULL);
2798 if (host == NULL)
2801 mmc = host->mmc;
2804 host->quirks = debug_quirks;
2806 host->quirks2 = debug_quirks2;
2808 override_timeout_clk = host->timeout_clk;
2810 sdhci_do_reset(host, SDHCI_RESET_ALL);
2812 host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
2813 host->version = (host->version & SDHCI_SPEC_VER_MASK)
2815 if (host->version > SDHCI_SPEC_300) {
2818 host->version);
2821 caps[0] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
2822 sdhci_readl(host, SDHCI_CAPABILITIES);
2824 if (host->version >= SDHCI_SPEC_300)
2825 caps[1] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ?
2826 host->caps1 :
2827 sdhci_readl(host, SDHCI_CAPABILITIES_1);
2829 if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
2830 host->flags |= SDHCI_USE_SDMA;
2834 host->flags |= SDHCI_USE_SDMA;
2836 if ((host->quirks & SDHCI_QUIRK_BROKEN_DMA) &&
2837 (host->flags & SDHCI_USE_SDMA)) {
2839 host->flags &= ~SDHCI_USE_SDMA;
2842 if ((host->version >= SDHCI_SPEC_200) &&
2844 host->flags |= SDHCI_USE_ADMA;
2846 if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
2847 (host->flags & SDHCI_USE_ADMA)) {
2849 host->flags &= ~SDHCI_USE_ADMA;
2852 if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
2853 if (host->ops->enable_dma) {
2854 if (host->ops->enable_dma(host)) {
2857 host->flags &=
2863 if (host->flags & SDHCI_USE_ADMA) {
2869 host->adma_desc = dma_alloc_coherent(mmc_dev(mmc),
2870 ADMA_SIZE, &host->adma_addr,
2872 host->align_buffer = kmalloc(128 * 4, GFP_KERNEL);
2873 if (!host->adma_desc || !host->align_buffer) {
2875 host->adma_desc, host->adma_addr);
2876 kfree(host->align_buffer);
2879 host->flags &= ~SDHCI_USE_ADMA;
2880 host->adma_desc = NULL;
2881 host->align_buffer = NULL;
2882 } else if (host->adma_addr & 3) {
2885 host->flags &= ~SDHCI_USE_ADMA;
2887 host->adma_desc, host->adma_addr);
2888 kfree(host->align_buffer);
2889 host->adma_desc = NULL;
2890 host->align_buffer = NULL;
2899 if (!(host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))) {
2900 host->dma_mask = DMA_BIT_MASK(64);
2901 mmc_dev(mmc)->dma_mask = &host->dma_mask;
2904 if (host->version >= SDHCI_SPEC_300)
2905 host->max_clk = (caps[0] & SDHCI_CLOCK_V3_BASE_MASK)
2908 host->max_clk = (caps[0] & SDHCI_CLOCK_BASE_MASK)
2911 host->max_clk *= 1000000;
2912 if (host->max_clk == 0 || host->quirks &
2914 if (!host->ops->get_max_clock) {
2919 host->max_clk = host->ops->get_max_clock(host);
2926 host->clk_mul = (caps[1] & SDHCI_CLOCK_MUL_MASK) >>
2935 if (host->clk_mul)
2936 host->clk_mul += 1;
2939 * Set host parameters.
2942 mmc->f_max = host->max_clk;
2943 if (host->ops->get_min_clock)
2944 mmc->f_min = host->ops->get_min_clock(host);
2945 else if (host->version >= SDHCI_SPEC_300) {
2946 if (host->clk_mul) {
2947 mmc->f_min = (host->max_clk * host->clk_mul) / 1024;
2948 mmc->f_max = host->max_clk * host->clk_mul;
2950 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300;
2952 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
2954 if (!(host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
2955 host->timeout_clk = (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >>
2957 if (host->timeout_clk == 0) {
2958 if (host->ops->get_timeout_clock) {
2959 host->timeout_clk =
2960 host->ops->get_timeout_clock(host);
2969 host->timeout_clk *= 1000;
2971 mmc->max_busy_timeout = host->ops->get_max_timeout_count ?
2972 host->ops->get_max_timeout_count(host) : 1 << 27;
2973 mmc->max_busy_timeout /= host->timeout_clk;
2977 host->timeout_clk = override_timeout_clk;
2982 if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12)
2983 host->flags |= SDHCI_AUTO_CMD12;
2986 if ((host->version >= SDHCI_SPEC_300) &&
2987 ((host->flags & SDHCI_USE_ADMA) ||
2988 !(host->flags & SDHCI_USE_SDMA))) {
2989 host->flags |= SDHCI_AUTO_CMD23;
3002 if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA))
3005 if (host->quirks2 & SDHCI_QUIRK2_HOST_NO_CMD23)
3011 if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
3034 if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V)
3049 if (!(host->quirks2 & SDHCI_QUIRK2_BROKEN_HS200)) {
3060 !(host->quirks2 & SDHCI_QUIRK2_BROKEN_DDR50))
3063 /* Does the host need tuning for SDR50? */
3065 host->flags |= SDHCI_SDR50_NEEDS_TUNING;
3067 /* Does the host need tuning for SDR104 / HS200? */
3069 host->flags |= SDHCI_SDR104_NEEDS_TUNING;
3071 /* Driver Type(s) (A, C, D) supported by the host */
3080 host->tuning_count = (caps[1] & SDHCI_RETUNING_TIMER_COUNT_MASK) >>
3087 if (host->tuning_count)
3088 host->tuning_count = 1 << (host->tuning_count - 1);
3091 host->tuning_mode = (caps[1] & SDHCI_RETUNING_MODE_MASK) >>
3103 max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
3149 if (host->ocr_mask)
3150 ocr_avail &= host->ocr_mask;
3154 if (host->ocr_avail_sdio)
3155 mmc->ocr_avail_sdio &= host->ocr_avail_sdio;
3157 if (host->ocr_avail_sd)
3158 mmc->ocr_avail_sd &= host->ocr_avail_sd;
3162 if (host->ocr_avail_mmc)
3163 mmc->ocr_avail_mmc &= host->ocr_avail_mmc;
3171 spin_lock_init(&host->lock);
3177 if (host->flags & SDHCI_USE_ADMA)
3179 else if (host->flags & SDHCI_USE_SDMA)
3195 if (host->flags & SDHCI_USE_ADMA) {
3196 if (host->quirks & SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC)
3208 if (host->quirks & SDHCI_QUIRK_FORCE_BLK_SZ_2048) {
3225 mmc->max_blk_count = (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
3230 tasklet_init(&host->finish_tasklet,
3231 sdhci_tasklet_finish, (unsigned long)host);
3233 setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host);
3235 if (host->version >= SDHCI_SPEC_300) {
3236 init_waitqueue_head(&host->buf_ready_int);
3239 init_timer(&host->tuning_timer);
3240 host->tuning_timer.data = (unsigned long)host;
3241 host->tuning_timer.function = sdhci_tuning_timer;
3244 sdhci_init(host, 0);
3246 ret = request_threaded_irq(host->irq, sdhci_irq, sdhci_thread_irq,
3247 IRQF_SHARED, mmc_hostname(mmc), host);
3250 mmc_hostname(mmc), host->irq, ret);
3255 sdhci_dumpregs(host);
3259 snprintf(host->led_name, sizeof(host->led_name),
3261 host->led.name = host->led_name;
3262 host->led.brightness = LED_OFF;
3263 host->led.default_trigger = mmc_hostname(mmc);
3264 host->led.brightness_set = sdhci_led_control;
3266 ret = led_classdev_register(mmc_dev(mmc), &host->led);
3279 mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
3280 (host->flags & SDHCI_USE_ADMA) ? "ADMA" :
3281 (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
3283 sdhci_enable_card_detection(host);
3289 sdhci_do_reset(host, SDHCI_RESET_ALL);
3290 sdhci_writel(host, 0, SDHCI_INT_ENABLE);
3291 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
3292 free_irq(host->irq, host);
3295 tasklet_kill(&host->finish_tasklet);
3302 void sdhci_remove_host(struct sdhci_host *host, int dead)
3304 struct mmc_host *mmc = host->mmc;
3308 spin_lock_irqsave(&host->lock, flags);
3310 host->flags |= SDHCI_DEVICE_DEAD;
3312 if (host->mrq) {
3316 host->mrq->cmd->error = -ENOMEDIUM;
3317 tasklet_schedule(&host->finish_tasklet);
3320 spin_unlock_irqrestore(&host->lock, flags);
3323 sdhci_disable_card_detection(host);
3328 led_classdev_unregister(&host->led);
3332 sdhci_do_reset(host, SDHCI_RESET_ALL);
3334 sdhci_writel(host, 0, SDHCI_INT_ENABLE);
3335 sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
3336 free_irq(host->irq, host);
3338 del_timer_sync(&host->timer);
3340 tasklet_kill(&host->finish_tasklet);
3348 if (host->adma_desc)
3350 host->adma_desc, host->adma_addr);
3351 kfree(host->align_buffer);
3353 host->adma_desc = NULL;
3354 host->align_buffer = NULL;
3359 void sdhci_free_host(struct sdhci_host *host)
3361 mmc_free_host(host->mmc);