Sdhci: tegra: enable quirk NO_CALC_MAX_DISCARD_TO
[linux-2.6.git] / drivers / mmc / host / sdhci-tegra.c
1 /*
2  * Copyright (C) 2010 Google, Inc.
3  *
4  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 #include <linux/err.h>
18 #include <linux/init.h>
19 #include <linux/platform_device.h>
20 #include <linux/clk.h>
21 #include <linux/io.h>
22 #include <linux/gpio.h>
23 #include <linux/slab.h>
24 #include <linux/mmc/card.h>
25 #include <linux/mmc/host.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/delay.h>
28
29 #include <mach/gpio.h>
30 #include <mach/sdhci.h>
31 #include <mach/io_dpd.h>
32
33 #include "sdhci-pltfm.h"
34
35 #define SDHCI_VENDOR_CLOCK_CNTRL        0x100
36 #define SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK      0x1
37 #define SDHCI_VENDOR_CLOCK_CNTRL_PADPIPE_CLKEN_OVERRIDE 0x8
38 #define SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT    8
39 #define SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT        16
40
41 #define SDHCI_VENDOR_MISC_CNTRL         0x120
42 #define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR104_SUPPORT   0x8
43 #define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR50_SUPPORT    0x10
44 #define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SD_3_0   0x20
45
46 #define SDMMC_AUTO_CAL_CONFIG   0x1E4
47 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE   0x20000000
48 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT  0x8
49 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET        0x70
50 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET        0x62
51
52 #define SDHOST_1V8_OCR_MASK     0x8
53 #define SDHOST_HIGH_VOLT_MIN    2700000
54 #define SDHOST_HIGH_VOLT_MAX    3600000
55 #define SDHOST_LOW_VOLT_MIN     1800000
56 #define SDHOST_LOW_VOLT_MAX     1800000
57
58 #define TEGRA_SDHOST_MIN_FREQ   50000000
59 #define TEGRA2_SDHOST_STD_FREQ  50000000
60 #define TEGRA3_SDHOST_STD_FREQ  104000000
61
62 static unsigned int tegra_sdhost_min_freq;
63 static unsigned int tegra_sdhost_std_freq;
64 static void tegra_3x_sdhci_set_card_clock(struct sdhci_host *sdhci, unsigned int clock);
65 static void tegra3_sdhci_post_reset_init(struct sdhci_host *sdhci);
66
67 static unsigned int tegra3_sdhost_max_clk[4] = {
68         208000000,      104000000,      208000000,      104000000 };
69
70 struct tegra_sdhci_hw_ops{
71         /* Set the internal clk and card clk.*/
72         void    (*set_card_clock)(struct sdhci_host *sdhci, unsigned int clock);
73         /* Post reset vendor registers configuration */
74         void    (*sdhost_init)(struct sdhci_host *sdhci);
75 };
76
77 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
78 static struct tegra_sdhci_hw_ops tegra_2x_sdhci_ops = {
79 };
80 #endif
81
82 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
83 static struct tegra_sdhci_hw_ops tegra_3x_sdhci_ops = {
84         .set_card_clock = tegra_3x_sdhci_set_card_clock,
85         .sdhost_init = tegra3_sdhci_post_reset_init,
86 };
87 #endif
88
89 struct tegra_sdhci_host {
90         bool    clk_enabled;
91         struct regulator *vdd_io_reg;
92         struct regulator *vdd_slot_reg;
93         /* Pointer to the chip specific HW ops */
94         struct tegra_sdhci_hw_ops *hw_ops;
95         /* Host controller instance */
96         unsigned int instance;
97         /* vddio_min */
98         unsigned int vddio_min_uv;
99         /* vddio_max */
100         unsigned int vddio_max_uv;
101         /* max clk supported by the platform */
102         unsigned int max_clk_limit;
103         struct tegra_io_dpd *dpd;
104         bool card_present;
105         bool is_rail_enabled;
106 };
107
108 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
109 {
110         u32 val;
111
112         if (unlikely(reg == SDHCI_PRESENT_STATE)) {
113                 /* Use wp_gpio here instead? */
114                 val = readl(host->ioaddr + reg);
115                 return val | SDHCI_WRITE_PROTECT;
116         }
117
118         return readl(host->ioaddr + reg);
119 }
120
121 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
122 {
123 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
124         if (unlikely(reg == SDHCI_HOST_VERSION)) {
125                 /* Erratum: Version register is invalid in HW. */
126                 return SDHCI_SPEC_200;
127         }
128 #endif
129         return readw(host->ioaddr + reg);
130 }
131
132 static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
133 {
134         /* Seems like we're getting spurious timeout and crc errors, so
135          * disable signalling of them. In case of real errors software
136          * timers should take care of eventually detecting them.
137          */
138         if (unlikely(reg == SDHCI_SIGNAL_ENABLE))
139                 val &= ~(SDHCI_INT_TIMEOUT|SDHCI_INT_CRC);
140
141         writel(val, host->ioaddr + reg);
142
143 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
144         if (unlikely(reg == SDHCI_INT_ENABLE)) {
145                 /* Erratum: Must enable block gap interrupt detection */
146                 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
147                 if (val & SDHCI_INT_CARD_INT)
148                         gap_ctrl |= 0x8;
149                 else
150                         gap_ctrl &= ~0x8;
151                 writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
152         }
153 #endif
154 }
155
156 static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
157 {
158         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
159         struct tegra_sdhci_platform_data *plat;
160
161         plat = pdev->dev.platform_data;
162
163         if (!gpio_is_valid(plat->wp_gpio))
164                 return -1;
165
166         return gpio_get_value(plat->wp_gpio);
167 }
168
169 static void tegra3_sdhci_post_reset_init(struct sdhci_host *sdhci)
170 {
171         u16 misc_ctrl;
172         u32 vendor_ctrl;
173         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
174         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
175         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
176         struct tegra_sdhci_platform_data *plat;
177
178         plat = pdev->dev.platform_data;
179         /* Set the base clock frequency */
180         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
181         vendor_ctrl &= ~(0xFF << SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT);
182         vendor_ctrl |= (tegra3_sdhost_max_clk[tegra_host->instance] / 1000000) <<
183                 SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT;
184         vendor_ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_PADPIPE_CLKEN_OVERRIDE;
185         /* Set tap delay */
186         if (plat->tap_delay) {
187                 vendor_ctrl &= ~(0xFF <<
188                         SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
189                 vendor_ctrl |= (plat->tap_delay <<
190                         SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
191         }
192         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
193
194         /* Enable SDHOST v3.0 support */
195         misc_ctrl = sdhci_readw(sdhci, SDHCI_VENDOR_MISC_CNTRL);
196         misc_ctrl |= SDHCI_VENDOR_MISC_CNTRL_ENABLE_SD_3_0 |
197                 SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR104_SUPPORT |
198                 SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR50_SUPPORT;
199         sdhci_writew(sdhci, misc_ctrl, SDHCI_VENDOR_MISC_CNTRL);
200 }
201
202 static int tegra_sdhci_set_uhs_signaling(struct sdhci_host *host,
203                 unsigned int uhs)
204 {
205         u16 clk, ctrl_2;
206         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
207
208         /* Select Bus Speed Mode for host */
209         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
210         switch (uhs) {
211         case MMC_TIMING_UHS_SDR12:
212                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
213                 break;
214         case MMC_TIMING_UHS_SDR25:
215                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
216                 break;
217         case MMC_TIMING_UHS_SDR50:
218                 ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
219                 break;
220         case MMC_TIMING_UHS_SDR104:
221                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
222                 break;
223         case MMC_TIMING_UHS_DDR50:
224                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
225                 break;
226         }
227
228         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
229
230         if (uhs == MMC_TIMING_UHS_DDR50) {
231                 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
232                 clk &= ~(0xFF << SDHCI_DIVIDER_SHIFT);
233                 clk |= 1 << SDHCI_DIVIDER_SHIFT;
234                 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
235         }
236         return 0;
237 }
238
239 static void tegra_sdhci_reset_exit(struct sdhci_host *sdhci, u8 mask)
240 {
241         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
242         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
243
244         if (mask & SDHCI_RESET_ALL) {
245                 if (tegra_host->hw_ops->sdhost_init)
246                         tegra_host->hw_ops->sdhost_init(sdhci);
247         }
248 }
249
250 static void sdhci_status_notify_cb(int card_present, void *dev_id)
251 {
252         struct sdhci_host *sdhci = (struct sdhci_host *)dev_id;
253         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
254         struct tegra_sdhci_platform_data *plat;
255         unsigned int status, oldstat;
256
257         pr_debug("%s: card_present %d\n", mmc_hostname(sdhci->mmc),
258                 card_present);
259
260         plat = pdev->dev.platform_data;
261         if (!plat->mmc_data.status) {
262                 mmc_detect_change(sdhci->mmc, 0);
263                 return;
264         }
265
266         status = plat->mmc_data.status(mmc_dev(sdhci->mmc));
267
268         oldstat = plat->mmc_data.card_present;
269         plat->mmc_data.card_present = status;
270         if (status ^ oldstat) {
271                 pr_debug("%s: Slot status change detected (%d -> %d)\n",
272                         mmc_hostname(sdhci->mmc), oldstat, status);
273                 if (status && !plat->mmc_data.built_in)
274                         mmc_detect_change(sdhci->mmc, (5 * HZ) / 2);
275                 else
276                         mmc_detect_change(sdhci->mmc, 0);
277         }
278 }
279
280 static irqreturn_t carddetect_irq(int irq, void *data)
281 {
282         struct sdhci_host *sdhost = (struct sdhci_host *)data;
283         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhost);
284         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
285         struct platform_device *pdev = to_platform_device(mmc_dev(sdhost->mmc));
286         struct tegra_sdhci_platform_data *plat;
287
288         plat = pdev->dev.platform_data;
289
290         tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
291
292         if (tegra_host->card_present) {
293                 if (!tegra_host->is_rail_enabled) {
294                         if (tegra_host->vdd_slot_reg)
295                                 regulator_enable(tegra_host->vdd_slot_reg);
296                         if (tegra_host->vdd_io_reg)
297                                 regulator_enable(tegra_host->vdd_io_reg);
298                         tegra_host->is_rail_enabled = 1;
299                 }
300         } else {
301                 if (tegra_host->is_rail_enabled) {
302                         if (tegra_host->vdd_io_reg)
303                                 regulator_disable(tegra_host->vdd_io_reg);
304                         if (tegra_host->vdd_slot_reg)
305                                 regulator_disable(tegra_host->vdd_slot_reg);
306                         tegra_host->is_rail_enabled = 0;
307                 }
308         }
309
310         tasklet_schedule(&sdhost->card_tasklet);
311         return IRQ_HANDLED;
312 };
313
314 static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
315 {
316         struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
317         struct tegra_sdhci_platform_data *plat;
318         u32 ctrl;
319
320         plat = pdev->dev.platform_data;
321
322         ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
323         if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
324                 ctrl &= ~SDHCI_CTRL_4BITBUS;
325                 ctrl |= SDHCI_CTRL_8BITBUS;
326         } else {
327                 ctrl &= ~SDHCI_CTRL_8BITBUS;
328                 if (bus_width == MMC_BUS_WIDTH_4)
329                         ctrl |= SDHCI_CTRL_4BITBUS;
330                 else
331                         ctrl &= ~SDHCI_CTRL_4BITBUS;
332         }
333         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
334         return 0;
335 }
336
337 static void tegra_sdhci_set_clk_rate(struct sdhci_host *sdhci,
338         unsigned int clock)
339 {
340         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
341         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
342         unsigned int clk_rate;
343
344         if (sdhci->mmc->card &&
345                 mmc_card_ddr_mode(sdhci->mmc->card)) {
346                 /*
347                  * In ddr mode, tegra sdmmc controller clock frequency
348                  * should be double the card clock frequency.
349                  */
350                  clk_rate = clock * 2;
351         } else {
352                 if (clock <= tegra_sdhost_min_freq)
353                         clk_rate = tegra_sdhost_min_freq;
354                 else if (clock <= tegra_sdhost_std_freq)
355                         clk_rate = tegra_sdhost_std_freq;
356                 else
357                         clk_rate = clock;
358         }
359
360         if (tegra_host->max_clk_limit &&
361                 (clk_rate > tegra_host->max_clk_limit))
362                 clk_rate = tegra_host->max_clk_limit;
363
364         clk_set_rate(pltfm_host->clk, clk_rate);
365         sdhci->max_clk = clk_get_rate(pltfm_host->clk);
366 }
367
368 static void tegra_3x_sdhci_set_card_clock(struct sdhci_host *sdhci, unsigned int clock)
369 {
370         int div;
371         u16 clk;
372         unsigned long timeout;
373         u8 ctrl;
374
375         if (clock && clock == sdhci->clock)
376                 return;
377
378         sdhci_writew(sdhci, 0, SDHCI_CLOCK_CONTROL);
379
380         if (clock == 0)
381                 goto out;
382         if (sdhci->mmc->ios.timing == MMC_TIMING_UHS_DDR50) {
383                 div = 1;
384                 goto set_clk;
385         }
386
387         if (sdhci->version >= SDHCI_SPEC_300) {
388                 /* Version 3.00 divisors must be a multiple of 2. */
389                 if (sdhci->max_clk <= clock) {
390                         div = 1;
391                 } else {
392                         for (div = 2; div < SDHCI_MAX_DIV_SPEC_300; div += 2) {
393                                 if ((sdhci->max_clk / div) <= clock)
394                                         break;
395                         }
396                 }
397         } else {
398                 /* Version 2.00 divisors must be a power of 2. */
399                 for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
400                         if ((sdhci->max_clk / div) <= clock)
401                                 break;
402                 }
403         }
404         div >>= 1;
405
406         /*
407          * Tegra3 sdmmc controller internal clock will not be stabilized when
408          * we use a clock divider value greater than 4. The WAR is as follows.
409          * - Enable internal clock.
410          * - Wait for 5 usec and do a dummy write.
411          * - Poll for clk stable.
412          */
413 set_clk:
414         clk = (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
415         clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
416                 << SDHCI_DIVIDER_HI_SHIFT;
417         clk |= SDHCI_CLOCK_INT_EN;
418         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
419
420         /* Wait for 5 usec */
421         udelay(5);
422
423         /* Do a dummy write */
424         ctrl = sdhci_readb(sdhci, SDHCI_CAPABILITIES);
425         ctrl |= 1;
426         sdhci_writeb(sdhci, ctrl, SDHCI_CAPABILITIES);
427
428         /* Wait max 20 ms */
429         timeout = 20;
430         while (!((clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL))
431                 & SDHCI_CLOCK_INT_STABLE)) {
432                 if (timeout == 0) {
433                         dev_err(mmc_dev(sdhci->mmc), "Internal clock never stabilised\n");
434                         return;
435                 }
436                 timeout--;
437                 mdelay(1);
438         }
439
440         clk |= SDHCI_CLOCK_CARD_EN;
441         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
442 out:
443         sdhci->clock = clock;
444 }
445
446 static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
447 {
448         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
449         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
450         u8 ctrl;
451
452         pr_debug("%s %s %u enabled=%u\n", __func__,
453                 mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
454
455         if (clock) {
456                 /* bring out sd instance from io dpd mode */
457                 tegra_io_dpd_disable(tegra_host->dpd);
458
459                 if (!tegra_host->clk_enabled) {
460                         clk_enable(pltfm_host->clk);
461                         ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
462                         ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
463                         sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
464                         tegra_host->clk_enabled = true;
465                 }
466                 tegra_sdhci_set_clk_rate(sdhci, clock);
467                 if (tegra_host->hw_ops->set_card_clock)
468                         tegra_host->hw_ops->set_card_clock(sdhci, clock);
469         } else if (!clock && tegra_host->clk_enabled) {
470                 if (tegra_host->hw_ops->set_card_clock)
471                         tegra_host->hw_ops->set_card_clock(sdhci, clock);
472                 ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
473                 ctrl &= ~SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
474                 sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
475                 clk_disable(pltfm_host->clk);
476                 tegra_host->clk_enabled = false;
477                 /* io dpd enable call for sd instance */
478                 tegra_io_dpd_enable(tegra_host->dpd);
479         }
480 }
481
482 static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
483         unsigned int signal_voltage)
484 {
485         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
486         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
487         unsigned int min_uV = SDHOST_HIGH_VOLT_MIN;
488         unsigned int max_uV = SDHOST_HIGH_VOLT_MAX;
489         unsigned int rc;
490         u16 clk, ctrl;
491         unsigned int val;
492
493         /* Switch OFF the card clock to prevent glitches on the clock line */
494         clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL);
495         clk &= ~SDHCI_CLOCK_CARD_EN;
496         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
497
498         ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
499         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
500                 ctrl |= SDHCI_CTRL_VDD_180;
501                 min_uV = SDHOST_LOW_VOLT_MIN;
502                 max_uV = SDHOST_LOW_VOLT_MAX;
503         } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
504                 if (ctrl & SDHCI_CTRL_VDD_180)
505                         ctrl &= ~SDHCI_CTRL_VDD_180;
506         }
507         sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
508
509         /* Switch the I/O rail voltage */
510         if (tegra_host->vdd_io_reg) {
511                 rc = regulator_set_voltage(tegra_host->vdd_io_reg,
512                         min_uV, max_uV);
513                 if (rc) {
514                         dev_err(mmc_dev(sdhci->mmc), "switching to 1.8V"
515                         "failed . Switching back to 3.3V\n");
516                         regulator_set_voltage(tegra_host->vdd_io_reg,
517                                 SDHOST_HIGH_VOLT_MIN,
518                                 SDHOST_HIGH_VOLT_MAX);
519                         return rc;
520                 }
521         }
522
523         /* Wait for 10 msec for the voltage to be switched */
524         mdelay(10);
525
526         /* Enable the card clock */
527         clk |= SDHCI_CLOCK_CARD_EN;
528         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
529
530         /* Wait for 1 msec after enabling clock */
531         mdelay(1);
532
533         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
534                 /* Do Auto Calibration for 1.8V signal voltage */
535                 val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
536                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
537                 /* Program Auto cal PD offset(bits 8:14) */
538                 val &= ~(0x7F <<
539                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
540                 val |= (SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET <<
541                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
542                 /* Program Auto cal PU offset(bits 0:6) */
543                 val &= ~0x7F;
544                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET;
545                 sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
546         }
547
548         return 0;
549 }
550
551 static int tegra_sdhci_suspend(struct sdhci_host *sdhci, pm_message_t state)
552 {
553         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
554         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
555
556         tegra_sdhci_set_clock(sdhci, 0);
557
558         /* Disable the power rails if any */
559         if (tegra_host->card_present) {
560                 if (tegra_host->is_rail_enabled) {
561                         if (tegra_host->vdd_io_reg)
562                                 regulator_disable(tegra_host->vdd_io_reg);
563                         if (tegra_host->vdd_slot_reg)
564                                 regulator_disable(tegra_host->vdd_slot_reg);
565                         tegra_host->is_rail_enabled = 0;
566                 }
567         }
568
569         return 0;
570 }
571
572 static int tegra_sdhci_resume(struct sdhci_host *sdhci)
573 {
574         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
575         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
576         unsigned long timeout;
577
578         /* Enable the power rails if any */
579         if (tegra_host->card_present) {
580                 if (!tegra_host->is_rail_enabled) {
581                         if (tegra_host->vdd_slot_reg)
582                                 regulator_enable(tegra_host->vdd_slot_reg);
583                         if (tegra_host->vdd_io_reg) {
584                                 regulator_enable(tegra_host->vdd_io_reg);
585                                 tegra_sdhci_signal_voltage_switch(sdhci, MMC_SIGNAL_VOLTAGE_330);
586                         }
587                         tegra_host->is_rail_enabled = 1;
588                 }
589         }
590
591         /* Setting the min identification clock of freq 400KHz */
592         tegra_sdhci_set_clock(sdhci, 400000);
593
594         /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
595         if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
596                 sdhci_writeb(sdhci, SDHCI_RESET_ALL, SDHCI_SOFTWARE_RESET);
597
598                 /* Wait max 100 ms */
599                 timeout = 100;
600
601                 /* hw clears the bit when it's done */
602                 while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & SDHCI_RESET_ALL) {
603                         if (timeout == 0) {
604                                 printk(KERN_ERR "%s: Reset 0x%x never completed.\n",
605                                         mmc_hostname(sdhci->mmc), (int)SDHCI_RESET_ALL);
606                                 return -ETIMEDOUT;
607                         }
608                         timeout--;
609                         mdelay(1);
610                 }
611
612                 sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
613                 sdhci->pwr = 0;
614         }
615
616         return 0;
617 }
618
619 static struct sdhci_ops tegra_sdhci_ops = {
620         .get_ro     = tegra_sdhci_get_ro,
621         .read_l     = tegra_sdhci_readl,
622         .read_w     = tegra_sdhci_readw,
623         .write_l    = tegra_sdhci_writel,
624         .platform_8bit_width = tegra_sdhci_8bit,
625         .set_clock  = tegra_sdhci_set_clock,
626         .suspend    = tegra_sdhci_suspend,
627         .resume     = tegra_sdhci_resume,
628         .platform_reset_exit = tegra_sdhci_reset_exit,
629         .set_uhs_signaling = tegra_sdhci_set_uhs_signaling,
630         .switch_signal_voltage = tegra_sdhci_signal_voltage_switch,
631 };
632
633 static struct sdhci_pltfm_data sdhci_tegra_pdata = {
634         .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
635 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
636                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
637                   SDHCI_QUIRK_NON_STD_VOLTAGE_SWITCHING |
638 #endif
639 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
640                   SDHCI_QUIRK_NONSTANDARD_CLOCK |
641 #endif
642                   SDHCI_QUIRK_SINGLE_POWER_WRITE |
643                   SDHCI_QUIRK_NO_HISPD_BIT |
644                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC |
645                   SDHCI_QUIRK_NO_CALC_MAX_DISCARD_TO,
646         .ops  = &tegra_sdhci_ops,
647 };
648
649 static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
650 {
651         struct sdhci_pltfm_host *pltfm_host;
652         struct tegra_sdhci_platform_data *plat;
653         struct sdhci_host *host;
654         struct tegra_sdhci_host *tegra_host;
655         struct clk *clk;
656         int rc;
657
658         host = sdhci_pltfm_init(pdev, &sdhci_tegra_pdata);
659         if (IS_ERR(host))
660                 return PTR_ERR(host);
661
662         pltfm_host = sdhci_priv(host);
663
664         plat = pdev->dev.platform_data;
665
666         if (plat == NULL) {
667                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
668                 rc = -ENXIO;
669                 goto err_no_plat;
670         }
671
672         tegra_host = kzalloc(sizeof(struct tegra_sdhci_host), GFP_KERNEL);
673         if (tegra_host == NULL) {
674                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra host\n");
675                 rc = -ENOMEM;
676                 goto err_no_mem;
677         }
678
679 #ifdef CONFIG_MMC_EMBEDDED_SDIO
680         if (plat->mmc_data.embedded_sdio)
681                 mmc_set_embedded_sdio_data(host->mmc,
682                         &plat->mmc_data.embedded_sdio->cis,
683                         &plat->mmc_data.embedded_sdio->cccr,
684                         plat->mmc_data.embedded_sdio->funcs,
685                         plat->mmc_data.embedded_sdio->num_funcs);
686 #endif
687
688         if (gpio_is_valid(plat->power_gpio)) {
689                 rc = gpio_request(plat->power_gpio, "sdhci_power");
690                 if (rc) {
691                         dev_err(mmc_dev(host->mmc),
692                                 "failed to allocate power gpio\n");
693                         goto err_power_req;
694                 }
695                 tegra_gpio_enable(plat->power_gpio);
696                 gpio_direction_output(plat->power_gpio, 1);
697         }
698
699         if (gpio_is_valid(plat->cd_gpio)) {
700                 rc = gpio_request(plat->cd_gpio, "sdhci_cd");
701                 if (rc) {
702                         dev_err(mmc_dev(host->mmc),
703                                 "failed to allocate cd gpio\n");
704                         goto err_cd_req;
705                 }
706                 tegra_gpio_enable(plat->cd_gpio);
707                 gpio_direction_input(plat->cd_gpio);
708
709                 tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
710
711                 rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
712                                  carddetect_irq,
713                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
714                                  mmc_hostname(host->mmc), host);
715
716                 if (rc) {
717                         dev_err(mmc_dev(host->mmc), "request irq error\n");
718                         goto err_cd_irq_req;
719                 }
720                 rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
721                 if (rc < 0)
722                         dev_err(mmc_dev(host->mmc),
723                                 "SD card wake-up event registration"
724                                         "failed with eroor: %d\n", rc);
725
726         } else if (plat->mmc_data.register_status_notify) {
727                 plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
728         }
729
730         if (plat->mmc_data.status) {
731                 plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
732         }
733
734         if (gpio_is_valid(plat->wp_gpio)) {
735                 rc = gpio_request(plat->wp_gpio, "sdhci_wp");
736                 if (rc) {
737                         dev_err(mmc_dev(host->mmc),
738                                 "failed to allocate wp gpio\n");
739                         goto err_wp_req;
740                 }
741                 tegra_gpio_enable(plat->wp_gpio);
742                 gpio_direction_input(plat->wp_gpio);
743         }
744
745
746         if (!plat->mmc_data.built_in) {
747                 if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
748                         tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
749                         tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
750                 } else {
751                         /*
752                          * Set the minV and maxV to default
753                          * voltage range of 2.7V - 3.6V
754                          */
755                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
756                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
757                 }
758                 tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc), "vddio_sdmmc");
759                 if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
760                         dev_err(mmc_dev(host->mmc), "%s regulator not found: %ld\n",
761                                 "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
762                         tegra_host->vdd_io_reg = NULL;
763                 } else {
764                         rc = regulator_set_voltage(tegra_host->vdd_io_reg,
765                                 tegra_host->vddio_min_uv,
766                                 tegra_host->vddio_max_uv);
767                         if (rc) {
768                                 dev_err(mmc_dev(host->mmc), "%s regulator_set_voltage failed: %d",
769                                         "vddio_sdmmc", rc);
770                         }
771                 }
772
773                 tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc), "vddio_sd_slot");
774                 if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
775                         dev_err(mmc_dev(host->mmc), "%s regulator not found: %ld\n",
776                                 "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
777                         tegra_host->vdd_slot_reg = NULL;
778                 } else {
779                         if (tegra_host->card_present) {
780                                 if (tegra_host->vdd_slot_reg)
781                                         regulator_enable(tegra_host->vdd_slot_reg);
782                                 if (tegra_host->vdd_io_reg)
783                                         regulator_enable(tegra_host->vdd_io_reg);
784                                 tegra_host->is_rail_enabled = 1;
785                         }
786                 }
787         }
788
789         clk = clk_get(mmc_dev(host->mmc), NULL);
790         if (IS_ERR(clk)) {
791                 dev_err(mmc_dev(host->mmc), "clk err\n");
792                 rc = PTR_ERR(clk);
793                 goto err_clk_get;
794         }
795         rc = clk_enable(clk);
796         if (rc != 0)
797                 goto err_clk_put;
798         pltfm_host->clk = clk;
799         pltfm_host->priv = tegra_host;
800         tegra_host->clk_enabled = true;
801         tegra_host->max_clk_limit = plat->max_clk_limit;
802         tegra_host->instance = pdev->id;
803         tegra_host->dpd = tegra_io_dpd_get(mmc_dev(host->mmc));
804
805         host->mmc->pm_caps = plat->pm_flags;
806
807         host->mmc->caps |= MMC_CAP_ERASE;
808         host->mmc->caps |= MMC_CAP_DISABLE;
809         /* enable 1/8V DDR capable */
810         host->mmc->caps |= MMC_CAP_1_8V_DDR;
811         if (plat->is_8bit)
812                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
813         host->mmc->caps |= MMC_CAP_SDIO_IRQ;
814
815         host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
816         if (plat->mmc_data.built_in) {
817                 host->mmc->caps |= MMC_CAP_NONREMOVABLE;
818                 host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
819         }
820         /* Do not turn OFF embedded sdio cards as it support Wake on Wireless */
821         if (plat->mmc_data.embedded_sdio)
822                 host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
823
824         tegra_sdhost_min_freq = TEGRA_SDHOST_MIN_FREQ;
825 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
826         tegra_host->hw_ops = &tegra_2x_sdhci_ops;
827         tegra_sdhost_std_freq = TEGRA2_SDHOST_STD_FREQ;
828 #else
829         tegra_host->hw_ops = &tegra_3x_sdhci_ops;
830         tegra_sdhost_std_freq = TEGRA3_SDHOST_STD_FREQ;
831 #endif
832
833         rc = sdhci_add_host(host);
834         if (rc)
835                 goto err_add_host;
836
837         return 0;
838
839 err_add_host:
840         clk_disable(pltfm_host->clk);
841 err_clk_put:
842         clk_put(pltfm_host->clk);
843 err_clk_get:
844         if (gpio_is_valid(plat->wp_gpio)) {
845                 tegra_gpio_disable(plat->wp_gpio);
846                 gpio_free(plat->wp_gpio);
847         }
848 err_wp_req:
849         if (gpio_is_valid(plat->cd_gpio))
850                 free_irq(gpio_to_irq(plat->cd_gpio), host);
851 err_cd_irq_req:
852         if (gpio_is_valid(plat->cd_gpio)) {
853                 tegra_gpio_disable(plat->cd_gpio);
854                 gpio_free(plat->cd_gpio);
855         }
856 err_cd_req:
857         if (gpio_is_valid(plat->power_gpio)) {
858                 tegra_gpio_disable(plat->power_gpio);
859                 gpio_free(plat->power_gpio);
860         }
861 err_power_req:
862 err_no_mem:
863         kfree(tegra_host);
864 err_no_plat:
865         sdhci_pltfm_free(pdev);
866         return rc;
867 }
868
869 static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
870 {
871         struct sdhci_host *host = platform_get_drvdata(pdev);
872         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
873         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
874         struct tegra_sdhci_platform_data *plat;
875         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
876
877         sdhci_remove_host(host, dead);
878
879         plat = pdev->dev.platform_data;
880
881         disable_irq_wake(gpio_to_irq(plat->cd_gpio));
882
883         if (tegra_host->vdd_slot_reg) {
884                 regulator_disable(tegra_host->vdd_slot_reg);
885                 regulator_put(tegra_host->vdd_slot_reg);
886         }
887
888         if (tegra_host->vdd_io_reg) {
889                 regulator_disable(tegra_host->vdd_io_reg);
890                 regulator_put(tegra_host->vdd_io_reg);
891         }
892
893         if (gpio_is_valid(plat->wp_gpio)) {
894                 tegra_gpio_disable(plat->wp_gpio);
895                 gpio_free(plat->wp_gpio);
896         }
897
898         if (gpio_is_valid(plat->cd_gpio)) {
899                 free_irq(gpio_to_irq(plat->cd_gpio), host);
900                 tegra_gpio_disable(plat->cd_gpio);
901                 gpio_free(plat->cd_gpio);
902         }
903
904         if (gpio_is_valid(plat->power_gpio)) {
905                 tegra_gpio_disable(plat->power_gpio);
906                 gpio_free(plat->power_gpio);
907         }
908
909         if (tegra_host->clk_enabled)
910                 clk_disable(pltfm_host->clk);
911         clk_put(pltfm_host->clk);
912
913         sdhci_pltfm_free(pdev);
914         kfree(tegra_host);
915
916         return 0;
917 }
918
919 static struct platform_driver sdhci_tegra_driver = {
920         .driver         = {
921                 .name   = "sdhci-tegra",
922                 .owner  = THIS_MODULE,
923         },
924         .probe          = sdhci_tegra_probe,
925         .remove         = __devexit_p(sdhci_tegra_remove),
926 #ifdef CONFIG_PM
927         .suspend        = sdhci_pltfm_suspend,
928         .resume         = sdhci_pltfm_resume,
929 #endif
930 };
931
932 static int __init sdhci_tegra_init(void)
933 {
934         return platform_driver_register(&sdhci_tegra_driver);
935 }
936 module_init(sdhci_tegra_init);
937
938 static void __exit sdhci_tegra_exit(void)
939 {
940         platform_driver_unregister(&sdhci_tegra_driver);
941 }
942 module_exit(sdhci_tegra_exit);
943
944 MODULE_DESCRIPTION("SDHCI driver for Tegra");
945 MODULE_AUTHOR(" Google, Inc.");
946 MODULE_LICENSE("GPL v2");