Revert "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
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
583 static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
584 {
585         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
586         struct sdhci_tegra *tegra_host = pltfm_host->priv;
587         u8 ctrl;
588
589         pr_debug("%s %s %u enabled=%u\n", __func__,
590                 mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
591
592         if (clock) {
593                 /* bring out sd instance from io dpd mode */
594                 if (tegra_host->dpd) {
595                         mutex_lock(&tegra_host->dpd->delay_lock);
596                         cancel_delayed_work_sync(&tegra_host->dpd->delay_dpd);
597                         tegra_io_dpd_disable(tegra_host->dpd);
598                         mutex_unlock(&tegra_host->dpd->delay_lock);
599                 }
600
601                 if (!tegra_host->clk_enabled) {
602                         clk_enable(pltfm_host->clk);
603                         ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
604                         ctrl |= SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
605                         sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
606                         tegra_host->clk_enabled = true;
607                 }
608                 tegra_sdhci_set_clk_rate(sdhci, clock);
609                 if (tegra_host->hw_ops->set_card_clock)
610                         tegra_host->hw_ops->set_card_clock(sdhci, clock);
611         } else if (!clock && tegra_host->clk_enabled) {
612                 if (tegra_host->hw_ops->set_card_clock)
613                         tegra_host->hw_ops->set_card_clock(sdhci, clock);
614                 ctrl = sdhci_readb(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
615                 ctrl &= ~SDHCI_VENDOR_CLOCK_CNTRL_SDMMC_CLK;
616                 sdhci_writeb(sdhci, ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
617                 clk_disable(pltfm_host->clk);
618                 tegra_host->clk_enabled = false;
619                 /* io dpd enable call for sd instance */
620
621                 if (tegra_host->dpd) {
622                         mutex_lock(&tegra_host->dpd->delay_lock);
623                         if (tegra_host->dpd->need_delay_dpd) {
624                                 schedule_delayed_work(
625                                         &tegra_host->dpd->delay_dpd,
626                                         msecs_to_jiffies(100));
627                         } else {
628                                 tegra_io_dpd_enable(tegra_host->dpd);
629                         }
630                         mutex_unlock(&tegra_host->dpd->delay_lock);
631                 }
632         }
633 }
634
635 static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
636         unsigned int signal_voltage)
637 {
638         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
639         struct sdhci_tegra *tegra_host = pltfm_host->priv;
640         unsigned int min_uV = SDHOST_HIGH_VOLT_MIN;
641         unsigned int max_uV = SDHOST_HIGH_VOLT_MAX;
642         unsigned int rc = 0;
643         u16 clk, ctrl;
644         unsigned int val;
645
646         ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
647         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
648                 ctrl |= SDHCI_CTRL_VDD_180;
649                 min_uV = SDHOST_LOW_VOLT_MIN;
650                 max_uV = SDHOST_LOW_VOLT_MAX;
651         } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
652                 if (ctrl & SDHCI_CTRL_VDD_180)
653                         ctrl &= ~SDHCI_CTRL_VDD_180;
654         }
655
656         /* Check if the slot can support the required voltage */
657         if (min_uV > tegra_host->vddio_max_uv)
658                 return 0;
659
660         /* Switch OFF the card clock to prevent glitches on the clock line */
661         clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL);
662         clk &= ~SDHCI_CLOCK_CARD_EN;
663         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
664
665         /* Set/clear the 1.8V signalling */
666         sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
667
668         /* Switch the I/O rail voltage */
669         if (tegra_host->vdd_io_reg) {
670                 rc = regulator_set_voltage(tegra_host->vdd_io_reg,
671                         min_uV, max_uV);
672                 if (rc) {
673                         dev_err(mmc_dev(sdhci->mmc), "switching to 1.8V"
674                         "failed . Switching back to 3.3V\n");
675                         regulator_set_voltage(tegra_host->vdd_io_reg,
676                                 SDHOST_HIGH_VOLT_MIN,
677                                 SDHOST_HIGH_VOLT_MAX);
678                         goto out;
679                 }
680         }
681
682         /* Wait for 10 msec for the voltage to be switched */
683         mdelay(10);
684
685         /* Enable the card clock */
686         clk |= SDHCI_CLOCK_CARD_EN;
687         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
688
689         /* Wait for 1 msec after enabling clock */
690         mdelay(1);
691
692         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
693                 /* Do Auto Calibration for 1.8V signal voltage */
694                 val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
695                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
696                 /* Program Auto cal PD offset(bits 8:14) */
697                 val &= ~(0x7F <<
698                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
699                 val |= (SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET <<
700                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
701                 /* Program Auto cal PU offset(bits 0:6) */
702                 val &= ~0x7F;
703                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET;
704                 sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
705
706                 val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
707                 val &= ~SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK;
708                 val |= 0x7;
709                 sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
710         }
711
712         return rc;
713 out:
714         /* Enable the card clock */
715         clk |= SDHCI_CLOCK_CARD_EN;
716         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
717
718         /* Wait for 1 msec for the clock to stabilize */
719         mdelay(1);
720
721         return rc;
722 }
723
724 static void tegra_sdhci_reset(struct sdhci_host *sdhci, u8 mask)
725 {
726         unsigned long timeout;
727
728         sdhci_writeb(sdhci, mask, SDHCI_SOFTWARE_RESET);
729
730         /* Wait max 100 ms */
731         timeout = 100;
732
733         /* hw clears the bit when it's done */
734         while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & mask) {
735                 if (timeout == 0) {
736                         dev_err(mmc_dev(sdhci->mmc), "Reset 0x%x never"
737                                 "completed.\n", (int)mask);
738                         return;
739                 }
740                 timeout--;
741                 mdelay(1);
742         }
743 }
744
745 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
746         unsigned int tap_delay)
747 {
748         u32 vendor_ctrl;
749
750         /* Max tap delay value is 255 */
751         BUG_ON(tap_delay > MAX_TAP_VALUES);
752
753         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VENDOR_CLOCK_CNTRL);
754         vendor_ctrl &= ~(0xFF << SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
755         vendor_ctrl |= (tap_delay << SDHCI_VENDOR_CLOCK_CNTRL_TAP_VALUE_SHIFT);
756         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VENDOR_CLOCK_CNTRL);
757 }
758
759 static int sdhci_tegra_run_frequency_tuning(struct sdhci_host *sdhci, u32 opcode, u32 block_size)
760 {
761         int err = 0;
762         u8 ctrl;
763         u32 mask;
764         unsigned int timeout = 10;
765         int flags;
766         u32 intstatus;
767
768         mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
769         while (sdhci_readl(sdhci, SDHCI_PRESENT_STATE) & mask) {
770                 if (timeout == 0) {
771                         dev_err(mmc_dev(sdhci->mmc), "Controller never"
772                                 "released inhibit bit(s).\n");
773                         err = -ETIMEDOUT;
774                         goto out;
775                 }
776                 timeout--;
777                 mdelay(1);
778         }
779
780         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
781         ctrl &= ~SDHCI_CTRL_TUNED_CLK;
782         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
783
784         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
785         ctrl |= SDHCI_CTRL_EXEC_TUNING;
786         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
787
788         /*
789          * In response to CMD19, the card sends 64 bytes of tuning
790          * block to the Host Controller. So we set the block size
791          * to 64 here.
792          * In response to CMD21, the card sends 128 bytes of tuning
793          * block for MMC_BUS_WIDTH_8 and 64 bytes for MMC_BUS_WIDTH_4
794          * to the Host Controller. So we set the block size to 64 here.
795          */
796         sdhci_writew(sdhci, SDHCI_MAKE_BLKSZ(7, block_size), SDHCI_BLOCK_SIZE);
797
798         sdhci_writeb(sdhci, 0xE, SDHCI_TIMEOUT_CONTROL);
799
800         sdhci_writeb(sdhci, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
801
802         sdhci_writel(sdhci, 0x0, SDHCI_ARGUMENT);
803
804         /* Set the cmd flags */
805         flags = SDHCI_CMD_RESP_SHORT | SDHCI_CMD_CRC | SDHCI_CMD_DATA;
806         /* Issue the command */
807         sdhci_writew(sdhci, SDHCI_MAKE_CMD(
808                 opcode, flags), SDHCI_COMMAND);
809
810         timeout = 5;
811         do {
812                 timeout--;
813                 mdelay(1);
814                 intstatus = sdhci_readl(sdhci, SDHCI_INT_STATUS);
815                 if (intstatus) {
816                         sdhci_writel(sdhci, intstatus, SDHCI_INT_STATUS);
817                         break;
818                 }
819         } while(timeout);
820
821         if ((intstatus & SDHCI_INT_DATA_AVAIL) &&
822                 !(intstatus & SDHCI_INT_DATA_CRC)) {
823                 err = 0;
824                 sdhci->tuning_done = 1;
825         } else {
826                 tegra_sdhci_reset(sdhci, SDHCI_RESET_CMD);
827                 tegra_sdhci_reset(sdhci, SDHCI_RESET_DATA);
828                 err = -EIO;
829         }
830
831         if (sdhci->tuning_done) {
832                 sdhci->tuning_done = 0;
833                 ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
834                 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING) &&
835                         (ctrl & SDHCI_CTRL_TUNED_CLK))
836                         err = 0;
837                 else
838                         err = -EIO;
839         }
840         mdelay(1);
841 out:
842         return err;
843 }
844
845 static int sdhci_tegra_execute_tuning(struct sdhci_host *sdhci, u32 opcode)
846 {
847         int err;
848         u32 block_size;
849         u16 ctrl_2;
850         u8 *tap_delay_status;
851         unsigned int i = 0;
852         unsigned int temp_low_pass_tap = 0;
853         unsigned int temp_pass_window = 0;
854         unsigned int best_low_pass_tap = 0;
855         unsigned int best_pass_window = 0;
856         u32 ier;
857
858         /* Tuning is valid only in SDR104 and SDR50 modes */
859         ctrl_2 = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
860         if (!(((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
861                 (((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
862                 (sdhci->flags & SDHCI_SDR50_NEEDS_TUNING))))
863                         return 0;
864
865         tap_delay_status = kzalloc(MAX_TAP_VALUES, GFP_KERNEL);
866         if (tap_delay_status == NULL) {
867                 dev_err(mmc_dev(sdhci->mmc), "failed to allocate memory"
868                         "for storing tap_delay_status\n");
869                 return -ENOMEM;
870         }
871
872         /* Tuning should be done only for MMC_BUS_WIDTH_8 and MMC_BUS_WIDTH_4 */
873         if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
874                 block_size = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_8;
875         else if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
876                 block_size = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_4;
877         else
878                 return -EINVAL;
879         /*
880          * Disable all interrupts signalling.Enable interrupt status
881          * detection for buffer read ready and data crc. We use
882          * polling for tuning as it involves less overhead.
883          */
884         ier = sdhci_readl(sdhci, SDHCI_INT_ENABLE);
885         sdhci_writel(sdhci, 0, SDHCI_SIGNAL_ENABLE);
886         sdhci_writel(sdhci, SDHCI_INT_DATA_AVAIL |
887                 SDHCI_INT_DATA_CRC, SDHCI_INT_ENABLE);
888
889         /*
890          * Set each tap delay value and run frequency tuning. After each
891          * run, update the tap delay status as working or not working.
892          */
893         do {
894                 /* Set the tap delay */
895                 sdhci_tegra_set_tap_delay(sdhci, i);
896
897                 /* Run frequency tuning */
898                 err = sdhci_tegra_run_frequency_tuning(sdhci, opcode, block_size);
899
900                 /* Update whether the tap delay worked or not */
901                 tap_delay_status[i] = (err) ? 0: 1;
902                 i++;
903         } while (i < 0xFF);
904
905         /* Find the best possible tap range */
906         for (i = 0; i < 0xFF; i++) {
907                 temp_pass_window = 0;
908
909                 /* Find the first passing tap in the current window */
910                 if (tap_delay_status[i]) {
911                         temp_low_pass_tap = i;
912
913                         /* Find the pass window */
914                         do {
915                                 temp_pass_window++;
916                                 i++;
917                                 if (i > 0xFF)
918                                         break;
919                         } while (tap_delay_status[i]);
920
921                         if ((temp_pass_window > best_pass_window) && (temp_pass_window > 1)){
922                                 best_low_pass_tap = temp_low_pass_tap;
923                                 best_pass_window = temp_pass_window;
924                         }
925                 }
926         }
927
928
929         pr_debug("%s: best pass tap window: start %d, end %d\n",
930                 mmc_hostname(sdhci->mmc), best_low_pass_tap,
931                 (best_low_pass_tap + best_pass_window));
932
933         /* Set the best tap */
934         sdhci_tegra_set_tap_delay(sdhci,
935                 (best_low_pass_tap + ((best_pass_window * 3) / 4)));
936
937         /* Run frequency tuning */
938         err = sdhci_tegra_run_frequency_tuning(sdhci, opcode, block_size);
939
940         /* Enable the normal interrupts signalling */
941         sdhci_writel(sdhci, ier, SDHCI_INT_ENABLE);
942         sdhci_writel(sdhci, ier, SDHCI_SIGNAL_ENABLE);
943
944         if (tap_delay_status)
945                 kfree(tap_delay_status);
946
947         return err;
948 }
949
950 static int tegra_sdhci_suspend(struct sdhci_host *sdhci)
951 {
952         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
953         struct sdhci_tegra *tegra_host = pltfm_host->priv;
954
955         tegra_sdhci_set_clock(sdhci, 0);
956
957         /* Disable the power rails if any */
958         if (tegra_host->card_present) {
959                 if (tegra_host->is_rail_enabled) {
960                         if (tegra_host->vdd_io_reg)
961                                 regulator_disable(tegra_host->vdd_io_reg);
962                         if (tegra_host->vdd_slot_reg)
963                                 regulator_disable(tegra_host->vdd_slot_reg);
964                         tegra_host->is_rail_enabled = 0;
965                 }
966         }
967
968         if (tegra_host->dpd) {
969                 mutex_lock(&tegra_host->dpd->delay_lock);
970                 tegra_host->dpd->need_delay_dpd = 1;
971                 mutex_unlock(&tegra_host->dpd->delay_lock);
972         }
973
974         return 0;
975 }
976
977 static int tegra_sdhci_resume(struct sdhci_host *sdhci)
978 {
979         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
980         struct sdhci_tegra *tegra_host = pltfm_host->priv;
981
982         /* Enable the power rails if any */
983         if (tegra_host->card_present) {
984                 if (!tegra_host->is_rail_enabled) {
985                         if (tegra_host->vdd_slot_reg)
986                                 regulator_enable(tegra_host->vdd_slot_reg);
987                         if (tegra_host->vdd_io_reg) {
988                                 regulator_enable(tegra_host->vdd_io_reg);
989                                 tegra_sdhci_signal_voltage_switch(sdhci, MMC_SIGNAL_VOLTAGE_330);
990                         }
991                         tegra_host->is_rail_enabled = 1;
992                 }
993         }
994         /* Setting the min identification clock of freq 400KHz */
995         tegra_sdhci_set_clock(sdhci, 400000);
996
997         /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
998         if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
999                 tegra_sdhci_reset(sdhci, SDHCI_RESET_ALL);
1000                 sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
1001                 sdhci->pwr = 0;
1002         }
1003
1004         return 0;
1005 }
1006
1007 static struct sdhci_ops tegra_sdhci_ops = {
1008 #ifndef CONFIG_ARCH_TEGRA_11x_SOC
1009         .get_ro     = tegra_sdhci_get_ro,
1010 #endif
1011         .get_cd     = tegra_sdhci_get_cd,
1012         .read_l     = tegra_sdhci_readl,
1013         .read_w     = tegra_sdhci_readw,
1014         .write_l    = tegra_sdhci_writel,
1015         .platform_8bit_width = tegra_sdhci_8bit,
1016         .set_clock              = tegra_sdhci_set_clock,
1017         .suspend                = tegra_sdhci_suspend,
1018         .resume                 = tegra_sdhci_resume,
1019         .platform_reset_exit    = tegra_sdhci_reset_exit,
1020         .set_uhs_signaling      = tegra_sdhci_set_uhs_signaling,
1021         .switch_signal_voltage  = tegra_sdhci_signal_voltage_switch,
1022         .execute_freq_tuning    = sdhci_tegra_execute_tuning,
1023 };
1024
1025 static struct sdhci_pltfm_data sdhci_tegra20_pdata = {
1026         .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
1027 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1028                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
1029                   SDHCI_QUIRK_NON_STD_VOLTAGE_SWITCHING |
1030                   SDHCI_QUIRK_NON_STANDARD_TUNING |
1031 #endif
1032 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
1033                   SDHCI_QUIRK_NONSTANDARD_CLOCK |
1034 #endif
1035 #ifndef CONFIG_ARCH_TEGRA_11x_SOC
1036                   SDHCI_QUIRK_BROKEN_CARD_DETECTION |
1037 #endif
1038                   SDHCI_QUIRK_SINGLE_POWER_WRITE |
1039                   SDHCI_QUIRK_NO_HISPD_BIT |
1040                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC |
1041                   SDHCI_QUIRK_NO_CALC_MAX_DISCARD_TO,
1042         .ops  = &tegra_sdhci_ops,
1043 };
1044
1045 static struct sdhci_tegra_soc_data soc_data_tegra20 = {
1046         .pdata = &sdhci_tegra20_pdata,
1047         .nvquirks = NVQUIRK_FORCE_SDHCI_SPEC_200 |
1048                     NVQUIRK_ENABLE_BLOCK_GAP_DET,
1049 };
1050
1051 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
1052 static struct sdhci_pltfm_data sdhci_tegra30_pdata = {
1053         .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
1054                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
1055                   SDHCI_QUIRK_SINGLE_POWER_WRITE |
1056                   SDHCI_QUIRK_NO_HISPD_BIT |
1057                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC,
1058         .ops  = &tegra_sdhci_ops,
1059 };
1060
1061 static struct sdhci_tegra_soc_data soc_data_tegra30 = {
1062         .pdata = &sdhci_tegra30_pdata,
1063 };
1064 #endif
1065
1066 static const struct of_device_id sdhci_tegra_dt_match[] __devinitdata = {
1067 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
1068         { .compatible = "nvidia,tegra30-sdhci", .data = &soc_data_tegra30 },
1069 #endif
1070 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
1071         { .compatible = "nvidia,tegra20-sdhci", .data = &soc_data_tegra20 },
1072 #endif
1073         {}
1074 };
1075 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
1076
1077 static struct tegra_sdhci_platform_data * __devinit sdhci_tegra_dt_parse_pdata(
1078                                                 struct platform_device *pdev)
1079 {
1080         struct tegra_sdhci_platform_data *plat;
1081         struct device_node *np = pdev->dev.of_node;
1082
1083         if (!np)
1084                 return NULL;
1085
1086         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
1087         if (!plat) {
1088                 dev_err(&pdev->dev, "Can't allocate platform data\n");
1089                 return NULL;
1090         }
1091
1092         plat->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
1093         plat->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
1094         plat->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
1095         if (of_find_property(np, "support-8bit", NULL))
1096                 plat->is_8bit = 1;
1097
1098         return plat;
1099 }
1100
1101 static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
1102 {
1103         const struct of_device_id *match;
1104         const struct sdhci_tegra_soc_data *soc_data;
1105         struct sdhci_host *host;
1106         struct sdhci_pltfm_host *pltfm_host;
1107         struct tegra_sdhci_platform_data *plat;
1108         struct sdhci_tegra *tegra_host;
1109         struct clk *clk;
1110         int rc;
1111
1112         match = of_match_device(sdhci_tegra_dt_match, &pdev->dev);
1113         if (match)
1114                 soc_data = match->data;
1115         else
1116                 soc_data = &soc_data_tegra20;
1117
1118         host = sdhci_pltfm_init(pdev, soc_data->pdata);
1119         if (IS_ERR(host))
1120                 return PTR_ERR(host);
1121
1122         pltfm_host = sdhci_priv(host);
1123
1124         plat = pdev->dev.platform_data;
1125
1126         if (plat == NULL)
1127                 plat = sdhci_tegra_dt_parse_pdata(pdev);
1128
1129         if (plat == NULL) {
1130                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
1131                 rc = -ENXIO;
1132                 goto err_no_plat;
1133         }
1134
1135         tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL);
1136         if (!tegra_host) {
1137                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n");
1138                 rc = -ENOMEM;
1139                 goto err_no_plat;
1140         }
1141
1142         tegra_host->plat = plat;
1143         tegra_host->soc_data = soc_data;
1144
1145         pltfm_host->priv = tegra_host;
1146
1147 #ifdef CONFIG_MMC_EMBEDDED_SDIO
1148         if (plat->mmc_data.embedded_sdio)
1149                 mmc_set_embedded_sdio_data(host->mmc,
1150                         &plat->mmc_data.embedded_sdio->cis,
1151                         &plat->mmc_data.embedded_sdio->cccr,
1152                         plat->mmc_data.embedded_sdio->funcs,
1153                         plat->mmc_data.embedded_sdio->num_funcs);
1154 #endif
1155
1156         if (gpio_is_valid(plat->power_gpio)) {
1157                 rc = gpio_request(plat->power_gpio, "sdhci_power");
1158                 if (rc) {
1159                         dev_err(mmc_dev(host->mmc),
1160                                 "failed to allocate power gpio\n");
1161                         goto err_power_req;
1162                 }
1163                 tegra_gpio_enable(plat->power_gpio);
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                 tegra_gpio_enable(plat->cd_gpio);
1175                 gpio_direction_input(plat->cd_gpio);
1176
1177                 tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
1178
1179                 rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
1180                                  carddetect_irq,
1181                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
1182                                  mmc_hostname(host->mmc), host);
1183
1184                 if (rc) {
1185                         dev_err(mmc_dev(host->mmc), "request irq error\n");
1186                         goto err_cd_irq_req;
1187                 }
1188                 rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
1189                 if (rc < 0)
1190                         dev_err(mmc_dev(host->mmc),
1191                                 "SD card wake-up event registration"
1192                                         "failed with eroor: %d\n", rc);
1193
1194         } else if (plat->mmc_data.register_status_notify) {
1195                 plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
1196         }
1197
1198         if (plat->mmc_data.status) {
1199                 plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
1200         }
1201
1202         if (gpio_is_valid(plat->wp_gpio)) {
1203                 rc = gpio_request(plat->wp_gpio, "sdhci_wp");
1204                 if (rc) {
1205                         dev_err(mmc_dev(host->mmc),
1206                                 "failed to allocate wp gpio\n");
1207                         goto err_wp_req;
1208                 }
1209                 tegra_gpio_enable(plat->wp_gpio);
1210                 gpio_direction_input(plat->wp_gpio);
1211         }
1212
1213         /*
1214          * If there is no card detect gpio, assume that the
1215          * card is always present.
1216          */
1217         if (!gpio_is_valid(plat->cd_gpio))
1218                 tegra_host->card_present = 1;
1219
1220         if (!plat->mmc_data.built_in) {
1221                 if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
1222                         tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
1223                         tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
1224                 } else {
1225                         /*
1226                          * Set the minV and maxV to default
1227                          * voltage range of 2.7V - 3.6V
1228                          */
1229                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
1230                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
1231                 }
1232                 tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc), "vddio_sdmmc");
1233                 if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
1234                         dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
1235                                 "Assuming vddio_sdmmc is not required.\n",
1236                                         "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
1237                         tegra_host->vdd_io_reg = NULL;
1238                 } else {
1239                         rc = regulator_set_voltage(tegra_host->vdd_io_reg,
1240                                 tegra_host->vddio_min_uv,
1241                                 tegra_host->vddio_max_uv);
1242                         if (rc) {
1243                                 dev_err(mmc_dev(host->mmc), "%s regulator_set_voltage failed: %d",
1244                                         "vddio_sdmmc", rc);
1245                                 regulator_put(tegra_host->vdd_io_reg);
1246                                 tegra_host->vdd_io_reg = NULL;
1247                         }
1248                 }
1249
1250                 tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc), "vddio_sd_slot");
1251                 if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
1252                         dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
1253                                 " Assuming vddio_sd_slot is not required.\n",
1254                                         "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
1255                         tegra_host->vdd_slot_reg = NULL;
1256                 }
1257
1258                 if (tegra_host->card_present) {
1259                         if (tegra_host->vdd_slot_reg)
1260                                 regulator_enable(tegra_host->vdd_slot_reg);
1261                         if (tegra_host->vdd_io_reg)
1262                                 regulator_enable(tegra_host->vdd_io_reg);
1263                         tegra_host->is_rail_enabled = 1;
1264                 }
1265         }
1266
1267         clk = clk_get(mmc_dev(host->mmc), NULL);
1268         if (IS_ERR(clk)) {
1269                 dev_err(mmc_dev(host->mmc), "clk err\n");
1270                 rc = PTR_ERR(clk);
1271                 goto err_clk_get;
1272         }
1273         rc = clk_enable(clk);
1274         if (rc != 0)
1275                 goto err_clk_put;
1276
1277         if (!strcmp(dev_name(mmc_dev(host->mmc)), "sdhci-tegra.3")) {
1278                 tegra_host->emc_clk = clk_get(mmc_dev(host->mmc), "emc");
1279                 if (IS_ERR(tegra_host->emc_clk)) {
1280                         dev_err(mmc_dev(host->mmc), "clk err\n");
1281                         rc = PTR_ERR(tegra_host->emc_clk);
1282                         goto err_clk_put;
1283                 }
1284                 tegra_host->emc_max_clk =
1285                         clk_round_rate(tegra_host->emc_clk, ULONG_MAX);
1286         }
1287
1288         pltfm_host->clk = clk;
1289         pltfm_host->priv = tegra_host;
1290         tegra_host->clk_enabled = true;
1291         tegra_host->max_clk_limit = plat->max_clk_limit;
1292         tegra_host->ddr_clk_limit = plat->ddr_clk_limit;
1293         tegra_host->instance = pdev->id;
1294         tegra_host->dpd = tegra_io_dpd_get(mmc_dev(host->mmc));
1295
1296         host->mmc->pm_caps |= plat->pm_caps;
1297         host->mmc->pm_flags |= plat->pm_flags;
1298
1299         /*
1300          * tegra sd controller is not able to reset the command inhibit
1301          * bit for the mmc sleep/awake command
1302          */
1303         host->mmc->caps2 |= MMC_CAP2_NO_SLEEP_CMD;
1304
1305         host->mmc->caps |= MMC_CAP_ERASE;
1306         /* enable 1/8V DDR capable */
1307         host->mmc->caps |= MMC_CAP_1_8V_DDR;
1308         if (plat->is_8bit)
1309                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
1310         host->mmc->caps |= MMC_CAP_SDIO_IRQ;
1311         host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
1312         if (plat->mmc_data.built_in) {
1313                 host->mmc->caps |= MMC_CAP_NONREMOVABLE;
1314         }
1315         host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
1316
1317 #ifdef CONFIG_MMC_BKOPS
1318         host->mmc->caps |= MMC_CAP_BKOPS;
1319 #endif
1320
1321         /* enable HS200 capable */
1322         host->mmc->caps2 |= MMC_CAP2_HS200;
1323 #ifdef CONFIG_MMC_EMBEDDED_SDIO
1324         /* Do not turn OFF embedded sdio cards as it support Wake on Wireless */
1325         if (plat->mmc_data.embedded_sdio)
1326                 host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
1327 #endif
1328
1329         tegra_sdhost_min_freq = TEGRA_SDHOST_MIN_FREQ;
1330 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
1331         tegra_host->hw_ops = &tegra_2x_sdhci_ops;
1332         tegra_sdhost_std_freq = TEGRA2_SDHOST_STD_FREQ;
1333 #elif defined(CONFIG_ARCH_TEGRA_3x_SOC)
1334         tegra_host->hw_ops = &tegra_3x_sdhci_ops;
1335         tegra_sdhost_std_freq = TEGRA3_SDHOST_STD_FREQ;
1336 #else
1337         tegra_host->hw_ops = &tegra_11x_sdhci_ops;
1338         tegra_sdhost_std_freq = TEGRA3_SDHOST_STD_FREQ;
1339 #endif
1340         rc = sdhci_add_host(host);
1341         if (rc)
1342                 goto err_add_host;
1343
1344         return 0;
1345
1346 err_add_host:
1347         clk_put(tegra_host->emc_clk);
1348         clk_disable(pltfm_host->clk);
1349 err_clk_put:
1350         clk_put(pltfm_host->clk);
1351 err_clk_get:
1352         if (gpio_is_valid(plat->wp_gpio)) {
1353                 tegra_gpio_disable(plat->wp_gpio);
1354                 gpio_free(plat->wp_gpio);
1355         }
1356 err_wp_req:
1357         if (gpio_is_valid(plat->cd_gpio))
1358                 free_irq(gpio_to_irq(plat->cd_gpio), host);
1359 err_cd_irq_req:
1360         if (gpio_is_valid(plat->cd_gpio)) {
1361                 tegra_gpio_disable(plat->cd_gpio);
1362                 gpio_free(plat->cd_gpio);
1363         }
1364 err_cd_req:
1365         if (gpio_is_valid(plat->power_gpio)) {
1366                 tegra_gpio_disable(plat->power_gpio);
1367                 gpio_free(plat->power_gpio);
1368         }
1369 err_power_req:
1370         kfree(tegra_host);
1371 err_no_plat:
1372         sdhci_pltfm_free(pdev);
1373         return rc;
1374 }
1375
1376 static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
1377 {
1378         struct sdhci_host *host = platform_get_drvdata(pdev);
1379         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1380         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1381         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
1382         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
1383
1384         sdhci_remove_host(host, dead);
1385
1386         disable_irq_wake(gpio_to_irq(plat->cd_gpio));
1387
1388         if (tegra_host->vdd_slot_reg) {
1389                 regulator_disable(tegra_host->vdd_slot_reg);
1390                 regulator_put(tegra_host->vdd_slot_reg);
1391         }
1392
1393         if (tegra_host->vdd_io_reg) {
1394                 regulator_disable(tegra_host->vdd_io_reg);
1395                 regulator_put(tegra_host->vdd_io_reg);
1396         }
1397
1398         if (gpio_is_valid(plat->wp_gpio)) {
1399                 tegra_gpio_disable(plat->wp_gpio);
1400                 gpio_free(plat->wp_gpio);
1401         }
1402
1403         if (gpio_is_valid(plat->cd_gpio)) {
1404                 free_irq(gpio_to_irq(plat->cd_gpio), host);
1405                 tegra_gpio_disable(plat->cd_gpio);
1406                 gpio_free(plat->cd_gpio);
1407         }
1408
1409         if (gpio_is_valid(plat->power_gpio)) {
1410                 tegra_gpio_disable(plat->power_gpio);
1411                 gpio_free(plat->power_gpio);
1412         }
1413
1414         if (tegra_host->clk_enabled)
1415                 clk_disable(pltfm_host->clk);
1416         clk_put(pltfm_host->clk);
1417
1418         sdhci_pltfm_free(pdev);
1419         kfree(tegra_host);
1420
1421         return 0;
1422 }
1423
1424 static struct platform_driver sdhci_tegra_driver = {
1425         .driver         = {
1426                 .name   = "sdhci-tegra",
1427                 .owner  = THIS_MODULE,
1428                 .of_match_table = sdhci_tegra_dt_match,
1429                 .pm     = SDHCI_PLTFM_PMOPS,
1430         },
1431         .probe          = sdhci_tegra_probe,
1432         .remove         = __devexit_p(sdhci_tegra_remove),
1433 };
1434
1435 module_platform_driver(sdhci_tegra_driver);
1436
1437 MODULE_DESCRIPTION("SDHCI driver for Tegra");
1438 MODULE_AUTHOR("Google, Inc.");
1439 MODULE_LICENSE("GPL v2");