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