source: src/linux/universal/linux-3.18/drivers/mmc/host/sdhci.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 6 weeks ago

update

File size: 89.0 KB
Line 
1/*
2 *  linux/drivers/mmc/host/sdhci.c - Secure Digital Host Controller Interface driver
3 *
4 *  Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 *
11 * Thanks to the following companies for their support:
12 *
13 *     - JMicron (hardware and technical support)
14 */
15
16#include <linux/delay.h>
17#include <linux/highmem.h>
18#include <linux/io.h>
19#include <linux/module.h>
20#include <linux/dma-mapping.h>
21#include <linux/slab.h>
22#include <linux/scatterlist.h>
23#include <linux/regulator/consumer.h>
24#include <linux/pm_runtime.h>
25
26#include <linux/leds.h>
27
28#include <linux/mmc/mmc.h>
29#include <linux/mmc/host.h>
30#include <linux/mmc/card.h>
31#include <linux/mmc/slot-gpio.h>
32
33#include "sdhci.h"
34
35#define DRIVER_NAME "sdhci"
36
37#define DBG(f, x...) \
38        pr_debug(DRIVER_NAME " [%s()]: " f, __func__,## x)
39
40#if defined(CONFIG_LEDS_CLASS) || (defined(CONFIG_LEDS_CLASS_MODULE) && \
41        defined(CONFIG_MMC_SDHCI_MODULE))
42#define SDHCI_USE_LEDS_CLASS
43#endif
44
45#define MAX_TUNING_LOOP 40
46
47#define ADMA_SIZE       ((128 * 2 + 1) * 4)
48
49static unsigned int debug_quirks = 0;
50static unsigned int debug_quirks2;
51
52static void sdhci_finish_data(struct sdhci_host *);
53
54static void sdhci_finish_command(struct sdhci_host *);
55static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode);
56static void sdhci_tuning_timer(unsigned long data);
57static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable);
58
59#ifdef CONFIG_PM_RUNTIME
60static int sdhci_runtime_pm_get(struct sdhci_host *host);
61static int sdhci_runtime_pm_put(struct sdhci_host *host);
62static void sdhci_runtime_pm_bus_on(struct sdhci_host *host);
63static void sdhci_runtime_pm_bus_off(struct sdhci_host *host);
64#else
65static inline int sdhci_runtime_pm_get(struct sdhci_host *host)
66{
67        return 0;
68}
69static inline int sdhci_runtime_pm_put(struct sdhci_host *host)
70{
71        return 0;
72}
73static void sdhci_runtime_pm_bus_on(struct sdhci_host *host)
74{
75}
76static void sdhci_runtime_pm_bus_off(struct sdhci_host *host)
77{
78}
79#endif
80
81static void sdhci_dumpregs(struct sdhci_host *host)
82{
83        pr_debug(DRIVER_NAME ": =========== REGISTER DUMP (%s)===========\n",
84                mmc_hostname(host->mmc));
85
86        pr_debug(DRIVER_NAME ": Sys addr: 0x%08x | Version:  0x%08x\n",
87                sdhci_readl(host, SDHCI_DMA_ADDRESS),
88                sdhci_readw(host, SDHCI_HOST_VERSION));
89        pr_debug(DRIVER_NAME ": Blk size: 0x%08x | Blk cnt:  0x%08x\n",
90                sdhci_readw(host, SDHCI_BLOCK_SIZE),
91                sdhci_readw(host, SDHCI_BLOCK_COUNT));
92        pr_debug(DRIVER_NAME ": Argument: 0x%08x | Trn mode: 0x%08x\n",
93                sdhci_readl(host, SDHCI_ARGUMENT),
94                sdhci_readw(host, SDHCI_TRANSFER_MODE));
95        pr_debug(DRIVER_NAME ": Present:  0x%08x | Host ctl: 0x%08x\n",
96                sdhci_readl(host, SDHCI_PRESENT_STATE),
97                sdhci_readb(host, SDHCI_HOST_CONTROL));
98        pr_debug(DRIVER_NAME ": Power:    0x%08x | Blk gap:  0x%08x\n",
99                sdhci_readb(host, SDHCI_POWER_CONTROL),
100                sdhci_readb(host, SDHCI_BLOCK_GAP_CONTROL));
101        pr_debug(DRIVER_NAME ": Wake-up:  0x%08x | Clock:    0x%08x\n",
102                sdhci_readb(host, SDHCI_WAKE_UP_CONTROL),
103                sdhci_readw(host, SDHCI_CLOCK_CONTROL));
104        pr_debug(DRIVER_NAME ": Timeout:  0x%08x | Int stat: 0x%08x\n",
105                sdhci_readb(host, SDHCI_TIMEOUT_CONTROL),
106                sdhci_readl(host, SDHCI_INT_STATUS));
107        pr_debug(DRIVER_NAME ": Int enab: 0x%08x | Sig enab: 0x%08x\n",
108                sdhci_readl(host, SDHCI_INT_ENABLE),
109                sdhci_readl(host, SDHCI_SIGNAL_ENABLE));
110        pr_debug(DRIVER_NAME ": AC12 err: 0x%08x | Slot int: 0x%08x\n",
111                sdhci_readw(host, SDHCI_ACMD12_ERR),
112                sdhci_readw(host, SDHCI_SLOT_INT_STATUS));
113        pr_debug(DRIVER_NAME ": Caps:     0x%08x | Caps_1:   0x%08x\n",
114                sdhci_readl(host, SDHCI_CAPABILITIES),
115                sdhci_readl(host, SDHCI_CAPABILITIES_1));
116        pr_debug(DRIVER_NAME ": Cmd:      0x%08x | Max curr: 0x%08x\n",
117                sdhci_readw(host, SDHCI_COMMAND),
118                sdhci_readl(host, SDHCI_MAX_CURRENT));
119        pr_debug(DRIVER_NAME ": Host ctl2: 0x%08x\n",
120                sdhci_readw(host, SDHCI_HOST_CONTROL2));
121
122        if (host->flags & SDHCI_USE_ADMA)
123                pr_debug(DRIVER_NAME ": ADMA Err: 0x%08x | ADMA Ptr: 0x%08x\n",
124                       readl(host->ioaddr + SDHCI_ADMA_ERROR),
125                       readl(host->ioaddr + SDHCI_ADMA_ADDRESS));
126
127        pr_debug(DRIVER_NAME ": ===========================================\n");
128}
129
130/*****************************************************************************\
131 *                                                                           *
132 * Low level functions                                                       *
133 *                                                                           *
134\*****************************************************************************/
135
136static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
137{
138        u32 present;
139
140        if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
141            (host->mmc->caps & MMC_CAP_NONREMOVABLE))
142                return;
143
144        if (enable) {
145                present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
146                                      SDHCI_CARD_PRESENT;
147
148                host->ier |= present ? SDHCI_INT_CARD_REMOVE :
149                                       SDHCI_INT_CARD_INSERT;
150        } else {
151                host->ier &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
152        }
153
154        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
155        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
156}
157
158static void sdhci_enable_card_detection(struct sdhci_host *host)
159{
160        sdhci_set_card_detection(host, true);
161}
162
163static void sdhci_disable_card_detection(struct sdhci_host *host)
164{
165        sdhci_set_card_detection(host, false);
166}
167
168void sdhci_reset(struct sdhci_host *host, u8 mask)
169{
170        unsigned long timeout;
171
172        sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
173
174        if (mask & SDHCI_RESET_ALL) {
175                host->clock = 0;
176                /* Reset-all turns off SD Bus Power */
177                if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
178                        sdhci_runtime_pm_bus_off(host);
179        }
180
181        /* Wait max 100 ms */
182        timeout = 100;
183
184        /* hw clears the bit when it's done */
185        while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
186                if (timeout == 0) {
187                        pr_err("%s: Reset 0x%x never completed.\n",
188                                mmc_hostname(host->mmc), (int)mask);
189                        sdhci_dumpregs(host);
190                        return;
191                }
192                timeout--;
193                mdelay(1);
194        }
195}
196EXPORT_SYMBOL_GPL(sdhci_reset);
197
198static void sdhci_do_reset(struct sdhci_host *host, u8 mask)
199{
200        if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
201                if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) &
202                        SDHCI_CARD_PRESENT))
203                        return;
204        }
205
206        host->ops->reset(host, mask);
207
208        if (mask & SDHCI_RESET_ALL) {
209                if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
210                        if (host->ops->enable_dma)
211                                host->ops->enable_dma(host);
212                }
213
214                /* Resetting the controller clears many */
215                host->preset_enabled = false;
216        }
217}
218
219static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios);
220
221static void sdhci_init(struct sdhci_host *host, int soft)
222{
223        if (soft)
224                sdhci_do_reset(host, SDHCI_RESET_CMD|SDHCI_RESET_DATA);
225        else
226                sdhci_do_reset(host, SDHCI_RESET_ALL);
227
228        host->ier = SDHCI_INT_BUS_POWER | SDHCI_INT_DATA_END_BIT |
229                    SDHCI_INT_DATA_CRC | SDHCI_INT_DATA_TIMEOUT |
230                    SDHCI_INT_INDEX | SDHCI_INT_END_BIT | SDHCI_INT_CRC |
231                    SDHCI_INT_TIMEOUT | SDHCI_INT_DATA_END |
232                    SDHCI_INT_RESPONSE;
233
234        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
235        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
236
237        if (soft) {
238                /* force clock reconfiguration */
239                host->clock = 0;
240                sdhci_set_ios(host->mmc, &host->mmc->ios);
241        }
242}
243
244static void sdhci_reinit(struct sdhci_host *host)
245{
246        sdhci_init(host, 0);
247        /*
248         * Retuning stuffs are affected by different cards inserted and only
249         * applicable to UHS-I cards. So reset these fields to their initial
250         * value when card is removed.
251         */
252        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
253                host->flags &= ~SDHCI_USING_RETUNING_TIMER;
254
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;
259        }
260        sdhci_enable_card_detection(host);
261}
262
263static void sdhci_activate_led(struct sdhci_host *host)
264{
265        u8 ctrl;
266
267        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
268        ctrl |= SDHCI_CTRL_LED;
269        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
270}
271
272static void sdhci_deactivate_led(struct sdhci_host *host)
273{
274        u8 ctrl;
275
276        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
277        ctrl &= ~SDHCI_CTRL_LED;
278        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
279}
280
281#ifdef SDHCI_USE_LEDS_CLASS
282static void sdhci_led_control(struct led_classdev *led,
283        enum led_brightness brightness)
284{
285        struct sdhci_host *host = container_of(led, struct sdhci_host, led);
286        unsigned long flags;
287
288        spin_lock_irqsave(&host->lock, flags);
289
290        if (host->runtime_suspended)
291                goto out;
292
293        if (brightness == LED_OFF)
294                sdhci_deactivate_led(host);
295        else
296                sdhci_activate_led(host);
297out:
298        spin_unlock_irqrestore(&host->lock, flags);
299}
300#endif
301
302/*****************************************************************************\
303 *                                                                           *
304 * Core functions                                                            *
305 *                                                                           *
306\*****************************************************************************/
307
308static void sdhci_read_block_pio(struct sdhci_host *host)
309{
310        unsigned long flags;
311        size_t blksize, len, chunk;
312        u32 uninitialized_var(scratch);
313        u8 *buf;
314
315        DBG("PIO reading\n");
316
317        blksize = host->data->blksz;
318        chunk = 0;
319
320        local_irq_save(flags);
321
322        while (blksize) {
323                if (!sg_miter_next(&host->sg_miter))
324                        BUG();
325
326                len = min(host->sg_miter.length, blksize);
327
328                blksize -= len;
329                host->sg_miter.consumed = len;
330
331                buf = host->sg_miter.addr;
332
333                while (len) {
334                        if (chunk == 0) {
335                                scratch = sdhci_readl(host, SDHCI_BUFFER);
336                                chunk = 4;
337                        }
338
339                        *buf = scratch & 0xFF;
340
341                        buf++;
342                        scratch >>= 8;
343                        chunk--;
344                        len--;
345                }
346        }
347
348        sg_miter_stop(&host->sg_miter);
349
350        local_irq_restore(flags);
351}
352
353static void sdhci_write_block_pio(struct sdhci_host *host)
354{
355        unsigned long flags;
356        size_t blksize, len, chunk;
357        u32 scratch;
358        u8 *buf;
359
360        DBG("PIO writing\n");
361
362        blksize = host->data->blksz;
363        chunk = 0;
364        scratch = 0;
365
366        local_irq_save(flags);
367
368        while (blksize) {
369                if (!sg_miter_next(&host->sg_miter))
370                        BUG();
371
372                len = min(host->sg_miter.length, blksize);
373
374                blksize -= len;
375                host->sg_miter.consumed = len;
376
377                buf = host->sg_miter.addr;
378
379                while (len) {
380                        scratch |= (u32)*buf << (chunk * 8);
381
382                        buf++;
383                        chunk++;
384                        len--;
385
386                        if ((chunk == 4) || ((len == 0) && (blksize == 0))) {
387                                sdhci_writel(host, scratch, SDHCI_BUFFER);
388                                chunk = 0;
389                                scratch = 0;
390                        }
391                }
392        }
393
394        sg_miter_stop(&host->sg_miter);
395
396        local_irq_restore(flags);
397}
398
399static void sdhci_transfer_pio(struct sdhci_host *host)
400{
401        u32 mask;
402
403        BUG_ON(!host->data);
404
405        if (host->blocks == 0)
406                return;
407
408        if (host->data->flags & MMC_DATA_READ)
409                mask = SDHCI_DATA_AVAILABLE;
410        else
411                mask = SDHCI_SPACE_AVAILABLE;
412
413        /*
414         * Some controllers (JMicron JMB38x) mess up the buffer bits
415         * for transfers < 4 bytes. As long as it is just one block,
416         * we can ignore the bits.
417         */
418        if ((host->quirks & SDHCI_QUIRK_BROKEN_SMALL_PIO) &&
419                (host->data->blocks == 1))
420                mask = ~0;
421
422        while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
423                if (host->quirks & SDHCI_QUIRK_PIO_NEEDS_DELAY)
424                        udelay(100);
425
426                if (host->data->flags & MMC_DATA_READ)
427                        sdhci_read_block_pio(host);
428                else
429                        sdhci_write_block_pio(host);
430
431                host->blocks--;
432                if (host->blocks == 0)
433                        break;
434        }
435
436        DBG("PIO transfer complete.\n");
437}
438
439static char *sdhci_kmap_atomic(struct scatterlist *sg, unsigned long *flags)
440{
441        local_irq_save(*flags);
442        return kmap_atomic(sg_page(sg)) + sg->offset;
443}
444
445static void sdhci_kunmap_atomic(void *buffer, unsigned long *flags)
446{
447        kunmap_atomic(buffer);
448        local_irq_restore(*flags);
449}
450
451static void sdhci_set_adma_desc(u8 *desc, u32 addr, int len, unsigned cmd)
452{
453        __le32 *dataddr = (__le32 __force *)(desc + 4);
454        __le16 *cmdlen = (__le16 __force *)desc;
455
456        /* SDHCI specification says ADMA descriptors should be 4 byte
457         * aligned, so using 16 or 32bit operations should be safe. */
458
459        cmdlen[0] = cpu_to_le16(cmd);
460        cmdlen[1] = cpu_to_le16(len);
461
462        dataddr[0] = cpu_to_le32(addr);
463}
464
465static int sdhci_adma_table_pre(struct sdhci_host *host,
466        struct mmc_data *data)
467{
468        int direction;
469
470        u8 *desc;
471        u8 *align;
472        dma_addr_t addr;
473        dma_addr_t align_addr;
474        int len, offset;
475
476        struct scatterlist *sg;
477        int i;
478        char *buffer;
479        unsigned long flags;
480
481        /*
482         * The spec does not specify endianness of descriptor table.
483         * We currently guess that it is LE.
484         */
485
486        if (data->flags & MMC_DATA_READ)
487                direction = DMA_FROM_DEVICE;
488        else
489                direction = DMA_TO_DEVICE;
490
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))
494                goto fail;
495        BUG_ON(host->align_addr & 0x3);
496
497        host->sg_count = dma_map_sg(mmc_dev(host->mmc),
498                data->sg, data->sg_len, direction);
499        if (host->sg_count == 0)
500                goto unmap_align;
501
502        desc = host->adma_desc;
503        align = host->align_buffer;
504
505        align_addr = host->align_addr;
506
507        for_each_sg(data->sg, sg, host->sg_count, i) {
508                addr = sg_dma_address(sg);
509                len = sg_dma_len(sg);
510
511                /*
512                 * The SDHCI specification states that ADMA
513                 * addresses must be 32-bit aligned. If they
514                 * aren't, then we use a bounce buffer for
515                 * the (up to three) bytes that screw up the
516                 * alignment.
517                 */
518                offset = (4 - (addr & 0x3)) & 0x3;
519                if (offset) {
520                        if (data->flags & MMC_DATA_WRITE) {
521                                buffer = sdhci_kmap_atomic(sg, &flags);
522                                WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
523                                memcpy(align, buffer, offset);
524                                sdhci_kunmap_atomic(buffer, &flags);
525                        }
526
527                        /* tran, valid */
528                        sdhci_set_adma_desc(desc, align_addr, offset, 0x21);
529
530                        BUG_ON(offset > 65536);
531
532                        align += 4;
533                        align_addr += 4;
534
535                        desc += 8;
536
537                        addr += offset;
538                        len -= offset;
539                }
540
541                BUG_ON(len > 65536);
542
543                /* tran, valid */
544                sdhci_set_adma_desc(desc, addr, len, 0x21);
545                desc += 8;
546
547                /*
548                 * If this triggers then we have a calculation bug
549                 * somewhere. :/
550                 */
551                WARN_ON((desc - host->adma_desc) > ADMA_SIZE);
552        }
553
554        if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) {
555                /*
556                * Mark the last descriptor as the terminating descriptor
557                */
558                if (desc != host->adma_desc) {
559                        desc -= 8;
560                        desc[0] |= 0x2; /* end */
561                }
562        } else {
563                /*
564                * Add a terminating entry.
565                */
566
567                /* nop, end, valid */
568                sdhci_set_adma_desc(desc, 0, 0, 0x3);
569        }
570
571        /*
572         * Resync align buffer as we might have changed it.
573         */
574        if (data->flags & MMC_DATA_WRITE) {
575                dma_sync_single_for_device(mmc_dev(host->mmc),
576                        host->align_addr, 128 * 4, direction);
577        }
578
579        return 0;
580
581unmap_align:
582        dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
583                128 * 4, direction);
584fail:
585        return -EINVAL;
586}
587
588static void sdhci_adma_table_post(struct sdhci_host *host,
589        struct mmc_data *data)
590{
591        int direction;
592
593        struct scatterlist *sg;
594        int i, size;
595        u8 *align;
596        char *buffer;
597        unsigned long flags;
598        bool has_unaligned;
599
600        if (data->flags & MMC_DATA_READ)
601                direction = DMA_FROM_DEVICE;
602        else
603                direction = DMA_TO_DEVICE;
604
605        dma_unmap_single(mmc_dev(host->mmc), host->align_addr,
606                128 * 4, direction);
607
608        /* Do a quick scan of the SG list for any unaligned mappings */
609        has_unaligned = false;
610        for_each_sg(data->sg, sg, host->sg_count, i)
611                if (sg_dma_address(sg) & 3) {
612                        has_unaligned = true;
613                        break;
614                }
615
616        if (has_unaligned && data->flags & MMC_DATA_READ) {
617                dma_sync_sg_for_cpu(mmc_dev(host->mmc), data->sg,
618                        data->sg_len, direction);
619
620                align = host->align_buffer;
621
622                for_each_sg(data->sg, sg, host->sg_count, i) {
623                        if (sg_dma_address(sg) & 0x3) {
624                                size = 4 - (sg_dma_address(sg) & 0x3);
625
626                                buffer = sdhci_kmap_atomic(sg, &flags);
627                                WARN_ON(((long)buffer & PAGE_MASK) > (PAGE_SIZE - 3));
628                                memcpy(buffer, align, size);
629                                sdhci_kunmap_atomic(buffer, &flags);
630
631                                align += 4;
632                        }
633                }
634        }
635
636        dma_unmap_sg(mmc_dev(host->mmc), data->sg,
637                data->sg_len, direction);
638}
639
640static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
641{
642        u8 count;
643        struct mmc_data *data = cmd->data;
644        unsigned target_timeout, current_timeout;
645
646        /*
647         * If the host controller provides us with an incorrect timeout
648         * value, just skip the check and use 0xE.  The hardware may take
649         * longer to time out, but that's much better than having a too-short
650         * timeout value.
651         */
652        if (host->quirks & SDHCI_QUIRK_BROKEN_TIMEOUT_VAL)
653                return 0xE;
654
655        /* Unspecified timeout, assume max */
656        if (!data && !cmd->busy_timeout)
657                return 0xE;
658
659        /* timeout in us */
660        if (!data)
661                target_timeout = cmd->busy_timeout * 1000;
662        else {
663                target_timeout = DIV_ROUND_UP(data->timeout_ns, 1000);
664                if (host->clock && data->timeout_clks) {
665                        unsigned long long val;
666
667                        /*
668                         * data->timeout_clks is in units of clock cycles.
669                         * host->clock is in Hz.  target_timeout is in us.
670                         * Hence, us = 1000000 * cycles / Hz.  Round up.
671                         */
672                        val = 1000000ULL * data->timeout_clks;
673                        if (do_div(val, host->clock))
674                                target_timeout++;
675                        target_timeout += val;
676                }
677        }
678
679        /*
680         * Figure out needed cycles.
681         * We do this in steps in order to fit inside a 32 bit int.
682         * The first step is the minimum timeout, which will have a
683         * minimum resolution of 6 bits:
684         * (1) 2^13*1000 > 2^22,
685         * (2) host->timeout_clk < 2^16
686         *     =>
687         *     (1) / (2) > 2^6
688         */
689        count = 0;
690        current_timeout = (1 << 13) * 1000 / host->timeout_clk;
691        while (current_timeout < target_timeout) {
692                count++;
693                current_timeout <<= 1;
694                if (count >= 0xF)
695                        break;
696        }
697
698        if (count >= 0xF) {
699                DBG("%s: Too large timeout 0x%x requested for CMD%d!\n",
700                    mmc_hostname(host->mmc), count, cmd->opcode);
701                count = 0xE;
702        }
703
704        return count;
705}
706
707static void sdhci_set_transfer_irqs(struct sdhci_host *host)
708{
709        u32 pio_irqs = SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL;
710        u32 dma_irqs = SDHCI_INT_DMA_END | SDHCI_INT_ADMA_ERROR;
711
712        if (host->flags & SDHCI_REQ_USE_DMA)
713                host->ier = (host->ier & ~pio_irqs) | dma_irqs;
714        else
715                host->ier = (host->ier & ~dma_irqs) | pio_irqs;
716
717        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
718        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
719}
720
721static void sdhci_set_timeout(struct sdhci_host *host, struct mmc_command *cmd)
722{
723        u8 count;
724
725        if (host->ops->set_timeout) {
726                host->ops->set_timeout(host, cmd);
727        } else {
728                count = sdhci_calc_timeout(host, cmd);
729                sdhci_writeb(host, count, SDHCI_TIMEOUT_CONTROL);
730        }
731}
732
733static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_command *cmd)
734{
735        u8 ctrl;
736        struct mmc_data *data = cmd->data;
737        int ret;
738
739        WARN_ON(host->data);
740
741        if (data || (cmd->flags & MMC_RSP_BUSY))
742                sdhci_set_timeout(host, cmd);
743
744        if (!data)
745                return;
746
747        /* Sanity checks */
748        BUG_ON(data->blksz * data->blocks > 524288);
749        BUG_ON(data->blksz > host->mmc->max_blk_size);
750        BUG_ON(data->blocks > 65535);
751
752        host->data = data;
753        host->data_early = 0;
754        host->data->bytes_xfered = 0;
755
756        if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))
757                host->flags |= SDHCI_REQ_USE_DMA;
758
759        /*
760         * FIXME: This doesn't account for merging when mapping the
761         * scatterlist.
762         */
763        if (host->flags & SDHCI_REQ_USE_DMA) {
764                int broken, i;
765                struct scatterlist *sg;
766
767                broken = 0;
768                if (host->flags & SDHCI_USE_ADMA) {
769                        if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE)
770                                broken = 1;
771                } else {
772                        if (host->quirks & SDHCI_QUIRK_32BIT_DMA_SIZE)
773                                broken = 1;
774                }
775
776                if (unlikely(broken)) {
777                        for_each_sg(data->sg, sg, data->sg_len, i) {
778                                if (sg->length & 0x3) {
779                                        DBG("Reverting to PIO because of "
780                                                "transfer size (%d)\n",
781                                                sg->length);
782                                        host->flags &= ~SDHCI_REQ_USE_DMA;
783                                        break;
784                                }
785                        }
786                }
787        }
788
789        /*
790         * The assumption here being that alignment is the same after
791         * translation to device address space.
792         */
793        if (host->flags & SDHCI_REQ_USE_DMA) {
794                int broken, i;
795                struct scatterlist *sg;
796
797                broken = 0;
798                if (host->flags & SDHCI_USE_ADMA) {
799                        /*
800                         * As we use 3 byte chunks to work around
801                         * alignment problems, we need to check this
802                         * quirk.
803                         */
804                        if (host->quirks & SDHCI_QUIRK_32BIT_ADMA_SIZE)
805                                broken = 1;
806                } else {
807                        if (host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR)
808                                broken = 1;
809                }
810
811                if (unlikely(broken)) {
812                        for_each_sg(data->sg, sg, data->sg_len, i) {
813                                if (sg->offset & 0x3) {
814                                        DBG("Reverting to PIO because of "
815                                                "bad alignment\n");
816                                        host->flags &= ~SDHCI_REQ_USE_DMA;
817                                        break;
818                                }
819                        }
820                }
821        }
822
823        if (host->flags & SDHCI_REQ_USE_DMA) {
824                if (host->flags & SDHCI_USE_ADMA) {
825                        ret = sdhci_adma_table_pre(host, data);
826                        if (ret) {
827                                /*
828                                 * This only happens when someone fed
829                                 * us an invalid request.
830                                 */
831                                WARN_ON(1);
832                                host->flags &= ~SDHCI_REQ_USE_DMA;
833                        } else {
834                                sdhci_writel(host, host->adma_addr,
835                                        SDHCI_ADMA_ADDRESS);
836                        }
837                } else {
838                        int sg_cnt;
839
840                        sg_cnt = dma_map_sg(mmc_dev(host->mmc),
841                                        data->sg, data->sg_len,
842                                        (data->flags & MMC_DATA_READ) ?
843                                                DMA_FROM_DEVICE :
844                                                DMA_TO_DEVICE);
845                        if (sg_cnt == 0) {
846                                /*
847                                 * This only happens when someone fed
848                                 * us an invalid request.
849                                 */
850                                WARN_ON(1);
851                                host->flags &= ~SDHCI_REQ_USE_DMA;
852                        } else {
853                                WARN_ON(sg_cnt != 1);
854                                sdhci_writel(host, sg_dma_address(data->sg),
855                                        SDHCI_DMA_ADDRESS);
856                        }
857                }
858        }
859
860        /*
861         * Always adjust the DMA selection as some controllers
862         * (e.g. JMicron) can't do PIO properly when the selection
863         * is ADMA.
864         */
865        if (host->version >= SDHCI_SPEC_200) {
866                ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
867                ctrl &= ~SDHCI_CTRL_DMA_MASK;
868                if ((host->flags & SDHCI_REQ_USE_DMA) &&
869                        (host->flags & SDHCI_USE_ADMA))
870                        ctrl |= SDHCI_CTRL_ADMA32;
871                else
872                        ctrl |= SDHCI_CTRL_SDMA;
873                sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
874        }
875
876        if (!(host->flags & SDHCI_REQ_USE_DMA)) {
877                int flags;
878
879                flags = SG_MITER_ATOMIC;
880                if (host->data->flags & MMC_DATA_READ)
881                        flags |= SG_MITER_TO_SG;
882                else
883                        flags |= SG_MITER_FROM_SG;
884                sg_miter_start(&host->sg_miter, data->sg, data->sg_len, flags);
885                host->blocks = data->blocks;
886        }
887
888        sdhci_set_transfer_irqs(host);
889
890        /* Set the DMA boundary value and block size */
891        sdhci_writew(host, SDHCI_MAKE_BLKSZ(SDHCI_DEFAULT_BOUNDARY_ARG,
892                data->blksz), SDHCI_BLOCK_SIZE);
893        sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
894}
895
896static void sdhci_set_transfer_mode(struct sdhci_host *host,
897        struct mmc_command *cmd)
898{
899        u16 mode;
900        struct mmc_data *data = cmd->data;
901
902        if (data == NULL) {
903                /* clear Auto CMD settings for no data CMDs */
904                mode = sdhci_readw(host, SDHCI_TRANSFER_MODE);
905                sdhci_writew(host, mode & ~(SDHCI_TRNS_AUTO_CMD12 |
906                                SDHCI_TRNS_AUTO_CMD23), SDHCI_TRANSFER_MODE);
907                return;
908        }
909
910        WARN_ON(!host->data);
911
912        mode = SDHCI_TRNS_BLK_CNT_EN;
913        if (mmc_op_multi(cmd->opcode) || data->blocks > 1) {
914                mode |= SDHCI_TRNS_MULTI;
915                /*
916                 * If we are sending CMD23, CMD12 never gets sent
917                 * on successful completion (so no Auto-CMD12).
918                 */
919                if (!host->mrq->sbc && (host->flags & SDHCI_AUTO_CMD12))
920                        mode |= SDHCI_TRNS_AUTO_CMD12;
921                else if (host->mrq->sbc && (host->flags & SDHCI_AUTO_CMD23)) {
922                        mode |= SDHCI_TRNS_AUTO_CMD23;
923                        sdhci_writel(host, host->mrq->sbc->arg, SDHCI_ARGUMENT2);
924                }
925        }
926
927        if (data->flags & MMC_DATA_READ)
928                mode |= SDHCI_TRNS_READ;
929        if (host->flags & SDHCI_REQ_USE_DMA)
930                mode |= SDHCI_TRNS_DMA;
931
932        sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
933}
934
935static void sdhci_finish_data(struct sdhci_host *host)
936{
937        struct mmc_data *data;
938
939        BUG_ON(!host->data);
940
941        data = host->data;
942        host->data = NULL;
943
944        if (host->flags & SDHCI_REQ_USE_DMA) {
945                if (host->flags & SDHCI_USE_ADMA)
946                        sdhci_adma_table_post(host, data);
947                else {
948                        dma_unmap_sg(mmc_dev(host->mmc), data->sg,
949                                data->sg_len, (data->flags & MMC_DATA_READ) ?
950                                        DMA_FROM_DEVICE : DMA_TO_DEVICE);
951                }
952        }
953
954        /*
955         * The specification states that the block count register must
956         * be updated, but it does not specify at what point in the
957         * data flow. That makes the register entirely useless to read
958         * back so we have to assume that nothing made it to the card
959         * in the event of an error.
960         */
961        if (data->error)
962                data->bytes_xfered = 0;
963        else
964                data->bytes_xfered = data->blksz * data->blocks;
965
966        /*
967         * Need to send CMD12 if -
968         * a) open-ended multiblock transfer (no CMD23)
969         * b) error in multiblock transfer
970         */
971        if (data->stop &&
972            (data->error ||
973             !host->mrq->sbc)) {
974
975                /*
976                 * The controller needs a reset of internal state machines
977                 * upon error conditions.
978                 */
979                if (data->error) {
980                        sdhci_do_reset(host, SDHCI_RESET_CMD);
981                        sdhci_do_reset(host, SDHCI_RESET_DATA);
982                }
983
984                sdhci_send_command(host, data->stop);
985        } else
986                tasklet_schedule(&host->finish_tasklet);
987}
988
989void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
990{
991        int flags;
992        u32 mask;
993        unsigned long timeout;
994
995        WARN_ON(host->cmd);
996
997        /* Wait max 10 ms */
998        timeout = 10;
999
1000        mask = SDHCI_CMD_INHIBIT;
1001        if ((cmd->data != NULL) || (cmd->flags & MMC_RSP_BUSY))
1002                mask |= SDHCI_DATA_INHIBIT;
1003
1004        /* We shouldn't wait for data inihibit for stop commands, even
1005           though they might use busy signaling */
1006        if (host->mrq->data && (cmd == host->mrq->data->stop))
1007                mask &= ~SDHCI_DATA_INHIBIT;
1008
1009        while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
1010                if (timeout == 0) {
1011                        pr_err("%s: Controller never released "
1012                                "inhibit bit(s).\n", mmc_hostname(host->mmc));
1013                        sdhci_dumpregs(host);
1014                        cmd->error = -EIO;
1015                        tasklet_schedule(&host->finish_tasklet);
1016                        return;
1017                }
1018                timeout--;
1019                mdelay(1);
1020        }
1021
1022        timeout = jiffies;
1023        if (!cmd->data && cmd->busy_timeout > 9000)
1024                timeout += DIV_ROUND_UP(cmd->busy_timeout, 1000) * HZ + HZ;
1025        else
1026                timeout += 10 * HZ;
1027        mod_timer(&host->timer, timeout);
1028
1029        host->cmd = cmd;
1030        host->busy_handle = 0;
1031
1032        sdhci_prepare_data(host, cmd);
1033
1034        sdhci_writel(host, cmd->arg, SDHCI_ARGUMENT);
1035
1036        sdhci_set_transfer_mode(host, cmd);
1037
1038        if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
1039                pr_err("%s: Unsupported response type!\n",
1040                        mmc_hostname(host->mmc));
1041                cmd->error = -EINVAL;
1042                tasklet_schedule(&host->finish_tasklet);
1043                return;
1044        }
1045
1046        if (!(cmd->flags & MMC_RSP_PRESENT))
1047                flags = SDHCI_CMD_RESP_NONE;
1048        else if (cmd->flags & MMC_RSP_136)
1049                flags = SDHCI_CMD_RESP_LONG;
1050        else if (cmd->flags & MMC_RSP_BUSY)
1051                flags = SDHCI_CMD_RESP_SHORT_BUSY;
1052        else
1053                flags = SDHCI_CMD_RESP_SHORT;
1054
1055        if (cmd->flags & MMC_RSP_CRC)
1056                flags |= SDHCI_CMD_CRC;
1057        if (cmd->flags & MMC_RSP_OPCODE)
1058                flags |= SDHCI_CMD_INDEX;
1059
1060        /* CMD19 is special in that the Data Present Select should be set */
1061        if (cmd->data || cmd->opcode == MMC_SEND_TUNING_BLOCK ||
1062            cmd->opcode == MMC_SEND_TUNING_BLOCK_HS200)
1063                flags |= SDHCI_CMD_DATA;
1064
1065        sdhci_writew(host, SDHCI_MAKE_CMD(cmd->opcode, flags), SDHCI_COMMAND);
1066}
1067EXPORT_SYMBOL_GPL(sdhci_send_command);
1068
1069static void sdhci_finish_command(struct sdhci_host *host)
1070{
1071        int i;
1072
1073        BUG_ON(host->cmd == NULL);
1074
1075        if (host->cmd->flags & MMC_RSP_PRESENT) {
1076                if (host->cmd->flags & MMC_RSP_136) {
1077                        /* CRC is stripped so we need to do some shifting. */
1078                        for (i = 0;i < 4;i++) {
1079                                host->cmd->resp[i] = sdhci_readl(host,
1080                                        SDHCI_RESPONSE + (3-i)*4) << 8;
1081                                if (i != 3)
1082                                        host->cmd->resp[i] |=
1083                                                sdhci_readb(host,
1084                                                SDHCI_RESPONSE + (3-i)*4-1);
1085                        }
1086                } else {
1087                        host->cmd->resp[0] = sdhci_readl(host, SDHCI_RESPONSE);
1088                }
1089        }
1090
1091        host->cmd->error = 0;
1092
1093        /* Finished CMD23, now send actual command. */
1094        if (host->cmd == host->mrq->sbc) {
1095                host->cmd = NULL;
1096                sdhci_send_command(host, host->mrq->cmd);
1097        } else {
1098
1099                /* Processed actual command. */
1100                if (host->data && host->data_early)
1101                        sdhci_finish_data(host);
1102
1103                if (!host->cmd->data)
1104                        tasklet_schedule(&host->finish_tasklet);
1105
1106                host->cmd = NULL;
1107        }
1108}
1109
1110static u16 sdhci_get_preset_value(struct sdhci_host *host)
1111{
1112        u16 preset = 0;
1113
1114        switch (host->timing) {
1115        case MMC_TIMING_UHS_SDR12:
1116                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
1117                break;
1118        case MMC_TIMING_UHS_SDR25:
1119                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR25);
1120                break;
1121        case MMC_TIMING_UHS_SDR50:
1122                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR50);
1123                break;
1124        case MMC_TIMING_UHS_SDR104:
1125        case MMC_TIMING_MMC_HS200:
1126                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR104);
1127                break;
1128        case MMC_TIMING_UHS_DDR50:
1129                preset = sdhci_readw(host, SDHCI_PRESET_FOR_DDR50);
1130                break;
1131        default:
1132                pr_warn("%s: Invalid UHS-I mode selected\n",
1133                        mmc_hostname(host->mmc));
1134                preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12);
1135                break;
1136        }
1137        return preset;
1138}
1139
1140void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
1141{
1142        int div = 0; /* Initialized for compiler warning */
1143        int real_div = div, clk_mul = 1;
1144        u16 clk = 0;
1145        unsigned long timeout;
1146
1147        host->mmc->actual_clock = 0;
1148
1149        sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
1150
1151        if (clock == 0)
1152                return;
1153
1154        if (host->version >= SDHCI_SPEC_300) {
1155                if (host->preset_enabled) {
1156                        u16 pre_val;
1157
1158                        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1159                        pre_val = sdhci_get_preset_value(host);
1160                        div = (pre_val & SDHCI_PRESET_SDCLK_FREQ_MASK)
1161                                >> SDHCI_PRESET_SDCLK_FREQ_SHIFT;
1162                        if (host->clk_mul &&
1163                                (pre_val & SDHCI_PRESET_CLKGEN_SEL_MASK)) {
1164                                clk = SDHCI_PROG_CLOCK_MODE;
1165                                real_div = div + 1;
1166                                clk_mul = host->clk_mul;
1167                        } else {
1168                                real_div = max_t(int, 1, div << 1);
1169                        }
1170                        goto clock_set;
1171                }
1172
1173                /*
1174                 * Check if the Host Controller supports Programmable Clock
1175                 * Mode.
1176                 */
1177                if (host->clk_mul) {
1178                        for (div = 1; div <= 1024; div++) {
1179                                if ((host->max_clk * host->clk_mul / div)
1180                                        <= clock)
1181                                        break;
1182                        }
1183                        /*
1184                         * Set Programmable Clock Mode in the Clock
1185                         * Control register.
1186                         */
1187                        clk = SDHCI_PROG_CLOCK_MODE;
1188                        real_div = div;
1189                        clk_mul = host->clk_mul;
1190                        div--;
1191                } else {
1192                        /* Version 3.00 divisors must be a multiple of 2. */
1193                        if (host->max_clk <= clock)
1194                                div = 1;
1195                        else {
1196                                for (div = 2; div < SDHCI_MAX_DIV_SPEC_300;
1197                                     div += 2) {
1198                                        if ((host->max_clk / div) <= clock)
1199                                                break;
1200                                }
1201                        }
1202                        real_div = div;
1203                        div >>= 1;
1204                }
1205        } else {
1206                /* Version 2.00 divisors must be a power of 2. */
1207                for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
1208                        if ((host->max_clk / div) <= clock)
1209                                break;
1210                }
1211                real_div = div;
1212                div >>= 1;
1213        }
1214
1215clock_set:
1216        if (real_div)
1217                host->mmc->actual_clock = (host->max_clk * clk_mul) / real_div;
1218        clk |= (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
1219        clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
1220                << SDHCI_DIVIDER_HI_SHIFT;
1221        clk |= SDHCI_CLOCK_INT_EN;
1222        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1223
1224        /* Wait max 20 ms */
1225        timeout = 20;
1226        while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
1227                & SDHCI_CLOCK_INT_STABLE)) {
1228                if (timeout == 0) {
1229                        pr_err("%s: Internal clock never "
1230                                "stabilised.\n", mmc_hostname(host->mmc));
1231                        sdhci_dumpregs(host);
1232                        return;
1233                }
1234                timeout--;
1235                spin_unlock_irq(&host->lock);
1236                usleep_range(900, 1100);
1237                spin_lock_irq(&host->lock);
1238        }
1239
1240        clk |= SDHCI_CLOCK_CARD_EN;
1241        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1242}
1243EXPORT_SYMBOL_GPL(sdhci_set_clock);
1244
1245static void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
1246                            unsigned short vdd)
1247{
1248        struct mmc_host *mmc = host->mmc;
1249        u8 pwr = 0;
1250
1251        if (!IS_ERR(mmc->supply.vmmc)) {
1252                spin_unlock_irq(&host->lock);
1253                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
1254                spin_lock_irq(&host->lock);
1255
1256                if (mode != MMC_POWER_OFF)
1257                        sdhci_writeb(host, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
1258                else
1259                        sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1260
1261                return;
1262        }
1263
1264        if (mode != MMC_POWER_OFF) {
1265                switch (1 << vdd) {
1266                case MMC_VDD_165_195:
1267                        pwr = SDHCI_POWER_180;
1268                        break;
1269                case MMC_VDD_29_30:
1270                case MMC_VDD_30_31:
1271                        pwr = SDHCI_POWER_300;
1272                        break;
1273                case MMC_VDD_32_33:
1274                case MMC_VDD_33_34:
1275                        pwr = SDHCI_POWER_330;
1276                        break;
1277                default:
1278                        BUG();
1279                }
1280        }
1281
1282        if (host->pwr == pwr)
1283                return;
1284
1285        host->pwr = pwr;
1286
1287        if (pwr == 0) {
1288                sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1289                if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
1290                        sdhci_runtime_pm_bus_off(host);
1291                vdd = 0;
1292        } else {
1293                /*
1294                 * Spec says that we should clear the power reg before setting
1295                 * a new value. Some controllers don't seem to like this though.
1296                 */
1297                if (!(host->quirks & SDHCI_QUIRK_SINGLE_POWER_WRITE))
1298                        sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
1299
1300                /*
1301                 * At least the Marvell CaFe chip gets confused if we set the
1302                 * voltage and set turn on power at the same time, so set the
1303                 * voltage first.
1304                 */
1305                if (host->quirks & SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER)
1306                        sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1307
1308                pwr |= SDHCI_POWER_ON;
1309
1310                sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
1311
1312                if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
1313                        sdhci_runtime_pm_bus_on(host);
1314
1315                /*
1316                 * Some controllers need an extra 10ms delay of 10ms before
1317                 * they can apply clock after applying power
1318                 */
1319                if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER)
1320                        mdelay(10);
1321        }
1322}
1323
1324/*****************************************************************************\
1325 *                                                                           *
1326 * MMC callbacks                                                             *
1327 *                                                                           *
1328\*****************************************************************************/
1329
1330static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
1331{
1332        struct sdhci_host *host;
1333        int present;
1334        unsigned long flags;
1335        u32 tuning_opcode;
1336
1337        host = mmc_priv(mmc);
1338
1339        sdhci_runtime_pm_get(host);
1340
1341        present = mmc_gpio_get_cd(host->mmc);
1342
1343        spin_lock_irqsave(&host->lock, flags);
1344
1345        WARN_ON(host->mrq != NULL);
1346
1347#ifndef SDHCI_USE_LEDS_CLASS
1348        sdhci_activate_led(host);
1349#endif
1350
1351        /*
1352         * Ensure we don't send the STOP for non-SET_BLOCK_COUNTED
1353         * requests if Auto-CMD12 is enabled.
1354         */
1355        if (!mrq->sbc && (host->flags & SDHCI_AUTO_CMD12)) {
1356                if (mrq->stop) {
1357                        mrq->data->stop = NULL;
1358                        mrq->stop = NULL;
1359                }
1360        }
1361
1362        host->mrq = mrq;
1363
1364        /*
1365         * Firstly check card presence from cd-gpio.  The return could
1366         * be one of the following possibilities:
1367         *     negative: cd-gpio is not available
1368         *     zero: cd-gpio is used, and card is removed
1369         *     one: cd-gpio is used, and card is present
1370         */
1371        if (present < 0) {
1372                /* If polling, assume that the card is always present. */
1373                if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
1374                        present = 1;
1375                else
1376                        present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
1377                                        SDHCI_CARD_PRESENT;
1378        }
1379
1380        if (!present || host->flags & SDHCI_DEVICE_DEAD) {
1381                host->mrq->cmd->error = -ENOMEDIUM;
1382                tasklet_schedule(&host->finish_tasklet);
1383        } else {
1384                u32 present_state;
1385
1386                present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
1387                /*
1388                 * Check if the re-tuning timer has already expired and there
1389                 * is no on-going data transfer and DAT0 is not busy. If so,
1390                 * we need to execute tuning procedure before sending command.
1391                 */
1392                if ((host->flags & SDHCI_NEEDS_RETUNING) &&
1393                    !(present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ)) &&
1394                    (present_state & SDHCI_DATA_0_LVL_MASK)) {
1395                        if (mmc->card) {
1396                                /* eMMC uses cmd21 but sd and sdio use cmd19 */
1397                                tuning_opcode =
1398                                        mmc->card->type == MMC_TYPE_MMC ?
1399                                        MMC_SEND_TUNING_BLOCK_HS200 :
1400                                        MMC_SEND_TUNING_BLOCK;
1401
1402                                /* Here we need to set the host->mrq to NULL,
1403                                 * in case the pending finish_tasklet
1404                                 * finishes it incorrectly.
1405                                 */
1406                                host->mrq = NULL;
1407
1408                                spin_unlock_irqrestore(&host->lock, flags);
1409                                sdhci_execute_tuning(mmc, tuning_opcode);
1410                                spin_lock_irqsave(&host->lock, flags);
1411
1412                                /* Restore original mmc_request structure */
1413                                host->mrq = mrq;
1414                        }
1415                }
1416
1417                if (mrq->sbc && !(host->flags & SDHCI_AUTO_CMD23))
1418                        sdhci_send_command(host, mrq->sbc);
1419                else
1420                        sdhci_send_command(host, mrq->cmd);
1421        }
1422
1423        mmiowb();
1424        spin_unlock_irqrestore(&host->lock, flags);
1425}
1426
1427void sdhci_set_bus_width(struct sdhci_host *host, int width)
1428{
1429        u8 ctrl;
1430
1431        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1432        if (width == MMC_BUS_WIDTH_8) {
1433                ctrl &= ~SDHCI_CTRL_4BITBUS;
1434                if (host->version >= SDHCI_SPEC_300)
1435                        ctrl |= SDHCI_CTRL_8BITBUS;
1436        } else {
1437                if (host->version >= SDHCI_SPEC_300)
1438                        ctrl &= ~SDHCI_CTRL_8BITBUS;
1439                if (width == MMC_BUS_WIDTH_4)
1440                        ctrl |= SDHCI_CTRL_4BITBUS;
1441                else
1442                        ctrl &= ~SDHCI_CTRL_4BITBUS;
1443        }
1444        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1445}
1446EXPORT_SYMBOL_GPL(sdhci_set_bus_width);
1447
1448void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing)
1449{
1450        u16 ctrl_2;
1451
1452        ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1453        /* Select Bus Speed Mode for host */
1454        ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
1455        if ((timing == MMC_TIMING_MMC_HS200) ||
1456            (timing == MMC_TIMING_UHS_SDR104))
1457                ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
1458        else if (timing == MMC_TIMING_UHS_SDR12)
1459                ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
1460        else if (timing == MMC_TIMING_UHS_SDR25)
1461                ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
1462        else if (timing == MMC_TIMING_UHS_SDR50)
1463                ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
1464        else if ((timing == MMC_TIMING_UHS_DDR50) ||
1465                 (timing == MMC_TIMING_MMC_DDR52))
1466                ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
1467        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
1468}
1469EXPORT_SYMBOL_GPL(sdhci_set_uhs_signaling);
1470
1471static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
1472{
1473        unsigned long flags;
1474        u8 ctrl;
1475        struct mmc_host *mmc = host->mmc;
1476
1477        spin_lock_irqsave(&host->lock, flags);
1478
1479        if (host->flags & SDHCI_DEVICE_DEAD) {
1480                spin_unlock_irqrestore(&host->lock, flags);
1481                if (!IS_ERR(mmc->supply.vmmc) &&
1482                    ios->power_mode == MMC_POWER_OFF)
1483                        mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, 0);
1484                return;
1485        }
1486
1487        /*
1488         * Reset the chip on each power off.
1489         * Should clear out any weird states.
1490         */
1491        if (ios->power_mode == MMC_POWER_OFF) {
1492                sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
1493                sdhci_reinit(host);
1494        }
1495
1496        if (host->version >= SDHCI_SPEC_300 &&
1497                (ios->power_mode == MMC_POWER_UP) &&
1498                !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN))
1499                sdhci_enable_preset_value(host, false);
1500
1501        if (!ios->clock || ios->clock != host->clock) {
1502                host->ops->set_clock(host, ios->clock);
1503                host->clock = ios->clock;
1504
1505                if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK &&
1506                    host->clock) {
1507                        host->timeout_clk = host->mmc->actual_clock ?
1508                                                host->mmc->actual_clock / 1000 :
1509                                                host->clock / 1000;
1510                        host->mmc->max_busy_timeout =
1511                                host->ops->get_max_timeout_count ?
1512                                host->ops->get_max_timeout_count(host) :
1513                                1 << 27;
1514                        host->mmc->max_busy_timeout /= host->timeout_clk;
1515                }
1516        }
1517
1518        sdhci_set_power(host, ios->power_mode, ios->vdd);
1519
1520        if (host->ops->platform_send_init_74_clocks)
1521                host->ops->platform_send_init_74_clocks(host, ios->power_mode);
1522
1523        host->ops->set_bus_width(host, ios->bus_width);
1524
1525        ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
1526
1527#ifdef CONFIG_ARCH_CNS3XXX
1528        if (ios->bus_width == MMC_BUS_WIDTH_8) //jacky for eMMC
1529                ctrl |= (0x1 << 5);//CNS34xxx proprietary
1530        else
1531                ctrl &= ~(0x1 << 5);
1532#endif
1533
1534        if ((ios->timing == MMC_TIMING_SD_HS ||
1535             ios->timing == MMC_TIMING_MMC_HS)
1536            && !(host->quirks & SDHCI_QUIRK_NO_HISPD_BIT))
1537                ctrl |= SDHCI_CTRL_HISPD;
1538        else
1539                ctrl &= ~SDHCI_CTRL_HISPD;
1540
1541        if (ios->timing == MMC_TIMING_MMC_HS)//for eMMC
1542                ctrl |= SDHCI_CTRL_HISPD;       else
1543                ctrl &= ~SDHCI_CTRL_HISPD;
1544
1545        if (ios->timing == MMC_TIMING_MMC_HS)
1546        {               
1547                sdhci_writeb(host, 0x3, 0x2d);
1548        }       
1549
1550        if (host->version >= SDHCI_SPEC_300) {
1551                u16 clk, ctrl_2;
1552
1553                /* In case of UHS-I modes, set High Speed Enable */
1554                if ((ios->timing == MMC_TIMING_MMC_HS200) ||
1555                    (ios->timing == MMC_TIMING_MMC_DDR52) ||
1556                    (ios->timing == MMC_TIMING_UHS_SDR50) ||
1557                    (ios->timing == MMC_TIMING_UHS_SDR104) ||
1558                    (ios->timing == MMC_TIMING_UHS_DDR50) ||
1559                    (ios->timing == MMC_TIMING_UHS_SDR25))
1560                        ctrl |= SDHCI_CTRL_HISPD;
1561
1562                if (!host->preset_enabled) {
1563                        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1564                        /*
1565                         * We only need to set Driver Strength if the
1566                         * preset value enable is not set.
1567                         */
1568                        ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1569                        ctrl_2 &= ~SDHCI_CTRL_DRV_TYPE_MASK;
1570                        if (ios->drv_type == MMC_SET_DRIVER_TYPE_A)
1571                                ctrl_2 |= SDHCI_CTRL_DRV_TYPE_A;
1572                        else if (ios->drv_type == MMC_SET_DRIVER_TYPE_C)
1573                                ctrl_2 |= SDHCI_CTRL_DRV_TYPE_C;
1574
1575                        sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
1576                } else {
1577                        /*
1578                         * According to SDHC Spec v3.00, if the Preset Value
1579                         * Enable in the Host Control 2 register is set, we
1580                         * need to reset SD Clock Enable before changing High
1581                         * Speed Enable to avoid generating clock gliches.
1582                         */
1583
1584                        /* Reset SD Clock Enable */
1585                        clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1586                        clk &= ~SDHCI_CLOCK_CARD_EN;
1587                        sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1588
1589                        sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1590
1591                        /* Re-enable SD Clock */
1592                        host->ops->set_clock(host, host->clock);
1593                }
1594
1595                /* Reset SD Clock Enable */
1596                clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
1597                clk &= ~SDHCI_CLOCK_CARD_EN;
1598                sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
1599
1600                host->ops->set_uhs_signaling(host, ios->timing);
1601                host->timing = ios->timing;
1602
1603                if (!(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN) &&
1604                                ((ios->timing == MMC_TIMING_UHS_SDR12) ||
1605                                 (ios->timing == MMC_TIMING_UHS_SDR25) ||
1606                                 (ios->timing == MMC_TIMING_UHS_SDR50) ||
1607                                 (ios->timing == MMC_TIMING_UHS_SDR104) ||
1608                                 (ios->timing == MMC_TIMING_UHS_DDR50))) {
1609                        u16 preset;
1610
1611                        sdhci_enable_preset_value(host, true);
1612                        preset = sdhci_get_preset_value(host);
1613                        ios->drv_type = (preset & SDHCI_PRESET_DRV_MASK)
1614                                >> SDHCI_PRESET_DRV_SHIFT;
1615                }
1616
1617                /* Re-enable SD Clock */
1618                host->ops->set_clock(host, host->clock);
1619        } else
1620                sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
1621
1622        /*
1623         * Some (ENE) controllers go apeshit on some ios operation,
1624         * signalling timeout and CRC errors even on CMD0. Resetting
1625         * it on each ios seems to solve the problem.
1626         */
1627        if(host->quirks & SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS)
1628                sdhci_do_reset(host, SDHCI_RESET_CMD | SDHCI_RESET_DATA);
1629
1630        mmiowb();
1631        spin_unlock_irqrestore(&host->lock, flags);
1632}
1633
1634static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
1635{
1636        struct sdhci_host *host = mmc_priv(mmc);
1637
1638        sdhci_runtime_pm_get(host);
1639        sdhci_do_set_ios(host, ios);
1640        sdhci_runtime_pm_put(host);
1641}
1642
1643static int sdhci_do_get_cd(struct sdhci_host *host)
1644{
1645        int gpio_cd = mmc_gpio_get_cd(host->mmc);
1646
1647        if (host->flags & SDHCI_DEVICE_DEAD)
1648                return 0;
1649
1650        /* If polling/nonremovable, assume that the card is always present. */
1651        if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) ||
1652            (host->mmc->caps & MMC_CAP_NONREMOVABLE))
1653                return 1;
1654
1655        /* Try slot gpio detect */
1656        if (!IS_ERR_VALUE(gpio_cd))
1657                return !!gpio_cd;
1658
1659        /* Host native card detect */
1660        return !!(sdhci_readl(host, SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT);
1661}
1662
1663static int sdhci_get_cd(struct mmc_host *mmc)
1664{
1665        struct sdhci_host *host = mmc_priv(mmc);
1666        int ret;
1667
1668        sdhci_runtime_pm_get(host);
1669        ret = sdhci_do_get_cd(host);
1670        sdhci_runtime_pm_put(host);
1671        return ret;
1672}
1673
1674static int sdhci_check_ro(struct sdhci_host *host)
1675{
1676        unsigned long flags;
1677        int is_readonly;
1678
1679        spin_lock_irqsave(&host->lock, flags);
1680
1681        if (host->flags & SDHCI_DEVICE_DEAD)
1682                is_readonly = 0;
1683        else if (host->ops->get_ro)
1684                is_readonly = host->ops->get_ro(host);
1685        else
1686                is_readonly = !(sdhci_readl(host, SDHCI_PRESENT_STATE)
1687                                & SDHCI_WRITE_PROTECT);
1688
1689        spin_unlock_irqrestore(&host->lock, flags);
1690
1691        /* This quirk needs to be replaced by a callback-function later */
1692        return host->quirks & SDHCI_QUIRK_INVERTED_WRITE_PROTECT ?
1693                !is_readonly : is_readonly;
1694}
1695
1696#define SAMPLE_COUNT    5
1697
1698static int sdhci_do_get_ro(struct sdhci_host *host)
1699{
1700        int i, ro_count;
1701
1702        if (!(host->quirks & SDHCI_QUIRK_UNSTABLE_RO_DETECT))
1703                return sdhci_check_ro(host);
1704
1705        ro_count = 0;
1706        for (i = 0; i < SAMPLE_COUNT; i++) {
1707                if (sdhci_check_ro(host)) {
1708                        if (++ro_count > SAMPLE_COUNT / 2)
1709                                return 1;
1710                }
1711                msleep(30);
1712        }
1713        return 0;
1714}
1715
1716static void sdhci_hw_reset(struct mmc_host *mmc)
1717{
1718        struct sdhci_host *host = mmc_priv(mmc);
1719
1720        if (host->ops && host->ops->hw_reset)
1721                host->ops->hw_reset(host);
1722}
1723
1724static int sdhci_get_ro(struct mmc_host *mmc)
1725{
1726        struct sdhci_host *host = mmc_priv(mmc);
1727        int ret;
1728
1729        sdhci_runtime_pm_get(host);
1730        ret = sdhci_do_get_ro(host);
1731        sdhci_runtime_pm_put(host);
1732        return ret;
1733}
1734
1735static void sdhci_enable_sdio_irq_nolock(struct sdhci_host *host, int enable)
1736{
1737        if (!(host->flags & SDHCI_DEVICE_DEAD)) {
1738                if (enable)
1739                        host->ier |= SDHCI_INT_CARD_INT;
1740                else
1741                        host->ier &= ~SDHCI_INT_CARD_INT;
1742
1743                sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
1744                sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
1745                mmiowb();
1746        }
1747}
1748
1749static void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable)
1750{
1751        struct sdhci_host *host = mmc_priv(mmc);
1752        unsigned long flags;
1753
1754        sdhci_runtime_pm_get(host);
1755
1756        spin_lock_irqsave(&host->lock, flags);
1757        if (enable)
1758                host->flags |= SDHCI_SDIO_IRQ_ENABLED;
1759        else
1760                host->flags &= ~SDHCI_SDIO_IRQ_ENABLED;
1761
1762        sdhci_enable_sdio_irq_nolock(host, enable);
1763        spin_unlock_irqrestore(&host->lock, flags);
1764
1765        sdhci_runtime_pm_put(host);
1766}
1767
1768static int sdhci_do_start_signal_voltage_switch(struct sdhci_host *host,
1769                                                struct mmc_ios *ios)
1770{
1771        struct mmc_host *mmc = host->mmc;
1772        u16 ctrl;
1773        int ret;
1774
1775        /*
1776         * Signal Voltage Switching is only applicable for Host Controllers
1777         * v3.00 and above.
1778         */
1779        if (host->version < SDHCI_SPEC_300)
1780                return 0;
1781
1782        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1783
1784        switch (ios->signal_voltage) {
1785        case MMC_SIGNAL_VOLTAGE_330:
1786                /* Set 1.8V Signal Enable in the Host Control2 register to 0 */
1787                ctrl &= ~SDHCI_CTRL_VDD_180;
1788                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1789
1790                if (!IS_ERR(mmc->supply.vqmmc)) {
1791                        ret = regulator_set_voltage(mmc->supply.vqmmc, 2700000,
1792                                                    3600000);
1793                        if (ret) {
1794                                pr_warn("%s: Switching to 3.3V signalling voltage failed\n",
1795                                        mmc_hostname(mmc));
1796                                return -EIO;
1797                        }
1798                }
1799                /* Wait for 5ms */
1800                usleep_range(5000, 5500);
1801
1802                /* 3.3V regulator output should be stable within 5 ms */
1803                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1804                if (!(ctrl & SDHCI_CTRL_VDD_180))
1805                        return 0;
1806
1807                pr_warn("%s: 3.3V regulator output did not became stable\n",
1808                        mmc_hostname(mmc));
1809
1810                return -EAGAIN;
1811        case MMC_SIGNAL_VOLTAGE_180:
1812                if (!IS_ERR(mmc->supply.vqmmc)) {
1813                        ret = regulator_set_voltage(mmc->supply.vqmmc,
1814                                        1700000, 1950000);
1815                        if (ret) {
1816                                pr_warn("%s: Switching to 1.8V signalling voltage failed\n",
1817                                        mmc_hostname(mmc));
1818                                return -EIO;
1819                        }
1820                }
1821
1822                /*
1823                 * Enable 1.8V Signal Enable in the Host Control2
1824                 * register
1825                 */
1826                ctrl |= SDHCI_CTRL_VDD_180;
1827                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1828
1829                /* 1.8V regulator output should be stable within 5 ms */
1830                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1831                if (ctrl & SDHCI_CTRL_VDD_180)
1832                        return 0;
1833
1834                pr_warn("%s: 1.8V regulator output did not became stable\n",
1835                        mmc_hostname(mmc));
1836
1837                return -EAGAIN;
1838        case MMC_SIGNAL_VOLTAGE_120:
1839                if (!IS_ERR(mmc->supply.vqmmc)) {
1840                        ret = regulator_set_voltage(mmc->supply.vqmmc, 1100000,
1841                                                    1300000);
1842                        if (ret) {
1843                                pr_warn("%s: Switching to 1.2V signalling voltage failed\n",
1844                                        mmc_hostname(mmc));
1845                                return -EIO;
1846                        }
1847                }
1848                return 0;
1849        default:
1850                /* No signal voltage switch required */
1851                return 0;
1852        }
1853}
1854
1855static int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
1856        struct mmc_ios *ios)
1857{
1858        struct sdhci_host *host = mmc_priv(mmc);
1859        int err;
1860
1861        if (host->version < SDHCI_SPEC_300)
1862                return 0;
1863        sdhci_runtime_pm_get(host);
1864        err = sdhci_do_start_signal_voltage_switch(host, ios);
1865        sdhci_runtime_pm_put(host);
1866        return err;
1867}
1868
1869static int sdhci_card_busy(struct mmc_host *mmc)
1870{
1871        struct sdhci_host *host = mmc_priv(mmc);
1872        u32 present_state;
1873
1874        sdhci_runtime_pm_get(host);
1875        /* Check whether DAT[3:0] is 0000 */
1876        present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
1877        sdhci_runtime_pm_put(host);
1878
1879        return !(present_state & SDHCI_DATA_LVL_MASK);
1880}
1881
1882static int sdhci_execute_tuning(struct mmc_host *mmc, u32 opcode)
1883{
1884        struct sdhci_host *host = mmc_priv(mmc);
1885        u16 ctrl;
1886        int tuning_loop_counter = MAX_TUNING_LOOP;
1887        int err = 0;
1888        unsigned long flags;
1889
1890        sdhci_runtime_pm_get(host);
1891        spin_lock_irqsave(&host->lock, flags);
1892
1893        /*
1894         * The Host Controller needs tuning only in case of SDR104 mode
1895         * and for SDR50 mode when Use Tuning for SDR50 is set in the
1896         * Capabilities register.
1897         * If the Host Controller supports the HS200 mode then the
1898         * tuning function has to be executed.
1899         */
1900        switch (host->timing) {
1901        case MMC_TIMING_MMC_HS200:
1902        case MMC_TIMING_UHS_SDR104:
1903                break;
1904
1905        case MMC_TIMING_UHS_SDR50:
1906                if (host->flags & SDHCI_SDR50_NEEDS_TUNING ||
1907                    host->flags & SDHCI_SDR104_NEEDS_TUNING)
1908                        break;
1909                /* FALLTHROUGH */
1910
1911        default:
1912                spin_unlock_irqrestore(&host->lock, flags);
1913                sdhci_runtime_pm_put(host);
1914                return 0;
1915        }
1916
1917        if (host->ops->platform_execute_tuning) {
1918                spin_unlock_irqrestore(&host->lock, flags);
1919                err = host->ops->platform_execute_tuning(host, opcode);
1920                sdhci_runtime_pm_put(host);
1921                return err;
1922        }
1923
1924        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
1925        ctrl |= SDHCI_CTRL_EXEC_TUNING;
1926        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
1927
1928        /*
1929         * As per the Host Controller spec v3.00, tuning command
1930         * generates Buffer Read Ready interrupt, so enable that.
1931         *
1932         * Note: The spec clearly says that when tuning sequence
1933         * is being performed, the controller does not generate
1934         * interrupts other than Buffer Read Ready interrupt. But
1935         * to make sure we don't hit a controller bug, we _only_
1936         * enable Buffer Read Ready interrupt here.
1937         */
1938        sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_INT_ENABLE);
1939        sdhci_writel(host, SDHCI_INT_DATA_AVAIL, SDHCI_SIGNAL_ENABLE);
1940
1941        /*
1942         * Issue CMD19 repeatedly till Execute Tuning is set to 0 or the number
1943         * of loops reaches 40 times or a timeout of 150ms occurs.
1944         */
1945        do {
1946                struct mmc_command cmd = {0};
1947                struct mmc_request mrq = {NULL};
1948
1949                cmd.opcode = opcode;
1950                cmd.arg = 0;
1951                cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
1952                cmd.retries = 0;
1953                cmd.data = NULL;
1954                cmd.error = 0;
1955
1956                if (tuning_loop_counter-- == 0)
1957                        break;
1958
1959                mrq.cmd = &cmd;
1960                host->mrq = &mrq;
1961
1962                /*
1963                 * In response to CMD19, the card sends 64 bytes of tuning
1964                 * block to the Host Controller. So we set the block size
1965                 * to 64 here.
1966                 */
1967                if (cmd.opcode == MMC_SEND_TUNING_BLOCK_HS200) {
1968                        if (mmc->ios.bus_width == MMC_BUS_WIDTH_8)
1969                                sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 128),
1970                                             SDHCI_BLOCK_SIZE);
1971                        else if (mmc->ios.bus_width == MMC_BUS_WIDTH_4)
1972                                sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
1973                                             SDHCI_BLOCK_SIZE);
1974                } else {
1975                        sdhci_writew(host, SDHCI_MAKE_BLKSZ(7, 64),
1976                                     SDHCI_BLOCK_SIZE);
1977                }
1978
1979                /*
1980                 * The tuning block is sent by the card to the host controller.
1981                 * So we set the TRNS_READ bit in the Transfer Mode register.
1982                 * This also takes care of setting DMA Enable and Multi Block
1983                 * Select in the same register to 0.
1984                 */
1985                sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
1986
1987                sdhci_send_command(host, &cmd);
1988
1989                host->cmd = NULL;
1990                host->mrq = NULL;
1991
1992                spin_unlock_irqrestore(&host->lock, flags);
1993                /* Wait for Buffer Read Ready interrupt */
1994                wait_event_interruptible_timeout(host->buf_ready_int,
1995                                        (host->tuning_done == 1),
1996                                        msecs_to_jiffies(50));
1997                spin_lock_irqsave(&host->lock, flags);
1998
1999                if (!host->tuning_done) {
2000                        pr_info(DRIVER_NAME ": Timeout waiting for "
2001                                "Buffer Read Ready interrupt during tuning "
2002                                "procedure, falling back to fixed sampling "
2003                                "clock\n");
2004                        ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2005                        ctrl &= ~SDHCI_CTRL_TUNED_CLK;
2006                        ctrl &= ~SDHCI_CTRL_EXEC_TUNING;
2007                        sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2008
2009                        sdhci_do_reset(host, SDHCI_RESET_CMD);
2010                        sdhci_do_reset(host, SDHCI_RESET_DATA);
2011
2012                        err = -EIO;
2013
2014                        if (cmd.opcode != MMC_SEND_TUNING_BLOCK_HS200)
2015                                goto out;
2016
2017                        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2018                        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2019
2020                        spin_unlock_irqrestore(&host->lock, flags);
2021
2022                        memset(&cmd, 0, sizeof(cmd));
2023                        cmd.opcode = MMC_STOP_TRANSMISSION;
2024                        cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
2025                        cmd.busy_timeout = 50;
2026                        mmc_wait_for_cmd(mmc, &cmd, 0);
2027
2028                        spin_lock_irqsave(&host->lock, flags);
2029
2030                        goto out;
2031                }
2032
2033                host->tuning_done = 0;
2034
2035                ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2036
2037                /* eMMC spec does not require a delay between tuning cycles */
2038                if (opcode == MMC_SEND_TUNING_BLOCK)
2039                        mdelay(1);
2040        } while (ctrl & SDHCI_CTRL_EXEC_TUNING);
2041
2042        /*
2043         * The Host Driver has exhausted the maximum number of loops allowed,
2044         * so use fixed sampling frequency.
2045         */
2046        if (tuning_loop_counter < 0) {
2047                ctrl &= ~SDHCI_CTRL_TUNED_CLK;
2048                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2049        }
2050        if (!(ctrl & SDHCI_CTRL_TUNED_CLK)) {
2051                pr_info(DRIVER_NAME ": Tuning procedure"
2052                        " failed, falling back to fixed sampling"
2053                        " clock\n");
2054                err = -EIO;
2055        }
2056
2057out:
2058        /*
2059         * If this is the very first time we are here, we start the retuning
2060         * timer. Since only during the first time, SDHCI_NEEDS_RETUNING
2061         * flag won't be set, we check this condition before actually starting
2062         * the timer.
2063         */
2064        if (!(host->flags & SDHCI_NEEDS_RETUNING) && host->tuning_count &&
2065            (host->tuning_mode == SDHCI_TUNING_MODE_1)) {
2066                host->flags |= SDHCI_USING_RETUNING_TIMER;
2067                mod_timer(&host->tuning_timer, jiffies +
2068                        host->tuning_count * HZ);
2069                /* Tuning mode 1 limits the maximum data length to 4MB */
2070                mmc->max_blk_count = (4 * 1024 * 1024) / mmc->max_blk_size;
2071        } else if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2072                host->flags &= ~SDHCI_NEEDS_RETUNING;
2073                /* Reload the new initial value for timer */
2074                mod_timer(&host->tuning_timer, jiffies +
2075                          host->tuning_count * HZ);
2076        }
2077
2078        /*
2079         * In case tuning fails, host controllers which support re-tuning can
2080         * try tuning again at a later time, when the re-tuning timer expires.
2081         * So for these controllers, we return 0. Since there might be other
2082         * controllers who do not have this capability, we return error for
2083         * them. SDHCI_USING_RETUNING_TIMER means the host is currently using
2084         * a retuning timer to do the retuning for the card.
2085         */
2086        if (err && (host->flags & SDHCI_USING_RETUNING_TIMER))
2087                err = 0;
2088
2089        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2090        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2091        spin_unlock_irqrestore(&host->lock, flags);
2092        sdhci_runtime_pm_put(host);
2093
2094        return err;
2095}
2096
2097
2098static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable)
2099{
2100        /* Host Controller v3.00 defines preset value registers */
2101        if (host->version < SDHCI_SPEC_300)
2102                return;
2103
2104        /*
2105         * We only enable or disable Preset Value if they are not already
2106         * enabled or disabled respectively. Otherwise, we bail out.
2107         */
2108        if (host->preset_enabled != enable) {
2109                u16 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2);
2110
2111                if (enable)
2112                        ctrl |= SDHCI_CTRL_PRESET_VAL_ENABLE;
2113                else
2114                        ctrl &= ~SDHCI_CTRL_PRESET_VAL_ENABLE;
2115
2116                sdhci_writew(host, ctrl, SDHCI_HOST_CONTROL2);
2117
2118                if (enable)
2119                        host->flags |= SDHCI_PV_ENABLED;
2120                else
2121                        host->flags &= ~SDHCI_PV_ENABLED;
2122
2123                host->preset_enabled = enable;
2124        }
2125}
2126
2127static void sdhci_card_event(struct mmc_host *mmc)
2128{
2129        struct sdhci_host *host = mmc_priv(mmc);
2130        unsigned long flags;
2131        int present;
2132
2133        /* First check if client has provided their own card event */
2134        if (host->ops->card_event)
2135                host->ops->card_event(host);
2136
2137        present = sdhci_do_get_cd(host);
2138
2139        spin_lock_irqsave(&host->lock, flags);
2140
2141        /* Check host->mrq first in case we are runtime suspended */
2142        if (host->mrq && !present) {
2143                pr_err("%s: Card removed during transfer!\n",
2144                        mmc_hostname(host->mmc));
2145                pr_err("%s: Resetting controller.\n",
2146                        mmc_hostname(host->mmc));
2147
2148                sdhci_do_reset(host, SDHCI_RESET_CMD);
2149                sdhci_do_reset(host, SDHCI_RESET_DATA);
2150
2151                host->mrq->cmd->error = -ENOMEDIUM;
2152                tasklet_schedule(&host->finish_tasklet);
2153        }
2154
2155        spin_unlock_irqrestore(&host->lock, flags);
2156}
2157
2158static const struct mmc_host_ops sdhci_ops = {
2159        .request        = sdhci_request,
2160        .set_ios        = sdhci_set_ios,
2161        .get_cd         = sdhci_get_cd,
2162        .get_ro         = sdhci_get_ro,
2163        .hw_reset       = sdhci_hw_reset,
2164        .enable_sdio_irq = sdhci_enable_sdio_irq,
2165        .start_signal_voltage_switch    = sdhci_start_signal_voltage_switch,
2166        .execute_tuning                 = sdhci_execute_tuning,
2167        .card_event                     = sdhci_card_event,
2168        .card_busy      = sdhci_card_busy,
2169};
2170
2171/*****************************************************************************\
2172 *                                                                           *
2173 * Tasklets                                                                  *
2174 *                                                                           *
2175\*****************************************************************************/
2176
2177static void sdhci_tasklet_finish(unsigned long param)
2178{
2179        struct sdhci_host *host;
2180        unsigned long flags;
2181        struct mmc_request *mrq;
2182
2183        host = (struct sdhci_host*)param;
2184
2185        spin_lock_irqsave(&host->lock, flags);
2186
2187        /*
2188         * If this tasklet gets rescheduled while running, it will
2189         * be run again afterwards but without any active request.
2190         */
2191        if (!host->mrq) {
2192                spin_unlock_irqrestore(&host->lock, flags);
2193                return;
2194        }
2195
2196        del_timer(&host->timer);
2197
2198        mrq = host->mrq;
2199
2200        /*
2201         * The controller needs a reset of internal state machines
2202         * upon error conditions.
2203         */
2204        if (!(host->flags & SDHCI_DEVICE_DEAD) &&
2205            ((mrq->cmd && mrq->cmd->error) ||
2206                 (mrq->data && (mrq->data->error ||
2207                  (mrq->data->stop && mrq->data->stop->error))) ||
2208                   (host->quirks & SDHCI_QUIRK_RESET_AFTER_REQUEST))) {
2209
2210                /* Some controllers need this kick or reset won't work here */
2211                if (host->quirks & SDHCI_QUIRK_CLOCK_BEFORE_RESET)
2212                        /* This is to force an update */
2213                        host->ops->set_clock(host, host->clock);
2214
2215                /* Spec says we should do both at the same time, but Ricoh
2216                   controllers do not like that. */
2217                sdhci_do_reset(host, SDHCI_RESET_CMD);
2218                sdhci_do_reset(host, SDHCI_RESET_DATA);
2219        }
2220
2221        host->mrq = NULL;
2222        host->cmd = NULL;
2223        host->data = NULL;
2224
2225#ifndef SDHCI_USE_LEDS_CLASS
2226        sdhci_deactivate_led(host);
2227#endif
2228
2229        mmiowb();
2230        spin_unlock_irqrestore(&host->lock, flags);
2231
2232        mmc_request_done(host->mmc, mrq);
2233        sdhci_runtime_pm_put(host);
2234}
2235
2236static void sdhci_timeout_timer(unsigned long data)
2237{
2238        struct sdhci_host *host;
2239        unsigned long flags;
2240
2241        host = (struct sdhci_host*)data;
2242
2243        spin_lock_irqsave(&host->lock, flags);
2244
2245        if (host->mrq) {
2246                pr_err("%s: Timeout waiting for hardware "
2247                        "interrupt.\n", mmc_hostname(host->mmc));
2248                sdhci_dumpregs(host);
2249
2250                if (host->data) {
2251                        host->data->error = -ETIMEDOUT;
2252                        sdhci_finish_data(host);
2253                } else {
2254                        if (host->cmd)
2255                                host->cmd->error = -ETIMEDOUT;
2256                        else
2257                                host->mrq->cmd->error = -ETIMEDOUT;
2258
2259                        tasklet_schedule(&host->finish_tasklet);
2260                }
2261        }
2262
2263        mmiowb();
2264        spin_unlock_irqrestore(&host->lock, flags);
2265}
2266
2267static void sdhci_tuning_timer(unsigned long data)
2268{
2269        struct sdhci_host *host;
2270        unsigned long flags;
2271
2272        host = (struct sdhci_host *)data;
2273
2274        spin_lock_irqsave(&host->lock, flags);
2275
2276        host->flags |= SDHCI_NEEDS_RETUNING;
2277
2278        spin_unlock_irqrestore(&host->lock, flags);
2279}
2280
2281/*****************************************************************************\
2282 *                                                                           *
2283 * Interrupt handling                                                        *
2284 *                                                                           *
2285\*****************************************************************************/
2286
2287static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask, u32 *mask)
2288{
2289        BUG_ON(intmask == 0);
2290
2291        if (!host->cmd) {
2292                pr_err("%s: Got command interrupt 0x%08x even "
2293                        "though no command operation was in progress.\n",
2294                        mmc_hostname(host->mmc), (unsigned)intmask);
2295                sdhci_dumpregs(host);
2296                return;
2297        }
2298
2299        if (intmask & SDHCI_INT_TIMEOUT)
2300                host->cmd->error = -ETIMEDOUT;
2301        else if (intmask & (SDHCI_INT_CRC | SDHCI_INT_END_BIT |
2302                        SDHCI_INT_INDEX))
2303                host->cmd->error = -EILSEQ;
2304
2305        if (host->cmd->error) {
2306                tasklet_schedule(&host->finish_tasklet);
2307                return;
2308        }
2309
2310        /*
2311         * The host can send and interrupt when the busy state has
2312         * ended, allowing us to wait without wasting CPU cycles.
2313         * Unfortunately this is overloaded on the "data complete"
2314         * interrupt, so we need to take some care when handling
2315         * it.
2316         *
2317         * Note: The 1.0 specification is a bit ambiguous about this
2318         *       feature so there might be some problems with older
2319         *       controllers.
2320         */
2321        if (host->cmd->flags & MMC_RSP_BUSY) {
2322                if (host->cmd->data)
2323                        DBG("Cannot wait for busy signal when also "
2324                                "doing a data transfer");
2325                else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ)
2326                                && !host->busy_handle) {
2327                        /* Mark that command complete before busy is ended */
2328                        host->busy_handle = 1;
2329                        return;
2330                }
2331
2332                /* The controller does not support the end-of-busy IRQ,
2333                 * fall through and take the SDHCI_INT_RESPONSE */
2334        } else if ((host->quirks2 & SDHCI_QUIRK2_STOP_WITH_TC) &&
2335                   host->cmd->opcode == MMC_STOP_TRANSMISSION && !host->data) {
2336                *mask &= ~SDHCI_INT_DATA_END;
2337        }
2338
2339        if (intmask & SDHCI_INT_RESPONSE)
2340                sdhci_finish_command(host);
2341}
2342
2343#ifdef CONFIG_MMC_DEBUG
2344static void sdhci_show_adma_error(struct sdhci_host *host)
2345{
2346        const char *name = mmc_hostname(host->mmc);
2347        u8 *desc = host->adma_desc;
2348        __le32 *dma;
2349        __le16 *len;
2350        u8 attr;
2351
2352        sdhci_dumpregs(host);
2353
2354        while (true) {
2355                dma = (__le32 *)(desc + 4);
2356                len = (__le16 *)(desc + 2);
2357                attr = *desc;
2358
2359                DBG("%s: %p: DMA 0x%08x, LEN 0x%04x, Attr=0x%02x\n",
2360                    name, desc, le32_to_cpu(*dma), le16_to_cpu(*len), attr);
2361
2362                desc += 8;
2363
2364                if (attr & 2)
2365                        break;
2366        }
2367}
2368#else
2369static void sdhci_show_adma_error(struct sdhci_host *host) { }
2370#endif
2371
2372static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
2373{
2374        u32 command;
2375        BUG_ON(intmask == 0);
2376
2377        /* CMD19 generates _only_ Buffer Read Ready interrupt */
2378        if (intmask & SDHCI_INT_DATA_AVAIL) {
2379                command = SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND));
2380                if (command == MMC_SEND_TUNING_BLOCK ||
2381                    command == MMC_SEND_TUNING_BLOCK_HS200) {
2382                        host->tuning_done = 1;
2383                        wake_up(&host->buf_ready_int);
2384                        return;
2385                }
2386        }
2387
2388        if (!host->data) {
2389                /*
2390                 * The "data complete" interrupt is also used to
2391                 * indicate that a busy state has ended. See comment
2392                 * above in sdhci_cmd_irq().
2393                 */
2394                if (host->cmd && (host->cmd->flags & MMC_RSP_BUSY)) {
2395                        if (intmask & SDHCI_INT_DATA_TIMEOUT) {
2396                                host->cmd->error = -ETIMEDOUT;
2397                                tasklet_schedule(&host->finish_tasklet);
2398                                return;
2399                        }
2400                        if (intmask & SDHCI_INT_DATA_END) {
2401                                /*
2402                                 * Some cards handle busy-end interrupt
2403                                 * before the command completed, so make
2404                                 * sure we do things in the proper order.
2405                                 */
2406                                if (host->busy_handle)
2407                                        sdhci_finish_command(host);
2408                                else
2409                                        host->busy_handle = 1;
2410                                return;
2411                        }
2412                }
2413
2414                pr_err("%s: Got data interrupt 0x%08x even "
2415                        "though no data operation was in progress.\n",
2416                        mmc_hostname(host->mmc), (unsigned)intmask);
2417                sdhci_dumpregs(host);
2418
2419                return;
2420        }
2421
2422        if (intmask & SDHCI_INT_DATA_TIMEOUT)
2423                host->data->error = -ETIMEDOUT;
2424        else if (intmask & SDHCI_INT_DATA_END_BIT)
2425                host->data->error = -EILSEQ;
2426        else if ((intmask & SDHCI_INT_DATA_CRC) &&
2427                SDHCI_GET_CMD(sdhci_readw(host, SDHCI_COMMAND))
2428                        != MMC_BUS_TEST_R)
2429                host->data->error = -EILSEQ;
2430        else if (intmask & SDHCI_INT_ADMA_ERROR) {
2431                pr_err("%s: ADMA error\n", mmc_hostname(host->mmc));
2432                sdhci_show_adma_error(host);
2433                host->data->error = -EIO;
2434                if (host->ops->adma_workaround)
2435                        host->ops->adma_workaround(host, intmask);
2436        }
2437
2438        if (host->data->error)
2439                sdhci_finish_data(host);
2440        else {
2441                if (intmask & (SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL))
2442                        sdhci_transfer_pio(host);
2443
2444                /*
2445                 * We currently don't do anything fancy with DMA
2446                 * boundaries, but as we can't disable the feature
2447                 * we need to at least restart the transfer.
2448                 *
2449                 * According to the spec sdhci_readl(host, SDHCI_DMA_ADDRESS)
2450                 * should return a valid address to continue from, but as
2451                 * some controllers are faulty, don't trust them.
2452                 */
2453                if (intmask & SDHCI_INT_DMA_END) {
2454                        u32 dmastart, dmanow;
2455                        dmastart = sg_dma_address(host->data->sg);
2456                        dmanow = dmastart + host->data->bytes_xfered;
2457                        /*
2458                         * Force update to the next DMA block boundary.
2459                         */
2460                        dmanow = (dmanow &
2461                                ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1)) +
2462                                SDHCI_DEFAULT_BOUNDARY_SIZE;
2463                        host->data->bytes_xfered = dmanow - dmastart;
2464                        DBG("%s: DMA base 0x%08x, transferred 0x%06x bytes,"
2465                                " next 0x%08x\n",
2466                                mmc_hostname(host->mmc), dmastart,
2467                                host->data->bytes_xfered, dmanow);
2468                        sdhci_writel(host, dmanow, SDHCI_DMA_ADDRESS);
2469                }
2470
2471                if (intmask & SDHCI_INT_DATA_END) {
2472                        if (host->cmd) {
2473                                /*
2474                                 * Data managed to finish before the
2475                                 * command completed. Make sure we do
2476                                 * things in the proper order.
2477                                 */
2478                                host->data_early = 1;
2479                        } else {
2480                                sdhci_finish_data(host);
2481                        }
2482                }
2483        }
2484}
2485
2486static irqreturn_t sdhci_irq(int irq, void *dev_id)
2487{
2488        irqreturn_t result = IRQ_NONE;
2489        struct sdhci_host *host = dev_id;
2490        u32 intmask, mask, unexpected = 0;
2491        int max_loops = 16;
2492
2493        spin_lock(&host->lock);
2494
2495        if (host->runtime_suspended && !sdhci_sdio_irq_enabled(host)) {
2496                spin_unlock(&host->lock);
2497                return IRQ_NONE;
2498        }
2499
2500        intmask = sdhci_readl(host, SDHCI_INT_STATUS);
2501        if (!intmask || intmask == 0xffffffff) {
2502                result = IRQ_NONE;
2503                goto out;
2504        }
2505
2506        do {
2507                /* Clear selected interrupts. */
2508                mask = intmask & (SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK |
2509                                  SDHCI_INT_BUS_POWER);
2510                sdhci_writel(host, mask, SDHCI_INT_STATUS);
2511
2512                DBG("*** %s got interrupt: 0x%08x\n",
2513                        mmc_hostname(host->mmc), intmask);
2514
2515                if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
2516                        u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
2517                                      SDHCI_CARD_PRESENT;
2518
2519                        /*
2520                         * There is a observation on i.mx esdhc.  INSERT
2521                         * bit will be immediately set again when it gets
2522                         * cleared, if a card is inserted.  We have to mask
2523                         * the irq to prevent interrupt storm which will
2524                         * freeze the system.  And the REMOVE gets the
2525                         * same situation.
2526                         *
2527                         * More testing are needed here to ensure it works
2528                         * for other platforms though.
2529                         */
2530                        host->ier &= ~(SDHCI_INT_CARD_INSERT |
2531                                       SDHCI_INT_CARD_REMOVE);
2532                        host->ier |= present ? SDHCI_INT_CARD_REMOVE :
2533                                               SDHCI_INT_CARD_INSERT;
2534                        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2535                        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2536
2537                        sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
2538                                     SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);
2539
2540                        host->thread_isr |= intmask & (SDHCI_INT_CARD_INSERT |
2541                                                       SDHCI_INT_CARD_REMOVE);
2542                        result = IRQ_WAKE_THREAD;
2543                }
2544
2545                if (intmask & SDHCI_INT_CMD_MASK)
2546                        sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK,
2547                                      &intmask);
2548
2549                if (intmask & SDHCI_INT_DATA_MASK)
2550                        sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
2551
2552                if (intmask & SDHCI_INT_BUS_POWER)
2553                        pr_err("%s: Card is consuming too much power!\n",
2554                                mmc_hostname(host->mmc));
2555
2556                if (intmask & SDHCI_INT_CARD_INT) {
2557                        sdhci_enable_sdio_irq_nolock(host, false);
2558                        host->thread_isr |= SDHCI_INT_CARD_INT;
2559                        result = IRQ_WAKE_THREAD;
2560                }
2561
2562                intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE |
2563                             SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK |
2564                             SDHCI_INT_ERROR | SDHCI_INT_BUS_POWER |
2565                             SDHCI_INT_CARD_INT);
2566
2567                if (intmask) {
2568                        unexpected |= intmask;
2569                        sdhci_writel(host, intmask, SDHCI_INT_STATUS);
2570                }
2571
2572                if (result == IRQ_NONE)
2573                        result = IRQ_HANDLED;
2574
2575                intmask = sdhci_readl(host, SDHCI_INT_STATUS);
2576        } while (intmask && --max_loops);
2577out:
2578        spin_unlock(&host->lock);
2579
2580        if (unexpected) {
2581                pr_err("%s: Unexpected interrupt 0x%08x.\n",
2582                           mmc_hostname(host->mmc), unexpected);
2583                sdhci_dumpregs(host);
2584        }
2585
2586        return result;
2587}
2588
2589static irqreturn_t sdhci_thread_irq(int irq, void *dev_id)
2590{
2591        struct sdhci_host *host = dev_id;
2592        unsigned long flags;
2593        u32 isr;
2594
2595        spin_lock_irqsave(&host->lock, flags);
2596        isr = host->thread_isr;
2597        host->thread_isr = 0;
2598        spin_unlock_irqrestore(&host->lock, flags);
2599
2600        if (isr & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
2601                sdhci_card_event(host->mmc);
2602                mmc_detect_change(host->mmc, msecs_to_jiffies(200));
2603        }
2604
2605        if (isr & SDHCI_INT_CARD_INT) {
2606                sdio_run_irqs(host->mmc);
2607
2608                spin_lock_irqsave(&host->lock, flags);
2609                if (host->flags & SDHCI_SDIO_IRQ_ENABLED)
2610                        sdhci_enable_sdio_irq_nolock(host, true);
2611                spin_unlock_irqrestore(&host->lock, flags);
2612        }
2613
2614        return isr ? IRQ_HANDLED : IRQ_NONE;
2615}
2616
2617/*****************************************************************************\
2618 *                                                                           *
2619 * Suspend/resume                                                            *
2620 *                                                                           *
2621\*****************************************************************************/
2622
2623#ifdef CONFIG_PM
2624void sdhci_enable_irq_wakeups(struct sdhci_host *host)
2625{
2626        u8 val;
2627        u8 mask = SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE
2628                        | SDHCI_WAKE_ON_INT;
2629
2630        val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
2631        val |= mask ;
2632        /* Avoid fake wake up */
2633        if (host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION)
2634                val &= ~(SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE);
2635        sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
2636}
2637EXPORT_SYMBOL_GPL(sdhci_enable_irq_wakeups);
2638
2639static void sdhci_disable_irq_wakeups(struct sdhci_host *host)
2640{
2641        u8 val;
2642        u8 mask = SDHCI_WAKE_ON_INSERT | SDHCI_WAKE_ON_REMOVE
2643                        | SDHCI_WAKE_ON_INT;
2644
2645        val = sdhci_readb(host, SDHCI_WAKE_UP_CONTROL);
2646        val &= ~mask;
2647        sdhci_writeb(host, val, SDHCI_WAKE_UP_CONTROL);
2648}
2649
2650int sdhci_suspend_host(struct sdhci_host *host)
2651{
2652        sdhci_disable_card_detection(host);
2653
2654        /* Disable tuning since we are suspending */
2655        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2656                del_timer_sync(&host->tuning_timer);
2657                host->flags &= ~SDHCI_NEEDS_RETUNING;
2658        }
2659
2660        if (!device_may_wakeup(mmc_dev(host->mmc))) {
2661                host->ier = 0;
2662                sdhci_writel(host, 0, SDHCI_INT_ENABLE);
2663                sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
2664                free_irq(host->irq, host);
2665        } else {
2666                sdhci_enable_irq_wakeups(host);
2667                enable_irq_wake(host->irq);
2668        }
2669        return 0;
2670}
2671
2672EXPORT_SYMBOL_GPL(sdhci_suspend_host);
2673
2674int sdhci_resume_host(struct sdhci_host *host)
2675{
2676        int ret = 0;
2677
2678        if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
2679                if (host->ops->enable_dma)
2680                        host->ops->enable_dma(host);
2681        }
2682
2683        if (!device_may_wakeup(mmc_dev(host->mmc))) {
2684                ret = request_threaded_irq(host->irq, sdhci_irq,
2685                                           sdhci_thread_irq, IRQF_SHARED,
2686                                           mmc_hostname(host->mmc), host);
2687                if (ret)
2688                        return ret;
2689        } else {
2690                sdhci_disable_irq_wakeups(host);
2691                disable_irq_wake(host->irq);
2692        }
2693
2694        if ((host->mmc->pm_flags & MMC_PM_KEEP_POWER) &&
2695            (host->quirks2 & SDHCI_QUIRK2_HOST_OFF_CARD_ON)) {
2696                /* Card keeps power but host controller does not */
2697                sdhci_init(host, 0);
2698                host->pwr = 0;
2699                host->clock = 0;
2700                sdhci_do_set_ios(host, &host->mmc->ios);
2701        } else {
2702                sdhci_init(host, (host->mmc->pm_flags & MMC_PM_KEEP_POWER));
2703                mmiowb();
2704        }
2705
2706        sdhci_enable_card_detection(host);
2707
2708        /* Set the re-tuning expiration flag */
2709        if (host->flags & SDHCI_USING_RETUNING_TIMER)
2710                host->flags |= SDHCI_NEEDS_RETUNING;
2711
2712        return ret;
2713}
2714
2715EXPORT_SYMBOL_GPL(sdhci_resume_host);
2716#endif /* CONFIG_PM */
2717
2718#ifdef CONFIG_PM_RUNTIME
2719
2720static int sdhci_runtime_pm_get(struct sdhci_host *host)
2721{
2722        return pm_runtime_get_sync(host->mmc->parent);
2723}
2724
2725static int sdhci_runtime_pm_put(struct sdhci_host *host)
2726{
2727        pm_runtime_mark_last_busy(host->mmc->parent);
2728        return pm_runtime_put_autosuspend(host->mmc->parent);
2729}
2730
2731static void sdhci_runtime_pm_bus_on(struct sdhci_host *host)
2732{
2733        if (host->bus_on)
2734                return;
2735        host->bus_on = true;
2736        pm_runtime_get_noresume(host->mmc->parent);
2737}
2738
2739static void sdhci_runtime_pm_bus_off(struct sdhci_host *host)
2740{
2741        if (!host->bus_on)
2742                return;
2743        host->bus_on = false;
2744        pm_runtime_put_noidle(host->mmc->parent);
2745}
2746
2747int sdhci_runtime_suspend_host(struct sdhci_host *host)
2748{
2749        unsigned long flags;
2750
2751        /* Disable tuning since we are suspending */
2752        if (host->flags & SDHCI_USING_RETUNING_TIMER) {
2753                del_timer_sync(&host->tuning_timer);
2754                host->flags &= ~SDHCI_NEEDS_RETUNING;
2755        }
2756
2757        spin_lock_irqsave(&host->lock, flags);
2758        host->ier &= SDHCI_INT_CARD_INT;
2759        sdhci_writel(host, host->ier, SDHCI_INT_ENABLE);
2760        sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
2761        spin_unlock_irqrestore(&host->lock, flags);
2762
2763        synchronize_hardirq(host->irq);
2764
2765        spin_lock_irqsave(&host->lock, flags);
2766        host->runtime_suspended = true;
2767        spin_unlock_irqrestore(&host->lock, flags);
2768
2769        return 0;
2770}
2771EXPORT_SYMBOL_GPL(sdhci_runtime_suspend_host);
2772
2773int sdhci_runtime_resume_host(struct sdhci_host *host)
2774{
2775        unsigned long flags;
2776        int host_flags = host->flags;
2777
2778        if (host_flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
2779                if (host->ops->enable_dma)
2780                        host->ops->enable_dma(host);
2781        }
2782
2783        sdhci_init(host, 0);
2784
2785        /* Force clock and power re-program */
2786        host->pwr = 0;
2787        host->clock = 0;
2788        sdhci_do_set_ios(host, &host->mmc->ios);
2789
2790        sdhci_do_start_signal_voltage_switch(host, &host->mmc->ios);
2791        if ((host_flags & SDHCI_PV_ENABLED) &&
2792                !(host->quirks2 & SDHCI_QUIRK2_PRESET_VALUE_BROKEN)) {
2793                spin_lock_irqsave(&host->lock, flags);
2794                sdhci_enable_preset_value(host, true);
2795                spin_unlock_irqrestore(&host->lock, flags);
2796        }
2797
2798        /* Set the re-tuning expiration flag */
2799        if (host->flags & SDHCI_USING_RETUNING_TIMER)
2800                host->flags |= SDHCI_NEEDS_RETUNING;
2801
2802        spin_lock_irqsave(&host->lock, flags);
2803
2804        host->runtime_suspended = false;
2805
2806        /* Enable SDIO IRQ */
2807        if (host->flags & SDHCI_SDIO_IRQ_ENABLED)
2808                sdhci_enable_sdio_irq_nolock(host, true);
2809
2810        /* Enable Card Detection */
2811        sdhci_enable_card_detection(host);
2812
2813        spin_unlock_irqrestore(&host->lock, flags);
2814
2815        return 0;
2816}
2817EXPORT_SYMBOL_GPL(sdhci_runtime_resume_host);
2818
2819#endif
2820
2821/*****************************************************************************\
2822 *                                                                           *
2823 * Device allocation/registration                                            *
2824 *                                                                           *
2825\*****************************************************************************/
2826
2827struct sdhci_host *sdhci_alloc_host(struct device *dev,
2828        size_t priv_size)
2829{
2830        struct mmc_host *mmc;
2831        struct sdhci_host *host;
2832
2833        WARN_ON(dev == NULL);
2834
2835        mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev);
2836        if (!mmc)
2837                return ERR_PTR(-ENOMEM);
2838
2839        host = mmc_priv(mmc);
2840        host->mmc = mmc;
2841
2842        return host;
2843}
2844
2845EXPORT_SYMBOL_GPL(sdhci_alloc_host);
2846
2847int sdhci_add_host(struct sdhci_host *host)
2848{
2849        struct mmc_host *mmc;
2850        u32 caps[2] = {0, 0};
2851        u32 max_current_caps;
2852        unsigned int ocr_avail;
2853        unsigned int override_timeout_clk;
2854        int ret;
2855
2856        WARN_ON(host == NULL);
2857        if (host == NULL)
2858                return -EINVAL;
2859
2860        mmc = host->mmc;
2861
2862        if (debug_quirks)
2863                host->quirks = debug_quirks;
2864        if (debug_quirks2)
2865                host->quirks2 = debug_quirks2;
2866
2867        override_timeout_clk = host->timeout_clk;
2868
2869        sdhci_do_reset(host, SDHCI_RESET_ALL);
2870
2871        host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
2872        host->version = (host->version & SDHCI_SPEC_VER_MASK)
2873                                >> SDHCI_SPEC_VER_SHIFT;
2874        if (host->version > SDHCI_SPEC_300) {
2875                pr_err("%s: Unknown controller version (%d). "
2876                        "You may experience problems.\n", mmc_hostname(mmc),
2877                        host->version);
2878        }
2879
2880        caps[0] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps :
2881                sdhci_readl(host, SDHCI_CAPABILITIES);
2882
2883        if (host->version >= SDHCI_SPEC_300)
2884                caps[1] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ?
2885                        host->caps1 :
2886                        sdhci_readl(host, SDHCI_CAPABILITIES_1);
2887
2888        if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
2889                host->flags |= SDHCI_USE_SDMA;
2890        else if (!(caps[0] & SDHCI_CAN_DO_SDMA))
2891                DBG("Controller doesn't have SDMA capability\n");
2892        else
2893                host->flags |= SDHCI_USE_SDMA;
2894
2895        if ((host->quirks & SDHCI_QUIRK_BROKEN_DMA) &&
2896                (host->flags & SDHCI_USE_SDMA)) {
2897                DBG("Disabling DMA as it is marked broken\n");
2898                host->flags &= ~SDHCI_USE_SDMA;
2899        }
2900
2901        if ((host->version >= SDHCI_SPEC_200) &&
2902                (caps[0] & SDHCI_CAN_DO_ADMA2))
2903                host->flags |= SDHCI_USE_ADMA;
2904
2905        if ((host->quirks & SDHCI_QUIRK_BROKEN_ADMA) &&
2906                (host->flags & SDHCI_USE_ADMA)) {
2907                DBG("Disabling ADMA as it is marked broken\n");
2908                host->flags &= ~SDHCI_USE_ADMA;
2909        }
2910
2911        if (host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA)) {
2912                if (host->ops->enable_dma) {
2913                        if (host->ops->enable_dma(host)) {
2914                                pr_warn("%s: No suitable DMA available - falling back to PIO\n",
2915                                        mmc_hostname(mmc));
2916                                host->flags &=
2917                                        ~(SDHCI_USE_SDMA | SDHCI_USE_ADMA);
2918                        }
2919                }
2920        }
2921
2922        if (host->flags & SDHCI_USE_ADMA) {
2923                /*
2924                 * We need to allocate descriptors for all sg entries
2925                 * (128) and potentially one alignment transfer for
2926                 * each of those entries.
2927                 */
2928                host->adma_desc = dma_alloc_coherent(mmc_dev(mmc),
2929                                                     ADMA_SIZE, &host->adma_addr,
2930                                                     GFP_KERNEL);
2931                host->align_buffer = kmalloc(128 * 4, GFP_KERNEL);
2932                if (!host->adma_desc || !host->align_buffer) {
2933                        dma_free_coherent(mmc_dev(mmc), ADMA_SIZE,
2934                                          host->adma_desc, host->adma_addr);
2935                        kfree(host->align_buffer);
2936                        pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n",
2937                                mmc_hostname(mmc));
2938                        host->flags &= ~SDHCI_USE_ADMA;
2939                        host->adma_desc = NULL;
2940                        host->align_buffer = NULL;
2941                } else if (host->adma_addr & 3) {
2942                        pr_warn("%s: unable to allocate aligned ADMA descriptor\n",
2943                                mmc_hostname(mmc));
2944                        host->flags &= ~SDHCI_USE_ADMA;
2945                        dma_free_coherent(mmc_dev(mmc), ADMA_SIZE,
2946                                          host->adma_desc, host->adma_addr);
2947                        kfree(host->align_buffer);
2948                        host->adma_desc = NULL;
2949                        host->align_buffer = NULL;
2950                }
2951        }
2952
2953        /*
2954         * If we use DMA, then it's up to the caller to set the DMA
2955         * mask, but PIO does not need the hw shim so we set a new
2956         * mask here in that case.
2957         */
2958        if (!(host->flags & (SDHCI_USE_SDMA | SDHCI_USE_ADMA))) {
2959                host->dma_mask = DMA_BIT_MASK(64);
2960                mmc_dev(mmc)->dma_mask = &host->dma_mask;
2961        }
2962
2963        if (host->version >= SDHCI_SPEC_300)
2964                host->max_clk = (caps[0] & SDHCI_CLOCK_V3_BASE_MASK)
2965                        >> SDHCI_CLOCK_BASE_SHIFT;
2966        else
2967                host->max_clk = (caps[0] & SDHCI_CLOCK_BASE_MASK)
2968                        >> SDHCI_CLOCK_BASE_SHIFT;
2969
2970        host->max_clk *= 1000000;
2971        if (host->max_clk == 0 || host->quirks &
2972                        SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN) {
2973                if (!host->ops->get_max_clock) {
2974                        pr_err("%s: Hardware doesn't specify base clock "
2975                               "frequency.\n", mmc_hostname(mmc));
2976                        return -ENODEV;
2977                }
2978                host->max_clk = host->ops->get_max_clock(host);
2979        }
2980
2981        /*
2982         * In case of Host Controller v3.00, find out whether clock
2983         * multiplier is supported.
2984         */
2985        host->clk_mul = (caps[1] & SDHCI_CLOCK_MUL_MASK) >>
2986                        SDHCI_CLOCK_MUL_SHIFT;
2987
2988        /*
2989         * In case the value in Clock Multiplier is 0, then programmable
2990         * clock mode is not supported, otherwise the actual clock
2991         * multiplier is one more than the value of Clock Multiplier
2992         * in the Capabilities Register.
2993         */
2994        if (host->clk_mul)
2995                host->clk_mul += 1;
2996
2997        /*
2998         * Set host parameters.
2999         */
3000        mmc->ops = &sdhci_ops;
3001        mmc->f_max = host->max_clk;
3002        if (host->ops->get_min_clock)
3003                mmc->f_min = host->ops->get_min_clock(host);
3004        else if (host->version >= SDHCI_SPEC_300) {
3005                if (host->clk_mul) {
3006                        mmc->f_min = (host->max_clk * host->clk_mul) / 1024;
3007                        mmc->f_max = host->max_clk * host->clk_mul;
3008                } else
3009                        mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_300;
3010        } else
3011                mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
3012
3013        if (!(host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
3014                host->timeout_clk = (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >>
3015                                        SDHCI_TIMEOUT_CLK_SHIFT;
3016                if (host->timeout_clk == 0) {
3017                        if (host->ops->get_timeout_clock) {
3018                                host->timeout_clk =
3019                                        host->ops->get_timeout_clock(host);
3020                        } else {
3021                                pr_err("%s: Hardware doesn't specify timeout clock frequency.\n",
3022                                        mmc_hostname(mmc));
3023                                return -ENODEV;
3024                        }
3025                }
3026
3027                if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
3028                        host->timeout_clk *= 1000;
3029
3030                if (override_timeout_clk)
3031                        host->timeout_clk = override_timeout_clk;
3032
3033                mmc->max_busy_timeout = host->ops->get_max_timeout_count ?
3034                        host->ops->get_max_timeout_count(host) : 1 << 27;
3035                mmc->max_busy_timeout /= host->timeout_clk;
3036        }
3037
3038        mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
3039        mmc->caps2 |= MMC_CAP2_SDIO_IRQ_NOTHREAD;
3040
3041        if (host->quirks & SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12)
3042                host->flags |= SDHCI_AUTO_CMD12;
3043
3044        /* Auto-CMD23 stuff only works in ADMA or PIO. */
3045        if ((host->version >= SDHCI_SPEC_300) &&
3046            ((host->flags & SDHCI_USE_ADMA) ||
3047             !(host->flags & SDHCI_USE_SDMA))) {
3048                host->flags |= SDHCI_AUTO_CMD23;
3049                DBG("%s: Auto-CMD23 available\n", mmc_hostname(mmc));
3050        } else {
3051                DBG("%s: Auto-CMD23 unavailable\n", mmc_hostname(mmc));
3052        }
3053
3054        /*
3055         * A controller may support 8-bit width, but the board itself
3056         * might not have the pins brought out.  Boards that support
3057         * 8-bit width must set "mmc->caps |= MMC_CAP_8_BIT_DATA;" in
3058         * their platform code before calling sdhci_add_host(), and we
3059         * won't assume 8-bit width for hosts without that CAP.
3060         */
3061        if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA))
3062                mmc->caps |= MMC_CAP_4_BIT_DATA;
3063
3064        if (host->quirks2 & SDHCI_QUIRK2_HOST_NO_CMD23)
3065                mmc->caps &= ~MMC_CAP_CMD23;
3066
3067        if (caps[0] & SDHCI_CAN_DO_HISPD)
3068                mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
3069
3070        if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
3071            !(mmc->caps & MMC_CAP_NONREMOVABLE))
3072                mmc->caps |= MMC_CAP_NEEDS_POLL;
3073
3074        /* If there are external regulators, get them */
3075        if (mmc_regulator_get_supply(mmc) == -EPROBE_DEFER)
3076                return -EPROBE_DEFER;
3077
3078        /* If vqmmc regulator and no 1.8V signalling, then there's no UHS */
3079        if (!IS_ERR(mmc->supply.vqmmc)) {
3080                ret = regulator_enable(mmc->supply.vqmmc);
3081                if (!regulator_is_supported_voltage(mmc->supply.vqmmc, 1700000,
3082                                                    1950000))
3083                        caps[1] &= ~(SDHCI_SUPPORT_SDR104 |
3084                                        SDHCI_SUPPORT_SDR50 |
3085                                        SDHCI_SUPPORT_DDR50);
3086                if (ret) {
3087                        pr_warn("%s: Failed to enable vqmmc regulator: %d\n",
3088                                mmc_hostname(mmc), ret);
3089                        mmc->supply.vqmmc = NULL;
3090                }
3091        }
3092
3093        if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V)
3094                caps[1] &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
3095                       SDHCI_SUPPORT_DDR50);
3096
3097        /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
3098        if (caps[1] & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
3099                       SDHCI_SUPPORT_DDR50))
3100                mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25;
3101
3102        /* SDR104 supports also implies SDR50 support */
3103        if (caps[1] & SDHCI_SUPPORT_SDR104) {
3104                mmc->caps |= MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_SDR50;
3105                /* SD3.0: SDR104 is supported so (for eMMC) the caps2
3106                 * field can be promoted to support HS200.
3107                 */
3108                if (!(host->quirks2 & SDHCI_QUIRK2_BROKEN_HS200)) {
3109                        mmc->caps2 |= MMC_CAP2_HS200;
3110                        if (IS_ERR(mmc->supply.vqmmc) ||
3111                                        !regulator_is_supported_voltage
3112                                        (mmc->supply.vqmmc, 1100000, 1300000))
3113                                mmc->caps2 &= ~MMC_CAP2_HS200_1_2V_SDR;
3114                }
3115        } else if (caps[1] & SDHCI_SUPPORT_SDR50)
3116                mmc->caps |= MMC_CAP_UHS_SDR50;
3117
3118        if ((caps[1] & SDHCI_SUPPORT_DDR50) &&
3119                !(host->quirks2 & SDHCI_QUIRK2_BROKEN_DDR50))
3120                mmc->caps |= MMC_CAP_UHS_DDR50;
3121
3122        /* Does the host need tuning for SDR50? */
3123        if (caps[1] & SDHCI_USE_SDR50_TUNING)
3124                host->flags |= SDHCI_SDR50_NEEDS_TUNING;
3125
3126        /* Does the host need tuning for SDR104 / HS200? */
3127        if (mmc->caps2 & MMC_CAP2_HS200)
3128                host->flags |= SDHCI_SDR104_NEEDS_TUNING;
3129
3130        /* Driver Type(s) (A, C, D) supported by the host */
3131        if (caps[1] & SDHCI_DRIVER_TYPE_A)
3132                mmc->caps |= MMC_CAP_DRIVER_TYPE_A;
3133        if (caps[1] & SDHCI_DRIVER_TYPE_C)
3134                mmc->caps |= MMC_CAP_DRIVER_TYPE_C;
3135        if (caps[1] & SDHCI_DRIVER_TYPE_D)
3136                mmc->caps |= MMC_CAP_DRIVER_TYPE_D;
3137
3138        /* Initial value for re-tuning timer count */
3139        host->tuning_count = (caps[1] & SDHCI_RETUNING_TIMER_COUNT_MASK) >>
3140                              SDHCI_RETUNING_TIMER_COUNT_SHIFT;
3141
3142        /*
3143         * In case Re-tuning Timer is not disabled, the actual value of
3144         * re-tuning timer will be 2 ^ (n - 1).
3145         */
3146        if (host->tuning_count)
3147                host->tuning_count = 1 << (host->tuning_count - 1);
3148
3149        /* Re-tuning mode supported by the Host Controller */
3150        host->tuning_mode = (caps[1] & SDHCI_RETUNING_MODE_MASK) >>
3151                             SDHCI_RETUNING_MODE_SHIFT;
3152
3153        ocr_avail = 0;
3154
3155        /*
3156         * According to SD Host Controller spec v3.00, if the Host System
3157         * can afford more than 150mA, Host Driver should set XPC to 1. Also
3158         * the value is meaningful only if Voltage Support in the Capabilities
3159         * register is set. The actual current value is 4 times the register
3160         * value.
3161         */
3162        max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
3163        if (!max_current_caps && !IS_ERR(mmc->supply.vmmc)) {
3164                int curr = regulator_get_current_limit(mmc->supply.vmmc);
3165                if (curr > 0) {
3166
3167                        /* convert to SDHCI_MAX_CURRENT format */
3168                        curr = curr/1000;  /* convert to mA */
3169                        curr = curr/SDHCI_MAX_CURRENT_MULTIPLIER;
3170
3171                        curr = min_t(u32, curr, SDHCI_MAX_CURRENT_LIMIT);
3172                        max_current_caps =
3173                                (curr << SDHCI_MAX_CURRENT_330_SHIFT) |
3174                                (curr << SDHCI_MAX_CURRENT_300_SHIFT) |
3175                                (curr << SDHCI_MAX_CURRENT_180_SHIFT);
3176                }
3177        }
3178
3179        if (caps[0] & SDHCI_CAN_VDD_330) {
3180                ocr_avail |= MMC_VDD_32_33 | MMC_VDD_33_34;
3181
3182                mmc->max_current_330 = ((max_current_caps &
3183                                   SDHCI_MAX_CURRENT_330_MASK) >>
3184                                   SDHCI_MAX_CURRENT_330_SHIFT) *
3185                                   SDHCI_MAX_CURRENT_MULTIPLIER;
3186        }
3187        if (caps[0] & SDHCI_CAN_VDD_300) {
3188                ocr_avail |= MMC_VDD_29_30 | MMC_VDD_30_31;
3189
3190                mmc->max_current_300 = ((max_current_caps &
3191                                   SDHCI_MAX_CURRENT_300_MASK) >>
3192                                   SDHCI_MAX_CURRENT_300_SHIFT) *
3193                                   SDHCI_MAX_CURRENT_MULTIPLIER;
3194        }
3195        if (caps[0] & SDHCI_CAN_VDD_180) {
3196                ocr_avail |= MMC_VDD_165_195;
3197
3198                mmc->max_current_180 = ((max_current_caps &
3199                                   SDHCI_MAX_CURRENT_180_MASK) >>
3200                                   SDHCI_MAX_CURRENT_180_SHIFT) *
3201                                   SDHCI_MAX_CURRENT_MULTIPLIER;
3202        }
3203
3204        /* If OCR set by external regulators, use it instead */
3205        if (mmc->ocr_avail)
3206                ocr_avail = mmc->ocr_avail;
3207
3208        if (host->ocr_mask)
3209                ocr_avail &= host->ocr_mask;
3210
3211        mmc->ocr_avail = ocr_avail;
3212        mmc->ocr_avail_sdio = ocr_avail;
3213        if (host->ocr_avail_sdio)
3214                mmc->ocr_avail_sdio &= host->ocr_avail_sdio;
3215        mmc->ocr_avail_sd = ocr_avail;
3216        if (host->ocr_avail_sd)
3217                mmc->ocr_avail_sd &= host->ocr_avail_sd;
3218        else /* normal SD controllers don't support 1.8V */
3219                mmc->ocr_avail_sd &= ~MMC_VDD_165_195;
3220        mmc->ocr_avail_mmc = ocr_avail;
3221        if (host->ocr_avail_mmc)
3222                mmc->ocr_avail_mmc &= host->ocr_avail_mmc;
3223
3224        if (mmc->ocr_avail == 0) {
3225                pr_err("%s: Hardware doesn't report any "
3226                        "support voltages.\n", mmc_hostname(mmc));
3227                return -ENODEV;
3228        }
3229
3230        spin_lock_init(&host->lock);
3231
3232        /*
3233         * Maximum number of segments. Depends on if the hardware
3234         * can do scatter/gather or not.
3235         */
3236        if (host->flags & SDHCI_USE_ADMA)
3237                mmc->max_segs = 128;
3238        else if (host->flags & SDHCI_USE_SDMA)
3239                mmc->max_segs = 1;
3240        else /* PIO */
3241                mmc->max_segs = 128;
3242
3243        /*
3244         * Maximum number of sectors in one transfer. Limited by DMA boundary
3245         * size (512KiB).
3246         */
3247        mmc->max_req_size = 524288;
3248
3249        /*
3250         * Maximum segment size. Could be one segment with the maximum number
3251         * of bytes. When doing hardware scatter/gather, each entry cannot
3252         * be larger than 64 KiB though.
3253         */
3254        if (host->flags & SDHCI_USE_ADMA) {
3255                if (host->quirks & SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC)
3256                        mmc->max_seg_size = 65535;
3257                else
3258                        mmc->max_seg_size = 65536;
3259        } else {
3260                mmc->max_seg_size = mmc->max_req_size;
3261        }
3262
3263        /*
3264         * Maximum block size. This varies from controller to controller and
3265         * is specified in the capabilities register.
3266         */
3267        if (host->quirks & SDHCI_QUIRK_FORCE_BLK_SZ_2048) {
3268                mmc->max_blk_size = 2;
3269        } else {
3270                mmc->max_blk_size = (caps[0] & SDHCI_MAX_BLOCK_MASK) >>
3271                                SDHCI_MAX_BLOCK_SHIFT;
3272                if (mmc->max_blk_size >= 3) {
3273                        pr_warn("%s: Invalid maximum block size, assuming 512 bytes\n",
3274                                mmc_hostname(mmc));
3275                        mmc->max_blk_size = 0;
3276                }
3277        }
3278
3279        mmc->max_blk_size = 512 << mmc->max_blk_size;
3280
3281        /*
3282         * Maximum block count.
3283         */
3284        mmc->max_blk_count = (host->quirks & SDHCI_QUIRK_NO_MULTIBLOCK) ? 1 : 65535;
3285
3286        /*
3287         * Init tasklets.
3288         */
3289        tasklet_init(&host->finish_tasklet,
3290                sdhci_tasklet_finish, (unsigned long)host);
3291
3292        setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host);
3293
3294        if (host->version >= SDHCI_SPEC_300) {
3295                init_waitqueue_head(&host->buf_ready_int);
3296
3297                /* Initialize re-tuning timer */
3298                init_timer(&host->tuning_timer);
3299                host->tuning_timer.data = (unsigned long)host;
3300                host->tuning_timer.function = sdhci_tuning_timer;
3301        }
3302
3303        sdhci_init(host, 0);
3304
3305        ret = request_threaded_irq(host->irq, sdhci_irq, sdhci_thread_irq,
3306                                   IRQF_SHARED, mmc_hostname(mmc), host);
3307        if (ret) {
3308                pr_err("%s: Failed to request IRQ %d: %d\n",
3309                       mmc_hostname(mmc), host->irq, ret);
3310                goto untasklet;
3311        }
3312
3313#ifdef CONFIG_MMC_DEBUG
3314        sdhci_dumpregs(host);
3315#endif
3316
3317#ifdef SDHCI_USE_LEDS_CLASS
3318        snprintf(host->led_name, sizeof(host->led_name),
3319                "%s::", mmc_hostname(mmc));
3320        host->led.name = host->led_name;
3321        host->led.brightness = LED_OFF;
3322        host->led.default_trigger = mmc_hostname(mmc);
3323        host->led.brightness_set = sdhci_led_control;
3324
3325        ret = led_classdev_register(mmc_dev(mmc), &host->led);
3326        if (ret) {
3327                pr_err("%s: Failed to register LED device: %d\n",
3328                       mmc_hostname(mmc), ret);
3329                goto reset;
3330        }
3331#endif
3332
3333        mmiowb();
3334
3335        mmc_add_host(mmc);
3336
3337        pr_info("%s: SDHCI controller on %s [%s] using %s\n",
3338                mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
3339                (host->flags & SDHCI_USE_ADMA) ? "ADMA" :
3340                (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
3341
3342        sdhci_enable_card_detection(host);
3343
3344        return 0;
3345
3346#ifdef SDHCI_USE_LEDS_CLASS
3347reset:
3348        sdhci_do_reset(host, SDHCI_RESET_ALL);
3349        sdhci_writel(host, 0, SDHCI_INT_ENABLE);
3350        sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
3351        free_irq(host->irq, host);
3352#endif
3353untasklet:
3354        tasklet_kill(&host->finish_tasklet);
3355
3356        return ret;
3357}
3358
3359EXPORT_SYMBOL_GPL(sdhci_add_host);
3360
3361void sdhci_remove_host(struct sdhci_host *host, int dead)
3362{
3363        struct mmc_host *mmc = host->mmc;
3364        unsigned long flags;
3365
3366        if (dead) {
3367                spin_lock_irqsave(&host->lock, flags);
3368
3369                host->flags |= SDHCI_DEVICE_DEAD;
3370
3371                if (host->mrq) {
3372                        pr_err("%s: Controller removed during "
3373                                " transfer!\n", mmc_hostname(mmc));
3374
3375                        host->mrq->cmd->error = -ENOMEDIUM;
3376                        tasklet_schedule(&host->finish_tasklet);
3377                }
3378
3379                spin_unlock_irqrestore(&host->lock, flags);
3380        }
3381
3382        sdhci_disable_card_detection(host);
3383
3384        mmc_remove_host(mmc);
3385
3386#ifdef SDHCI_USE_LEDS_CLASS
3387        led_classdev_unregister(&host->led);
3388#endif
3389
3390        if (!dead)
3391                sdhci_do_reset(host, SDHCI_RESET_ALL);
3392
3393        sdhci_writel(host, 0, SDHCI_INT_ENABLE);
3394        sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
3395        free_irq(host->irq, host);
3396
3397        del_timer_sync(&host->timer);
3398
3399        tasklet_kill(&host->finish_tasklet);
3400
3401        if (!IS_ERR(mmc->supply.vmmc))
3402                regulator_disable(mmc->supply.vmmc);
3403
3404        if (!IS_ERR(mmc->supply.vqmmc))
3405                regulator_disable(mmc->supply.vqmmc);
3406
3407        if (host->adma_desc)
3408                dma_free_coherent(mmc_dev(mmc), ADMA_SIZE,
3409                                  host->adma_desc, host->adma_addr);
3410        kfree(host->align_buffer);
3411
3412        host->adma_desc = NULL;
3413        host->align_buffer = NULL;
3414}
3415
3416EXPORT_SYMBOL_GPL(sdhci_remove_host);
3417
3418void sdhci_free_host(struct sdhci_host *host)
3419{
3420        mmc_free_host(host->mmc);
3421}
3422
3423EXPORT_SYMBOL_GPL(sdhci_free_host);
3424
3425/*****************************************************************************\
3426 *                                                                           *
3427 * Driver init/exit                                                          *
3428 *                                                                           *
3429\*****************************************************************************/
3430
3431static int __init sdhci_drv_init(void)
3432{
3433        pr_info(DRIVER_NAME
3434                ": Secure Digital Host Controller Interface driver\n");
3435        pr_info(DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
3436
3437        return 0;
3438}
3439
3440static void __exit sdhci_drv_exit(void)
3441{
3442}
3443
3444module_init(sdhci_drv_init);
3445module_exit(sdhci_drv_exit);
3446
3447module_param(debug_quirks, uint, 0444);
3448module_param(debug_quirks2, uint, 0444);
3449
3450MODULE_AUTHOR("Pierre Ossman <pierre@ossman.eu>");
3451MODULE_DESCRIPTION("Secure Digital Host Controller Interface core driver");
3452MODULE_LICENSE("GPL");
3453
3454MODULE_PARM_DESC(debug_quirks, "Force certain quirks.");
3455MODULE_PARM_DESC(debug_quirks2, "Force certain other quirks.");
Note: See TracBrowser for help on using the repository browser.