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