Revert "mmc: tegra: enabling MMC_PM_KEEP_POWER flag for built_in devices"
[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/mmc/sd.h>
27 #include <linux/regulator/consumer.h>
28 #include <linux/delay.h>
29
30 #include <mach/gpio.h>
31 #include <mach/sdhci.h>
32 #include <mach/io_dpd.h>
33
34 #include "sdhci-pltfm.h"
35
36 #define SDHCI_VENDOR_CLOCK_CNTRL        0x100
37 #define SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK      0x1
38 #define SDHCI_VENDOR_CLOCK_CNTRL_PADPIPE_CLKEN_OVERRIDE 0x8
39 #define SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT    8
40 #define SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT        16
41 #define SDHCI_VENDOR_CLOCK_CNTRL_SDR50_TUNING           0x20
42
43 #define SDHCI_VENDOR_MISC_CNTRL         0x120
44 #define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR104_SUPPORT   0x8
45 #define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR50_SUPPORT    0x10
46 #define SDHCI_VENDOR_MISC_CNTRL_ENABLE_SD_3_0   0x20
47
48 #define SDMMC_SDMEMCOMPPADCTRL  0x1E0
49 #define SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK    0xF
50
51 #define SDMMC_AUTO_CAL_CONFIG   0x1E4
52 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE   0x20000000
53 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT  0x8
54 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET        0x70
55 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET        0x62
56
57 #define SDHOST_1V8_OCR_MASK     0x8
58 #define SDHOST_HIGH_VOLT_MIN    2700000
59 #define SDHOST_HIGH_VOLT_MAX    3600000
60 #define SDHOST_LOW_VOLT_MIN     1800000
61 #define SDHOST_LOW_VOLT_MAX     1800000
62
63 #define TEGRA_SDHOST_MIN_FREQ   50000000
64 #define TEGRA2_SDHOST_STD_FREQ  50000000
65 #define TEGRA3_SDHOST_STD_FREQ  104000000
66
67 #define SD_SEND_TUNING_PATTERN  19
68 #define MAX_TAP_VALUES  256
69
70 static unsigned int tegra_sdhost_min_freq;
71 static unsigned int tegra_sdhost_std_freq;
72 static void tegra_3x_sdhci_set_card_clock(struct sdhci_host *sdhci, unsigned int clock);
73 static void tegra3_sdhci_post_reset_init(struct sdhci_host *sdhci);
74
75 static unsigned int tegra3_sdhost_max_clk[4] = {
76         208000000,      104000000,      208000000,      104000000 };
77
78 struct tegra_sdhci_hw_ops{
79         /* Set the internal clk and card clk.*/
80         void    (*set_card_clock)(struct sdhci_host *sdhci, unsigned int clock);
81         /* Post reset vendor registers configuration */
82         void    (*sdhost_init)(struct sdhci_host *sdhci);
83 };
84
85 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
86 static struct tegra_sdhci_hw_ops tegra_2x_sdhci_ops = {
87 };
88 #endif
89
90 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
91 static struct tegra_sdhci_hw_ops tegra_3x_sdhci_ops = {
92         .set_card_clock = tegra_3x_sdhci_set_card_clock,
93         .sdhost_init = tegra3_sdhci_post_reset_init,
94 };
95 #endif
96
97 struct tegra_sdhci_host {
98         bool    clk_enabled;
99         struct regulator *vdd_io_reg;
100         struct regulator *vdd_slot_reg;
101         /* Pointer to the chip specific HW ops */
102         struct tegra_sdhci_hw_ops *hw_ops;
103         /* Host controller instance */
104         unsigned int instance;
105         /* vddio_min */
106         unsigned int vddio_min_uv;
107         /* vddio_max */
108         unsigned int vddio_max_uv;
109         /* max clk supported by the platform */
110         unsigned int max_clk_limit;
111         struct tegra_io_dpd *dpd;
112         bool card_present;
113         bool is_rail_enabled;
114 };
115
116 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
117 {
118         u32 val;
119
120         if (unlikely(reg == SDHCI_PRESENT_STATE)) {
121                 /* Use wp_gpio here instead? */
122                 val = readl(host->ioaddr + reg);
123                 return val | SDHCI_WRITE_PROTECT;
124         }
125
126         return readl(host->ioaddr + reg);
127 }
128
129 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
130 {
131 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
132         if (unlikely(reg == SDHCI_HOST_VERSION)) {
133                 /* Erratum: Version register is invalid in HW. */
134                 return SDHCI_SPEC_200;
135         }
136 #endif
137         return readw(host->ioaddr + reg);
138 }
139
140 static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
141 {
142         /* Seems like we're getting spurious timeout and crc errors, so
143          * disable signalling of them. In case of real errors software
144          * timers should take care of eventually detecting them.
145          */
146         if (unlikely(reg == SDHCI_SIGNAL_ENABLE))
147                 val &= ~(SDHCI_INT_TIMEOUT|SDHCI_INT_CRC);
148
149         writel(val, host->ioaddr + reg);
150
151 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
152         if (unlikely(reg == SDHCI_INT_ENABLE)) {
153                 /* Erratum: Must enable block gap interrupt detection */
154                 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
155                 if (val & SDHCI_INT_CARD_INT)
156                         gap_ctrl |= 0x8;
157                 else
158                         gap_ctrl &= ~0x8;
159                 writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
160         }
161 #endif
162 }
163
164 static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
165 {
166         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
167         struct tegra_sdhci_platform_data *plat;
168
169         plat = pdev->dev.platform_data;
170
171         if (!gpio_is_valid(plat->wp_gpio))
172                 return -1;
173
174         return gpio_get_value(plat->wp_gpio);
175 }
176
177 static void tegra3_sdhci_post_reset_init(struct sdhci_host *sdhci)
178 {
179         u16 misc_ctrl;
180         u32 vendor_ctrl;
181         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
182         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
183         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
184         struct tegra_sdhci_platform_data *plat;
185
186         plat = pdev->dev.platform_data;
187         /* Set the base clock frequency */
188         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
189         vendor_ctrl &= ~(0xFF << SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT);
190         vendor_ctrl |= (tegra3_sdhost_max_clk[tegra_host->instance] / 1000000) <<
191                 SDHCI_VENDOR_CLOCK_CNTRL_BASE_CLK_FREQ_SHIFT;
192         vendor_ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_PADPIPE_CLKEN_OVERRIDE;
193         /* Set tap delay */
194         if (plat->tap_delay) {
195                 vendor_ctrl &= ~(0xFF <<
196                         SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
197                 vendor_ctrl |= (plat->tap_delay <<
198                         SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
199         }
200         /* Enable frequency tuning for SDR50 mode */
201         vendor_ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_SDR50_TUNING;
202         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
203
204         /* Enable SDHOST v3.0 support */
205         misc_ctrl = sdhci_readw(sdhci, SDHCI_VENDOR_MISC_CNTRL);
206         misc_ctrl |= SDHCI_VENDOR_MISC_CNTRL_ENABLE_SD_3_0 |
207                 SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR104_SUPPORT |
208                 SDHCI_VENDOR_MISC_CNTRL_ENABLE_SDR50_SUPPORT;
209         sdhci_writew(sdhci, misc_ctrl, SDHCI_VENDOR_MISC_CNTRL);
210 }
211
212 static int tegra_sdhci_set_uhs_signaling(struct sdhci_host *host,
213                 unsigned int uhs)
214 {
215         u16 clk, ctrl_2;
216         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
217
218         /* Select Bus Speed Mode for host */
219         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
220         switch (uhs) {
221         case MMC_TIMING_UHS_SDR12:
222                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
223                 break;
224         case MMC_TIMING_UHS_SDR25:
225                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
226                 break;
227         case MMC_TIMING_UHS_SDR50:
228                 ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
229                 break;
230         case MMC_TIMING_UHS_SDR104:
231                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
232                 break;
233         case MMC_TIMING_UHS_DDR50:
234                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
235                 break;
236         }
237
238         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
239
240         if (uhs == MMC_TIMING_UHS_DDR50) {
241                 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
242                 clk &= ~(0xFF << SDHCI_DIVIDER_SHIFT);
243                 clk |= 1 << SDHCI_DIVIDER_SHIFT;
244                 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
245         }
246         return 0;
247 }
248
249 static void tegra_sdhci_reset_exit(struct sdhci_host *sdhci, u8 mask)
250 {
251         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
252         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
253
254         if (mask & SDHCI_RESET_ALL) {
255                 if (tegra_host->hw_ops->sdhost_init)
256                         tegra_host->hw_ops->sdhost_init(sdhci);
257         }
258 }
259
260 static void sdhci_status_notify_cb(int card_present, void *dev_id)
261 {
262         struct sdhci_host *sdhci = (struct sdhci_host *)dev_id;
263         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
264         struct tegra_sdhci_platform_data *plat;
265         unsigned int status, oldstat;
266
267         pr_debug("%s: card_present %d\n", mmc_hostname(sdhci->mmc),
268                 card_present);
269
270         plat = pdev->dev.platform_data;
271         if (!plat->mmc_data.status) {
272                 mmc_detect_change(sdhci->mmc, 0);
273                 return;
274         }
275
276         status = plat->mmc_data.status(mmc_dev(sdhci->mmc));
277
278         oldstat = plat->mmc_data.card_present;
279         plat->mmc_data.card_present = status;
280         if (status ^ oldstat) {
281                 pr_debug("%s: Slot status change detected (%d -> %d)\n",
282                         mmc_hostname(sdhci->mmc), oldstat, status);
283                 if (status && !plat->mmc_data.built_in)
284                         mmc_detect_change(sdhci->mmc, (5 * HZ) / 2);
285                 else
286                         mmc_detect_change(sdhci->mmc, 0);
287         }
288 }
289
290 static irqreturn_t carddetect_irq(int irq, void *data)
291 {
292         struct sdhci_host *sdhost = (struct sdhci_host *)data;
293         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhost);
294         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
295         struct platform_device *pdev = to_platform_device(mmc_dev(sdhost->mmc));
296         struct tegra_sdhci_platform_data *plat;
297
298         plat = pdev->dev.platform_data;
299
300         tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
301
302         if (tegra_host->card_present) {
303                 if (!tegra_host->is_rail_enabled) {
304                         if (tegra_host->vdd_slot_reg)
305                                 regulator_enable(tegra_host->vdd_slot_reg);
306                         if (tegra_host->vdd_io_reg)
307                                 regulator_enable(tegra_host->vdd_io_reg);
308                         tegra_host->is_rail_enabled = 1;
309                 }
310         } else {
311                 if (tegra_host->is_rail_enabled) {
312                         if (tegra_host->vdd_io_reg)
313                                 regulator_disable(tegra_host->vdd_io_reg);
314                         if (tegra_host->vdd_slot_reg)
315                                 regulator_disable(tegra_host->vdd_slot_reg);
316                         tegra_host->is_rail_enabled = 0;
317                 }
318         }
319
320         tasklet_schedule(&sdhost->card_tasklet);
321         return IRQ_HANDLED;
322 };
323
324 static int tegra_sdhci_8bit(struct sdhci_host *host, int bus_width)
325 {
326         struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));
327         struct tegra_sdhci_platform_data *plat;
328         u32 ctrl;
329
330         plat = pdev->dev.platform_data;
331
332         ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
333         if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
334                 ctrl &= ~SDHCI_CTRL_4BITBUS;
335                 ctrl |= SDHCI_CTRL_8BITBUS;
336         } else {
337                 ctrl &= ~SDHCI_CTRL_8BITBUS;
338                 if (bus_width == MMC_BUS_WIDTH_4)
339                         ctrl |= SDHCI_CTRL_4BITBUS;
340                 else
341                         ctrl &= ~SDHCI_CTRL_4BITBUS;
342         }
343         sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
344         return 0;
345 }
346
347 static void tegra_sdhci_set_clk_rate(struct sdhci_host *sdhci,
348         unsigned int clock)
349 {
350         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
351         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
352         unsigned int clk_rate;
353
354         if (sdhci->mmc->card &&
355                 mmc_card_ddr_mode(sdhci->mmc->card)) {
356                 /*
357                  * In ddr mode, tegra sdmmc controller clock frequency
358                  * should be double the card clock frequency.
359                  */
360                  clk_rate = clock * 2;
361         } else {
362                 if (clock <= tegra_sdhost_min_freq)
363                         clk_rate = tegra_sdhost_min_freq;
364                 else if (clock <= tegra_sdhost_std_freq)
365                         clk_rate = tegra_sdhost_std_freq;
366                 else
367                         clk_rate = clock;
368
369                 /*
370                  * In SDR50 mode, run the sdmmc controller at 208MHz to ensure
371                  * the core voltage is at 1.2V. If the core voltage is below 1.2V, CRC
372                  * errors would occur during data transfers.
373                  */
374                 if ((sdhci->mmc->ios.timing == MMC_TIMING_UHS_SDR50) &&
375                         (clk_rate == tegra_sdhost_std_freq))
376                         clk_rate <<= 1;
377         }
378
379         if (tegra_host->max_clk_limit &&
380                 (clk_rate > tegra_host->max_clk_limit))
381                 clk_rate = tegra_host->max_clk_limit;
382
383         clk_set_rate(pltfm_host->clk, clk_rate);
384         sdhci->max_clk = clk_get_rate(pltfm_host->clk);
385 }
386
387 static void tegra_3x_sdhci_set_card_clock(struct sdhci_host *sdhci, unsigned int clock)
388 {
389         int div;
390         u16 clk;
391         unsigned long timeout;
392         u8 ctrl;
393
394         if (clock && clock == sdhci->clock)
395                 return;
396
397         sdhci_writew(sdhci, 0, SDHCI_CLOCK_CONTROL);
398
399         if (clock == 0)
400                 goto out;
401         if (sdhci->mmc->ios.timing == MMC_TIMING_UHS_DDR50) {
402                 div = 1;
403                 goto set_clk;
404         }
405
406         if (sdhci->version >= SDHCI_SPEC_300) {
407                 /* Version 3.00 divisors must be a multiple of 2. */
408                 if (sdhci->max_clk <= clock) {
409                         div = 1;
410                 } else {
411                         for (div = 2; div < SDHCI_MAX_DIV_SPEC_300; div += 2) {
412                                 if ((sdhci->max_clk / div) <= clock)
413                                         break;
414                         }
415                 }
416         } else {
417                 /* Version 2.00 divisors must be a power of 2. */
418                 for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
419                         if ((sdhci->max_clk / div) <= clock)
420                                 break;
421                 }
422         }
423         div >>= 1;
424
425         /*
426          * Tegra3 sdmmc controller internal clock will not be stabilized when
427          * we use a clock divider value greater than 4. The WAR is as follows.
428          * - Enable internal clock.
429          * - Wait for 5 usec and do a dummy write.
430          * - Poll for clk stable.
431          */
432 set_clk:
433         clk = (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
434         clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
435                 << SDHCI_DIVIDER_HI_SHIFT;
436         clk |= SDHCI_CLOCK_INT_EN;
437         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
438
439         /* Wait for 5 usec */
440         udelay(5);
441
442         /* Do a dummy write */
443         ctrl = sdhci_readb(sdhci, SDHCI_CAPABILITIES);
444         ctrl |= 1;
445         sdhci_writeb(sdhci, ctrl, SDHCI_CAPABILITIES);
446
447         /* Wait max 20 ms */
448         timeout = 20;
449         while (!((clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL))
450                 & SDHCI_CLOCK_INT_STABLE)) {
451                 if (timeout == 0) {
452                         dev_err(mmc_dev(sdhci->mmc), "Internal clock never stabilised\n");
453                         return;
454                 }
455                 timeout--;
456                 mdelay(1);
457         }
458
459         clk |= SDHCI_CLOCK_CARD_EN;
460         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
461 out:
462         sdhci->clock = clock;
463 }
464
465 static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
466 {
467         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
468         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
469         u8 ctrl;
470
471         pr_debug("%s %s %u enabled=%u\n", __func__,
472                 mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
473
474         if (clock) {
475                 /* bring out sd instance from io dpd mode */
476                 tegra_io_dpd_disable(tegra_host->dpd);
477
478                 if (!tegra_host->clk_enabled) {
479                         clk_enable(pltfm_host->clk);
480                         ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
481                         ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
482                         sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
483                         tegra_host->clk_enabled = true;
484                 }
485                 tegra_sdhci_set_clk_rate(sdhci, clock);
486                 if (tegra_host->hw_ops->set_card_clock)
487                         tegra_host->hw_ops->set_card_clock(sdhci, clock);
488         } else if (!clock && tegra_host->clk_enabled) {
489                 if (tegra_host->hw_ops->set_card_clock)
490                         tegra_host->hw_ops->set_card_clock(sdhci, clock);
491                 ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
492                 ctrl &= ~SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
493                 sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
494                 clk_disable(pltfm_host->clk);
495                 tegra_host->clk_enabled = false;
496                 /* io dpd enable call for sd instance */
497                 tegra_io_dpd_enable(tegra_host->dpd);
498         }
499 }
500
501 static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
502         unsigned int signal_voltage)
503 {
504         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
505         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
506         unsigned int min_uV = SDHOST_HIGH_VOLT_MIN;
507         unsigned int max_uV = SDHOST_HIGH_VOLT_MAX;
508         unsigned int rc = 0;
509         u16 clk, ctrl;
510         unsigned int val;
511
512         /* Switch OFF the card clock to prevent glitches on the clock line */
513         clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL);
514         clk &= ~SDHCI_CLOCK_CARD_EN;
515         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
516
517         ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
518         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
519                 ctrl |= SDHCI_CTRL_VDD_180;
520                 min_uV = SDHOST_LOW_VOLT_MIN;
521                 max_uV = SDHOST_LOW_VOLT_MAX;
522         } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
523                 if (ctrl & SDHCI_CTRL_VDD_180)
524                         ctrl &= ~SDHCI_CTRL_VDD_180;
525         }
526         sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
527
528         /* Switch the I/O rail voltage */
529         if (tegra_host->vdd_io_reg) {
530                 rc = regulator_set_voltage(tegra_host->vdd_io_reg,
531                         min_uV, max_uV);
532                 if (rc) {
533                         dev_err(mmc_dev(sdhci->mmc), "switching to 1.8V"
534                         "failed . Switching back to 3.3V\n");
535                         regulator_set_voltage(tegra_host->vdd_io_reg,
536                                 SDHOST_HIGH_VOLT_MIN,
537                                 SDHOST_HIGH_VOLT_MAX);
538                         goto out;
539                 }
540         }
541
542         /* Wait for 10 msec for the voltage to be switched */
543         mdelay(10);
544
545         /* Enable the card clock */
546         clk |= SDHCI_CLOCK_CARD_EN;
547         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
548
549         /* Wait for 1 msec after enabling clock */
550         mdelay(1);
551
552         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
553                 /* Do Auto Calibration for 1.8V signal voltage */
554                 val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
555                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
556                 /* Program Auto cal PD offset(bits 8:14) */
557                 val &= ~(0x7F <<
558                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
559                 val |= (SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET <<
560                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
561                 /* Program Auto cal PU offset(bits 0:6) */
562                 val &= ~0x7F;
563                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET;
564                 sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
565
566                 val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
567                 val &= ~SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK;
568                 val |= 0x7;
569                 sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
570         }
571
572         return rc;
573 out:
574         /* Enable the card clock */
575         clk |= SDHCI_CLOCK_CARD_EN;
576         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
577
578         /* Wait for 1 msec for the clock to stabilize */
579         mdelay(1);
580
581         return rc;
582 }
583
584 static void tegra_sdhci_reset(struct sdhci_host *sdhci, u8 mask)
585 {
586         unsigned long timeout;
587
588         sdhci_writeb(sdhci, mask, SDHCI_SOFTWARE_RESET);
589
590         /* Wait max 100 ms */
591         timeout = 100;
592
593         /* hw clears the bit when it's done */
594         while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & mask) {
595                 if (timeout == 0) {
596                         dev_err(mmc_dev(sdhci->mmc), "Reset 0x%x never"
597                                 "completed.\n", (int)mask);
598                         return;
599                 }
600                 timeout--;
601                 mdelay(1);
602         }
603 }
604
605 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
606         unsigned int tap_delay)
607 {
608         u32 vendor_ctrl;
609
610         /* Max tap delay value is 255 */
611         BUG_ON(tap_delay > MAX_TAP_VALUES);
612
613         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
614         vendor_ctrl &= ~(0xFF << SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
615         vendor_ctrl |= (tap_delay << SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
616         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
617 }
618
619 static void sdhci_tegra_clear_set_irqs(struct sdhci_host *host,
620         u32 clear, u32 set)
621 {
622         u32 ier;
623
624         ier = sdhci_readl(host, SDHCI_INT_ENABLE);
625         ier &= ~clear;
626         ier |= set;
627         sdhci_writel(host, ier, SDHCI_INT_ENABLE);
628         sdhci_writel(host, ier, SDHCI_SIGNAL_ENABLE);
629 }
630
631 static int sdhci_tegra_run_frequency_tuning(struct sdhci_host *sdhci)
632 {
633         int err = 0;
634         u8 ctrl;
635         u32 ier;
636         u32 mask;
637         unsigned int timeout = 10;
638         int flags;
639         u32 intstatus;
640
641         /*
642          * As per the Host Controller spec v3.00, tuning command
643          * generates Buffer Read Ready interrupt only, so enable that.
644          */
645         ier = sdhci_readl(sdhci, SDHCI_INT_ENABLE);
646         sdhci_tegra_clear_set_irqs(sdhci, ier, SDHCI_INT_DATA_AVAIL |
647                 SDHCI_INT_DATA_CRC);
648
649         mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
650         while (sdhci_readl(sdhci, SDHCI_PRESENT_STATE) & mask) {
651                 if (timeout == 0) {
652                         dev_err(mmc_dev(sdhci->mmc), "Controller never"
653                                 "released inhibit bit(s).\n");
654                         err = -ETIMEDOUT;
655                         goto out;
656                 }
657                 timeout--;
658                 mdelay(1);
659         }
660
661         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
662         ctrl &= ~SDHCI_CTRL_TUNED_CLK;
663         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
664
665         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
666         ctrl |= SDHCI_CTRL_EXEC_TUNING;
667         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
668
669         /*
670          * In response to CMD19, the card sends 64 bytes of tuning
671          * block to the Host Controller. So we set the block size
672          * to 64 here.
673          */
674         sdhci_writew(sdhci, SDHCI_MAKE_BLKSZ(7, 64), SDHCI_BLOCK_SIZE);
675
676         sdhci_writeb(sdhci, 0xE, SDHCI_TIMEOUT_CONTROL);
677
678         sdhci_writeb(sdhci, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
679
680         sdhci_writel(sdhci, 0x0, SDHCI_ARGUMENT);
681
682         /* Set the cmd flags */
683         flags = SDHCI_CMD_RESP_SHORT | SDHCI_CMD_CRC | SDHCI_CMD_DATA;
684         /* Issue the command */
685         sdhci_writew(sdhci, SDHCI_MAKE_CMD(
686                 SD_SEND_TUNING_PATTERN, flags), SDHCI_COMMAND);
687
688         timeout = 5;
689         do {
690                 timeout--;
691                 mdelay(1);
692                 intstatus = sdhci_readl(sdhci, SDHCI_INT_STATUS);
693                 if (intstatus) {
694                         sdhci_writel(sdhci, intstatus, SDHCI_INT_STATUS);
695                         break;
696                 }
697         } while(timeout);
698
699         if ((intstatus & SDHCI_INT_DATA_AVAIL) &&
700                 !(intstatus & SDHCI_INT_DATA_CRC)) {
701                 err = 0;
702                 sdhci->tuning_done = 1;
703         } else {
704                 tegra_sdhci_reset(sdhci, SDHCI_RESET_CMD);
705                 tegra_sdhci_reset(sdhci, SDHCI_RESET_DATA);
706                 err = -EIO;
707         }
708
709         if (sdhci->tuning_done) {
710                 sdhci->tuning_done = 0;
711                 ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
712                 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING) &&
713                         (ctrl & SDHCI_CTRL_TUNED_CLK))
714                         err = 0;
715                 else
716                         err = -EIO;
717         }
718         mdelay(1);
719 out:
720         sdhci_tegra_clear_set_irqs(sdhci, SDHCI_INT_DATA_AVAIL, ier);
721         return err;
722 }
723
724 static int sdhci_tegra_execute_tuning(struct sdhci_host *sdhci)
725 {
726         int err;
727         u16 ctrl_2;
728         u8 *tap_delay_status;
729         unsigned int i = 0;
730         unsigned int temp_low_pass_tap = 0;
731         unsigned int temp_pass_window = 0;
732         unsigned int best_low_pass_tap = 0;
733         unsigned int best_pass_window = 0;
734
735         /* Tuning is valid only in SDR104 and SDR50 modes */
736         ctrl_2 = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
737         if (!(((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
738                 (((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
739                 (sdhci->flags & SDHCI_SDR50_NEEDS_TUNING))))
740                         return 0;
741
742         tap_delay_status = kzalloc(MAX_TAP_VALUES, GFP_KERNEL);
743         if (tap_delay_status == NULL) {
744                 dev_err(mmc_dev(sdhci->mmc), "failed to allocate memory"
745                         "for storing tap_delay_status\n");
746                 err = -ENOMEM;
747                 goto out;
748         }
749
750         /*
751          * Set each tap delay value and run frequency tuning. After each
752          * run, update the tap delay status as working or not working.
753          */
754         do {
755                 /* Set the tap delay */
756                 sdhci_tegra_set_tap_delay(sdhci, i);
757
758                 /* Run frequency tuning */
759                 err = sdhci_tegra_run_frequency_tuning(sdhci);
760
761                 /* Update whether the tap delay worked or not */
762                 tap_delay_status[i] = (err) ? 0: 1;
763                 i++;
764         } while (i < 0xFF);
765
766         /* Find the best possible tap range */
767         for (i = 0; i < 0xFF; i++) {
768                 temp_pass_window = 0;
769
770                 /* Find the first passing tap in the current window */
771                 if (tap_delay_status[i]) {
772                         temp_low_pass_tap = i;
773
774                         /* Find the pass window */
775                         do {
776                                 temp_pass_window++;
777                                 i++;
778                                 if (i > 0xFF)
779                                         break;
780                         } while (tap_delay_status[i]);
781
782                         if ((temp_pass_window > best_pass_window) && (temp_pass_window > 1)){
783                                 best_low_pass_tap = temp_low_pass_tap;
784                                 best_pass_window = temp_pass_window;
785                         }
786                 }
787         }
788
789
790         pr_debug("%s: best pass tap window: start %d, end %d\n",
791                 mmc_hostname(sdhci->mmc), best_low_pass_tap,
792                 (best_low_pass_tap + best_pass_window));
793
794         /* Set the best tap */
795         sdhci_tegra_set_tap_delay(sdhci,
796                 (best_low_pass_tap + ((best_pass_window * 3) / 4)));
797
798         /* Run frequency tuning */
799         err = sdhci_tegra_run_frequency_tuning(sdhci);
800
801 out:
802         if (tap_delay_status)
803                 kfree(tap_delay_status);
804
805         return err;
806 }
807
808 static int tegra_sdhci_suspend(struct sdhci_host *sdhci, pm_message_t state)
809 {
810         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
811         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
812
813         tegra_sdhci_set_clock(sdhci, 0);
814
815         /* Disable the power rails if any */
816         if (tegra_host->card_present) {
817                 if (tegra_host->is_rail_enabled) {
818                         if (tegra_host->vdd_io_reg)
819                                 regulator_disable(tegra_host->vdd_io_reg);
820                         if (tegra_host->vdd_slot_reg)
821                                 regulator_disable(tegra_host->vdd_slot_reg);
822                         tegra_host->is_rail_enabled = 0;
823                 }
824         }
825
826         return 0;
827 }
828
829 static int tegra_sdhci_resume(struct sdhci_host *sdhci)
830 {
831         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
832         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
833
834         /* Enable the power rails if any */
835         if (tegra_host->card_present) {
836                 if (!tegra_host->is_rail_enabled) {
837                         if (tegra_host->vdd_slot_reg)
838                                 regulator_enable(tegra_host->vdd_slot_reg);
839                         if (tegra_host->vdd_io_reg) {
840                                 regulator_enable(tegra_host->vdd_io_reg);
841                                 tegra_sdhci_signal_voltage_switch(sdhci, MMC_SIGNAL_VOLTAGE_330);
842                         }
843                         tegra_host->is_rail_enabled = 1;
844                 }
845         }
846         /* Setting the min identification clock of freq 400KHz */
847         tegra_sdhci_set_clock(sdhci, 400000);
848
849         /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
850         if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
851                 tegra_sdhci_reset(sdhci, SDHCI_RESET_ALL);
852                 sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
853                 sdhci->pwr = 0;
854         }
855
856         return 0;
857 }
858
859 static struct sdhci_ops tegra_sdhci_ops = {
860         .get_ro     = tegra_sdhci_get_ro,
861         .read_l     = tegra_sdhci_readl,
862         .read_w     = tegra_sdhci_readw,
863         .write_l    = tegra_sdhci_writel,
864         .platform_8bit_width = tegra_sdhci_8bit,
865         .set_clock  = tegra_sdhci_set_clock,
866         .suspend    = tegra_sdhci_suspend,
867         .resume     = tegra_sdhci_resume,
868         .platform_reset_exit = tegra_sdhci_reset_exit,
869         .set_uhs_signaling = tegra_sdhci_set_uhs_signaling,
870         .switch_signal_voltage = tegra_sdhci_signal_voltage_switch,
871         .execute_freq_tuning = sdhci_tegra_execute_tuning,
872 };
873
874 static struct sdhci_pltfm_data sdhci_tegra_pdata = {
875         .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
876 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
877                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
878                   SDHCI_QUIRK_NON_STD_VOLTAGE_SWITCHING |
879 #endif
880 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
881                   SDHCI_QUIRK_NONSTANDARD_CLOCK |
882                   SDHCI_QUIRK_NON_STANDARD_TUNING |
883 #endif
884                   SDHCI_QUIRK_SINGLE_POWER_WRITE |
885                   SDHCI_QUIRK_NO_HISPD_BIT |
886                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC |
887                   SDHCI_QUIRK_NO_CALC_MAX_DISCARD_TO,
888         .ops  = &tegra_sdhci_ops,
889 };
890
891 static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
892 {
893         struct sdhci_pltfm_host *pltfm_host;
894         struct tegra_sdhci_platform_data *plat;
895         struct sdhci_host *host;
896         struct tegra_sdhci_host *tegra_host;
897         struct clk *clk;
898         int rc;
899
900         host = sdhci_pltfm_init(pdev, &sdhci_tegra_pdata);
901         if (IS_ERR(host))
902                 return PTR_ERR(host);
903
904         pltfm_host = sdhci_priv(host);
905
906         plat = pdev->dev.platform_data;
907
908         if (plat == NULL) {
909                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
910                 rc = -ENXIO;
911                 goto err_no_plat;
912         }
913
914         tegra_host = kzalloc(sizeof(struct tegra_sdhci_host), GFP_KERNEL);
915         if (tegra_host == NULL) {
916                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra host\n");
917                 rc = -ENOMEM;
918                 goto err_no_mem;
919         }
920
921 #ifdef CONFIG_MMC_EMBEDDED_SDIO
922         if (plat->mmc_data.embedded_sdio)
923                 mmc_set_embedded_sdio_data(host->mmc,
924                         &plat->mmc_data.embedded_sdio->cis,
925                         &plat->mmc_data.embedded_sdio->cccr,
926                         plat->mmc_data.embedded_sdio->funcs,
927                         plat->mmc_data.embedded_sdio->num_funcs);
928 #endif
929
930         if (gpio_is_valid(plat->power_gpio)) {
931                 rc = gpio_request(plat->power_gpio, "sdhci_power");
932                 if (rc) {
933                         dev_err(mmc_dev(host->mmc),
934                                 "failed to allocate power gpio\n");
935                         goto err_power_req;
936                 }
937                 tegra_gpio_enable(plat->power_gpio);
938                 gpio_direction_output(plat->power_gpio, 1);
939         }
940
941         if (gpio_is_valid(plat->cd_gpio)) {
942                 rc = gpio_request(plat->cd_gpio, "sdhci_cd");
943                 if (rc) {
944                         dev_err(mmc_dev(host->mmc),
945                                 "failed to allocate cd gpio\n");
946                         goto err_cd_req;
947                 }
948                 tegra_gpio_enable(plat->cd_gpio);
949                 gpio_direction_input(plat->cd_gpio);
950
951                 tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
952
953                 rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
954                                  carddetect_irq,
955                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
956                                  mmc_hostname(host->mmc), host);
957
958                 if (rc) {
959                         dev_err(mmc_dev(host->mmc), "request irq error\n");
960                         goto err_cd_irq_req;
961                 }
962                 rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
963                 if (rc < 0)
964                         dev_err(mmc_dev(host->mmc),
965                                 "SD card wake-up event registration"
966                                         "failed with eroor: %d\n", rc);
967
968         } else if (plat->mmc_data.register_status_notify) {
969                 plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
970         }
971
972         if (plat->mmc_data.status) {
973                 plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
974         }
975
976         if (gpio_is_valid(plat->wp_gpio)) {
977                 rc = gpio_request(plat->wp_gpio, "sdhci_wp");
978                 if (rc) {
979                         dev_err(mmc_dev(host->mmc),
980                                 "failed to allocate wp gpio\n");
981                         goto err_wp_req;
982                 }
983                 tegra_gpio_enable(plat->wp_gpio);
984                 gpio_direction_input(plat->wp_gpio);
985         }
986
987
988         if (!plat->mmc_data.built_in) {
989                 if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
990                         tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
991                         tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
992                 } else {
993                         /*
994                          * Set the minV and maxV to default
995                          * voltage range of 2.7V - 3.6V
996                          */
997                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
998                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
999                 }
1000                 tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc), "vddio_sdmmc");
1001                 if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
1002                         dev_err(mmc_dev(host->mmc), "%s regulator not found: %ld\n",
1003                                 "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
1004                         tegra_host->vdd_io_reg = NULL;
1005                 } else {
1006                         rc = regulator_set_voltage(tegra_host->vdd_io_reg,
1007                                 tegra_host->vddio_min_uv,
1008                                 tegra_host->vddio_max_uv);
1009                         if (rc) {
1010                                 dev_err(mmc_dev(host->mmc), "%s regulator_set_voltage failed: %d",
1011                                         "vddio_sdmmc", rc);
1012                         }
1013                 }
1014
1015                 tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc), "vddio_sd_slot");
1016                 if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
1017                         dev_err(mmc_dev(host->mmc), "%s regulator not found: %ld\n",
1018                                 "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
1019                         tegra_host->vdd_slot_reg = NULL;
1020                 }
1021
1022                 if (tegra_host->card_present) {
1023                         if (tegra_host->vdd_slot_reg)
1024                                 regulator_enable(tegra_host->vdd_slot_reg);
1025                         if (tegra_host->vdd_io_reg)
1026                                 regulator_enable(tegra_host->vdd_io_reg);
1027                         tegra_host->is_rail_enabled = 1;
1028                 }
1029         }
1030
1031         clk = clk_get(mmc_dev(host->mmc), NULL);
1032         if (IS_ERR(clk)) {
1033                 dev_err(mmc_dev(host->mmc), "clk err\n");
1034                 rc = PTR_ERR(clk);
1035                 goto err_clk_get;
1036         }
1037         rc = clk_enable(clk);
1038         if (rc != 0)
1039                 goto err_clk_put;
1040         pltfm_host->clk = clk;
1041         pltfm_host->priv = tegra_host;
1042         tegra_host->clk_enabled = true;
1043         tegra_host->max_clk_limit = plat->max_clk_limit;
1044         tegra_host->instance = pdev->id;
1045         tegra_host->dpd = tegra_io_dpd_get(mmc_dev(host->mmc));
1046
1047         host->mmc->pm_caps = plat->pm_flags;
1048
1049         host->mmc->caps |= MMC_CAP_ERASE;
1050         host->mmc->caps |= MMC_CAP_DISABLE;
1051         /* enable 1/8V DDR capable */
1052         host->mmc->caps |= MMC_CAP_1_8V_DDR;
1053         if (plat->is_8bit)
1054                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
1055         host->mmc->caps |= MMC_CAP_SDIO_IRQ;
1056
1057         host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
1058         if (plat->mmc_data.built_in) {
1059                 host->mmc->caps |= MMC_CAP_NONREMOVABLE;
1060                 host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
1061         }
1062         /* Do not turn OFF embedded sdio cards as it support Wake on Wireless */
1063         if (plat->mmc_data.embedded_sdio)
1064                 host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
1065
1066         tegra_sdhost_min_freq = TEGRA_SDHOST_MIN_FREQ;
1067 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
1068         tegra_host->hw_ops = &tegra_2x_sdhci_ops;
1069         tegra_sdhost_std_freq = TEGRA2_SDHOST_STD_FREQ;
1070 #else
1071         tegra_host->hw_ops = &tegra_3x_sdhci_ops;
1072         tegra_sdhost_std_freq = TEGRA3_SDHOST_STD_FREQ;
1073 #endif
1074
1075         rc = sdhci_add_host(host);
1076         if (rc)
1077                 goto err_add_host;
1078
1079         return 0;
1080
1081 err_add_host:
1082         clk_disable(pltfm_host->clk);
1083 err_clk_put:
1084         clk_put(pltfm_host->clk);
1085 err_clk_get:
1086         if (gpio_is_valid(plat->wp_gpio)) {
1087                 tegra_gpio_disable(plat->wp_gpio);
1088                 gpio_free(plat->wp_gpio);
1089         }
1090 err_wp_req:
1091         if (gpio_is_valid(plat->cd_gpio))
1092                 free_irq(gpio_to_irq(plat->cd_gpio), host);
1093 err_cd_irq_req:
1094         if (gpio_is_valid(plat->cd_gpio)) {
1095                 tegra_gpio_disable(plat->cd_gpio);
1096                 gpio_free(plat->cd_gpio);
1097         }
1098 err_cd_req:
1099         if (gpio_is_valid(plat->power_gpio)) {
1100                 tegra_gpio_disable(plat->power_gpio);
1101                 gpio_free(plat->power_gpio);
1102         }
1103 err_power_req:
1104 err_no_mem:
1105         kfree(tegra_host);
1106 err_no_plat:
1107         sdhci_pltfm_free(pdev);
1108         return rc;
1109 }
1110
1111 static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
1112 {
1113         struct sdhci_host *host = platform_get_drvdata(pdev);
1114         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1115         struct tegra_sdhci_host *tegra_host = pltfm_host->priv;
1116         struct tegra_sdhci_platform_data *plat;
1117         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
1118
1119         sdhci_remove_host(host, dead);
1120
1121         plat = pdev->dev.platform_data;
1122
1123         disable_irq_wake(gpio_to_irq(plat->cd_gpio));
1124
1125         if (tegra_host->vdd_slot_reg) {
1126                 regulator_disable(tegra_host->vdd_slot_reg);
1127                 regulator_put(tegra_host->vdd_slot_reg);
1128         }
1129
1130         if (tegra_host->vdd_io_reg) {
1131                 regulator_disable(tegra_host->vdd_io_reg);
1132                 regulator_put(tegra_host->vdd_io_reg);
1133         }
1134
1135         if (gpio_is_valid(plat->wp_gpio)) {
1136                 tegra_gpio_disable(plat->wp_gpio);
1137                 gpio_free(plat->wp_gpio);
1138         }
1139
1140         if (gpio_is_valid(plat->cd_gpio)) {
1141                 free_irq(gpio_to_irq(plat->cd_gpio), host);
1142                 tegra_gpio_disable(plat->cd_gpio);
1143                 gpio_free(plat->cd_gpio);
1144         }
1145
1146         if (gpio_is_valid(plat->power_gpio)) {
1147                 tegra_gpio_disable(plat->power_gpio);
1148                 gpio_free(plat->power_gpio);
1149         }
1150
1151         if (tegra_host->clk_enabled)
1152                 clk_disable(pltfm_host->clk);
1153         clk_put(pltfm_host->clk);
1154
1155         sdhci_pltfm_free(pdev);
1156         kfree(tegra_host);
1157
1158         return 0;
1159 }
1160
1161 static struct platform_driver sdhci_tegra_driver = {
1162         .driver         = {
1163                 .name   = "sdhci-tegra",
1164                 .owner  = THIS_MODULE,
1165         },
1166         .probe          = sdhci_tegra_probe,
1167         .remove         = __devexit_p(sdhci_tegra_remove),
1168 #ifdef CONFIG_PM
1169         .suspend        = sdhci_pltfm_suspend,
1170         .resume         = sdhci_pltfm_resume,
1171 #endif
1172 };
1173
1174 static int __init sdhci_tegra_init(void)
1175 {
1176         return platform_driver_register(&sdhci_tegra_driver);
1177 }
1178 module_init(sdhci_tegra_init);
1179
1180 static void __exit sdhci_tegra_exit(void)
1181 {
1182         platform_driver_unregister(&sdhci_tegra_driver);
1183 }
1184 module_exit(sdhci_tegra_exit);
1185
1186 MODULE_DESCRIPTION("SDHCI driver for Tegra");
1187 MODULE_AUTHOR(" Google, Inc.");
1188 MODULE_LICENSE("GPL v2");