mmc: tegra: Fix parent clk configuration
[linux-3.10.git] / drivers / mmc / host / sdhci-tegra.c
1 /*
2  * Copyright (C) 2010 Google, Inc.
3  *
4  * Copyright (c) 2012-2014, 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 #include <linux/pm_runtime.h>
35
36 #ifndef CONFIG_ARM64
37 #include <asm/gpio.h>
38 #endif
39 #include <linux/debugfs.h>
40 #include <linux/seq_file.h>
41 #include <linux/reboot.h>
42 #include <linux/devfreq.h>
43 #include <linux/clk/tegra.h>
44 #include <linux/tegra-soc.h>
45
46 #include <linux/platform_data/mmc-sdhci-tegra.h>
47 #include <mach/pinmux.h>
48 #include <mach/pm_domains.h>
49
50 #include "sdhci-pltfm.h"
51
52 #if 0
53 #define SDHCI_TEGRA_DBG(stuff...)       pr_info(stuff)
54 #else
55 #define SDHCI_TEGRA_DBG(stuff...)       do {} while (0)
56 #endif
57
58 #define SDHCI_VNDR_CLK_CTRL                             0x100
59 #define SDHCI_VNDR_CLK_CTRL_SDMMC_CLK                   0x1
60 #define SDHCI_VNDR_CLK_CTRL_PADPIPE_CLKEN_OVERRIDE      0x8
61 #define SDHCI_VNDR_CLK_CTRL_SPI_MODE_CLKEN_OVERRIDE     0x4
62 #define SDHCI_VNDR_CLK_CTRL_INPUT_IO_CLK                0x2
63 #define SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT             16
64 #define SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT            24
65 #define SDHCI_VNDR_CLK_CTRL_SDR50_TUNING                0x20
66 #define SDHCI_VNDR_CLK_CTRL_INTERNAL_CLK                0x2
67
68 #define SDHCI_VNDR_MISC_CTRL                            0x120
69 #define SDHCI_VNDR_MISC_CTRL_ENABLE_SDR104_SUPPORT      0x8
70 #define SDHCI_VNDR_MISC_CTRL_ENABLE_SDR50_SUPPORT       0x10
71 #define SDHCI_VNDR_MISC_CTRL_ENABLE_DDR50_SUPPORT       0x200
72 #define SDHCI_VNDR_MISC_CTRL_ENABLE_SD_3_0              0x20
73 #define SDHCI_VNDR_MISC_CTRL_INFINITE_ERASE_TIMEOUT     0x1
74 #define SDHCI_VNDR_MISC_CTRL_PIPE_STAGES_MASK           0x180
75 #define SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT      17
76
77 #define SDHCI_VNDR_PRESET_VAL0_0        0x1d4
78 #define SDCLK_FREQ_SEL_HS_SHIFT         20
79 #define SDCLK_FREQ_SEL_DEFAULT_SHIFT    10
80
81 #define SDHCI_VNDR_PRESET_VAL1_0        0x1d8
82 #define SDCLK_FREQ_SEL_SDR50_SHIFT      20
83 #define SDCLK_FREQ_SEL_SDR25_SHIFT      10
84
85 #define SDHCI_VNDR_PRESET_VAL2_0        0x1dc
86 #define SDCLK_FREQ_SEL_DDR50_SHIFT      10
87
88 #define SDMMC_SDMEMCOMPPADCTRL  0x1E0
89 #define SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK    0xF
90 #define SDMMC_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD_MASK       0x80000000
91
92 #define SDMMC_AUTO_CAL_CONFIG   0x1E4
93 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_START    0x80000000
94 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE   0x20000000
95 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT  0x8
96
97 #define SDMMC_AUTO_CAL_STATUS   0x1EC
98 #define SDMMC_AUTO_CAL_STATUS_AUTO_CAL_ACTIVE   0x80000000
99 #define SDMMC_AUTO_CAL_STATUS_PULLDOWN_OFFSET   24
100 #define PULLUP_ADJUSTMENT_OFFSET        20
101
102 /* Erratum: Version register is invalid in HW */
103 #define NVQUIRK_FORCE_SDHCI_SPEC_200            BIT(0)
104 /* Erratum: Enable block gap interrupt detection */
105 #define NVQUIRK_ENABLE_BLOCK_GAP_DET            BIT(1)
106 /* Do not enable auto calibration if the platform doesn't support */
107 #define NVQUIRK_DISABLE_AUTO_CALIBRATION        BIT(2)
108 /* Set Calibration Offsets */
109 #define NVQUIRK_SET_CALIBRATION_OFFSETS         BIT(3)
110 /* Set Drive Strengths */
111 #define NVQUIRK_SET_DRIVE_STRENGTH              BIT(4)
112 /* Enable PADPIPE CLKEN */
113 #define NVQUIRK_ENABLE_PADPIPE_CLKEN            BIT(5)
114 /* DISABLE SPI_MODE CLKEN */
115 #define NVQUIRK_DISABLE_SPI_MODE_CLKEN          BIT(6)
116 /* Set tap delay */
117 #define NVQUIRK_SET_TAP_DELAY                   BIT(7)
118 /* Set trim delay */
119 #define NVQUIRK_SET_TRIM_DELAY                  BIT(8)
120 /* Enable SDHOST v3.0 support */
121 #define NVQUIRK_ENABLE_SD_3_0                   BIT(9)
122 /* Enable SDR50 mode */
123 #define NVQUIRK_ENABLE_SDR50                    BIT(10)
124 /* Enable SDR104 mode */
125 #define NVQUIRK_ENABLE_SDR104                   BIT(11)
126 /*Enable DDR50 mode */
127 #define NVQUIRK_ENABLE_DDR50                    BIT(12)
128 /* Enable Frequency Tuning for SDR50 mode */
129 #define NVQUIRK_ENABLE_SDR50_TUNING             BIT(13)
130 /* Enable HS200 mode */
131 #define NVQUIRK_ENABLE_HS200                    BIT(14)
132 /* Enable Infinite Erase Timeout*/
133 #define NVQUIRK_INFINITE_ERASE_TIMEOUT          BIT(15)
134 /* No Calibration for sdmmc4 */
135 #define NVQUIRK_DISABLE_SDMMC4_CALIB            BIT(16)
136 /* ENAABLE FEEDBACK IO CLOCK */
137 #define NVQUIRK_EN_FEEDBACK_CLK                 BIT(17)
138 /* Disable AUTO CMD23 */
139 #define NVQUIRK_DISABLE_AUTO_CMD23              BIT(18)
140 /* Shadow write xfer mode reg and write it alongwith CMD register */
141 #define NVQUIRK_SHADOW_XFER_MODE_REG            BIT(19)
142 /* update PAD_E_INPUT_OR_E_PWRD bit */
143 #define NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD       BIT(20)
144 /* Shadow write xfer mode reg and write it alongwith CMD register */
145 #define NVQUIRK_SET_PIPE_STAGES_MASK_0          BIT(21)
146 #define NVQUIRK_HIGH_FREQ_TAP_PROCEDURE         BIT(22)
147 /* Disable SDMMC3 external loopback */
148 #define NVQUIRK_DISABLE_EXTERNAL_LOOPBACK       BIT(23)
149 #define NVQUIRK_TMP_VAR_1_5_TAP_MARGIN          BIT(24)
150
151 /* Common subset of quirks for Tegra3 and later sdmmc controllers */
152 #define TEGRA_SDHCI_NVQUIRKS    (NVQUIRK_ENABLE_PADPIPE_CLKEN | \
153                   NVQUIRK_DISABLE_SPI_MODE_CLKEN | \
154                   NVQUIRK_EN_FEEDBACK_CLK | \
155                   NVQUIRK_SET_TAP_DELAY | \
156                   NVQUIRK_ENABLE_SDR50_TUNING | \
157                   NVQUIRK_ENABLE_SDR50 | \
158                   NVQUIRK_ENABLE_SDR104 | \
159                   NVQUIRK_SHADOW_XFER_MODE_REG | \
160                   NVQUIRK_DISABLE_AUTO_CMD23)
161
162 #define TEGRA_SDHCI_QUIRKS              (SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | \
163                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | \
164                   SDHCI_QUIRK_SINGLE_POWER_WRITE | \
165                   SDHCI_QUIRK_NO_HISPD_BIT | \
166                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC | \
167                   SDHCI_QUIRK_BROKEN_CARD_DETECTION)
168
169 #define TEGRA_SDHCI_QUIRKS2     (SDHCI_QUIRK2_PRESET_VALUE_BROKEN | \
170                   SDHCI_QUIRK2_NON_STD_VOLTAGE_SWITCHING | \
171                   SDHCI_QUIRK2_NON_STANDARD_TUNING | \
172                   SDHCI_QUIRK2_NO_CALC_MAX_DISCARD_TO | \
173                   SDHCI_QUIRK2_REG_ACCESS_REQ_HOST_CLK)
174
175 /* Interface voltages */
176 #define SDHOST_1V8_OCR_MASK     0x8
177 #define SDHOST_HIGH_VOLT_MIN    2700000
178 #define SDHOST_HIGH_VOLT_MAX    3600000
179 #define SDHOST_HIGH_VOLT_2V8    2800000
180 #define SDHOST_LOW_VOLT_MIN     1800000
181 #define SDHOST_LOW_VOLT_MAX     1800000
182 #define SDHOST_HIGH_VOLT_3V2    3200000
183 #define SDHOST_HIGH_VOLT_3V3    3300000
184
185 /* Clock related definitions */
186 #define MAX_DIVISOR_VALUE       128
187 #define DEFAULT_SDHOST_FREQ     50000000
188 #define SDMMC_AHB_MAX_FREQ      150000000
189 #define SDMMC_EMC_MAX_FREQ      150000000
190 #define SDMMC_EMC_NOM_VOLT_FREQ 900000000
191
192 /* Tuning related definitions */
193 #define MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_8       128
194 #define MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_4       64
195 #define MAX_TAP_VALUES  255
196 #define TUNING_FREQ_COUNT       3
197 #define TUNING_VOLTAGES_COUNT   3
198 #define TUNING_RETRIES  1
199 #define DFS_FREQ_COUNT  2
200 #define NEG_MAR_CHK_WIN_COUNT   2
201 /* Tuning core voltage requirements */
202 #define NOMINAL_VCORE_TUN       BIT(0)
203 #define BOOT_VCORE_TUN  BIT(1)
204 #define MIN_OVERRIDE_VCORE_TUN  BIT(2)
205
206 /* Tap cmd sysfs commands */
207 #define TAP_CMD_TRIM_DEFAULT_VOLTAGE    1
208 #define TAP_CMD_TRIM_HIGH_VOLTAGE       2
209
210 /*
211  * Defined the chip specific quirks and clock sources. For now, the used clock
212  * sources vary only from chip to chip. If the sources allowed varies from
213  * platform to platform, then move the clock sources list to platform data.
214  * When filling the tuning_freq_list in soc_data, the number of entries should
215  * be equal to TUNNG_FREQ_COUNT. Depending on number DFS frequencies supported,
216  * set the desired low, high or max frequencies and set the remaining entries
217  * as 0s. The number of entries should always be equal to TUNING_FREQ_COUNT
218  * inorder to get the right tuning data.
219  */
220 struct sdhci_tegra_soc_data {
221         const struct sdhci_pltfm_data *pdata;
222         u32 nvquirks;
223         const char *parent_clk_list[2];
224         unsigned int tuning_freq_list[TUNING_FREQ_COUNT];
225         u8 t2t_coeffs_count;
226         u8 tap_hole_coeffs_count;
227         struct tuning_t2t_coeffs *t2t_coeffs;
228         struct tap_hole_coeffs *tap_hole_coeffs;
229 };
230
231
232 enum tegra_regulator_config_ops {
233         CONFIG_REG_EN,
234         CONFIG_REG_DIS,
235         CONFIG_REG_SET_VOLT,
236 };
237
238 enum tegra_tuning_freq {
239         TUNING_LOW_FREQ,
240         TUNING_HIGH_FREQ,
241         TUNING_MAX_FREQ,
242 };
243
244 struct tuning_t2t_coeffs {
245         const char *dev_id;
246         int vmax;
247         int vmin;
248         unsigned int t2t_vnom_slope;
249         unsigned int t2t_vnom_int;
250         unsigned int t2t_vmax_slope;
251         unsigned int t2t_vmax_int;
252         unsigned int t2t_vmin_slope;
253         unsigned int t2t_vmin_int;
254 };
255
256 #define SET_TUNING_COEFFS(_device_id, _vmax, _vmin, _t2t_vnom_slope,    \
257         _t2t_vnom_int, _t2t_vmax_slope, _t2t_vmax_int, _t2t_vmin_slope, \
258         _t2t_vmin_int)  \
259         {                                               \
260                 .dev_id = _device_id,                   \
261                 .vmax = _vmax,                          \
262                 .vmin = _vmin,                          \
263                 .t2t_vnom_slope = _t2t_vnom_slope,      \
264                 .t2t_vnom_int = _t2t_vnom_int,          \
265                 .t2t_vmax_slope = _t2t_vmax_slope,      \
266                 .t2t_vmax_int = _t2t_vmax_int,          \
267                 .t2t_vmin_slope = _t2t_vmin_slope,      \
268                 .t2t_vmin_int = _t2t_vmin_int,          \
269         }
270
271 struct tuning_t2t_coeffs t11x_tuning_coeffs[] = {
272         SET_TUNING_COEFFS("sdhci-tegra.3",      1250,   950,    55,     135434,
273                 73,     170493, 243,    455948),
274         SET_TUNING_COEFFS("sdhci-tegra.2",      1250,   950,    50,     129738,
275                 73,     168898, 241,    453050),
276         SET_TUNING_COEFFS("sdhci-tegra.0",      1250,   950,    62,     143469,
277                 82,     180096, 238,    444285),
278 };
279
280 struct tuning_t2t_coeffs t12x_tuning_coeffs[] = {
281         SET_TUNING_COEFFS("sdhci-tegra.3",      1150,   950,    27,     118295,
282                 27,     118295, 48,     188148),
283         SET_TUNING_COEFFS("sdhci-tegra.2",      1150,   950,    29,     124427,
284                 29, 124427,      54,    203707),
285         SET_TUNING_COEFFS("sdhci-tegra.0",      1150,   950,    25,     115933,
286                 25,     115933, 47,     187224),
287 };
288
289 struct tap_hole_coeffs {
290         const char *dev_id;
291         unsigned int freq_khz;
292         unsigned int thole_vnom_slope;
293         unsigned int thole_vnom_int;
294         unsigned int thole_vmax_slope;
295         unsigned int thole_vmax_int;
296         unsigned int thole_vmin_slope;
297         unsigned int thole_vmin_int;
298 };
299
300 #define SET_TAP_HOLE_COEFFS(_device_id, _freq_khz, _thole_vnom_slope,   \
301         _thole_vnom_int, _thole_vmax_slope, _thole_vmax_int,    \
302         _thole_vmin_slope, _thole_vmin_int)     \
303         {                                       \
304                 .dev_id = _device_id,           \
305                 .freq_khz = _freq_khz,          \
306                 .thole_vnom_slope = _thole_vnom_slope,  \
307                 .thole_vnom_int = _thole_vnom_int,      \
308                 .thole_vmax_slope = _thole_vmax_slope,  \
309                 .thole_vmax_int = _thole_vmax_int,      \
310                 .thole_vmin_slope = _thole_vmin_slope,  \
311                 .thole_vmin_int = _thole_vmin_int,      \
312         }
313
314 struct tap_hole_coeffs t11x_tap_hole_coeffs[] = {
315         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    200000, 765,    102357, 507,
316                 81144,  131,    36346),
317         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    156000, 1042,   142044, 776,
318                 121659, 152,    48728),
319         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    136000, 1215,   167702, 905,
320                 143825, 207,    63477),
321         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    81600,  1925,   284516, 1528,
322                 253188, 366,    120001),
323         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    204000, 472,    53312,  318,
324                 41756,  84,     15496),
325         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    156000, 765,    95512,  526,
326                 77404,  134,    33032),
327         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    136000, 949,    121887, 656,
328                 99684,  165,    43992),
329         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    81600,  1901,   259035, 1334,
330                 215539, 326,    100986),
331         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    204000, 411,    54495,  305,
332                 46415,  91,     20366),
333         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    156000, 715,    97623,  516,
334                 82375,  145,    38278),
335         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    136000, 905,    124579, 648,
336                 104850, 179,    50204),
337         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    81600,  1893,   264746, 1333,
338                 221722, 354,    109880),
339 };
340
341 struct tap_hole_coeffs t12x_tap_hole_coeffs[] = {
342         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    200000, 1037,   106934, 1037,
343                 106934, 558,    74315),
344         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    136000, 1703,   186307, 1703,
345                 186307, 890,    130617),
346         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    100000, 2452,   275601, 2452,
347                 275601, 1264,   193957),
348         SET_TAP_HOLE_COEFFS("sdhci-tegra.3",    81600,  3090,   351666, 3090,
349                 351666, 1583,   247913),
350         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    204000, 468,    36031,  468,
351                 36031,  253,    21264),
352         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    200000, 468,    36031,  468,
353                 36031,  253,    21264),
354         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    136000, 1146,   117841, 1146,
355                 117841, 589,    78993),
356         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    100000, 1879,   206195, 1879,
357                 206195, 953,    141341),
358         SET_TAP_HOLE_COEFFS("sdhci-tegra.2",    81600,  2504,   281460, 2504,
359                 281460, 1262,   194452),
360         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    204000, 874,    85243,  874,
361                 85243,  449,    57321),
362         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    136000, 1554,   167210, 1554,
363                 167210, 793,    115672),
364         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    100000, 2290,   255734, 2290,
365                 255734, 1164,   178691),
366         SET_TAP_HOLE_COEFFS("sdhci-tegra.0",    81600,  2916,   331143, 2916,
367                 331143, 1480,   232373),
368 };
369
370 struct freq_tuning_constraints {
371         unsigned int vcore_mask;
372 };
373
374 static struct freq_tuning_constraints tuning_vcore_constraints[3] = {
375         [0] = {
376                 .vcore_mask = BOOT_VCORE_TUN,
377         },
378         [1] = {
379                 .vcore_mask = BOOT_VCORE_TUN,
380         },
381         [2] = {
382                 .vcore_mask = BOOT_VCORE_TUN,
383         },
384 };
385
386 struct tuning_ui {
387         int ui;
388         bool is_valid_ui;
389 };
390
391 enum tap_win_edge_attr {
392         WIN_EDGE_BOUN_START,
393         WIN_EDGE_BOUN_END,
394         WIN_EDGE_HOLE,
395 };
396
397 struct tap_window_data {
398         int win_start;
399         int win_end;
400         enum tap_win_edge_attr win_start_attr;
401         enum tap_win_edge_attr win_end_attr;
402         u8 win_size;
403         u8 hole_pos;
404 };
405
406 struct tuning_values {
407         int t2t_vmax;
408         int t2t_vmin;
409         int ui;
410         int ui_vmin;
411         int vmax_thole;
412         int vmin_thole;
413 };
414 struct tegra_tuning_data {
415         unsigned int freq_hz;
416         int best_tap_value;
417         int nom_best_tap_value;
418         struct freq_tuning_constraints constraints;
419         struct tap_hole_coeffs *thole_coeffs;
420         struct tuning_t2t_coeffs *t2t_coeffs;
421         struct tuning_values est_values;
422         struct tuning_values calc_values;
423         struct tap_window_data *tap_data;
424         struct tap_window_data *final_tap_data;
425         u8 num_of_valid_tap_wins;
426         u8 nr_voltages;
427         u8 freq_band;
428         bool tuning_done;
429         bool is_partial_win_valid;
430 };
431
432 #ifdef CONFIG_MMC_FREQ_SCALING
433 struct freq_gov_params {
434         u8      idle_mon_cycles;
435         u8      polling_interval_ms;
436         u8      active_load_threshold;
437 };
438
439 static struct freq_gov_params gov_params[3] = {
440         [MMC_TYPE_MMC] = {
441                 .idle_mon_cycles = 3,
442                 .polling_interval_ms = 50,
443                 .active_load_threshold = 25,
444         },
445         [MMC_TYPE_SDIO] = {
446                 .idle_mon_cycles = 3,
447                 .polling_interval_ms = 50,
448                 .active_load_threshold = 25,
449         },
450         [MMC_TYPE_SD] = {
451                 .idle_mon_cycles = 3,
452                 .polling_interval_ms = 50,
453                 .active_load_threshold = 25,
454         },
455 };
456 #endif
457
458 struct tegra_freq_gov_data {
459         unsigned int            curr_active_load;
460         unsigned int            avg_active_load;
461         unsigned int            act_load_high_threshold;
462         unsigned int            max_idle_monitor_cycles;
463         unsigned int            curr_freq;
464         unsigned int            freqs[DFS_FREQ_COUNT];
465         unsigned int            freq_switch_count;
466         bool                    monitor_idle_load;
467 };
468
469 struct sdhci_tegra_sd_stats {
470         unsigned int data_crc_count;
471         unsigned int cmd_crc_count;
472         unsigned int data_to_count;
473         unsigned int cmd_to_count;
474 };
475
476 struct sdhci_tegra {
477         const struct tegra_sdhci_platform_data *plat;
478         const struct sdhci_tegra_soc_data *soc_data;
479         bool    clk_enabled;
480         /* ensure atomic set clock calls */
481         struct mutex            set_clock_mutex;
482         struct regulator *vdd_io_reg;
483         struct regulator *vdd_slot_reg;
484         struct regulator *vcore_reg;
485         /* Host controller instance */
486         unsigned int instance;
487         /* vddio_min */
488         unsigned int vddio_min_uv;
489         /* vddio_max */
490         unsigned int vddio_max_uv;
491         /* DDR and low speed modes clock */
492         struct clk *ddr_clk;
493         /* HS200, SDR104 modes clock */
494         struct clk *sdr_clk;
495         /* Check if ddr_clk is being used */
496         bool is_ddr_clk_set;
497         /* max clk supported by the platform */
498         unsigned int max_clk_limit;
499         /* max ddr clk supported by the platform */
500         unsigned int ddr_clk_limit;
501         bool card_present;
502         bool is_rail_enabled;
503         struct clk *emc_clk;
504         bool is_sdmmc_emc_clk_on;
505         struct clk *sclk;
506         bool is_sdmmc_sclk_on;
507         struct sdhci_tegra_sd_stats *sd_stat_head;
508         struct notifier_block reboot_notify;
509         bool is_parent_pllc;
510         bool set_1v8_calib_offsets;
511         int nominal_vcore_mv;
512         int min_vcore_override_mv;
513         int boot_vcore_mv;
514         /* Tuning related structures and variables */
515         /* Tuning opcode to be used */
516         unsigned int tuning_opcode;
517         /* Tuning packet size */
518         unsigned int tuning_bsize;
519         /* Num of tuning freqs selected */
520         int tuning_freq_count;
521         unsigned int tap_cmd;
522         /* Tuning status */
523         unsigned int tuning_status;
524         bool force_retune;
525 #define TUNING_STATUS_DONE      1
526 #define TUNING_STATUS_RETUNE    2
527         /* Freq tuning information for each sampling clock freq */
528         struct tegra_tuning_data tuning_data[DFS_FREQ_COUNT];
529         struct tegra_freq_gov_data *gov_data;
530         u32 speedo;
531 };
532
533 static struct clk *pll_c;
534 static struct clk *pll_p;
535 static unsigned long pll_c_rate;
536 static unsigned long pll_p_rate;
537 static bool vcore_overrides_allowed;
538 static bool maintain_boot_voltage;
539 static unsigned int boot_volt_req_refcount;
540 DEFINE_MUTEX(tuning_mutex);
541
542 static struct tegra_tuning_data *sdhci_tegra_get_tuning_data(
543         struct sdhci_host *sdhci, unsigned int clock);
544 static unsigned long get_nearest_clock_freq(unsigned long pll_rate,
545                 unsigned long desired_rate);
546 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
547         unsigned int tap_delay);
548 static int tegra_sdhci_configure_regulators(struct sdhci_tegra *tegra_host,
549         u8 option, int min_uV, int max_uV);
550 static void tegra_sdhci_do_calibration(struct sdhci_host *sdhci);
551
552 static int show_error_stats_dump(struct seq_file *s, void *data)
553 {
554         struct sdhci_host *host = s->private;
555         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
556         struct sdhci_tegra *tegra_host = pltfm_host->priv;
557         struct sdhci_tegra_sd_stats *head;
558
559         seq_printf(s, "ErrorStatistics:\n");
560         seq_printf(s, "DataCRC\tCmdCRC\tDataTimeout\tCmdTimeout\n");
561         head = tegra_host->sd_stat_head;
562         if (head != NULL)
563                 seq_printf(s, "%d\t%d\t%d\t%d\n", head->data_crc_count,
564                         head->cmd_crc_count, head->data_to_count,
565                         head->cmd_to_count);
566         return 0;
567 }
568
569 static int show_dfs_stats_dump(struct seq_file *s, void *data)
570 {
571         struct sdhci_host *host = s->private;
572         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
573         struct sdhci_tegra *tegra_host = pltfm_host->priv;
574         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
575
576         seq_printf(s, "DFS statistics:\n");
577
578         if (host->mmc->dev_stats != NULL)
579                 seq_printf(s, "Polling_period: %d\n",
580                         host->mmc->dev_stats->polling_interval);
581
582         if (gov_data != NULL) {
583                 seq_printf(s, "cur_active_load: %d\n",
584                         gov_data->curr_active_load);
585                 seq_printf(s, "avg_active_load: %d\n",
586                         gov_data->avg_active_load);
587                 seq_printf(s, "act_load_high_threshold: %d\n",
588                         gov_data->act_load_high_threshold);
589                 seq_printf(s, "freq_switch_count: %d\n",
590                         gov_data->freq_switch_count);
591         }
592         return 0;
593 }
594
595 static int sdhci_error_stats_dump(struct inode *inode, struct file *file)
596 {
597         return single_open(file, show_error_stats_dump, inode->i_private);
598 }
599
600 static int sdhci_dfs_stats_dump(struct inode *inode, struct file *file)
601 {
602         return single_open(file, show_dfs_stats_dump, inode->i_private);
603 }
604
605
606 static const struct file_operations sdhci_host_fops = {
607         .open           = sdhci_error_stats_dump,
608         .read           = seq_read,
609         .llseek         = seq_lseek,
610         .release        = single_release,
611 };
612
613 static const struct file_operations sdhci_host_dfs_fops = {
614         .open           = sdhci_dfs_stats_dump,
615         .read           = seq_read,
616         .llseek         = seq_lseek,
617         .release        = single_release,
618 };
619
620 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
621 {
622         u32 val;
623
624         if (unlikely(reg == SDHCI_PRESENT_STATE)) {
625                 /* Use wp_gpio here instead? */
626                 val = readl(host->ioaddr + reg);
627                 return val | SDHCI_WRITE_PROTECT;
628         }
629         return readl(host->ioaddr + reg);
630 }
631
632 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
633 {
634         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
635         struct sdhci_tegra *tegra_host = pltfm_host->priv;
636         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
637
638         if (unlikely((soc_data->nvquirks & NVQUIRK_FORCE_SDHCI_SPEC_200) &&
639                         (reg == SDHCI_HOST_VERSION))) {
640                 return SDHCI_SPEC_200;
641         }
642         return readw(host->ioaddr + reg);
643 }
644
645 static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
646 {
647         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
648         struct sdhci_tegra *tegra_host = pltfm_host->priv;
649         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
650
651         /* Seems like we're getting spurious timeout and crc errors, so
652          * disable signalling of them. In case of real errors software
653          * timers should take care of eventually detecting them.
654          */
655         if (unlikely(reg == SDHCI_SIGNAL_ENABLE))
656                 val &= ~(SDHCI_INT_TIMEOUT|SDHCI_INT_CRC);
657
658         writel(val, host->ioaddr + reg);
659
660         if (unlikely((soc_data->nvquirks & NVQUIRK_ENABLE_BLOCK_GAP_DET) &&
661                         (reg == SDHCI_INT_ENABLE))) {
662                 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
663                 if (val & SDHCI_INT_CARD_INT)
664                         gap_ctrl |= 0x8;
665                 else
666                         gap_ctrl &= ~0x8;
667                 writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
668         }
669 }
670
671 static void tegra_sdhci_writew(struct sdhci_host *host, u16 val, int reg)
672 {
673         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
674         struct sdhci_tegra *tegra_host = pltfm_host->priv;
675         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
676
677         if (soc_data->nvquirks & NVQUIRK_SHADOW_XFER_MODE_REG) {
678                 switch (reg) {
679                 case SDHCI_TRANSFER_MODE:
680                         /*
681                          * Postpone this write, we must do it together with a
682                          * command write that is down below.
683                          */
684                         pltfm_host->xfer_mode_shadow = val;
685                         return;
686                 case SDHCI_COMMAND:
687                         writel((val << 16) | pltfm_host->xfer_mode_shadow,
688                                 host->ioaddr + SDHCI_TRANSFER_MODE);
689                         pltfm_host->xfer_mode_shadow = 0;
690                         return;
691                 }
692         }
693
694         writew(val, host->ioaddr + reg);
695 }
696
697 #ifdef CONFIG_MMC_FREQ_SCALING
698
699 static bool disable_scaling __read_mostly;
700 module_param(disable_scaling, bool, 0644);
701
702 /*
703  * Dynamic frequency calculation.
704  * The active load for the current period and the average active load
705  * are calculated at the end of each polling interval.
706  *
707  * If the current active load is greater than the threshold load, then the
708  * frequency is boosted(156MHz).
709  * If the active load is lower than the threshold, then the load is monitored
710  * for a max of three cycles before reducing the frequency(82MHz). If the
711  * average active load is lower, then the monitoring cycles is reduced.
712  *
713  * The active load threshold value for both eMMC and SDIO is set to 25 which
714  * is found to give the optimal power and performance. The polling interval is
715  * set to 50 msec.
716  *
717  * The polling interval and active load threshold values can be changed by
718  * the user through sysfs.
719 */
720 static unsigned long calculate_mmc_target_freq(
721         struct tegra_freq_gov_data *gov_data)
722 {
723         unsigned long desired_freq = gov_data->curr_freq;
724         unsigned int type = MMC_TYPE_MMC;
725
726         if (gov_data->curr_active_load >= gov_data->act_load_high_threshold) {
727                 desired_freq = gov_data->freqs[TUNING_HIGH_FREQ];
728                 gov_data->monitor_idle_load = false;
729                 gov_data->max_idle_monitor_cycles =
730                         gov_params[type].idle_mon_cycles;
731         } else {
732                 if (gov_data->monitor_idle_load) {
733                         if (!gov_data->max_idle_monitor_cycles) {
734                                 desired_freq = gov_data->freqs[TUNING_LOW_FREQ];
735                                 gov_data->max_idle_monitor_cycles =
736                                         gov_params[type].idle_mon_cycles;
737                         } else {
738                                 gov_data->max_idle_monitor_cycles--;
739                         }
740                 } else {
741                         gov_data->monitor_idle_load = true;
742                         gov_data->max_idle_monitor_cycles *=
743                                 gov_data->avg_active_load;
744                         gov_data->max_idle_monitor_cycles /= 100;
745                 }
746         }
747
748         return desired_freq;
749 }
750
751 static unsigned long calculate_sdio_target_freq(
752         struct tegra_freq_gov_data *gov_data)
753 {
754         unsigned long desired_freq = gov_data->curr_freq;
755         unsigned int type = MMC_TYPE_SDIO;
756
757         if (gov_data->curr_active_load >= gov_data->act_load_high_threshold) {
758                 desired_freq = gov_data->freqs[TUNING_HIGH_FREQ];
759                 gov_data->monitor_idle_load = false;
760                 gov_data->max_idle_monitor_cycles =
761                         gov_params[type].idle_mon_cycles;
762         } else {
763                 if (gov_data->monitor_idle_load) {
764                         if (!gov_data->max_idle_monitor_cycles) {
765                                 desired_freq = gov_data->freqs[TUNING_LOW_FREQ];
766                                 gov_data->max_idle_monitor_cycles =
767                                         gov_params[type].idle_mon_cycles;
768                         } else {
769                                 gov_data->max_idle_monitor_cycles--;
770                         }
771                 } else {
772                         gov_data->monitor_idle_load = true;
773                         gov_data->max_idle_monitor_cycles *=
774                                 gov_data->avg_active_load;
775                         gov_data->max_idle_monitor_cycles /= 100;
776                 }
777         }
778
779         return desired_freq;
780 }
781
782 static unsigned long calculate_sd_target_freq(
783         struct tegra_freq_gov_data *gov_data)
784 {
785         unsigned long desired_freq = gov_data->curr_freq;
786         unsigned int type = MMC_TYPE_SD;
787
788         if (gov_data->curr_active_load >= gov_data->act_load_high_threshold) {
789                 desired_freq = gov_data->freqs[TUNING_HIGH_FREQ];
790                 gov_data->monitor_idle_load = false;
791                 gov_data->max_idle_monitor_cycles =
792                         gov_params[type].idle_mon_cycles;
793         } else {
794                 if (gov_data->monitor_idle_load) {
795                         if (!gov_data->max_idle_monitor_cycles) {
796                                 desired_freq = gov_data->freqs[TUNING_LOW_FREQ];
797                                 gov_data->max_idle_monitor_cycles =
798                                         gov_params[type].idle_mon_cycles;
799                         } else {
800                                 gov_data->max_idle_monitor_cycles--;
801                         }
802                 } else {
803                         gov_data->monitor_idle_load = true;
804                         gov_data->max_idle_monitor_cycles *=
805                                 gov_data->avg_active_load;
806                         gov_data->max_idle_monitor_cycles /= 100;
807                 }
808         }
809
810         return desired_freq;
811 }
812
813 static unsigned long sdhci_tegra_get_target_freq(struct sdhci_host *sdhci,
814         struct devfreq_dev_status *dfs_stats)
815 {
816         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
817         struct sdhci_tegra *tegra_host = pltfm_host->priv;
818         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
819         unsigned long freq = sdhci->mmc->actual_clock;
820
821         if (!gov_data) {
822                 dev_err(mmc_dev(sdhci->mmc),
823                         "No gov data. Continue using current freq %ld", freq);
824                 return freq;
825         }
826
827         if (disable_scaling)
828                 return freq;
829
830         /*
831          * If clock gating is enabled and clock is currently disabled, then
832          * return freq as 0.
833          */
834         if (!tegra_host->clk_enabled)
835                 return 0;
836
837         if (dfs_stats->total_time) {
838                 gov_data->curr_active_load = (dfs_stats->busy_time * 100) /
839                         dfs_stats->total_time;
840         } else {
841                 gov_data->curr_active_load = 0;
842         }
843
844         gov_data->avg_active_load += gov_data->curr_active_load;
845         gov_data->avg_active_load >>= 1;
846
847         if (sdhci->mmc->card) {
848                 if (sdhci->mmc->card->type == MMC_TYPE_SDIO)
849                         freq = calculate_sdio_target_freq(gov_data);
850                 else if (sdhci->mmc->card->type == MMC_TYPE_MMC)
851                         freq = calculate_mmc_target_freq(gov_data);
852                 else if (sdhci->mmc->card->type == MMC_TYPE_SD)
853                         freq = calculate_sd_target_freq(gov_data);
854                 if (gov_data->curr_freq != freq)
855                         gov_data->freq_switch_count++;
856                 gov_data->curr_freq = freq;
857         }
858
859         return freq;
860 }
861
862 static int sdhci_tegra_freq_gov_init(struct sdhci_host *sdhci)
863 {
864         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
865         struct sdhci_tegra *tegra_host = pltfm_host->priv;
866         unsigned int i;
867         unsigned int freq;
868         unsigned int type;
869
870         if (!((sdhci->mmc->ios.timing == MMC_TIMING_UHS_SDR104) ||
871                 (sdhci->mmc->ios.timing == MMC_TIMING_MMC_HS200))) {
872                 dev_info(mmc_dev(sdhci->mmc),
873                         "DFS not required for current operating mode\n");
874                 return -EACCES;
875         }
876
877         if (!tegra_host->gov_data) {
878                 tegra_host->gov_data = devm_kzalloc(mmc_dev(sdhci->mmc),
879                         sizeof(struct tegra_freq_gov_data), GFP_KERNEL);
880                 if (!tegra_host->gov_data) {
881                         dev_err(mmc_dev(sdhci->mmc),
882                                 "Failed to allocate memory for dfs data\n");
883                         return -ENOMEM;
884                 }
885         }
886
887         /* Find the supported frequencies */
888         dev_info(mmc_dev(sdhci->mmc), "DFS supported freqs");
889         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
890                 freq = tegra_host->tuning_data[i].freq_hz;
891                 /*
892                  * Check the nearest possible clock with pll_c and pll_p as
893                  * the clock sources. Choose the higher frequency.
894                  */
895                 tegra_host->gov_data->freqs[i] =
896                         get_nearest_clock_freq(pll_c_rate, freq);
897                 freq = get_nearest_clock_freq(pll_p_rate, freq);
898                 if (freq > tegra_host->gov_data->freqs[i])
899                         tegra_host->gov_data->freqs[i] = freq;
900                 pr_err("%d,", tegra_host->gov_data->freqs[i]);
901         }
902
903         tegra_host->gov_data->monitor_idle_load = false;
904         tegra_host->gov_data->curr_freq = sdhci->mmc->actual_clock;
905         if (sdhci->mmc->card) {
906                 type = sdhci->mmc->card->type;
907                 sdhci->mmc->dev_stats->polling_interval =
908                         gov_params[type].polling_interval_ms;
909                 tegra_host->gov_data->act_load_high_threshold =
910                         gov_params[type].active_load_threshold;
911                 tegra_host->gov_data->max_idle_monitor_cycles =
912                         gov_params[type].idle_mon_cycles;
913         }
914
915         return 0;
916 }
917
918 #endif
919
920 static unsigned int tegra_sdhci_get_cd(struct sdhci_host *sdhci)
921 {
922         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
923         struct sdhci_tegra *tegra_host = pltfm_host->priv;
924
925         return tegra_host->card_present;
926 }
927
928 static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
929 {
930         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
931         struct sdhci_tegra *tegra_host = pltfm_host->priv;
932         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
933
934         if (!gpio_is_valid(plat->wp_gpio))
935                 return -1;
936
937         return gpio_get_value_cansleep(plat->wp_gpio);
938 }
939
940 static int tegra_sdhci_set_uhs_signaling(struct sdhci_host *host,
941                 unsigned int uhs)
942 {
943         u16 clk, ctrl_2;
944         u32 vndr_ctrl;
945         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
946         struct sdhci_tegra *tegra_host = pltfm_host->priv;
947         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
948
949         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
950
951         /* Select Bus Speed Mode for host
952          * For HS200 we need to set UHS_MODE_SEL to SDR104.
953          * It works as SDR 104 in SD 4-bit mode and HS200 in eMMC 8-bit mode.
954          * SDR50 mode timing seems to have issues. Programming SDR104
955          * mode for SDR50 mode for reliable transfers over interface.
956          */
957         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
958         switch (uhs) {
959         case MMC_TIMING_UHS_SDR12:
960                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
961                 break;
962         case MMC_TIMING_UHS_SDR25:
963                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
964                 break;
965         case MMC_TIMING_UHS_SDR50:
966                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
967                 break;
968         case MMC_TIMING_UHS_SDR104:
969         case MMC_TIMING_MMC_HS200:
970                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
971                 break;
972         case MMC_TIMING_UHS_DDR50:
973                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
974                 break;
975         }
976
977         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
978
979         if (uhs == MMC_TIMING_UHS_DDR50) {
980                 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
981                 clk &= ~(0xFF << SDHCI_DIVIDER_SHIFT);
982                 clk |= 1 << SDHCI_DIVIDER_SHIFT;
983                 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
984
985                 /* Set the ddr mode trim delay if required */
986                 if (plat->ddr_trim_delay != -1) {
987                         vndr_ctrl = sdhci_readl(host, SDHCI_VNDR_CLK_CTRL);
988                         vndr_ctrl &= ~(0x1F <<
989                                 SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT);
990                         vndr_ctrl |= (plat->ddr_trim_delay <<
991                                 SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT);
992                         sdhci_writel(host, vndr_ctrl, SDHCI_VNDR_CLK_CTRL);
993                 }
994         }
995
996         return 0;
997 }
998
999 static void sdhci_status_notify_cb(int card_present, void *dev_id)
1000 {
1001         struct sdhci_host *sdhci = (struct sdhci_host *)dev_id;
1002         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
1003         struct tegra_sdhci_platform_data *plat;
1004         unsigned int status, oldstat;
1005
1006         pr_debug("%s: card_present %d\n", mmc_hostname(sdhci->mmc),
1007                 card_present);
1008
1009         plat = pdev->dev.platform_data;
1010         if (!plat->mmc_data.status) {
1011                 if (card_present == 1) {
1012                         sdhci->mmc->rescan_disable = 0;
1013                         mmc_detect_change(sdhci->mmc, 0);
1014                 } else if (card_present == 0) {
1015                         sdhci->mmc->detect_change = 0;
1016                         sdhci->mmc->rescan_disable = 1;
1017                 }
1018                 return;
1019         }
1020
1021         status = plat->mmc_data.status(mmc_dev(sdhci->mmc));
1022
1023         oldstat = plat->mmc_data.card_present;
1024         plat->mmc_data.card_present = status;
1025         if (status ^ oldstat) {
1026                 pr_debug("%s: Slot status change detected (%d -> %d)\n",
1027                         mmc_hostname(sdhci->mmc), oldstat, status);
1028                 if (status && !plat->mmc_data.built_in)
1029                         mmc_detect_change(sdhci->mmc, (5 * HZ) / 2);
1030                 else
1031                         mmc_detect_change(sdhci->mmc, 0);
1032         }
1033 }
1034
1035 static irqreturn_t carddetect_irq(int irq, void *data)
1036 {
1037         struct sdhci_host *sdhost = (struct sdhci_host *)data;
1038         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhost);
1039         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1040         struct platform_device *pdev = to_platform_device(mmc_dev(sdhost->mmc));
1041         struct tegra_sdhci_platform_data *plat;
1042         int err;
1043
1044         plat = pdev->dev.platform_data;
1045
1046         tegra_host->card_present =
1047                         (gpio_get_value_cansleep(plat->cd_gpio) == 0);
1048
1049         if (tegra_host->card_present) {
1050                 err = tegra_sdhci_configure_regulators(tegra_host,
1051                         CONFIG_REG_EN, 0, 0);
1052                 if (err)
1053                         dev_err(mmc_dev(sdhost->mmc),
1054                                 "Failed to enable card regulators %d\n", err);
1055         } else {
1056                 err = tegra_sdhci_configure_regulators(tegra_host,
1057                         CONFIG_REG_DIS, 0 , 0);
1058                 if (err)
1059                         dev_err(mmc_dev(sdhost->mmc),
1060                                 "Failed to disable card regulators %d\n", err);
1061                 /*
1062                  * Set retune request as tuning should be done next time
1063                  * a card is inserted.
1064                  */
1065                 tegra_host->tuning_status = TUNING_STATUS_RETUNE;
1066                 tegra_host->force_retune = true;
1067         }
1068
1069         tasklet_schedule(&sdhost->card_tasklet);
1070         return IRQ_HANDLED;
1071 };
1072
1073 static void tegra_sdhci_reset_exit(struct sdhci_host *host, u8 mask)
1074 {
1075         u32 misc_ctrl;
1076         u32 vendor_ctrl;
1077         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1078         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1079         struct tegra_tuning_data *tuning_data;
1080         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1081         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
1082         unsigned int best_tap_value;
1083
1084         if (!(mask & SDHCI_RESET_ALL))
1085                 return;
1086
1087         if (tegra_host->sd_stat_head != NULL) {
1088                 tegra_host->sd_stat_head->data_crc_count = 0;
1089                 tegra_host->sd_stat_head->cmd_crc_count = 0;
1090                 tegra_host->sd_stat_head->data_to_count = 0;
1091                 tegra_host->sd_stat_head->cmd_to_count = 0;
1092         }
1093
1094         if (tegra_host->gov_data != NULL)
1095                 tegra_host->gov_data->freq_switch_count = 0;
1096
1097         vendor_ctrl = sdhci_readl(host, SDHCI_VNDR_CLK_CTRL);
1098         if (soc_data->nvquirks & NVQUIRK_ENABLE_PADPIPE_CLKEN) {
1099                 vendor_ctrl |=
1100                         SDHCI_VNDR_CLK_CTRL_PADPIPE_CLKEN_OVERRIDE;
1101         }
1102         if (soc_data->nvquirks & NVQUIRK_DISABLE_SPI_MODE_CLKEN) {
1103                 vendor_ctrl &=
1104                         ~SDHCI_VNDR_CLK_CTRL_SPI_MODE_CLKEN_OVERRIDE;
1105         }
1106         if (soc_data->nvquirks & NVQUIRK_EN_FEEDBACK_CLK) {
1107                 vendor_ctrl &=
1108                         ~SDHCI_VNDR_CLK_CTRL_INPUT_IO_CLK;
1109         } else {
1110                 vendor_ctrl |= SDHCI_VNDR_CLK_CTRL_INTERNAL_CLK;
1111         }
1112
1113         if (soc_data->nvquirks & NVQUIRK_SET_TAP_DELAY) {
1114                 if ((tegra_host->tuning_status == TUNING_STATUS_DONE)
1115                         && (host->mmc->pm_flags & MMC_PM_KEEP_POWER)) {
1116                         tuning_data = sdhci_tegra_get_tuning_data(host,
1117                                 host->mmc->ios.clock);
1118                         best_tap_value = (tegra_host->tap_cmd ==
1119                                 TAP_CMD_TRIM_HIGH_VOLTAGE) ?
1120                                 tuning_data->nom_best_tap_value :
1121                                 tuning_data->best_tap_value;
1122                 } else {
1123                         best_tap_value = tegra_host->plat->tap_delay;
1124                 }
1125                 vendor_ctrl &= ~(0xFF << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1126                 vendor_ctrl |= (best_tap_value <<
1127                         SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1128         }
1129
1130         if (soc_data->nvquirks & NVQUIRK_SET_TRIM_DELAY) {
1131                 vendor_ctrl &= ~(0x1F <<
1132                 SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT);
1133                 vendor_ctrl |= (plat->trim_delay <<
1134                 SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT);
1135         }
1136         if (soc_data->nvquirks & NVQUIRK_ENABLE_SDR50_TUNING)
1137                 vendor_ctrl |= SDHCI_VNDR_CLK_CTRL_SDR50_TUNING;
1138         sdhci_writel(host, vendor_ctrl, SDHCI_VNDR_CLK_CTRL);
1139
1140         misc_ctrl = sdhci_readl(host, SDHCI_VNDR_MISC_CTRL);
1141         if (soc_data->nvquirks & NVQUIRK_ENABLE_SD_3_0)
1142                 misc_ctrl |= SDHCI_VNDR_MISC_CTRL_ENABLE_SD_3_0;
1143         if (soc_data->nvquirks & NVQUIRK_ENABLE_SDR104) {
1144                 misc_ctrl |=
1145                 SDHCI_VNDR_MISC_CTRL_ENABLE_SDR104_SUPPORT;
1146         }
1147         if (soc_data->nvquirks & NVQUIRK_ENABLE_SDR50) {
1148                 misc_ctrl |=
1149                 SDHCI_VNDR_MISC_CTRL_ENABLE_SDR50_SUPPORT;
1150         }
1151         /* Enable DDR mode support only for SDMMC4 */
1152         if (soc_data->nvquirks & NVQUIRK_ENABLE_DDR50) {
1153                 if (tegra_host->instance == 3) {
1154                         misc_ctrl |=
1155                         SDHCI_VNDR_MISC_CTRL_ENABLE_DDR50_SUPPORT;
1156                 }
1157         }
1158         if (soc_data->nvquirks & NVQUIRK_INFINITE_ERASE_TIMEOUT) {
1159                 misc_ctrl |=
1160                 SDHCI_VNDR_MISC_CTRL_INFINITE_ERASE_TIMEOUT;
1161         }
1162         if (soc_data->nvquirks & NVQUIRK_SET_PIPE_STAGES_MASK_0)
1163                 misc_ctrl &= ~SDHCI_VNDR_MISC_CTRL_PIPE_STAGES_MASK;
1164
1165         /* External loopback is valid for sdmmc3 only */
1166         if ((soc_data->nvquirks & NVQUIRK_DISABLE_EXTERNAL_LOOPBACK) &&
1167                 (tegra_host->instance == 2)) {
1168                 if ((tegra_host->tuning_status == TUNING_STATUS_DONE)
1169                         && (host->mmc->pm_flags &
1170                         MMC_PM_KEEP_POWER)) {
1171                         misc_ctrl &= ~(1 <<
1172                         SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
1173                 } else {
1174                         misc_ctrl |= (1 <<
1175                         SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
1176                 }
1177         }
1178         sdhci_writel(host, misc_ctrl, SDHCI_VNDR_MISC_CTRL);
1179
1180         if (soc_data->nvquirks & NVQUIRK_DISABLE_AUTO_CMD23)
1181                 host->flags &= ~SDHCI_AUTO_CMD23;
1182
1183         /* Mask the support for any UHS modes if specified */
1184         if (plat->uhs_mask & MMC_UHS_MASK_SDR104)
1185                 host->mmc->caps &= ~MMC_CAP_UHS_SDR104;
1186
1187         if (plat->uhs_mask & MMC_UHS_MASK_DDR50)
1188                 host->mmc->caps &= ~MMC_CAP_UHS_DDR50;
1189
1190         if (plat->uhs_mask & MMC_UHS_MASK_SDR50)
1191                 host->mmc->caps &= ~MMC_CAP_UHS_SDR50;
1192
1193         if (plat->uhs_mask & MMC_UHS_MASK_SDR25)
1194                 host->mmc->caps &= ~MMC_CAP_UHS_SDR25;
1195
1196         if (plat->uhs_mask & MMC_UHS_MASK_SDR12)
1197                 host->mmc->caps &= ~MMC_CAP_UHS_SDR12;
1198
1199 #ifdef CONFIG_MMC_SDHCI_TEGRA_HS200_DISABLE
1200         host->mmc->caps2 &= ~MMC_CAP2_HS200;
1201 #else
1202         if (plat->uhs_mask & MMC_MASK_HS200)
1203                 host->mmc->caps2 &= ~MMC_CAP2_HS200;
1204 #endif
1205 }
1206
1207 static int tegra_sdhci_buswidth(struct sdhci_host *sdhci, int bus_width)
1208 {
1209         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
1210         const struct tegra_sdhci_platform_data *plat;
1211         u32 ctrl;
1212
1213         plat = pdev->dev.platform_data;
1214
1215         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL);
1216         if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
1217                 ctrl &= ~SDHCI_CTRL_4BITBUS;
1218                 ctrl |= SDHCI_CTRL_8BITBUS;
1219         } else {
1220                 ctrl &= ~SDHCI_CTRL_8BITBUS;
1221                 if (bus_width == MMC_BUS_WIDTH_4)
1222                         ctrl |= SDHCI_CTRL_4BITBUS;
1223                 else
1224                         ctrl &= ~SDHCI_CTRL_4BITBUS;
1225         }
1226         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL);
1227         return 0;
1228 }
1229
1230 /*
1231 * Calculation of nearest clock frequency for desired rate:
1232 * Get the divisor value, div = p / d_rate
1233 * 1. If it is nearer to ceil(p/d_rate) then increment the div value by 0.5 and
1234 * nearest_rate, i.e. result = p / (div + 0.5) = (p << 1)/((div << 1) + 1).
1235 * 2. If not, result = p / div
1236 * As the nearest clk freq should be <= to desired_rate,
1237 * 3. If result > desired_rate then increment the div by 0.5
1238 * and do, (p << 1)/((div << 1) + 1)
1239 * 4. Else return result
1240 * Here, If condtions 1 & 3 are both satisfied then to keep track of div value,
1241 * defined index variable.
1242 */
1243 static unsigned long get_nearest_clock_freq(unsigned long pll_rate,
1244                 unsigned long desired_rate)
1245 {
1246         unsigned long result;
1247         int div;
1248         int index = 1;
1249
1250         div = pll_rate / desired_rate;
1251         if (div > MAX_DIVISOR_VALUE) {
1252                 div = MAX_DIVISOR_VALUE;
1253                 result = pll_rate / div;
1254         } else {
1255                 if ((pll_rate % desired_rate) >= (desired_rate / 2))
1256                         result = (pll_rate << 1) / ((div << 1) + index++);
1257                 else
1258                         result = pll_rate / div;
1259
1260                 if (desired_rate < result) {
1261                         /*
1262                         * Trying to get lower clock freq than desired clock,
1263                         * by increasing the divisor value by 0.5
1264                         */
1265                         result = (pll_rate << 1) / ((div << 1) + index);
1266                 }
1267         }
1268
1269         return result;
1270 }
1271
1272 static void tegra_sdhci_clock_set_parent(struct sdhci_host *host,
1273                 unsigned long desired_rate)
1274 {
1275         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1276         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1277         struct clk *parent_clk;
1278         unsigned long pll_c_freq;
1279         unsigned long pll_p_freq;
1280         int rc;
1281
1282 #ifdef CONFIG_TEGRA_FPGA_PLATFORM
1283         return;
1284 #endif
1285         /*
1286          * Currently pll_p and pll_c are used as clock sources for SDMMC. If clk
1287          * rate is missing for either of them, then no selection is needed and
1288          * the default parent is used.
1289          */
1290         if (!pll_c_rate || !pll_p_rate)
1291                 return ;
1292
1293         pll_c_freq = get_nearest_clock_freq(pll_c_rate, desired_rate);
1294         pll_p_freq = get_nearest_clock_freq(pll_p_rate, desired_rate);
1295
1296         /*
1297          * For low freq requests, both the desired rates might be higher than
1298          * the requested clock frequency. In such cases, select the parent
1299          * with the lower frequency rate.
1300          */
1301         if ((pll_c_freq > desired_rate) && (pll_p_freq > desired_rate)) {
1302                 if (pll_p_freq <= pll_c_freq) {
1303                         desired_rate = pll_p_freq;
1304                         pll_c_freq = 0;
1305                 } else {
1306                         desired_rate = pll_c_freq;
1307                         pll_p_freq = 0;
1308                 }
1309                 rc = clk_set_rate(pltfm_host->clk, desired_rate);
1310         }
1311
1312         if (pll_c_freq > pll_p_freq) {
1313                 if (!tegra_host->is_parent_pllc) {
1314                         parent_clk = pll_c;
1315                         tegra_host->is_parent_pllc = true;
1316                         clk_set_rate(pltfm_host->clk, DEFAULT_SDHOST_FREQ);
1317                 } else
1318                         return;
1319         } else if (tegra_host->is_parent_pllc) {
1320                 parent_clk = pll_p;
1321                 tegra_host->is_parent_pllc = false;
1322         } else
1323                 return;
1324
1325         rc = clk_set_parent(pltfm_host->clk, parent_clk);
1326         if (rc)
1327                 pr_err("%s: failed to set pll parent clock %d\n",
1328                         mmc_hostname(host->mmc), rc);
1329 }
1330
1331 static void tegra_sdhci_set_clk_rate(struct sdhci_host *sdhci,
1332         unsigned int clock)
1333 {
1334         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1335         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1336         unsigned int clk_rate;
1337 #ifdef CONFIG_MMC_FREQ_SCALING
1338         unsigned int tap_value;
1339         struct tegra_tuning_data *tuning_data;
1340 #endif
1341
1342         if (sdhci->mmc->ios.timing == MMC_TIMING_UHS_DDR50) {
1343                 /*
1344                  * In ddr mode, tegra sdmmc controller clock frequency
1345                  * should be double the card clock frequency.
1346                  */
1347                 if (tegra_host->ddr_clk_limit)
1348                         clk_rate = tegra_host->ddr_clk_limit * 2;
1349                 else
1350                         clk_rate = clock * 2;
1351         } else {
1352                 clk_rate = clock;
1353         }
1354
1355         if (tegra_host->max_clk_limit &&
1356                 (clk_rate > tegra_host->max_clk_limit))
1357                 clk_rate = tegra_host->max_clk_limit;
1358
1359         tegra_sdhci_clock_set_parent(sdhci, clk_rate);
1360         clk_set_rate(pltfm_host->clk, clk_rate);
1361         sdhci->max_clk = clk_get_rate(pltfm_host->clk);
1362
1363         /* FPGA supports 26MHz of clock for SDMMC. */
1364         if (tegra_platform_is_fpga())
1365                 sdhci->max_clk = 26000000;
1366
1367 #ifdef CONFIG_MMC_FREQ_SCALING
1368         /* Set the tap delay if tuning is done and dfs is enabled */
1369         if (sdhci->mmc->df &&
1370                 (tegra_host->tuning_status == TUNING_STATUS_DONE)) {
1371                 tuning_data = sdhci_tegra_get_tuning_data(sdhci, clock);
1372                 tap_value = (tegra_host->tap_cmd == TAP_CMD_TRIM_HIGH_VOLTAGE) ?
1373                         tuning_data->nom_best_tap_value :
1374                         tuning_data->best_tap_value;
1375                 sdhci_tegra_set_tap_delay(sdhci, tap_value);
1376         }
1377 #endif
1378 }
1379
1380 static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
1381 {
1382         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1383         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1384         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
1385         u8 ctrl;
1386         int ret = 0;
1387
1388         mutex_lock(&tegra_host->set_clock_mutex);
1389         pr_debug("%s %s %u enabled=%u\n", __func__,
1390                 mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
1391         if (clock) {
1392                 if (!tegra_host->clk_enabled) {
1393                         pm_runtime_get_sync(&pdev->dev);
1394                         ret = clk_prepare_enable(pltfm_host->clk);
1395                         if (ret) {
1396                                 dev_err(mmc_dev(sdhci->mmc),
1397                                 "clock enable is failed, ret: %d\n", ret);
1398                                 return;
1399                         }
1400                         tegra_host->clk_enabled = true;
1401                         sdhci->is_clk_on = tegra_host->clk_enabled;
1402                         ctrl = sdhci_readb(sdhci, SDHCI_VNDR_CLK_CTRL);
1403                         ctrl |= SDHCI_VNDR_CLK_CTRL_SDMMC_CLK;
1404                         sdhci_writeb(sdhci, ctrl, SDHCI_VNDR_CLK_CTRL);
1405                 }
1406                 tegra_sdhci_set_clk_rate(sdhci, clock);
1407
1408                 if (tegra_host->emc_clk && (!tegra_host->is_sdmmc_emc_clk_on)) {
1409                         ret = clk_prepare_enable(tegra_host->emc_clk);
1410                         if (ret) {
1411                                 dev_err(mmc_dev(sdhci->mmc),
1412                                 "clock enable is failed, ret: %d\n", ret);
1413                                 return;
1414                         }
1415                         tegra_host->is_sdmmc_emc_clk_on = true;
1416                 }
1417                 if (tegra_host->sclk && (!tegra_host->is_sdmmc_sclk_on)) {
1418                         ret = clk_prepare_enable(tegra_host->sclk);
1419                         if (ret) {
1420                                 dev_err(mmc_dev(sdhci->mmc),
1421                                 "clock enable is failed, ret: %d\n", ret);
1422                                 return;
1423                         }
1424                         tegra_host->is_sdmmc_sclk_on = true;
1425                 }
1426         } else if (!clock && tegra_host->clk_enabled) {
1427                 if (tegra_host->emc_clk && tegra_host->is_sdmmc_emc_clk_on) {
1428                         clk_disable_unprepare(tegra_host->emc_clk);
1429                         tegra_host->is_sdmmc_emc_clk_on = false;
1430                 }
1431                 if (tegra_host->sclk && tegra_host->is_sdmmc_sclk_on) {
1432                         clk_disable_unprepare(tegra_host->sclk);
1433                         tegra_host->is_sdmmc_sclk_on = false;
1434                 }
1435                 ctrl = sdhci_readb(sdhci, SDHCI_VNDR_CLK_CTRL);
1436                 ctrl &= ~SDHCI_VNDR_CLK_CTRL_SDMMC_CLK;
1437                 sdhci_writeb(sdhci, ctrl, SDHCI_VNDR_CLK_CTRL);
1438                 clk_disable_unprepare(pltfm_host->clk);
1439                 tegra_host->clk_enabled = false;
1440                 sdhci->is_clk_on = tegra_host->clk_enabled;
1441                 pm_runtime_put_sync(&pdev->dev);
1442         }
1443         mutex_unlock(&tegra_host->set_clock_mutex);
1444 }
1445
1446 static unsigned int get_calibration_offsets(struct sdhci_host *sdhci)
1447 {
1448         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1449         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1450         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
1451         unsigned int offsets = 0;
1452
1453         if (sdhci->mmc->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330)
1454                 offsets = plat->calib_3v3_offsets;
1455         else if (sdhci->mmc->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_180)
1456                 offsets = plat->calib_1v8_offsets;
1457
1458         return offsets;
1459 }
1460
1461 static void tegra_sdhci_do_calibration(struct sdhci_host *sdhci)
1462 {
1463         unsigned int val;
1464         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1465         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1466         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1467         unsigned int timeout = 10;
1468         unsigned int calib_offsets;
1469
1470         /* No Calibration for sdmmc4 */
1471         if (unlikely(soc_data->nvquirks & NVQUIRK_DISABLE_SDMMC4_CALIB) &&
1472                 (tegra_host->instance == 3))
1473                 return;
1474
1475         if (unlikely(soc_data->nvquirks & NVQUIRK_DISABLE_AUTO_CALIBRATION))
1476                 return;
1477
1478         val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
1479         val &= ~SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK;
1480         if (soc_data->nvquirks & NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD)
1481                 val |= SDMMC_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD_MASK;
1482         val |= 0x7;
1483         sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
1484
1485         /* Enable Auto Calibration*/
1486         val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
1487         val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
1488         val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_START;
1489         if (unlikely(soc_data->nvquirks & NVQUIRK_SET_CALIBRATION_OFFSETS)) {
1490                 calib_offsets = get_calibration_offsets(sdhci);
1491                 if (calib_offsets) {
1492                         /* Program Auto cal PD offset(bits 8:14) */
1493                         val &= ~(0x7F <<
1494                                 SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
1495                         val |= (((calib_offsets >> 8) & 0xFF) <<
1496                                 SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
1497                         /* Program Auto cal PU offset(bits 0:6) */
1498                         val &= ~0x7F;
1499                         val |= (calib_offsets & 0xFF);
1500                 }
1501         }
1502         sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
1503
1504         /* Wait until the calibration is done */
1505         do {
1506                 if (!(sdhci_readl(sdhci, SDMMC_AUTO_CAL_STATUS) &
1507                         SDMMC_AUTO_CAL_STATUS_AUTO_CAL_ACTIVE))
1508                         break;
1509
1510                 mdelay(1);
1511                 timeout--;
1512         } while (timeout);
1513
1514         if (!timeout)
1515                 dev_err(mmc_dev(sdhci->mmc), "Auto calibration failed\n");
1516
1517         if (soc_data->nvquirks & NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD) {
1518                 val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
1519                 val &= ~SDMMC_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD_MASK;
1520                 sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
1521         }
1522
1523         if (unlikely(soc_data->nvquirks & NVQUIRK_SET_DRIVE_STRENGTH)) {
1524                 unsigned int pulldown_code;
1525                 unsigned int pullup_code;
1526                 int pg;
1527                 int err;
1528
1529                 /* Disable Auto calibration */
1530                 val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
1531                 val &= ~SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
1532                 sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
1533
1534                 pg = tegra_drive_get_pingroup(mmc_dev(sdhci->mmc));
1535                 if (pg != -1) {
1536                         /* Get the pull down codes from auto cal status reg */
1537                         pulldown_code = (
1538                                 sdhci_readl(sdhci, SDMMC_AUTO_CAL_STATUS) >>
1539                                 SDMMC_AUTO_CAL_STATUS_PULLDOWN_OFFSET);
1540                         /* Set the pull down in the pinmux reg */
1541                         err = tegra_drive_pinmux_set_pull_down(pg,
1542                                 pulldown_code);
1543                         if (err)
1544                                 dev_err(mmc_dev(sdhci->mmc),
1545                                 "Failed to set pulldown codes %d err %d\n",
1546                                 pulldown_code, err);
1547
1548                         /* Calculate the pull up codes */
1549                         pullup_code = pulldown_code + PULLUP_ADJUSTMENT_OFFSET;
1550                         if (pullup_code >= TEGRA_MAX_PULL)
1551                                 pullup_code = TEGRA_MAX_PULL - 1;
1552                         /* Set the pull up code in the pinmux reg */
1553                         err = tegra_drive_pinmux_set_pull_up(pg, pullup_code);
1554                         if (err)
1555                                 dev_err(mmc_dev(sdhci->mmc),
1556                                 "Failed to set pullup codes %d err %d\n",
1557                                 pullup_code, err);
1558                 }
1559         }
1560 }
1561
1562 static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
1563         unsigned int signal_voltage)
1564 {
1565         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1566         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1567         unsigned int min_uV = tegra_host->vddio_min_uv;
1568         unsigned int max_uV = tegra_host->vddio_max_uv;
1569         unsigned int rc = 0;
1570         u16 ctrl;
1571
1572
1573         ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
1574         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
1575                 ctrl |= SDHCI_CTRL_VDD_180;
1576                 min_uV = SDHOST_LOW_VOLT_MIN;
1577                 max_uV = SDHOST_LOW_VOLT_MAX;
1578         } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1579                 if (ctrl & SDHCI_CTRL_VDD_180)
1580                         ctrl &= ~SDHCI_CTRL_VDD_180;
1581         }
1582
1583         /* Check if the slot can support the required voltage */
1584         if (min_uV > tegra_host->vddio_max_uv)
1585                 return 0;
1586
1587         /* Set/clear the 1.8V signalling */
1588         sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
1589
1590         /* Switch the I/O rail voltage */
1591         rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_SET_VOLT,
1592                 min_uV, max_uV);
1593         if (rc && (signal_voltage == MMC_SIGNAL_VOLTAGE_180)) {
1594                 dev_err(mmc_dev(sdhci->mmc),
1595                         "setting 1.8V failed %d. Revert to 3.3V\n", rc);
1596                 rc = tegra_sdhci_configure_regulators(tegra_host,
1597                         CONFIG_REG_SET_VOLT, SDHOST_HIGH_VOLT_MIN,
1598                         SDHOST_HIGH_VOLT_MAX);
1599         }
1600
1601         return rc;
1602 }
1603
1604 static int tegra_sdhci_configure_regulators(struct sdhci_tegra *tegra_host,
1605         u8 option, int min_uV, int max_uV)
1606 {
1607         int rc = 0;
1608
1609         switch (option) {
1610         case CONFIG_REG_EN:
1611                 if (!tegra_host->is_rail_enabled) {
1612                         if (tegra_host->vdd_slot_reg)
1613                                 rc = regulator_enable(tegra_host->vdd_slot_reg);
1614                         if (tegra_host->vdd_io_reg)
1615                                 rc = regulator_enable(tegra_host->vdd_io_reg);
1616                         tegra_host->is_rail_enabled = true;
1617                 }
1618         break;
1619         case CONFIG_REG_DIS:
1620                 if (tegra_host->is_rail_enabled) {
1621                         if (tegra_host->vdd_io_reg)
1622                                 rc = regulator_disable(tegra_host->vdd_io_reg);
1623                         if (tegra_host->vdd_slot_reg)
1624                                 rc = regulator_disable(
1625                                         tegra_host->vdd_slot_reg);
1626                         tegra_host->is_rail_enabled = false;
1627                 }
1628         break;
1629         case CONFIG_REG_SET_VOLT:
1630                 if (tegra_host->vdd_io_reg)
1631                         rc = regulator_set_voltage(tegra_host->vdd_io_reg,
1632                                 min_uV, max_uV);
1633         break;
1634         default:
1635                 pr_err("Invalid argument passed to reg config %d\n", option);
1636         }
1637
1638         return rc;
1639 }
1640
1641 static void tegra_sdhci_reset(struct sdhci_host *sdhci, u8 mask)
1642 {
1643         unsigned long timeout;
1644
1645         sdhci_writeb(sdhci, mask, SDHCI_SOFTWARE_RESET);
1646
1647         /* Wait max 100 ms */
1648         timeout = 100;
1649
1650         /* hw clears the bit when it's done */
1651         while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & mask) {
1652                 if (timeout == 0) {
1653                         dev_err(mmc_dev(sdhci->mmc), "Reset 0x%x never"
1654                                 "completed.\n", (int)mask);
1655                         return;
1656                 }
1657                 timeout--;
1658                 mdelay(1);
1659         }
1660
1661         tegra_sdhci_reset_exit(sdhci, mask);
1662 }
1663
1664 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
1665         unsigned int tap_delay)
1666 {
1667         u32 vendor_ctrl;
1668
1669         /* Max tap delay value is 255 */
1670         if (tap_delay > MAX_TAP_VALUES) {
1671                 dev_err(mmc_dev(sdhci->mmc),
1672                         "Valid tap range (0-255). Setting tap value %d\n",
1673                         tap_delay);
1674                 dump_stack();
1675                 return;
1676         }
1677
1678         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_CLK_CTRL);
1679         vendor_ctrl &= ~(0xFF << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1680         vendor_ctrl |= (tap_delay << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1681         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VNDR_CLK_CTRL);
1682 }
1683
1684 static int sdhci_tegra_sd_error_stats(struct sdhci_host *host, u32 int_status)
1685 {
1686         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1687         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1688         struct sdhci_tegra_sd_stats *head = tegra_host->sd_stat_head;
1689
1690         if (int_status & SDHCI_INT_DATA_CRC)
1691                 head->data_crc_count++;
1692         if (int_status & SDHCI_INT_CRC)
1693                 head->cmd_crc_count++;
1694         if (int_status & SDHCI_INT_TIMEOUT)
1695                 head->cmd_to_count++;
1696         if (int_status & SDHCI_INT_DATA_TIMEOUT)
1697                 head->data_to_count++;
1698         return 0;
1699 }
1700
1701 static struct tegra_tuning_data *sdhci_tegra_get_tuning_data(
1702         struct sdhci_host *sdhci, unsigned int clock)
1703 {
1704         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1705         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1706         struct tegra_tuning_data *tuning_data;
1707         unsigned int low_freq;
1708         u8 i = 0;
1709
1710         if (tegra_host->tuning_freq_count == 1) {
1711                 tuning_data = &tegra_host->tuning_data[0];
1712                 goto out;
1713         }
1714
1715         /* Get the lowest supported freq */
1716         for (i = 0; i < TUNING_FREQ_COUNT; ++i) {
1717                 low_freq = tegra_host->soc_data->tuning_freq_list[i];
1718                 if (low_freq)
1719                         break;
1720         }
1721
1722         if (clock <= low_freq)
1723                 tuning_data = &tegra_host->tuning_data[0];
1724         else
1725                 tuning_data = &tegra_host->tuning_data[1];
1726
1727 out:
1728         return tuning_data;
1729 }
1730
1731 static void calculate_vmin_values(struct sdhci_host *sdhci,
1732         struct tegra_tuning_data *tuning_data, int vmin, int boot_mv)
1733 {
1734         struct tuning_values *est_values = &tuning_data->est_values;
1735         struct tuning_values *calc_values = &tuning_data->calc_values;
1736         struct tuning_t2t_coeffs *t2t_coeffs = tuning_data->t2t_coeffs;
1737         struct tap_hole_coeffs *thole_coeffs = tuning_data->thole_coeffs;
1738         int vmin_slope, vmin_int, temp_calc_vmin;
1739         int t2t_vmax, t2t_vmin;
1740         int vmax_thole, vmin_thole;
1741
1742         /*
1743          * If current vmin is equal to vmin or vmax of tuning data, use the
1744          * previously calculated estimated T2T values directly. Note that the
1745          * estimated T2T_vmax is not at Vmax specified in tuning data. It is
1746          * the T2T at the boot or max voltage for the current SKU. Hence,
1747          * boot_mv is used in place of t2t_coeffs->vmax.
1748          */
1749         if (vmin == t2t_coeffs->vmin) {
1750                 t2t_vmin = est_values->t2t_vmin;
1751         } else if (vmin == boot_mv) {
1752                 t2t_vmin = est_values->t2t_vmax;
1753         } else {
1754                 /*
1755                  * For any intermediate voltage between boot voltage and vmin
1756                  * of tuning data, calculate the slope and intercept from the
1757                  * t2t at boot_mv and vmin and calculate the actual values.
1758                  */
1759                 t2t_vmax = 1000 / est_values->t2t_vmax;
1760                 t2t_vmin = 1000 / est_values->t2t_vmin;
1761                 vmin_slope = ((t2t_vmax - t2t_vmin) * 1000) /
1762                         (boot_mv - t2t_coeffs->vmin);
1763                 vmin_int = (t2t_vmax * 1000 - (vmin_slope * boot_mv)) / 1000;
1764                 t2t_vmin = (vmin_slope * vmin) / 1000 + vmin_int;
1765                 t2t_vmin = (1000 / t2t_vmin);
1766         }
1767
1768         calc_values->t2t_vmin = (t2t_vmin * calc_values->t2t_vmax) /
1769                 est_values->t2t_vmax;
1770
1771         calc_values->ui_vmin = (1000000 / (tuning_data->freq_hz / 1000000)) /
1772                 calc_values->t2t_vmin;
1773
1774         /* Calculate the vmin tap hole at vmin of tuning data */
1775         temp_calc_vmin = (est_values->t2t_vmin * calc_values->t2t_vmax) /
1776                 est_values->t2t_vmax;
1777         vmin_thole = (thole_coeffs->thole_vmin_int -
1778                 (thole_coeffs->thole_vmin_slope * temp_calc_vmin)) /
1779                 1000;
1780         vmax_thole = calc_values->vmax_thole;
1781
1782         if (vmin == t2t_coeffs->vmin) {
1783                 calc_values->vmin_thole = vmin_thole;
1784         } else if (vmin == boot_mv) {
1785                 calc_values->vmin_thole = vmax_thole;
1786         } else {
1787                 /*
1788                  * Interpolate the tap hole for any intermediate voltage.
1789                  * Calculate the slope and intercept from the available data
1790                  * and use them to calculate the actual values.
1791                  */
1792                 vmin_slope = ((vmax_thole - vmin_thole) * 1000) /
1793                         (boot_mv - t2t_coeffs->vmin);
1794                 vmin_int = (vmax_thole * 1000 - (vmin_slope * boot_mv)) / 1000;
1795                 calc_values->vmin_thole = (vmin_slope * vmin) / 1000 + vmin_int;
1796         }
1797
1798         /* Adjust the partial win start for Vmin boundary */
1799         if (tuning_data->is_partial_win_valid)
1800                 tuning_data->final_tap_data[0].win_start =
1801                         (tuning_data->final_tap_data[0].win_start *
1802                         tuning_data->calc_values.t2t_vmax) /
1803                         tuning_data->calc_values.t2t_vmin;
1804
1805         pr_info("**********Tuning values*********\n");
1806         pr_info("**estimated values**\n");
1807         pr_info("T2T_Vmax %d, T2T_Vmin %d, 1'st_hole_Vmax %d, UI_Vmax %d\n",
1808                 est_values->t2t_vmax, est_values->t2t_vmin,
1809                 est_values->vmax_thole, est_values->ui);
1810         pr_info("**Calculated values**\n");
1811         pr_info("T2T_Vmax %d, 1'st_hole_Vmax %d, UI_Vmax %d\n",
1812                 calc_values->t2t_vmax, calc_values->vmax_thole,
1813                 calc_values->ui);
1814         pr_info("T2T_Vmin %d, 1'st_hole_Vmin %d, UI_Vmin %d\n",
1815                 calc_values->t2t_vmin, calc_values->vmin_thole,
1816                 calc_values->ui_vmin);
1817         pr_info("***********************************\n");
1818 }
1819
1820 static int slide_window_start(struct sdhci_host *sdhci,
1821         struct tegra_tuning_data *tuning_data,
1822         int tap_value, enum tap_win_edge_attr edge_attr, int tap_hole)
1823 {
1824         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1825         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1826         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1827
1828         if (edge_attr == WIN_EDGE_BOUN_START) {
1829                 if (tap_value < 0)
1830                         tap_value += (1000 / tuning_data->calc_values.t2t_vmin);
1831                 else
1832                         tap_value += (1000 / tuning_data->calc_values.t2t_vmax);
1833         } else if (edge_attr == WIN_EDGE_HOLE) {
1834                 if (soc_data->nvquirks & NVQUIRK_TMP_VAR_1_5_TAP_MARGIN)
1835                         tap_value += ((7 * tap_hole) / 100) + 2;
1836                 else
1837                         tap_value += ((7 * tap_hole) / 100) +
1838                         (((2 * (450 / tuning_data->calc_values.t2t_vmax))
1839                         + 1) / 2);
1840         }
1841
1842         if (tap_value > MAX_TAP_VALUES)
1843                 tap_value = MAX_TAP_VALUES;
1844
1845         return tap_value;
1846 }
1847
1848 static int slide_window_end(struct sdhci_host *sdhci,
1849         struct tegra_tuning_data *tuning_data,
1850         int tap_value, enum tap_win_edge_attr edge_attr, int tap_hole)
1851 {
1852         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1853         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1854         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1855
1856         if (edge_attr == WIN_EDGE_BOUN_END) {
1857                 tap_value = (tap_value * tuning_data->calc_values.t2t_vmax) /
1858                         tuning_data->calc_values.t2t_vmin;
1859                 tap_value -= (1000 / tuning_data->calc_values.t2t_vmin);
1860         } else if (edge_attr == WIN_EDGE_HOLE) {
1861                 if (tap_hole > 0)
1862                         tap_value = tap_hole;
1863                 if (soc_data->nvquirks & NVQUIRK_TMP_VAR_1_5_TAP_MARGIN)
1864                         tap_value -= ((7 * tap_hole) / 100) + 2;
1865                 else
1866                         tap_value -= ((7 * tap_hole) / 100) +
1867                         (((2 * (450 / tuning_data->calc_values.t2t_vmin))
1868                         + 1) / 2);
1869         }
1870
1871         return tap_value;
1872 }
1873
1874 static int adjust_window_boundaries(struct sdhci_host *sdhci,
1875         struct tegra_tuning_data *tuning_data,
1876         struct tap_window_data *temp_tap_data)
1877 {
1878         struct tap_window_data *tap_data;
1879         int vmin_tap_hole;
1880         int vmax_tap_hole;
1881         u8 i = 0;
1882
1883         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
1884                 tap_data = &temp_tap_data[i];
1885                 /* Update with next hole if first hole is taken care of */
1886                 if (tap_data->win_start_attr == WIN_EDGE_HOLE)
1887                         vmax_tap_hole = tuning_data->calc_values.vmax_thole +
1888                                 (tap_data->hole_pos - 1) *
1889                                 tuning_data->calc_values.ui;
1890                 tap_data->win_start = slide_window_start(sdhci, tuning_data,
1891                         tap_data->win_start, tap_data->win_start_attr,
1892                         vmax_tap_hole);
1893
1894                 /* Update with next hole if first hole is taken care of */
1895                 if (tap_data->win_end_attr == WIN_EDGE_HOLE)
1896                         vmin_tap_hole = tuning_data->calc_values.vmin_thole +
1897                                 (tap_data->hole_pos - 1) *
1898                                 tuning_data->calc_values.ui_vmin;
1899                 tap_data->win_end = slide_window_end(sdhci, tuning_data,
1900                         tap_data->win_end, tap_data->win_end_attr,
1901                         vmin_tap_hole);
1902         }
1903
1904         pr_info("***********final tuning windows**********\n");
1905         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
1906                 tap_data = &temp_tap_data[i];
1907                 pr_info("win[%d]: %d - %d\n", i, tap_data->win_start,
1908                         tap_data->win_end);
1909         }
1910         pr_info("********************************\n");
1911         return 0;
1912 }
1913
1914 static int find_best_tap_value(struct tegra_tuning_data *tuning_data,
1915         struct tap_window_data *temp_tap_data, int vmin)
1916 {
1917         struct tap_window_data *tap_data;
1918         u8 i = 0, sel_win = 0;
1919         int pref_win = 0, curr_win_size = 0;
1920         int best_tap_value = 0;
1921
1922         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
1923                 tap_data = &temp_tap_data[i];
1924                 if (!i && tuning_data->is_partial_win_valid) {
1925                         pref_win = tap_data->win_end - tap_data->win_start;
1926                         if ((tap_data->win_end * 2) < pref_win)
1927                                 pref_win = tap_data->win_end * 2;
1928                         sel_win = 0;
1929                 } else {
1930                         curr_win_size = tap_data->win_end - tap_data->win_start;
1931                         if ((curr_win_size > 0) && (curr_win_size > pref_win)) {
1932                                 pref_win = curr_win_size;
1933                                 sel_win = i;
1934                         }
1935                 }
1936         }
1937
1938         if (pref_win <= 0) {
1939                 pr_err("No window opening for %d vmin\n", vmin);
1940                 return -1;
1941         }
1942
1943         tap_data = &temp_tap_data[sel_win];
1944         if (!sel_win && tuning_data->is_partial_win_valid) {
1945                 i = sel_win;
1946                 best_tap_value = tap_data->win_end - (pref_win / 2);
1947                 if (best_tap_value < 0)
1948                         best_tap_value = 0;
1949         } else {
1950                 best_tap_value = tap_data->win_start +
1951                         ((tap_data->win_end - tap_data->win_start) *
1952                         tuning_data->calc_values.t2t_vmin) /
1953                         (tuning_data->calc_values.t2t_vmin +
1954                         tuning_data->calc_values.t2t_vmax);
1955         }
1956
1957         pr_err("best tap win - (%d-%d), best tap value %d\n",
1958                 tap_data->win_start, tap_data->win_end, best_tap_value);
1959         return best_tap_value;
1960 }
1961
1962 static int sdhci_tegra_calculate_best_tap(struct sdhci_host *sdhci,
1963         struct tegra_tuning_data *tuning_data)
1964 {
1965         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1966         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1967         struct tap_window_data *temp_tap_data = NULL;
1968         int vmin, curr_vmin, best_tap_value = 0;
1969         int err = 0;
1970
1971         curr_vmin = tegra_dvfs_predict_millivolts(pltfm_host->clk,
1972                 tuning_data->freq_hz);
1973         vmin = curr_vmin;
1974
1975         do {
1976                 SDHCI_TEGRA_DBG("%s: checking for win opening with vmin %d\n",
1977                         mmc_hostname(sdhci->mmc), vmin);
1978                 if ((best_tap_value < 0) &&
1979                         (vmin > tegra_host->boot_vcore_mv)) {
1980                         dev_err(mmc_dev(sdhci->mmc),
1981                                 "No best tap for any vcore range\n");
1982                         return -EINVAL;
1983                 }
1984
1985                 calculate_vmin_values(sdhci, tuning_data, vmin,
1986                         tegra_host->boot_vcore_mv);
1987
1988                 if (temp_tap_data == NULL) {
1989                         temp_tap_data = kzalloc(sizeof(struct tap_window_data) *
1990                                 tuning_data->num_of_valid_tap_wins, GFP_KERNEL);
1991                         if (IS_ERR_OR_NULL(temp_tap_data)) {
1992                                 dev_err(mmc_dev(sdhci->mmc),
1993                                 "No memory for final tap value calculation\n");
1994                                 return -ENOMEM;
1995                         }
1996                 }
1997
1998                 memcpy(temp_tap_data, tuning_data->final_tap_data,
1999                         sizeof(struct tap_window_data) *
2000                         tuning_data->num_of_valid_tap_wins);
2001
2002                 adjust_window_boundaries(sdhci, tuning_data, temp_tap_data);
2003
2004                 best_tap_value = find_best_tap_value(tuning_data,
2005                         temp_tap_data, vmin);
2006
2007                 if (best_tap_value < 0)
2008                         vmin += 50;
2009         } while (best_tap_value < 0);
2010
2011         tuning_data->best_tap_value = best_tap_value;
2012         tuning_data->nom_best_tap_value = best_tap_value;
2013
2014         /* Set the new vmin if there is any change. */
2015         if ((tuning_data->best_tap_value >= 0) && (curr_vmin != vmin))
2016                 err = tegra_dvfs_set_fmax_at_vmin(pltfm_host->clk,
2017                         tuning_data->freq_hz, vmin);
2018
2019         kfree(temp_tap_data);
2020         return err;
2021 }
2022
2023 static int sdhci_tegra_issue_tuning_cmd(struct sdhci_host *sdhci)
2024 {
2025         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2026         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2027         int err = 0;
2028         u8 ctrl;
2029         u32 mask;
2030         unsigned int timeout = 10;
2031         int flags;
2032         u32 intstatus;
2033
2034         mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
2035         while (sdhci_readl(sdhci, SDHCI_PRESENT_STATE) & mask) {
2036                 if (timeout == 0) {
2037                         dev_err(mmc_dev(sdhci->mmc), "Controller never"
2038                                 "released inhibit bit(s).\n");
2039                         err = -ETIMEDOUT;
2040                         goto out;
2041                 }
2042                 timeout--;
2043                 mdelay(1);
2044         }
2045
2046         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
2047         ctrl &= ~SDHCI_CTRL_TUNED_CLK;
2048         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
2049
2050         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
2051         ctrl |= SDHCI_CTRL_EXEC_TUNING;
2052         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
2053
2054         /*
2055          * In response to CMD19, the card sends 64 bytes of tuning
2056          * block to the Host Controller. So we set the block size
2057          * to 64 here.
2058          * In response to CMD21, the card sends 128 bytes of tuning
2059          * block for MMC_BUS_WIDTH_8 and 64 bytes for MMC_BUS_WIDTH_4
2060          * to the Host Controller. So we set the block size to 64 here.
2061          */
2062         sdhci_writew(sdhci, SDHCI_MAKE_BLKSZ(7, tegra_host->tuning_bsize),
2063                 SDHCI_BLOCK_SIZE);
2064
2065         sdhci_writeb(sdhci, 0xE, SDHCI_TIMEOUT_CONTROL);
2066
2067         sdhci_writew(sdhci, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
2068
2069         sdhci_writel(sdhci, 0x0, SDHCI_ARGUMENT);
2070
2071         /* Set the cmd flags */
2072         flags = SDHCI_CMD_RESP_SHORT | SDHCI_CMD_CRC | SDHCI_CMD_DATA;
2073         /* Issue the command */
2074         sdhci_writew(sdhci, SDHCI_MAKE_CMD(
2075                 tegra_host->tuning_opcode, flags), SDHCI_COMMAND);
2076
2077         timeout = 5;
2078         do {
2079                 timeout--;
2080                 mdelay(1);
2081                 intstatus = sdhci_readl(sdhci, SDHCI_INT_STATUS);
2082                 if (intstatus) {
2083                         sdhci_writel(sdhci, intstatus, SDHCI_INT_STATUS);
2084                         break;
2085                 }
2086         } while(timeout);
2087
2088         if ((intstatus & SDHCI_INT_DATA_AVAIL) &&
2089                 !(intstatus & SDHCI_INT_DATA_CRC)) {
2090                 err = 0;
2091                 sdhci->tuning_done = 1;
2092         } else {
2093                 tegra_sdhci_reset(sdhci, SDHCI_RESET_CMD);
2094                 tegra_sdhci_reset(sdhci, SDHCI_RESET_DATA);
2095                 err = -EIO;
2096         }
2097
2098         if (sdhci->tuning_done) {
2099                 sdhci->tuning_done = 0;
2100                 ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
2101                 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING) &&
2102                         (ctrl & SDHCI_CTRL_TUNED_CLK))
2103                         err = 0;
2104                 else
2105                         err = -EIO;
2106         }
2107         mdelay(1);
2108 out:
2109         return err;
2110 }
2111
2112 static int sdhci_tegra_scan_tap_values(struct sdhci_host *sdhci,
2113         unsigned int starting_tap, bool expect_failure)
2114 {
2115         unsigned int tap_value = starting_tap;
2116         int err;
2117         unsigned int retry = TUNING_RETRIES;
2118
2119         do {
2120                 /* Set the tap delay */
2121                 sdhci_tegra_set_tap_delay(sdhci, tap_value);
2122
2123                 /* Run frequency tuning */
2124                 err = sdhci_tegra_issue_tuning_cmd(sdhci);
2125                 if (err && retry) {
2126                         retry--;
2127                         continue;
2128                 } else {
2129                         retry = TUNING_RETRIES;
2130                         if ((expect_failure && !err) ||
2131                                 (!expect_failure && err))
2132                                 break;
2133                 }
2134                 tap_value++;
2135         } while (tap_value <= MAX_TAP_VALUES);
2136
2137         return tap_value;
2138 }
2139
2140 static int calculate_actual_tuning_values(int speedo,
2141         struct tegra_tuning_data *tuning_data, int voltage_mv)
2142 {
2143         struct tuning_t2t_coeffs *t2t_coeffs = tuning_data->t2t_coeffs;
2144         struct tap_hole_coeffs *thole_coeffs = tuning_data->thole_coeffs;
2145         struct tuning_values *calc_values = &tuning_data->calc_values;
2146         int slope, inpt;
2147         int vmax_thole, vmin_thole;
2148
2149         /* T2T_Vmax = (1000000/freq_MHz)/Calc_UI */
2150         calc_values->t2t_vmax = (1000000 / (tuning_data->freq_hz / 1000000)) /
2151                 calc_values->ui;
2152
2153         /*
2154          * Interpolate the tap hole.
2155          * Vmax_1'st_hole = (Calc_T2T_Vmax*(-thole_slope)+thole_tint.
2156          */
2157         vmax_thole = (thole_coeffs->thole_vmax_int -
2158                 (thole_coeffs->thole_vmax_slope * calc_values->t2t_vmax)) /
2159                 1000;
2160         vmin_thole = (thole_coeffs->thole_vmin_int -
2161                 (thole_coeffs->thole_vmin_slope * calc_values->t2t_vmax)) /
2162                 1000;
2163         if (voltage_mv == t2t_coeffs->vmin) {
2164                 calc_values->vmax_thole = vmin_thole;
2165         } else if (voltage_mv == t2t_coeffs->vmax) {
2166                 calc_values->vmax_thole = vmax_thole;
2167         } else {
2168                 slope = (vmax_thole - vmin_thole) /
2169                         (t2t_coeffs->vmax - t2t_coeffs->vmin);
2170                 inpt = ((vmax_thole * 1000) - (slope * 1250)) / 1000;
2171                 calc_values->vmax_thole = slope * voltage_mv + inpt;
2172         }
2173
2174         return 0;
2175 }
2176
2177 /*
2178  * All coeffs are filled up in the table after multiplying by 1000. So, all
2179  * calculations should have a divide by 1000 at the end.
2180  */
2181 static int calculate_estimated_tuning_values(int speedo,
2182         struct tegra_tuning_data *tuning_data, int voltage_mv)
2183 {
2184         struct tuning_t2t_coeffs *t2t_coeffs = tuning_data->t2t_coeffs;
2185         struct tap_hole_coeffs *thole_coeffs = tuning_data->thole_coeffs;
2186         struct tuning_values *est_values = &tuning_data->est_values;
2187         int slope, inpt;
2188         int vmax_t2t, vmin_t2t;
2189         int vmax_thole, vmin_thole;
2190
2191         /* Est_T2T_Vmax = (speedo*(-t2t_slope)+t2t_int */
2192         vmax_t2t = (t2t_coeffs->t2t_vmax_int - (speedo *
2193                 t2t_coeffs->t2t_vmax_slope)) / 1000;
2194         vmin_t2t = (t2t_coeffs->t2t_vmin_int - (speedo *
2195                 t2t_coeffs->t2t_vmin_slope)) / 1000;
2196         est_values->t2t_vmin = vmin_t2t;
2197
2198         if (voltage_mv == t2t_coeffs->vmin) {
2199                 est_values->t2t_vmax = vmin_t2t;
2200         } else if (voltage_mv == t2t_coeffs->vmax) {
2201                 est_values->t2t_vmax = vmax_t2t;
2202         } else {
2203                 vmax_t2t = 1000 / vmax_t2t;
2204                 vmin_t2t = 1000 / vmin_t2t;
2205                 /*
2206                  * For any intermediate voltage between 0.95V and 1.25V,
2207                  * calculate the slope and intercept from the T2T and tap hole
2208                  * values of 0.95V and 1.25V and use them to calculate the
2209                  * actual values. 1/T2T is a linear function of voltage.
2210                  */
2211                 slope = ((vmax_t2t - vmin_t2t) * 1000) /
2212                         (t2t_coeffs->vmax - t2t_coeffs->vmin);
2213                 inpt = (vmax_t2t * 1000 - (slope * t2t_coeffs->vmax)) / 1000;
2214                 est_values->t2t_vmax = (slope * voltage_mv) / 1000 + inpt;
2215                 est_values->t2t_vmax = (1000 / est_values->t2t_vmax);
2216         }
2217
2218         /* Est_UI  = (1000000/freq_MHz)/Est_T2T_Vmax */
2219         est_values->ui = (1000000 / (thole_coeffs->freq_khz / 1000)) /
2220                 est_values->t2t_vmax;
2221
2222         /*
2223          * Est_1'st_hole = (Est_T2T_Vmax*(-thole_slope)) + thole_int.
2224          */
2225         vmax_thole = (thole_coeffs->thole_vmax_int -
2226                 (thole_coeffs->thole_vmax_slope * est_values->t2t_vmax)) / 1000;
2227         vmin_thole = (thole_coeffs->thole_vmin_int -
2228                 (thole_coeffs->thole_vmin_slope * est_values->t2t_vmax)) / 1000;
2229
2230         if (voltage_mv == t2t_coeffs->vmin) {
2231                 est_values->vmax_thole = vmin_thole;
2232         } else if (voltage_mv == t2t_coeffs->vmax) {
2233                 est_values->vmax_thole = vmax_thole;
2234         } else {
2235                 /*
2236                  * For any intermediate voltage between 0.95V and 1.25V,
2237                  * calculate the slope and intercept from the t2t and tap hole
2238                  * values of 0.95V and 1.25V and use them to calculate the
2239                  * actual values. Tap hole is a linear function of voltage.
2240                  */
2241                 slope = ((vmax_thole - vmin_thole) * 1000) /
2242                         (t2t_coeffs->vmax - t2t_coeffs->vmin);
2243                 inpt = (vmax_thole * 1000 - (slope * t2t_coeffs->vmax)) / 1000;
2244                 est_values->vmax_thole = (slope * voltage_mv) / 1000 + inpt;
2245         }
2246         est_values->vmin_thole = vmin_thole;
2247
2248         return 0;
2249 }
2250
2251 /*
2252  * Insert the calculated holes and get the final tap windows
2253  * with the boundaries and holes set.
2254  */
2255 static int adjust_holes_in_tap_windows(struct sdhci_host *sdhci,
2256         struct tegra_tuning_data *tuning_data)
2257 {
2258         struct tap_window_data *tap_data;
2259         struct tap_window_data *final_tap_data;
2260         struct tuning_values *calc_values = &tuning_data->calc_values;
2261         int tap_hole, size = 0;
2262         u8 i = 0, j = 0, num_of_wins, hole_pos = 0;
2263
2264         tuning_data->final_tap_data =
2265                 devm_kzalloc(mmc_dev(sdhci->mmc),
2266                         sizeof(struct tap_window_data) * 42, GFP_KERNEL);
2267         if (IS_ERR_OR_NULL(tuning_data->final_tap_data)) {
2268                 dev_err(mmc_dev(sdhci->mmc), "No mem for final tap wins\n");
2269                 return -ENOMEM;
2270         }
2271
2272         num_of_wins = tuning_data->num_of_valid_tap_wins;
2273         tap_hole = calc_values->vmax_thole;
2274         hole_pos++;
2275         do {
2276                 tap_data = &tuning_data->tap_data[i];
2277                 final_tap_data = &tuning_data->final_tap_data[j];
2278                 if (tap_hole < tap_data->win_start) {
2279                         tap_hole += calc_values->ui;
2280                         hole_pos++;
2281                         continue;
2282                 } else if (tap_hole > tap_data->win_end) {
2283                         memcpy(final_tap_data, tap_data,
2284                                 sizeof(struct tap_window_data));
2285                         i++;
2286                         j++;
2287                         num_of_wins--;
2288                         continue;
2289                 } else if ((tap_hole >= tap_data->win_start) &&
2290                         (tap_hole <= tap_data->win_end)) {
2291                         size = tap_data->win_end - tap_data->win_start;
2292                         do {
2293                                 final_tap_data =
2294                                         &tuning_data->final_tap_data[j];
2295                                 if (tap_hole == tap_data->win_start) {
2296                                         final_tap_data->win_start =
2297                                                 tap_hole + 1;
2298                                         final_tap_data->win_start_attr =
2299                                                 WIN_EDGE_HOLE;
2300                                         final_tap_data->hole_pos = hole_pos;
2301                                         tap_hole += calc_values->ui;
2302                                         hole_pos++;
2303                                 } else {
2304                                         final_tap_data->win_start =
2305                                                 tap_data->win_start;
2306                                         final_tap_data->win_start_attr =
2307                                                 WIN_EDGE_BOUN_START;
2308                                 }
2309                                 if (tap_hole <= tap_data->win_end) {
2310                                         final_tap_data->win_end = tap_hole - 1;
2311                                         final_tap_data->win_end_attr =
2312                                                 WIN_EDGE_HOLE;
2313                                         final_tap_data->hole_pos = hole_pos;
2314                                         tap_data->win_start = tap_hole;
2315                                 } else if (tap_hole > tap_data->win_end) {
2316                                         final_tap_data->win_end =
2317                                                 tap_data->win_end;
2318                                         final_tap_data->win_end_attr =
2319                                                 WIN_EDGE_BOUN_END;
2320                                         tap_data->win_start =
2321                                                 tap_data->win_end;
2322                                 }
2323                                 size = tap_data->win_end - tap_data->win_start;
2324                                 j++;
2325                         } while (size > 0);
2326                         i++;
2327                         num_of_wins--;
2328                 }
2329         } while (num_of_wins > 0);
2330
2331         /* Update the num of valid wins count after tap holes insertion */
2332         tuning_data->num_of_valid_tap_wins = j;
2333
2334         pr_info("********tuning windows after inserting holes*****\n");
2335         pr_info("WIN_ATTR legend: 0-BOUN_ST, 1-BOUN_END, 2-HOLE\n");
2336         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
2337                 final_tap_data = &tuning_data->final_tap_data[i];
2338                 pr_info("win[%d]:%d(%d) - %d(%d)\n", i,
2339                         final_tap_data->win_start,
2340                         final_tap_data->win_start_attr,
2341                         final_tap_data->win_end, final_tap_data->win_end_attr);
2342         }
2343         pr_info("***********************************************\n");
2344
2345         return 0;
2346 }
2347
2348 /*
2349  * Insert the boundaries from negative margin calculations into the windows
2350  * from auto tuning.
2351  */
2352 static int insert_boundaries_in_tap_windows(struct sdhci_host *sdhci,
2353         struct tegra_tuning_data *tuning_data, u8 boun_end)
2354 {
2355         struct tap_window_data *tap_data;
2356         struct tap_window_data *new_tap_data;
2357         struct tap_window_data *temp_tap_data;
2358         struct tuning_values *calc_values = &tuning_data->calc_values;
2359         int curr_boun;
2360         u8 i = 0, j = 0, num_of_wins;
2361         bool get_next_boun = false;
2362
2363         temp_tap_data = devm_kzalloc(mmc_dev(sdhci->mmc),
2364                         sizeof(struct tap_window_data) * 42, GFP_KERNEL);
2365         if (IS_ERR_OR_NULL(temp_tap_data)) {
2366                 dev_err(mmc_dev(sdhci->mmc), "No mem for final tap wins\n");
2367                 return -ENOMEM;
2368         }
2369
2370         num_of_wins = tuning_data->num_of_valid_tap_wins;
2371         curr_boun = boun_end % calc_values->ui;
2372         do {
2373                 if (get_next_boun) {
2374                         curr_boun += calc_values->ui;
2375                         /*
2376                          * If the boun_end exceeds the intial boundary end,
2377                          * just copy remaining windows and return.
2378                          */
2379                         if (curr_boun >= boun_end)
2380                                 curr_boun += MAX_TAP_VALUES;
2381                 }
2382
2383                 tap_data = &tuning_data->tap_data[i];
2384                 new_tap_data = &temp_tap_data[j];
2385                 if (curr_boun <= tap_data->win_start) {
2386                         get_next_boun = true;
2387                         continue;
2388                 } else if (curr_boun >= tap_data->win_end) {
2389                         memcpy(new_tap_data, tap_data,
2390                                 sizeof(struct tap_window_data));
2391                         i++;
2392                         j++;
2393                         num_of_wins--;
2394                         get_next_boun = false;
2395                         continue;
2396                 } else if ((curr_boun >= tap_data->win_start) &&
2397                         (curr_boun <= tap_data->win_end)) {
2398                                 new_tap_data->win_start = tap_data->win_start;
2399                                 new_tap_data->win_start_attr =
2400                                         tap_data->win_start_attr;
2401                                 new_tap_data->win_end = curr_boun - 1;
2402                                 new_tap_data->win_end_attr =
2403                                         tap_data->win_end_attr;
2404                                 j++;
2405                                 new_tap_data = &temp_tap_data[j];
2406                                 new_tap_data->win_start = curr_boun;
2407                                 new_tap_data->win_end = curr_boun;
2408                                 new_tap_data->win_start_attr =
2409                                         WIN_EDGE_BOUN_START;
2410                                 new_tap_data->win_end_attr =
2411                                         WIN_EDGE_BOUN_END;
2412                                 j++;
2413                                 new_tap_data = &temp_tap_data[j];
2414                                 new_tap_data->win_start = curr_boun + 1;
2415                                 new_tap_data->win_start_attr = WIN_EDGE_BOUN_START;
2416                                 new_tap_data->win_end = tap_data->win_end;
2417                                 new_tap_data->win_end_attr =
2418                                         tap_data->win_end_attr;
2419                                 i++;
2420                                 j++;
2421                                 num_of_wins--;
2422                                 get_next_boun = true;
2423                 }
2424         } while (num_of_wins > 0);
2425
2426         /* Update the num of valid wins count after tap holes insertion */
2427         tuning_data->num_of_valid_tap_wins = j;
2428
2429         memcpy(tuning_data->tap_data, temp_tap_data,
2430                 j * sizeof(struct tap_window_data));
2431         SDHCI_TEGRA_DBG("***tuning windows after inserting boundaries***\n");
2432         SDHCI_TEGRA_DBG("WIN_ATTR legend: 0-BOUN_ST, 1-BOUN_END, 2-HOLE\n");
2433         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
2434                 new_tap_data = &tuning_data->tap_data[i];
2435                 SDHCI_TEGRA_DBG("win[%d]:%d(%d) - %d(%d)\n", i,
2436                         new_tap_data->win_start,
2437                         new_tap_data->win_start_attr,
2438                         new_tap_data->win_end, new_tap_data->win_end_attr);
2439         }
2440         SDHCI_TEGRA_DBG("***********************************************\n");
2441
2442         return 0;
2443 }
2444
2445 /*
2446  * Scan for all tap values and get all passing tap windows.
2447  */
2448 static int sdhci_tegra_get_tap_window_data(struct sdhci_host *sdhci,
2449         struct tegra_tuning_data *tuning_data)
2450 {
2451         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2452         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2453         struct tap_window_data *tap_data;
2454         struct tuning_ui tuning_ui[10];
2455         int err = 0, partial_win_start = 0, temp_margin = 0;
2456         unsigned int tap_value, calc_ui = 0;
2457         u8 prev_boundary_end = 0, num_of_wins = 0;
2458         u8 num_of_uis = 0, valid_num_uis = 0;
2459         u8 ref_ui, first_valid_full_win = 0;
2460         u8 boun_end = 0, next_boun_end = 0;
2461         u8 j = 0;
2462         bool valid_ui_found = false;
2463
2464         /*
2465          * Assume there are a max of 10 windows and allocate tap window
2466          * structures for the same. If there are more windows, the array
2467          * size can be adjusted later using realloc.
2468          */
2469         tuning_data->tap_data = devm_kzalloc(mmc_dev(sdhci->mmc),
2470                 sizeof(struct tap_window_data) * 42, GFP_KERNEL);
2471         if (IS_ERR_OR_NULL(tuning_data->tap_data)) {
2472                 dev_err(mmc_dev(sdhci->mmc), "No memory for tap data\n");
2473                 return -ENOMEM;
2474         }
2475
2476         spin_lock(&sdhci->lock);
2477         tap_value = 0;
2478         do {
2479                 tap_data = &tuning_data->tap_data[num_of_wins];
2480                 /* Get the window start */
2481                 tap_value = sdhci_tegra_scan_tap_values(sdhci, tap_value, true);
2482                 tap_data->win_start = min_t(u8, tap_value, MAX_TAP_VALUES);
2483                 tap_value++;
2484                 if (tap_value >= MAX_TAP_VALUES) {
2485                         /* If it's first iteration, then all taps failed */
2486                         if (!num_of_wins) {
2487                                 dev_err(mmc_dev(sdhci->mmc),
2488                                         "All tap values(0-255) failed\n");
2489                                 spin_unlock(&sdhci->lock);
2490                                 return -EINVAL;
2491                         } else {
2492                                 /* All windows obtained */
2493                                 break;
2494                         }
2495                 }
2496
2497                 /* Get the window end */
2498                 tap_value = sdhci_tegra_scan_tap_values(sdhci,
2499                                 tap_value, false);
2500                 tap_data->win_end = min_t(u8, (tap_value - 1), MAX_TAP_VALUES);
2501                 tap_data->win_size = tap_data->win_end - tap_data->win_start;
2502                 tap_value++;
2503
2504                 /*
2505                  * If the size of window is more than 4 taps wide, then it is a
2506                  * valid window. If tap value 0 has passed, then a partial
2507                  * window exists. Mark all the window edges as boundary edges.
2508                  */
2509                 if (tap_data->win_size > 4) {
2510                         if (tap_data->win_start == 0)
2511                                 tuning_data->is_partial_win_valid = true;
2512                         tap_data->win_start_attr = WIN_EDGE_BOUN_START;
2513                         tap_data->win_end_attr = WIN_EDGE_BOUN_END;
2514                 } else {
2515                         /* Invalid window as size is less than 5 taps */
2516                         SDHCI_TEGRA_DBG("Invalid tuning win (%d-%d) ignored\n",
2517                                 tap_data->win_start, tap_data->win_end);
2518                         continue;
2519                 }
2520
2521                 /* Ignore first and last partial UIs */
2522                 if (tap_data->win_end_attr == WIN_EDGE_BOUN_END) {
2523                                 tuning_ui[num_of_uis].ui = tap_data->win_end -
2524                                         prev_boundary_end;
2525                                 tuning_ui[num_of_uis].is_valid_ui = true;
2526                                 num_of_uis++;
2527                         prev_boundary_end = tap_data->win_end;
2528                 }
2529                 num_of_wins++;
2530         } while (tap_value < MAX_TAP_VALUES);
2531         spin_unlock(&sdhci->lock);
2532
2533         tuning_data->num_of_valid_tap_wins = num_of_wins;
2534         valid_num_uis = num_of_uis;
2535
2536         /* Print info of all tap windows */
2537         pr_info("**********Auto tuning windows*************\n");
2538         pr_info("WIN_ATTR legend: 0-BOUN_ST, 1-BOUN_END, 2-HOLE\n");
2539         for (j = 0; j < tuning_data->num_of_valid_tap_wins; j++) {
2540                 tap_data = &tuning_data->tap_data[j];
2541                 pr_info("win[%d]: %d(%d) - %d(%d)\n",
2542                         j, tap_data->win_start, tap_data->win_start_attr,
2543                         tap_data->win_end, tap_data->win_end_attr);
2544         }
2545         pr_info("***************************************\n");
2546
2547         /* Mark the first last partial UIs as invalid */
2548         tuning_ui[0].is_valid_ui = false;
2549         tuning_ui[num_of_uis - 1].is_valid_ui = false;
2550         valid_num_uis -= 2;
2551
2552         /* Discredit all uis at either end with size less than 30% of est ui */
2553         ref_ui = (30 * tuning_data->est_values.ui) / 100;
2554         for (j = 0; j < num_of_uis; j++) {
2555                 if (tuning_ui[j].is_valid_ui) {
2556                         tuning_ui[j].is_valid_ui = false;
2557                         valid_num_uis--;
2558                 }
2559                 if (tuning_ui[j].ui > ref_ui)
2560                         break;
2561         }
2562
2563         for (j = num_of_uis; j > 0; j--) {
2564                 if (tuning_ui[j - 1].ui < ref_ui) {
2565                         if (tuning_ui[j - 1].is_valid_ui) {
2566                                 tuning_ui[j - 1].is_valid_ui = false;
2567                                 valid_num_uis--;
2568                         }
2569                 } else
2570                         break;
2571         }
2572
2573         /* Calculate 0.75*est_UI */
2574         ref_ui = (75 * tuning_data->est_values.ui) / 100;
2575
2576         /*
2577          * Check for valid UIs and discredit invalid UIs. A UI is considered
2578          * valid if it's greater than (0.75*est_UI). If an invalid UI is found,
2579          * also discredit the smaller of the two adjacent windows.
2580          */
2581         for (j = 1; j < (num_of_uis - 1); j++) {
2582                 if (tuning_ui[j].ui > ref_ui && tuning_ui[j].is_valid_ui) {
2583                         tuning_ui[j].is_valid_ui = true;
2584                 } else {
2585                         if (tuning_ui[j].is_valid_ui) {
2586                                 tuning_ui[j].is_valid_ui = false;
2587                                 valid_num_uis--;
2588                         }
2589                         if (!tuning_ui[j + 1].is_valid_ui ||
2590                                 !tuning_ui[j - 1].is_valid_ui) {
2591                                 if (tuning_ui[j - 1].is_valid_ui) {
2592                                         tuning_ui[j - 1].is_valid_ui = false;
2593                                         valid_num_uis--;
2594                                 } else if (tuning_ui[j + 1].is_valid_ui) {
2595                                         tuning_ui[j + 1].is_valid_ui = false;
2596                                         valid_num_uis--;
2597                                 }
2598                         } else {
2599
2600                                 if (tuning_ui[j - 1].ui > tuning_ui[j + 1].ui)
2601                                         tuning_ui[j + 1].is_valid_ui = false;
2602                                 else
2603                                         tuning_ui[j - 1].is_valid_ui = false;
2604                                 valid_num_uis--;
2605                         }
2606                 }
2607         }
2608
2609         /* Calculate the cumulative UI if there are valid UIs left */
2610         if (valid_num_uis) {
2611                 for (j = 0; j < num_of_uis; j++)
2612                         if (tuning_ui[j].is_valid_ui) {
2613                                 calc_ui += tuning_ui[j].ui;
2614                                 if (!first_valid_full_win)
2615                                         first_valid_full_win = j;
2616                         }
2617         }
2618
2619         if (calc_ui) {
2620                 tuning_data->calc_values.ui = (calc_ui / valid_num_uis);
2621                 valid_ui_found = true;
2622         } else {
2623                 tuning_data->calc_values.ui = tuning_data->est_values.ui;
2624                 valid_ui_found = false;
2625         }
2626
2627         SDHCI_TEGRA_DBG("****Tuning UIs***********\n");
2628         for (j = 0; j < num_of_uis; j++)
2629                 SDHCI_TEGRA_DBG("Tuning UI[%d] : %d, Is valid[%d]\n",
2630                         j, tuning_ui[j].ui, tuning_ui[j].is_valid_ui);
2631         SDHCI_TEGRA_DBG("*************************\n");
2632
2633         /* Get the calculated tuning values */
2634         err = calculate_actual_tuning_values(tegra_host->speedo, tuning_data,
2635                 tegra_host->boot_vcore_mv);
2636
2637         /*
2638          * Calculate negative margin if partial win is valid. There are two
2639          * cases here.
2640          * Case 1: If Avg_UI is found, then keep subtracting avg_ui from start
2641          * of first valid full window until a value <=0 is obtained.
2642          * Case 2: If Avg_UI is not found, subtract avg_ui from all boundary
2643          * starts until a value <=0 is found.
2644          */
2645         if (tuning_data->is_partial_win_valid && (num_of_wins > 1)) {
2646                 if (valid_ui_found) {
2647                         partial_win_start =
2648                         tuning_data->tap_data[first_valid_full_win].win_start;
2649                         boun_end = partial_win_start;
2650                         partial_win_start %= tuning_data->calc_values.ui;
2651                         partial_win_start -= tuning_data->calc_values.ui;
2652                 } else {
2653                         for (j = 0; j < NEG_MAR_CHK_WIN_COUNT; j++) {
2654                                 temp_margin =
2655                                         tuning_data->tap_data[j + 1].win_start;
2656                                 if (!boun_end)
2657                                         boun_end = temp_margin;
2658                                 else if (!next_boun_end)
2659                                         next_boun_end = temp_margin;
2660                                 temp_margin %= tuning_data->calc_values.ui;
2661                                 temp_margin -= tuning_data->calc_values.ui;
2662                                 if (!partial_win_start ||
2663                                         (temp_margin > partial_win_start))
2664                                         partial_win_start = temp_margin;
2665                         }
2666                 }
2667                 if (partial_win_start <= 0)
2668                         tuning_data->tap_data[0].win_start = partial_win_start;
2669         }
2670
2671         if (boun_end)
2672                 insert_boundaries_in_tap_windows(sdhci, tuning_data, boun_end);
2673         if (next_boun_end)
2674                 insert_boundaries_in_tap_windows(sdhci, tuning_data, next_boun_end);
2675
2676         /* Insert calculated holes into the windows */
2677         err = adjust_holes_in_tap_windows(sdhci, tuning_data);
2678
2679         return err;
2680 }
2681
2682 static void sdhci_tegra_dump_tuning_constraints(struct sdhci_host *sdhci)
2683 {
2684         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2685         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2686         struct tegra_tuning_data *tuning_data;
2687         u8 i;
2688
2689         SDHCI_TEGRA_DBG("%s: Num of tuning frequencies%d\n",
2690                 mmc_hostname(sdhci->mmc), tegra_host->tuning_freq_count);
2691         for (i = 0; i < tegra_host->tuning_freq_count; ++i) {
2692                 tuning_data = &tegra_host->tuning_data[i];
2693                 SDHCI_TEGRA_DBG("%s: Tuning freq[%d]: %d, freq band %d\n",
2694                         mmc_hostname(sdhci->mmc), i,
2695                         tuning_data->freq_hz, tuning_data->freq_band);
2696         }
2697 }
2698
2699 static unsigned int get_tuning_voltage(struct sdhci_tegra *tegra_host, u8 *mask)
2700 {
2701         u8 i = 0;
2702
2703         i = ffs(*mask) - 1;
2704         *mask &= ~(1 << i);
2705         switch (BIT(i)) {
2706         case NOMINAL_VCORE_TUN:
2707                 return tegra_host->nominal_vcore_mv;
2708         case BOOT_VCORE_TUN:
2709                 return tegra_host->boot_vcore_mv;
2710         case MIN_OVERRIDE_VCORE_TUN:
2711                 return tegra_host->min_vcore_override_mv;
2712         }
2713
2714         return tegra_host->boot_vcore_mv;
2715 }
2716
2717 static u8 sdhci_tegra_get_freq_point(struct sdhci_host *sdhci)
2718 {
2719         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2720         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2721         const unsigned int *freq_list;
2722         u32 curr_clock;
2723         u8 i;
2724
2725         curr_clock = sdhci->max_clk;
2726         freq_list = tegra_host->soc_data->tuning_freq_list;
2727
2728         for (i = 0; i < TUNING_FREQ_COUNT; ++i)
2729                 if (curr_clock <= freq_list[i])
2730                         return i;
2731
2732         return TUNING_MAX_FREQ;
2733 }
2734
2735 /*
2736  * The frequency tuning algorithm tries to calculate the tap-to-tap delay
2737  * UI and estimate holes using equations and predetermined coefficients from
2738  * the characterization data. The algorithm will not work without this data.
2739  */
2740 static int find_tuning_coeffs_data(struct sdhci_host *sdhci,
2741                                         bool force_retuning)
2742 {
2743         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2744         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2745         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
2746         struct tegra_tuning_data *tuning_data;
2747         struct tuning_t2t_coeffs *t2t_coeffs;
2748         struct tap_hole_coeffs *thole_coeffs;
2749         const char *dev_id;
2750         unsigned int freq_khz;
2751         u8 i, j;
2752         bool coeffs_set = false;
2753
2754         dev_id = dev_name(mmc_dev(sdhci->mmc));
2755         /* Find the coeffs data for all supported frequencies */
2756         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
2757                 tuning_data = &tegra_host->tuning_data[i];
2758
2759                 /* Skip if T2T coeffs are already found */
2760                 if (tuning_data->t2t_coeffs == NULL || force_retuning) {
2761                         t2t_coeffs = soc_data->t2t_coeffs;
2762                         for (j = 0; j < soc_data->t2t_coeffs_count; j++) {
2763                                 if (!strcmp(dev_id, t2t_coeffs->dev_id)) {
2764                                         tuning_data->t2t_coeffs = t2t_coeffs;
2765                                         coeffs_set = true;
2766                                         dev_info(mmc_dev(sdhci->mmc),
2767                                                 "Found T2T coeffs data\n");
2768                                         break;
2769                                 }
2770                                 t2t_coeffs++;
2771                         }
2772                         if (!coeffs_set) {
2773                                 dev_err(mmc_dev(sdhci->mmc),
2774                                         "T2T coeffs data missing\n");
2775                                 tuning_data->t2t_coeffs = NULL;
2776                                 return -ENODATA;
2777                         }
2778                 }
2779
2780                 coeffs_set = false;
2781                 /* Skip if tap hole coeffs are already found */
2782                 if (tuning_data->thole_coeffs == NULL || force_retuning) {
2783                         thole_coeffs = soc_data->tap_hole_coeffs;
2784                         freq_khz = tuning_data->freq_hz / 1000;
2785                         for (j = 0; j < soc_data->tap_hole_coeffs_count; j++) {
2786                                 if (!strcmp(dev_id, thole_coeffs->dev_id) &&
2787                                         (freq_khz == thole_coeffs->freq_khz)) {
2788                                         tuning_data->thole_coeffs =
2789                                                 thole_coeffs;
2790                                         coeffs_set = true;
2791                                         dev_info(mmc_dev(sdhci->mmc),
2792                                                 "%dMHz tap hole coeffs found\n",
2793                                                 (freq_khz / 1000));
2794                                         break;
2795                                 }
2796                                 thole_coeffs++;
2797                         }
2798
2799                         if (!coeffs_set) {
2800                                 dev_err(mmc_dev(sdhci->mmc),
2801                                         "%dMHz Tap hole coeffs data missing\n",
2802                                         (freq_khz / 1000));
2803                                 tuning_data->thole_coeffs = NULL;
2804                                 return -ENODATA;
2805                         }
2806                 }
2807         }
2808
2809         return 0;
2810 }
2811
2812 /*
2813  * Determines the numbers of frequencies required and then fills up the tuning
2814  * constraints for each of the frequencies. The data of lower frequency is
2815  * filled first and then the higher frequency data. Max supported frequencies
2816  * is currently two.
2817  */
2818 static int setup_freq_constraints(struct sdhci_host *sdhci,
2819         const unsigned int *freq_list)
2820 {
2821         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2822         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2823         struct tegra_tuning_data *tuning_data;
2824         int i, freq_count;
2825         u8 freq_band;
2826
2827         if ((sdhci->mmc->ios.timing != MMC_TIMING_UHS_SDR50) &&
2828                 (sdhci->mmc->caps2 & MMC_CAP2_FREQ_SCALING))
2829                 freq_count = DFS_FREQ_COUNT;
2830         else
2831                 freq_count = 1;
2832
2833         freq_band = sdhci_tegra_get_freq_point(sdhci);
2834         /* Fill up the req frequencies */
2835         switch (freq_count) {
2836         case 1:
2837                 tuning_data = &tegra_host->tuning_data[0];
2838                 tuning_data->freq_hz = sdhci->max_clk;
2839                 tuning_data->freq_band = freq_band;
2840                 tuning_data->constraints.vcore_mask =
2841                         tuning_vcore_constraints[freq_band].vcore_mask;
2842                 tuning_data->nr_voltages =
2843                         hweight32(tuning_data->constraints.vcore_mask);
2844         break;
2845         case 2:
2846                 tuning_data = &tegra_host->tuning_data[1];
2847                 tuning_data->freq_hz = sdhci->max_clk;
2848                 tuning_data->freq_band = freq_band;
2849                 tuning_data->constraints.vcore_mask =
2850                         tuning_vcore_constraints[freq_band].vcore_mask;
2851                 tuning_data->nr_voltages =
2852                         hweight32(tuning_data->constraints.vcore_mask);
2853
2854                 tuning_data = &tegra_host->tuning_data[0];
2855                 for (i = (freq_band - 1); i >= 0; i--) {
2856                         if (!freq_list[i])
2857                                 continue;
2858                         tuning_data->freq_hz = freq_list[i];
2859                         tuning_data->freq_band = i;
2860                         tuning_data->nr_voltages = 1;
2861                         tuning_data->constraints.vcore_mask =
2862                                 tuning_vcore_constraints[i].vcore_mask;
2863                         tuning_data->nr_voltages =
2864                                 hweight32(tuning_data->constraints.vcore_mask);
2865                 }
2866         break;
2867         default:
2868                 dev_err(mmc_dev(sdhci->mmc), "Unsupported freq count\n");
2869                 freq_count = -1;
2870         }
2871
2872         return freq_count;
2873 }
2874
2875 /*
2876  * Get the supported frequencies and other tuning related constraints for each
2877  * frequency. The supported frequencies should be determined from the list of
2878  * frequencies in the soc data and also consider the platform clock limits as
2879  * well as any DFS related restrictions.
2880  */
2881 static int sdhci_tegra_get_tuning_constraints(struct sdhci_host *sdhci,
2882                                                         bool force_retuning)
2883 {
2884         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2885         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2886         const unsigned int *freq_list;
2887         int err = 0;
2888
2889         /* A valid freq count means freq constraints are already set up */
2890         if (!tegra_host->tuning_freq_count || force_retuning) {
2891                 freq_list = tegra_host->soc_data->tuning_freq_list;
2892                 tegra_host->tuning_freq_count =
2893                         setup_freq_constraints(sdhci, freq_list);
2894                 if (tegra_host->tuning_freq_count < 0) {
2895                         dev_err(mmc_dev(sdhci->mmc),
2896                                 "Invalid tuning freq count\n");
2897                         return -EINVAL;
2898                 }
2899         }
2900
2901         err = find_tuning_coeffs_data(sdhci, force_retuning);
2902         if (err)
2903                 return err;
2904
2905         sdhci_tegra_dump_tuning_constraints(sdhci);
2906
2907         return err;
2908 }
2909
2910 /*
2911  * During boot, only boot voltage for vcore can be set. Check if the current
2912  * voltage is allowed to be used. Nominal and min override voltages can be
2913  * set once boot is done. This will be notified through late subsys init call.
2914  */
2915 static int sdhci_tegra_set_tuning_voltage(struct sdhci_host *sdhci,
2916         unsigned int voltage)
2917 {
2918         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2919         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2920         int err = 0;
2921         bool nom_emc_freq_set = false;
2922
2923         if (voltage && (voltage != tegra_host->boot_vcore_mv) &&
2924                 !vcore_overrides_allowed) {
2925                 SDHCI_TEGRA_DBG("%s: Override vcore %dmv not allowed\n",
2926                         mmc_hostname(sdhci->mmc), voltage);
2927                 return -EPERM;
2928         }
2929
2930         SDHCI_TEGRA_DBG("%s: Setting vcore override %d\n",
2931                 mmc_hostname(sdhci->mmc), voltage);
2932         /* First clear any previous dvfs override settings */
2933         err = tegra_dvfs_override_core_voltage(pltfm_host->clk, 0);
2934         if (!voltage)
2935                 return err;
2936
2937         /* EMC clock freq boost might be required for nominal core voltage */
2938         if ((voltage == tegra_host->nominal_vcore_mv) &&
2939                 tegra_host->plat->en_nominal_vcore_tuning &&
2940                 tegra_host->emc_clk) {
2941                 err = clk_set_rate(tegra_host->emc_clk,
2942                         SDMMC_EMC_NOM_VOLT_FREQ);
2943                 if (err)
2944                         dev_err(mmc_dev(sdhci->mmc),
2945                                 "Failed to set emc nom clk freq %d\n", err);
2946                 else
2947                         nom_emc_freq_set = true;
2948         }
2949
2950         err = tegra_dvfs_override_core_voltage(pltfm_host->clk, voltage);
2951         if (err)
2952                 dev_err(mmc_dev(sdhci->mmc),
2953                         "failed to set vcore override %dmv\n", voltage);
2954
2955         /* Revert emc clock to normal freq */
2956         if (nom_emc_freq_set) {
2957                 err = clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_MAX_FREQ);
2958                 if (err)
2959                         dev_err(mmc_dev(sdhci->mmc),
2960                                 "Failed to revert emc nom clk freq %d\n", err);
2961         }
2962
2963         return err;
2964 }
2965
2966 static int sdhci_tegra_run_tuning(struct sdhci_host *sdhci,
2967         struct tegra_tuning_data *tuning_data)
2968 {
2969         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2970         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2971         int err = 0;
2972         int voltage = 0;
2973         u8 i, vcore_mask = 0;
2974
2975         vcore_mask = tuning_data->constraints.vcore_mask;
2976         for (i = 0; i < tuning_data->nr_voltages; i++) {
2977                 voltage = get_tuning_voltage(tegra_host, &vcore_mask);
2978                 err = sdhci_tegra_set_tuning_voltage(sdhci, voltage);
2979                 if (err) {
2980                         dev_err(mmc_dev(sdhci->mmc),
2981                                 "Unable to set override voltage.\n");
2982                         return err;
2983                 }
2984
2985                 /* Get the tuning window info */
2986                 SDHCI_TEGRA_DBG("Getting tuning windows...\n");
2987                 err = sdhci_tegra_get_tap_window_data(sdhci, tuning_data);
2988                 if (err) {
2989                         dev_err(mmc_dev(sdhci->mmc),
2990                                 "Failed to get tap win %d\n", err);
2991                         return err;
2992                 }
2993                 SDHCI_TEGRA_DBG("%s: %d tuning window data obtained\n",
2994                         mmc_hostname(sdhci->mmc), tuning_data->freq_hz);
2995         }
2996         return err;
2997 }
2998
2999 static int sdhci_tegra_verify_best_tap(struct sdhci_host *sdhci)
3000 {
3001         struct tegra_tuning_data *tuning_data;
3002         int err = 0;
3003
3004         tuning_data = sdhci_tegra_get_tuning_data(sdhci, sdhci->max_clk);
3005         if ((tuning_data->best_tap_value < 0) ||
3006                 (tuning_data->best_tap_value > MAX_TAP_VALUES)) {
3007                 dev_err(mmc_dev(sdhci->mmc),
3008                         "Trying to verify invalid best tap value\n");
3009                 return -EINVAL;
3010         } else {
3011                 dev_err(mmc_dev(sdhci->mmc),
3012                         "%s: tuning freq %dhz, best tap %d\n",
3013                         __func__, tuning_data->freq_hz,
3014                         tuning_data->best_tap_value);
3015         }
3016
3017         /* Set the best tap value */
3018         sdhci_tegra_set_tap_delay(sdhci, tuning_data->best_tap_value);
3019
3020         /* Run tuning after setting the best tap value */
3021         err = sdhci_tegra_issue_tuning_cmd(sdhci);
3022         if (err)
3023                 dev_err(mmc_dev(sdhci->mmc),
3024                         "%dMHz best tap value verification failed %d\n",
3025                         tuning_data->freq_hz, err);
3026         return err;
3027 }
3028
3029 static int sdhci_tegra_execute_tuning(struct sdhci_host *sdhci, u32 opcode)
3030 {
3031         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3032         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3033         struct tegra_tuning_data *tuning_data;
3034         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
3035         int err;
3036         u16 ctrl_2;
3037         u32 misc_ctrl;
3038         u32 ier;
3039         u8 i, set_retuning = 0;
3040         bool force_retuning = false;
3041         bool enable_lb_clk;
3042
3043         /* Tuning is valid only in SDR104 and SDR50 modes */
3044         ctrl_2 = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
3045         if (!(((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
3046                 (((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
3047                 (sdhci->flags & SDHCI_SDR50_NEEDS_TUNING))))
3048                         return 0;
3049
3050         /* Tuning should be done only for MMC_BUS_WIDTH_8 and MMC_BUS_WIDTH_4 */
3051         if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
3052                 tegra_host->tuning_bsize = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_8;
3053         else if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
3054                 tegra_host->tuning_bsize = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_4;
3055         else
3056                 return -EINVAL;
3057
3058         SDHCI_TEGRA_DBG("%s: Starting freq tuning\n", mmc_hostname(sdhci->mmc));
3059         enable_lb_clk = (soc_data->nvquirks &
3060                         NVQUIRK_DISABLE_EXTERNAL_LOOPBACK) &&
3061                         (tegra_host->instance == 2);
3062         if (enable_lb_clk) {
3063                 misc_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_MISC_CTRL);
3064                 misc_ctrl &= ~(1 <<
3065                         SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
3066                 sdhci_writel(sdhci, misc_ctrl, SDHCI_VNDR_MISC_CTRL);
3067         }
3068         mutex_lock(&tuning_mutex);
3069
3070         /* Set the tuning command to be used */
3071         tegra_host->tuning_opcode = opcode;
3072
3073         /*
3074          * Disable all interrupts signalling.Enable interrupt status
3075          * detection for buffer read ready and data crc. We use
3076          * polling for tuning as it involves less overhead.
3077          */
3078         ier = sdhci_readl(sdhci, SDHCI_INT_ENABLE);
3079         sdhci_writel(sdhci, 0, SDHCI_SIGNAL_ENABLE);
3080         sdhci_writel(sdhci, SDHCI_INT_DATA_AVAIL |
3081                 SDHCI_INT_DATA_CRC, SDHCI_INT_ENABLE);
3082
3083         /*
3084          * If tuning is already done and retune request is not set, then skip
3085          * best tap value calculation and use the old best tap value. If the
3086          * previous best tap value verification failed, force retuning.
3087          */
3088         if (tegra_host->tuning_status == TUNING_STATUS_DONE) {
3089                 err = sdhci_tegra_verify_best_tap(sdhci);
3090                 if (err) {
3091                         dev_err(mmc_dev(sdhci->mmc),
3092                                 "Prev best tap failed. Re-running tuning\n");
3093                         force_retuning = true;
3094                 } else {
3095                         goto out;
3096                 }
3097         }
3098
3099         if (tegra_host->force_retune == true) {
3100                 force_retuning = true;
3101                 tegra_host->force_retune = false;
3102         }
3103
3104         tegra_host->tuning_status = 0;
3105         err = sdhci_tegra_get_tuning_constraints(sdhci, force_retuning);
3106         if (err) {
3107                 dev_err(mmc_dev(sdhci->mmc),
3108                         "Failed to get tuning constraints\n");
3109                 goto out;
3110         }
3111
3112         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
3113                 tuning_data = &tegra_host->tuning_data[i];
3114                 if (tuning_data->tuning_done && !force_retuning)
3115                         continue;
3116
3117                 SDHCI_TEGRA_DBG("%s: Setting tuning freq%d\n",
3118                         mmc_hostname(sdhci->mmc), tuning_data->freq_hz);
3119                 tegra_sdhci_set_clock(sdhci, tuning_data->freq_hz);
3120
3121                 SDHCI_TEGRA_DBG("%s: Calculating estimated tuning values\n",
3122                         mmc_hostname(sdhci->mmc));
3123                 err = calculate_estimated_tuning_values(tegra_host->speedo,
3124                         tuning_data, tegra_host->boot_vcore_mv);
3125                 if (err)
3126                         goto out;
3127
3128                 SDHCI_TEGRA_DBG("Running tuning...\n");
3129                 err = sdhci_tegra_run_tuning(sdhci, tuning_data);
3130                 if (err)
3131                         goto out;
3132
3133                 SDHCI_TEGRA_DBG("calculating best tap value\n");
3134                 err = sdhci_tegra_calculate_best_tap(sdhci, tuning_data);
3135                 if (err)
3136                         goto out;
3137
3138                 err = sdhci_tegra_verify_best_tap(sdhci);
3139                 if (!err && !set_retuning) {
3140                         tuning_data->tuning_done = true;
3141                         tegra_host->tuning_status |= TUNING_STATUS_DONE;
3142                 } else {
3143                         tegra_host->tuning_status |= TUNING_STATUS_RETUNE;
3144                 }
3145         }
3146 out:
3147         /* Release any override core voltages set */
3148         sdhci_tegra_set_tuning_voltage(sdhci, 0);
3149
3150         /* Enable interrupts. Enable full range for core voltage */
3151         sdhci_writel(sdhci, ier, SDHCI_INT_ENABLE);
3152         sdhci_writel(sdhci, ier, SDHCI_SIGNAL_ENABLE);
3153         mutex_unlock(&tuning_mutex);
3154
3155         SDHCI_TEGRA_DBG("%s: Freq tuning done\n", mmc_hostname(sdhci->mmc));
3156         if (enable_lb_clk) {
3157                 misc_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_MISC_CTRL);
3158                 if (err) {
3159                         /* Tuning is failed and card will try to enumerate in
3160                          * Legacy High Speed mode. So, Enable External Loopback
3161                          * for SDMMC3.
3162                          */
3163                         misc_ctrl |= (1 <<
3164                                 SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
3165                 } else {
3166                         misc_ctrl &= ~(1 <<
3167                                 SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
3168                 }
3169                 sdhci_writel(sdhci, misc_ctrl, SDHCI_VNDR_MISC_CTRL);
3170         }
3171         return err;
3172 }
3173
3174 static int __init sdhci_tegra_enable_vcore_override_tuning(void)
3175 {
3176         vcore_overrides_allowed = true;
3177         maintain_boot_voltage = false;
3178         return 0;
3179 }
3180 late_initcall(sdhci_tegra_enable_vcore_override_tuning);
3181
3182 static int tegra_sdhci_suspend(struct sdhci_host *sdhci)
3183 {
3184         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3185         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3186         int err = 0;
3187
3188         tegra_sdhci_set_clock(sdhci, 0);
3189
3190         /* Disable the power rails if any */
3191         if (tegra_host->card_present) {
3192                 err = tegra_sdhci_configure_regulators(tegra_host,
3193                         CONFIG_REG_DIS, 0, 0);
3194                 if (err)
3195                         dev_err(mmc_dev(sdhci->mmc),
3196                         "Regulators disable in suspend failed %d\n", err);
3197         }
3198         return err;
3199 }
3200
3201 static int tegra_sdhci_resume(struct sdhci_host *sdhci)
3202 {
3203         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3204         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3205         struct platform_device *pdev;
3206         struct tegra_sdhci_platform_data *plat;
3207         int err;
3208
3209         pdev = to_platform_device(mmc_dev(sdhci->mmc));
3210         plat = pdev->dev.platform_data;
3211
3212         if (gpio_is_valid(plat->cd_gpio)) {
3213                 tegra_host->card_present =
3214                         (gpio_get_value_cansleep(plat->cd_gpio) == 0);
3215         }
3216
3217         /* Setting the min identification clock of freq 400KHz */
3218         tegra_sdhci_set_clock(sdhci, 400000);
3219
3220         /* Enable the power rails if any */
3221         if (tegra_host->card_present) {
3222                 err = tegra_sdhci_configure_regulators(tegra_host,
3223                         CONFIG_REG_EN, 0, 0);
3224                 if (err) {
3225                         dev_err(mmc_dev(sdhci->mmc),
3226                                 "Regulators enable in resume failed %d\n", err);
3227                         return err;
3228                 }
3229                 if (tegra_host->vdd_io_reg) {
3230                         if (plat->mmc_data.ocr_mask &
3231                                                 SDHOST_1V8_OCR_MASK)
3232                                 tegra_sdhci_signal_voltage_switch(sdhci,
3233                                                 MMC_SIGNAL_VOLTAGE_180);
3234                         else
3235                                 tegra_sdhci_signal_voltage_switch(sdhci,
3236                                                 MMC_SIGNAL_VOLTAGE_330);
3237                 }
3238         }
3239
3240         /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
3241         if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
3242                 tegra_sdhci_reset(sdhci, SDHCI_RESET_ALL);
3243                 sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
3244                 sdhci->pwr = 0;
3245         }
3246
3247         return 0;
3248 }
3249
3250 static void tegra_sdhci_post_resume(struct sdhci_host *sdhci)
3251 {
3252         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3253         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3254
3255         /* Turn OFF the clocks if the device is not present */
3256         if ((!tegra_host->card_present || !sdhci->mmc->card) &&
3257                 tegra_host->clk_enabled)
3258                 tegra_sdhci_set_clock(sdhci, 0);
3259 }
3260
3261 /*
3262  * For tegra specific tuning, core voltage has to be fixed at different
3263  * voltages to get the tap values. Fixing the core voltage during tuning for one
3264  * device might affect transfers of other SDMMC devices. Check if tuning mutex
3265  * is locked before starting a data transfer. The new tuning procedure might
3266  * take at max 1.5s for completion for a single run. Taking DFS into count,
3267  * setting the max timeout for tuning mutex check a 3 secs. Since tuning is
3268  * run only during boot or the first time device is inserted, there wouldn't
3269  * be any delays in cmd/xfer execution once devices enumeration is done.
3270  */
3271 static void tegra_sdhci_get_bus(struct sdhci_host *sdhci)
3272 {
3273         unsigned int timeout = 300;
3274
3275         while (mutex_is_locked(&tuning_mutex)) {
3276                 msleep(10);
3277                 --timeout;
3278                 if (!timeout) {
3279                         dev_err(mmc_dev(sdhci->mmc),
3280                                 "Tuning mutex locked for long time\n");
3281                         return;
3282                 }
3283         };
3284 }
3285
3286 /*
3287  * The host/device can be powered off before the retuning request is handled in
3288  * case of SDIDO being off if Wifi is turned off, sd card removal etc. In such
3289  * cases, cancel the pending tuning timer and remove any core voltage
3290  * constraints that are set earlier.
3291  */
3292 static void tegra_sdhci_power_off(struct sdhci_host *sdhci, u8 power_mode)
3293 {
3294         int retuning_req_set = 0;
3295
3296         retuning_req_set = (timer_pending(&sdhci->tuning_timer) ||
3297                 (sdhci->flags & SDHCI_NEEDS_RETUNING));
3298
3299         if (retuning_req_set) {
3300                 del_timer_sync(&sdhci->tuning_timer);
3301
3302                 if (boot_volt_req_refcount)
3303                         --boot_volt_req_refcount;
3304
3305                 if (!boot_volt_req_refcount) {
3306                         sdhci_tegra_set_tuning_voltage(sdhci, 0);
3307                         SDHCI_TEGRA_DBG("%s: Release override as host is off\n",
3308                                 mmc_hostname(sdhci->mmc));
3309                 }
3310         }
3311 }
3312
3313 static int show_polling_period(void *data, u64 *value)
3314 {
3315         struct sdhci_host *host = (struct sdhci_host *)data;
3316
3317         if (host->mmc->dev_stats != NULL)
3318                 *value = host->mmc->dev_stats->polling_interval;
3319
3320         return 0;
3321 }
3322
3323 static int set_polling_period(void *data, u64 value)
3324 {
3325         struct sdhci_host *host = (struct sdhci_host *)data;
3326
3327         if (host->mmc->dev_stats != NULL) {
3328                 /* Limiting the maximum polling period to 1 sec */
3329                 if (value > 1000)
3330                         value = 1000;
3331                 host->mmc->dev_stats->polling_interval = value;
3332         }
3333
3334         return 0;
3335 }
3336 static int show_active_load_high_threshold(void *data, u64 *value)
3337 {
3338         struct sdhci_host *host = (struct sdhci_host *)data;
3339         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3340         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3341         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
3342
3343         if (gov_data != NULL)
3344                 *value = gov_data->act_load_high_threshold;
3345
3346         return 0;
3347 }
3348
3349 static int set_active_load_high_threshold(void *data, u64 value)
3350 {
3351         struct sdhci_host *host = (struct sdhci_host *)data;
3352         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3353         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3354         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
3355
3356         if (gov_data != NULL) {
3357                 /* Maximum threshold load percentage is 100.*/
3358                 if (value > 100)
3359                         value = 100;
3360                 gov_data->act_load_high_threshold = value;
3361         }
3362
3363         return 0;
3364 }
3365
3366 DEFINE_SIMPLE_ATTRIBUTE(sdhci_polling_period_fops, show_polling_period,
3367                 set_polling_period, "%llu\n");
3368 DEFINE_SIMPLE_ATTRIBUTE(sdhci_active_load_high_threshold_fops,
3369                 show_active_load_high_threshold,
3370                 set_active_load_high_threshold, "%llu\n");
3371
3372 static void sdhci_tegra_error_stats_debugfs(struct sdhci_host *host)
3373 {
3374         struct dentry *root = host->debugfs_root;
3375         struct dentry *dfs_root;
3376         unsigned saved_line;
3377
3378         if (!root) {
3379                 root = debugfs_create_dir(dev_name(mmc_dev(host->mmc)), NULL);
3380                 if (IS_ERR_OR_NULL(root)) {
3381                         saved_line = __LINE__;
3382                         goto err_root;
3383                 }
3384                 host->debugfs_root = root;
3385         }
3386
3387         dfs_root = debugfs_create_dir("dfs_stats_dir", root);
3388         if (IS_ERR_OR_NULL(dfs_root)) {
3389                 saved_line = __LINE__;
3390                 goto err_node;
3391         }
3392
3393         if (!debugfs_create_file("error_stats", S_IRUSR, root, host,
3394                                 &sdhci_host_fops)) {
3395                 saved_line = __LINE__;
3396                 goto err_node;
3397         }
3398         if (!debugfs_create_file("dfs_stats", S_IRUSR, dfs_root, host,
3399                                 &sdhci_host_dfs_fops)) {
3400                 saved_line = __LINE__;
3401                 goto err_node;
3402         }
3403         if (!debugfs_create_file("polling_period", 0644, dfs_root, (void *)host,
3404                                 &sdhci_polling_period_fops)) {
3405                 saved_line = __LINE__;
3406                 goto err_node;
3407         }
3408         if (!debugfs_create_file("active_load_high_threshold", 0644,
3409                                 dfs_root, (void *)host,
3410                                 &sdhci_active_load_high_threshold_fops)) {
3411                 saved_line = __LINE__;
3412                 goto err_node;
3413         }
3414         return;
3415
3416 err_node:
3417         debugfs_remove_recursive(root);
3418         host->debugfs_root = NULL;
3419 err_root:
3420         pr_err("%s %s: Failed to initialize debugfs functionality at line=%d\n", __func__,
3421                 mmc_hostname(host->mmc), saved_line);
3422         return;
3423 }
3424
3425 static ssize_t sdhci_handle_boost_mode_tap(struct device *dev,
3426         struct device_attribute *attr, const char *buf, size_t count)
3427 {
3428         int tap_cmd;
3429         struct mmc_card *card;
3430         char *p = (char *)buf;
3431         struct sdhci_host *host = dev_get_drvdata(dev);
3432         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3433         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3434         struct tegra_tuning_data *tuning_data;
3435         u32 present_state;
3436         u8 timeout;
3437         bool clk_set_for_tap_prog = false;
3438
3439         tap_cmd = memparse(p, &p);
3440
3441         card = host->mmc->card;
3442         if (!card)
3443                 return -ENODEV;
3444
3445         /* if not uhs -- no tuning and no tap value to set */
3446         if (!mmc_sd_card_uhs(card) && !mmc_card_hs200(card))
3447                 return count;
3448
3449         /* if no change in tap value -- just exit */
3450         if (tap_cmd == tegra_host->tap_cmd)
3451                 return count;
3452
3453         if ((tap_cmd != TAP_CMD_TRIM_DEFAULT_VOLTAGE) &&
3454                 (tap_cmd != TAP_CMD_TRIM_HIGH_VOLTAGE)) {
3455                 pr_info("echo 1 > cmd_state  # to set normal voltage\n");
3456                 pr_info("echo 2 > cmd_state  # to set high voltage\n");
3457                 return -EINVAL;
3458         }
3459
3460         tegra_host->tap_cmd = tap_cmd;
3461         tuning_data = sdhci_tegra_get_tuning_data(host, host->max_clk);
3462         /* Check if host clock is enabled */
3463         if (!tegra_host->clk_enabled) {
3464                 /* Nothing to do if the host is not powered ON */
3465                 if (host->mmc->ios.power_mode != MMC_POWER_ON)
3466                         return count;
3467                 else {
3468                         tegra_sdhci_set_clock(host, host->mmc->ios.clock);
3469                         clk_set_for_tap_prog = true;
3470                 }
3471         } else {
3472                 timeout = 10;
3473                 /* Wait for any on-going data transfers */
3474                 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
3475                 while (present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ)) {
3476                         if (!timeout)
3477                                 break;
3478                         timeout--;
3479                         mdelay(1);
3480                         present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
3481                 };
3482         }
3483         spin_lock(&host->lock);
3484         switch (tap_cmd) {
3485         case TAP_CMD_TRIM_DEFAULT_VOLTAGE:
3486                 /* set tap value for voltage range 1.1 to 1.25 */
3487                 sdhci_tegra_set_tap_delay(host, tuning_data->best_tap_value);
3488                 break;
3489
3490         case TAP_CMD_TRIM_HIGH_VOLTAGE:
3491                 /* set tap value for voltage range 1.25 to 1.39 */
3492                 sdhci_tegra_set_tap_delay(host,
3493                         tuning_data->nom_best_tap_value);
3494                 break;
3495         }
3496         spin_unlock(&host->lock);
3497         if (clk_set_for_tap_prog) {
3498                 tegra_sdhci_set_clock(host, 0);
3499                 clk_set_for_tap_prog = false;
3500         }
3501         return count;
3502 }
3503
3504 static ssize_t sdhci_show_turbo_mode(struct device *dev,
3505                         struct device_attribute *attr, char *buf)
3506 {
3507         struct sdhci_host *host = dev_get_drvdata(dev);
3508         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3509         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3510
3511         return sprintf(buf, "%d\n", tegra_host->tap_cmd);
3512 }
3513
3514 static DEVICE_ATTR(cmd_state, 0644, sdhci_show_turbo_mode,
3515                         sdhci_handle_boost_mode_tap);
3516
3517 static int tegra_sdhci_reboot_notify(struct notifier_block *nb,
3518                                 unsigned long event, void *data)
3519 {
3520         struct sdhci_tegra *tegra_host =
3521                 container_of(nb, struct sdhci_tegra, reboot_notify);
3522         int err;
3523
3524         switch (event) {
3525         case SYS_RESTART:
3526         case SYS_POWER_OFF:
3527                 err = tegra_sdhci_configure_regulators(tegra_host,
3528                         CONFIG_REG_DIS, 0, 0);
3529                 if (err)
3530                         pr_err("Disable regulator in reboot notify failed %d\n",
3531                                 err);
3532                 return NOTIFY_OK;
3533         }
3534         return NOTIFY_DONE;
3535 }
3536
3537 void tegra_sdhci_ios_config_enter(struct sdhci_host *sdhci, struct mmc_ios *ios)
3538 {
3539         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3540         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3541         struct clk *new_mode_clk;
3542         bool change_clk = false;
3543
3544         /*
3545          * Tegra sdmmc controllers require clock to be enabled for any register
3546          * access. Set the minimum controller clock if no clock is requested.
3547          */
3548         if (!sdhci->clock && !ios->clock) {
3549                 tegra_sdhci_set_clock(sdhci, sdhci->mmc->f_min);
3550                 sdhci->clock = sdhci->mmc->f_min;
3551         } else if (ios->clock && (ios->clock != sdhci->clock)) {
3552                 tegra_sdhci_set_clock(sdhci, ios->clock);
3553         }
3554
3555         /*
3556          * Check for DDR50 mode setting and set ddr_clk if not already
3557          * done. Return if only one clock option is available.
3558          */
3559         if (!tegra_host->ddr_clk || !tegra_host->sdr_clk) {
3560                 return;
3561         } else {
3562                 if ((ios->timing == MMC_TIMING_UHS_DDR50) &&
3563                         !tegra_host->is_ddr_clk_set) {
3564                         change_clk = true;
3565                         new_mode_clk = tegra_host->ddr_clk;
3566                 } else if ((ios->timing != MMC_TIMING_UHS_DDR50) &&
3567                         tegra_host->is_ddr_clk_set) {
3568                         change_clk = true;
3569                         new_mode_clk = tegra_host->sdr_clk;
3570                 }
3571
3572                 if (change_clk) {
3573                         tegra_sdhci_set_clock(sdhci, 0);
3574                         pltfm_host->clk = new_mode_clk;
3575                         /* Restore the previous frequency */
3576                         tegra_sdhci_set_clock(sdhci, sdhci->max_clk);
3577                         tegra_host->is_ddr_clk_set =
3578                                 !tegra_host->is_ddr_clk_set;
3579                 }
3580         }
3581 }
3582
3583 void tegra_sdhci_ios_config_exit(struct sdhci_host *sdhci, struct mmc_ios *ios)
3584 {
3585         /*
3586          * Do any required handling for retuning requests before powering off
3587          * the host.
3588          */
3589         if (ios->power_mode == MMC_POWER_OFF)
3590                 tegra_sdhci_power_off(sdhci, ios->power_mode);
3591
3592         /*
3593          * In case of power off, turn off controller clock now as all the
3594          * required register accesses are already done.
3595          */
3596         if (!ios->clock && !sdhci->mmc->skip_host_clkgate)
3597                 tegra_sdhci_set_clock(sdhci, 0);
3598 }
3599
3600 static const struct sdhci_ops tegra_sdhci_ops = {
3601         .get_ro     = tegra_sdhci_get_ro,
3602         .get_cd     = tegra_sdhci_get_cd,
3603         .read_l     = tegra_sdhci_readl,
3604         .read_w     = tegra_sdhci_readw,
3605         .write_l    = tegra_sdhci_writel,
3606         .write_w    = tegra_sdhci_writew,
3607         .platform_bus_width = tegra_sdhci_buswidth,
3608         .set_clock              = tegra_sdhci_set_clock,
3609         .suspend                = tegra_sdhci_suspend,
3610         .resume                 = tegra_sdhci_resume,
3611         .platform_resume        = tegra_sdhci_post_resume,
3612         .platform_reset_exit    = tegra_sdhci_reset_exit,
3613         .platform_get_bus       = tegra_sdhci_get_bus,
3614         .platform_ios_config_enter      = tegra_sdhci_ios_config_enter,
3615         .platform_ios_config_exit       = tegra_sdhci_ios_config_exit,
3616         .set_uhs_signaling      = tegra_sdhci_set_uhs_signaling,
3617         .switch_signal_voltage  = tegra_sdhci_signal_voltage_switch,
3618         .switch_signal_voltage_exit = tegra_sdhci_do_calibration,
3619         .execute_freq_tuning    = sdhci_tegra_execute_tuning,
3620         .sd_error_stats         = sdhci_tegra_sd_error_stats,
3621 #ifdef CONFIG_MMC_FREQ_SCALING
3622         .dfs_gov_init           = sdhci_tegra_freq_gov_init,
3623         .dfs_gov_get_target_freq        = sdhci_tegra_get_target_freq,
3624 #endif
3625 };
3626
3627 static struct sdhci_pltfm_data sdhci_tegra11_pdata = {
3628         .quirks = TEGRA_SDHCI_QUIRKS,
3629         .quirks2 = TEGRA_SDHCI_QUIRKS2,
3630         .ops  = &tegra_sdhci_ops,
3631 };
3632
3633 static struct sdhci_tegra_soc_data soc_data_tegra11 = {
3634         .pdata = &sdhci_tegra11_pdata,
3635         .nvquirks = TEGRA_SDHCI_NVQUIRKS |
3636                     NVQUIRK_SET_DRIVE_STRENGTH |
3637                     NVQUIRK_SET_TRIM_DELAY |
3638                     NVQUIRK_ENABLE_DDR50 |
3639                     NVQUIRK_ENABLE_HS200 |
3640                     NVQUIRK_INFINITE_ERASE_TIMEOUT |
3641                     NVQUIRK_DISABLE_EXTERNAL_LOOPBACK |
3642                     NVQUIRK_DISABLE_SDMMC4_CALIB,
3643         .parent_clk_list = {"pll_p", "pll_c"},
3644         .tuning_freq_list = {81600000, 156000000, 200000000},
3645         .t2t_coeffs = t11x_tuning_coeffs,
3646         .t2t_coeffs_count = 3,
3647         .tap_hole_coeffs = t11x_tap_hole_coeffs,
3648         .tap_hole_coeffs_count = 12,
3649 };
3650
3651 static struct sdhci_pltfm_data sdhci_tegra12_pdata = {
3652         .quirks = TEGRA_SDHCI_QUIRKS,
3653         .quirks2 = TEGRA_SDHCI_QUIRKS2 |
3654                 SDHCI_QUIRK2_SUPPORT_64BIT_DMA,
3655         .ops  = &tegra_sdhci_ops,
3656 };
3657
3658 static struct sdhci_tegra_soc_data soc_data_tegra12 = {
3659         .pdata = &sdhci_tegra12_pdata,
3660         .nvquirks = TEGRA_SDHCI_NVQUIRKS |
3661                     NVQUIRK_SET_TRIM_DELAY |
3662                     NVQUIRK_ENABLE_DDR50 |
3663                     NVQUIRK_ENABLE_HS200 |
3664                     NVQUIRK_INFINITE_ERASE_TIMEOUT |
3665                     NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD |
3666                     NVQUIRK_HIGH_FREQ_TAP_PROCEDURE |
3667                     NVQUIRK_SET_CALIBRATION_OFFSETS |
3668                     NVQUIRK_DISABLE_EXTERNAL_LOOPBACK,
3669         .parent_clk_list = {"pll_p", "pll_c"},
3670         .tuning_freq_list = {81600000, 136000000, 200000000},
3671         .t2t_coeffs = t12x_tuning_coeffs,
3672         .t2t_coeffs_count = 3,
3673         .tap_hole_coeffs = t12x_tap_hole_coeffs,
3674         .tap_hole_coeffs_count = 13,
3675 };
3676
3677 static const struct of_device_id sdhci_tegra_dt_match[] = {
3678         { .compatible = "nvidia,tegra124-sdhci", .data = &soc_data_tegra12 },
3679         { .compatible = "nvidia,tegra114-sdhci", .data = &soc_data_tegra11 },
3680         {}
3681 };
3682 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
3683
3684 static struct tegra_sdhci_platform_data *sdhci_tegra_dt_parse_pdata(
3685                                                 struct platform_device *pdev)
3686 {
3687         int val;
3688         struct tegra_sdhci_platform_data *plat;
3689         struct device_node *np = pdev->dev.of_node;
3690         u32 bus_width;
3691
3692         if (!np)
3693                 return NULL;
3694
3695         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
3696         if (!plat) {
3697                 dev_err(&pdev->dev, "Can't allocate platform data\n");
3698                 return NULL;
3699         }
3700
3701         plat->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
3702         plat->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
3703         plat->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
3704
3705         if (of_property_read_u32(np, "bus-width", &bus_width) == 0 &&
3706             bus_width == 8)
3707                 plat->is_8bit = 1;
3708
3709         of_property_read_u32(np, "tap-delay", &plat->tap_delay);
3710         of_property_read_u32(np, "trim-delay", &plat->trim_delay);
3711         of_property_read_u32(np, "ddr-clk-limit", &plat->ddr_clk_limit);
3712         of_property_read_u32(np, "max-clk-limit", &plat->max_clk_limit);
3713
3714         of_property_read_u32(np, "uhs_mask", &plat->uhs_mask);
3715
3716         if (of_find_property(np, "built-in", NULL))
3717                 plat->mmc_data.built_in = 1;
3718
3719         if (!of_property_read_u32(np, "mmc-ocr-mask", &val)) {
3720                 if (val == 0)
3721                         plat->mmc_data.ocr_mask = MMC_OCR_1V8_MASK;
3722                 else if (val == 1)
3723                         plat->mmc_data.ocr_mask = MMC_OCR_2V8_MASK;
3724                 else if (val == 2)
3725                         plat->mmc_data.ocr_mask = MMC_OCR_3V2_MASK;
3726                 else if (val == 3)
3727                         plat->mmc_data.ocr_mask = MMC_OCR_3V3_MASK;
3728         }
3729         return plat;
3730 }
3731
3732 static int sdhci_tegra_probe(struct platform_device *pdev)
3733 {
3734         const struct of_device_id *match;
3735         const struct sdhci_tegra_soc_data *soc_data;
3736         struct sdhci_host *host;
3737         struct sdhci_pltfm_host *pltfm_host;
3738         struct tegra_sdhci_platform_data *plat;
3739         struct sdhci_tegra *tegra_host;
3740         unsigned int low_freq;
3741         int rc;
3742         u8 i;
3743
3744         match = of_match_device(sdhci_tegra_dt_match, &pdev->dev);
3745         if (match) {
3746                 soc_data = match->data;
3747         } else {
3748                 /* Use id tables and remove the following chip defines */
3749 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
3750                 soc_data = &soc_data_tegra11;
3751 #else
3752                 soc_data = &soc_data_tegra12;
3753 #endif
3754         }
3755
3756         host = sdhci_pltfm_init(pdev, soc_data->pdata);
3757
3758         /* sdio delayed clock gate quirk in sdhci_host used */
3759         host->quirks2 |= SDHCI_QUIRK2_DELAYED_CLK_GATE;
3760
3761         if (IS_ERR(host))
3762                 return PTR_ERR(host);
3763
3764         pltfm_host = sdhci_priv(host);
3765
3766         plat = pdev->dev.platform_data;
3767
3768         if (plat == NULL)
3769                 plat = sdhci_tegra_dt_parse_pdata(pdev);
3770
3771         if (plat == NULL) {
3772                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
3773                 rc = -ENXIO;
3774                 goto err_no_plat;
3775         }
3776
3777         tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL);
3778         if (!tegra_host) {
3779                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n");
3780                 rc = -ENOMEM;
3781                 goto err_no_plat;
3782         }
3783
3784         tegra_host->plat = plat;
3785         pdev->dev.platform_data = plat;
3786
3787         tegra_host->sd_stat_head = devm_kzalloc(&pdev->dev,
3788                 sizeof(struct sdhci_tegra_sd_stats), GFP_KERNEL);
3789         if (!tegra_host->sd_stat_head) {
3790                 dev_err(mmc_dev(host->mmc), "failed to allocate sd_stat_head\n");
3791                 rc = -ENOMEM;
3792                 goto err_power_req;
3793         }
3794
3795         tegra_host->soc_data = soc_data;
3796         pltfm_host->priv = tegra_host;
3797
3798         for (i = 0; i < ARRAY_SIZE(soc_data->parent_clk_list); i++) {
3799                 if (!soc_data->parent_clk_list[i])
3800                         continue;
3801                 if (!strcmp(soc_data->parent_clk_list[i], "pll_c")) {
3802                         pll_c = clk_get_sys(NULL, "pll_c");
3803                         if (IS_ERR(pll_c)) {
3804                                 rc = PTR_ERR(pll_c);
3805                                 dev_err(mmc_dev(host->mmc),
3806                                         "clk error in getting pll_c: %d\n", rc);
3807                         }
3808                         pll_c_rate = clk_get_rate(pll_c);
3809                 }
3810
3811                 if (!strcmp(soc_data->parent_clk_list[i], "pll_p")) {
3812                         pll_p = clk_get_sys(NULL, "pll_p");
3813                         if (IS_ERR(pll_p)) {
3814                                 rc = PTR_ERR(pll_p);
3815                                 dev_err(mmc_dev(host->mmc),
3816                                         "clk error in getting pll_p: %d\n", rc);
3817                         }
3818                         pll_p_rate = clk_get_rate(pll_p);
3819                 }
3820         }
3821
3822 #ifdef CONFIG_MMC_EMBEDDED_SDIO
3823         if (plat->mmc_data.embedded_sdio)
3824                 mmc_set_embedded_sdio_data(host->mmc,
3825                         &plat->mmc_data.embedded_sdio->cis,
3826                         &plat->mmc_data.embedded_sdio->cccr,
3827                         plat->mmc_data.embedded_sdio->funcs,
3828                         plat->mmc_data.embedded_sdio->num_funcs);
3829 #endif
3830
3831         if (gpio_is_valid(plat->power_gpio)) {
3832                 rc = gpio_request(plat->power_gpio, "sdhci_power");
3833                 if (rc) {
3834                         dev_err(mmc_dev(host->mmc),
3835                                 "failed to allocate power gpio\n");
3836                         goto err_power_req;
3837                 }
3838                 gpio_direction_output(plat->power_gpio, 1);
3839         }
3840
3841         if (gpio_is_valid(plat->cd_gpio)) {
3842                 rc = gpio_request(plat->cd_gpio, "sdhci_cd");
3843                 if (rc) {
3844                         dev_err(mmc_dev(host->mmc),
3845                                 "failed to allocate cd gpio\n");
3846                         goto err_cd_req;
3847                 }
3848                 gpio_direction_input(plat->cd_gpio);
3849
3850                 tegra_host->card_present =
3851                         (gpio_get_value_cansleep(plat->cd_gpio) == 0);
3852
3853         } else if (plat->mmc_data.register_status_notify) {
3854                 plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
3855         }
3856
3857         if (plat->mmc_data.status) {
3858                 plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
3859         }
3860
3861         if (gpio_is_valid(plat->wp_gpio)) {
3862                 rc = gpio_request(plat->wp_gpio, "sdhci_wp");
3863                 if (rc) {
3864                         dev_err(mmc_dev(host->mmc),
3865                                 "failed to allocate wp gpio\n");
3866                         goto err_wp_req;
3867                 }
3868                 gpio_direction_input(plat->wp_gpio);
3869         }
3870
3871         /*
3872          * If there is no card detect gpio, assume that the
3873          * card is always present.
3874          */
3875         if (!gpio_is_valid(plat->cd_gpio))
3876                 tegra_host->card_present = 1;
3877
3878         if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
3879                 tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
3880                 tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
3881         } else if (plat->mmc_data.ocr_mask & MMC_OCR_2V8_MASK) {
3882                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_2V8;
3883                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3884         } else if (plat->mmc_data.ocr_mask & MMC_OCR_3V2_MASK) {
3885                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_3V2;
3886                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3887         } else if (plat->mmc_data.ocr_mask & MMC_OCR_3V3_MASK) {
3888                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_3V3;
3889                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3890         } else {
3891                 /*
3892                  * Set the minV and maxV to default
3893                  * voltage range of 2.7V - 3.6V
3894                  */
3895                 tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
3896                 tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3897         }
3898
3899         tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc),
3900                                                         "vddio_sdmmc");
3901         if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
3902                 dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
3903                         "Assuming vddio_sdmmc is not required.\n",
3904                         "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
3905                 tegra_host->vdd_io_reg = NULL;
3906         } else {
3907                 rc = tegra_sdhci_configure_regulators(tegra_host,
3908                         CONFIG_REG_SET_VOLT,
3909                         tegra_host->vddio_min_uv,
3910                         tegra_host->vddio_max_uv);
3911                 if (rc) {
3912                         dev_err(mmc_dev(host->mmc),
3913                                 "Init volt(%duV-%duV) setting failed %d\n",
3914                                 tegra_host->vddio_min_uv,
3915                                 tegra_host->vddio_max_uv, rc);
3916                         regulator_put(tegra_host->vdd_io_reg);
3917                         tegra_host->vdd_io_reg = NULL;
3918                 }
3919         }
3920
3921         tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc),
3922                                                         "vddio_sd_slot");
3923         if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
3924                 dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
3925                         " Assuming vddio_sd_slot is not required.\n",
3926                         "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
3927                 tegra_host->vdd_slot_reg = NULL;
3928         }
3929
3930         if (tegra_host->card_present) {
3931                 rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_EN,
3932                         0, 0);
3933                 if (rc) {
3934                         dev_err(mmc_dev(host->mmc),
3935                                 "Enable regulators failed in probe %d\n", rc);
3936                         goto err_clk_get;
3937                 }
3938         }
3939
3940         tegra_pd_add_device(&pdev->dev);
3941         pm_runtime_enable(&pdev->dev);
3942
3943         /* Get the ddr clock */
3944         tegra_host->ddr_clk = clk_get(mmc_dev(host->mmc), "ddr");
3945         if (IS_ERR(tegra_host->ddr_clk)) {
3946                 dev_err(mmc_dev(host->mmc), "ddr clk err\n");
3947                 tegra_host->ddr_clk = NULL;
3948         }
3949
3950         /* Get high speed clock */
3951         tegra_host->sdr_clk = clk_get(mmc_dev(host->mmc), NULL);
3952         if (IS_ERR(tegra_host->sdr_clk)) {
3953                 dev_err(mmc_dev(host->mmc), "sdr clk err\n");
3954                 tegra_host->sdr_clk = NULL;
3955                 /* If both ddr and sdr clks are missing, then fail probe */
3956                 if (!tegra_host->ddr_clk && !tegra_host->sdr_clk) {
3957                         dev_err(mmc_dev(host->mmc),
3958                                 "Failed to get ddr and sdr clks\n");
3959                         rc = -EINVAL;
3960                         goto err_clk_get;
3961                 }
3962         }
3963
3964         if (tegra_host->sdr_clk) {
3965                 pltfm_host->clk = tegra_host->sdr_clk;
3966                 tegra_host->is_ddr_clk_set = false;
3967         } else {
3968                 pltfm_host->clk = tegra_host->ddr_clk;
3969                 tegra_host->is_ddr_clk_set = true;
3970         }
3971
3972         if (clk_get_parent(pltfm_host->clk) == pll_c)
3973                 tegra_host->is_parent_pllc = true;
3974
3975         pm_runtime_get_sync(&pdev->dev);
3976         rc = clk_prepare_enable(pltfm_host->clk);
3977         if (rc != 0)
3978                 goto err_clk_put;
3979
3980         tegra_host->emc_clk = devm_clk_get(mmc_dev(host->mmc), "emc");
3981         if (IS_ERR_OR_NULL(tegra_host->emc_clk)) {
3982                 dev_err(mmc_dev(host->mmc), "Can't get emc clk\n");
3983                 tegra_host->emc_clk = NULL;
3984         } else {
3985                 clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_MAX_FREQ);
3986         }
3987
3988         tegra_host->sclk = devm_clk_get(mmc_dev(host->mmc), "sclk");
3989         if (IS_ERR_OR_NULL(tegra_host->sclk)) {
3990                 dev_err(mmc_dev(host->mmc), "Can't get sclk clock\n");
3991                 tegra_host->sclk = NULL;
3992         } else {
3993                 clk_set_rate(tegra_host->sclk, SDMMC_AHB_MAX_FREQ);
3994         }
3995         pltfm_host->priv = tegra_host;
3996         tegra_host->clk_enabled = true;
3997         host->is_clk_on = tegra_host->clk_enabled;
3998         mutex_init(&tegra_host->set_clock_mutex);
3999
4000         tegra_host->max_clk_limit = plat->max_clk_limit;
4001         tegra_host->ddr_clk_limit = plat->ddr_clk_limit;
4002         tegra_host->instance = pdev->id;
4003         tegra_host->tap_cmd = TAP_CMD_TRIM_DEFAULT_VOLTAGE;
4004         tegra_host->speedo = plat->cpu_speedo;
4005         dev_info(mmc_dev(host->mmc), "Speedo value %d\n", tegra_host->speedo);
4006         host->mmc->pm_caps |= plat->pm_caps;
4007         host->mmc->pm_flags |= plat->pm_flags;
4008
4009         host->mmc->caps |= MMC_CAP_ERASE;
4010         /* enable 1/8V DDR capable */
4011         host->mmc->caps |= MMC_CAP_1_8V_DDR;
4012         if (plat->is_8bit)
4013                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
4014         host->mmc->caps |= MMC_CAP_SDIO_IRQ;
4015         host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
4016         if (plat->mmc_data.built_in) {
4017                 host->mmc->caps |= MMC_CAP_NONREMOVABLE;
4018         }
4019         host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
4020
4021         /* disable access to boot partitions */
4022         host->mmc->caps2 |= MMC_CAP2_BOOTPART_NOACC;
4023
4024 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
4025         if (soc_data->nvquirks & NVQUIRK_ENABLE_HS200)
4026                 host->mmc->caps2 |= MMC_CAP2_HS200;
4027 #ifdef CONFIG_TEGRA_FPGA_PLATFORM
4028         /* Enable HS200 mode */
4029         host->mmc->caps2 |= MMC_CAP2_HS200;
4030 #else
4031         host->mmc->caps2 |= MMC_CAP2_CACHE_CTRL;
4032         host->mmc->caps |= MMC_CAP_CMD23;
4033         host->mmc->caps2 |= MMC_CAP2_PACKED_CMD;
4034 #endif
4035 #endif
4036
4037         /*
4038          * Enable dyamic frequency scaling support only if the platform clock
4039          * limit is higher than the lowest supported frequency by tuning.
4040          */
4041         for (i = 0; i < TUNING_FREQ_COUNT; i++) {
4042                 low_freq = soc_data->tuning_freq_list[i];
4043                 if (low_freq)
4044                         break;
4045         }
4046         if (plat->en_freq_scaling && (plat->max_clk_limit > low_freq))
4047                 host->mmc->caps2 |= MMC_CAP2_FREQ_SCALING;
4048
4049         if (!plat->disable_clock_gate)
4050                 host->mmc->caps2 |= MMC_CAP2_CLOCK_GATING;
4051
4052         if (plat->nominal_vcore_mv)
4053                 tegra_host->nominal_vcore_mv = plat->nominal_vcore_mv;
4054         if (plat->min_vcore_override_mv)
4055                 tegra_host->min_vcore_override_mv = plat->min_vcore_override_mv;
4056         if (plat->boot_vcore_mv)
4057                 tegra_host->boot_vcore_mv = plat->boot_vcore_mv;
4058         dev_info(mmc_dev(host->mmc),
4059                 "Tuning constraints: nom_mv %d, boot_mv %d, min_or_mv %d\n",
4060                 tegra_host->nominal_vcore_mv, tegra_host->boot_vcore_mv,
4061                 tegra_host->min_vcore_override_mv);
4062
4063         /*
4064          * If nominal voltage is equal to boot voltage, there is no need for
4065          * nominal voltage tuning.
4066          */
4067         if (plat->nominal_vcore_mv <= plat->boot_vcore_mv)
4068                 plat->en_nominal_vcore_tuning = false;
4069
4070         INIT_DELAYED_WORK(&host->delayed_clk_gate_wrk, delayed_clk_gate_cb);
4071         rc = sdhci_add_host(host);
4072         if (rc)
4073                 goto err_add_host;
4074
4075         if (gpio_is_valid(plat->cd_gpio)) {
4076                 rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
4077                         carddetect_irq,
4078                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
4079                         mmc_hostname(host->mmc), host);
4080                 if (rc) {
4081                         dev_err(mmc_dev(host->mmc), "request irq error\n");
4082                         goto err_cd_irq_req;
4083                 }
4084                 if (!plat->cd_wakeup_incapable) {
4085                         rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
4086                         if (rc < 0)
4087                                 dev_err(mmc_dev(host->mmc),
4088                                         "SD card wake-up event registration "
4089                                         "failed with error: %d\n", rc);
4090                 }
4091         }
4092         sdhci_tegra_error_stats_debugfs(host);
4093         device_create_file(&pdev->dev, &dev_attr_cmd_state);
4094
4095         /* Enable async suspend/resume to reduce LP0 latency */
4096         device_enable_async_suspend(&pdev->dev);
4097
4098         if (plat->power_off_rail) {
4099                 tegra_host->reboot_notify.notifier_call =
4100                         tegra_sdhci_reboot_notify;
4101                 register_reboot_notifier(&tegra_host->reboot_notify);
4102         }
4103         return 0;
4104
4105 err_cd_irq_req:
4106         if (gpio_is_valid(plat->cd_gpio))
4107                 gpio_free(plat->cd_gpio);
4108 err_add_host:
4109         if (tegra_host->is_ddr_clk_set)
4110                 clk_disable_unprepare(tegra_host->ddr_clk);
4111         else
4112                 clk_disable_unprepare(tegra_host->sdr_clk);
4113         pm_runtime_put_sync(&pdev->dev);
4114 err_clk_put:
4115         if (tegra_host->ddr_clk)
4116                 clk_put(tegra_host->ddr_clk);
4117         if (tegra_host->sdr_clk)
4118                 clk_put(tegra_host->sdr_clk);
4119 err_clk_get:
4120         if (gpio_is_valid(plat->wp_gpio))
4121                 gpio_free(plat->wp_gpio);
4122 err_wp_req:
4123         if (gpio_is_valid(plat->cd_gpio))
4124                 free_irq(gpio_to_irq(plat->cd_gpio), host);
4125 err_cd_req:
4126         if (gpio_is_valid(plat->power_gpio))
4127                 gpio_free(plat->power_gpio);
4128 err_power_req:
4129 err_no_plat:
4130         sdhci_pltfm_free(pdev);
4131         return rc;
4132 }
4133
4134 static int sdhci_tegra_remove(struct platform_device *pdev)
4135 {
4136         struct sdhci_host *host = platform_get_drvdata(pdev);
4137         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
4138         struct sdhci_tegra *tegra_host = pltfm_host->priv;
4139         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
4140         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
4141         int rc = 0;
4142
4143         sdhci_remove_host(host, dead);
4144
4145         disable_irq_wake(gpio_to_irq(plat->cd_gpio));
4146
4147         rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_DIS, 0, 0);
4148         if (rc)
4149                 dev_err(mmc_dev(host->mmc),
4150                         "Regulator disable in remove failed %d\n", rc);
4151
4152         if (tegra_host->vdd_slot_reg)
4153                 regulator_put(tegra_host->vdd_slot_reg);
4154         if (tegra_host->vdd_io_reg)
4155                 regulator_put(tegra_host->vdd_io_reg);
4156
4157         if (gpio_is_valid(plat->wp_gpio))
4158                 gpio_free(plat->wp_gpio);
4159
4160         if (gpio_is_valid(plat->cd_gpio)) {
4161                 free_irq(gpio_to_irq(plat->cd_gpio), host);
4162                 gpio_free(plat->cd_gpio);
4163         }
4164
4165         if (gpio_is_valid(plat->power_gpio))
4166                 gpio_free(plat->power_gpio);
4167
4168         if (tegra_host->clk_enabled) {
4169                 if (tegra_host->is_ddr_clk_set)
4170                         clk_disable_unprepare(tegra_host->ddr_clk);
4171                 else
4172                         clk_disable_unprepare(tegra_host->sdr_clk);
4173                 pm_runtime_put_sync(&pdev->dev);
4174         }
4175
4176         if (tegra_host->ddr_clk)
4177                 clk_put(tegra_host->ddr_clk);
4178         if (tegra_host->sdr_clk)
4179                 clk_put(tegra_host->sdr_clk);
4180
4181         if (tegra_host->emc_clk && tegra_host->is_sdmmc_emc_clk_on)
4182                 clk_disable_unprepare(tegra_host->emc_clk);
4183         if (tegra_host->sclk && tegra_host->is_sdmmc_sclk_on)
4184                 clk_disable_unprepare(tegra_host->sclk);
4185         if (plat->power_off_rail)
4186                 unregister_reboot_notifier(&tegra_host->reboot_notify);
4187
4188         sdhci_pltfm_free(pdev);
4189
4190         return rc;
4191 }
4192
4193 static struct platform_driver sdhci_tegra_driver = {
4194         .driver         = {
4195                 .name   = "sdhci-tegra",
4196                 .owner  = THIS_MODULE,
4197                 .of_match_table = sdhci_tegra_dt_match,
4198                 .pm     = SDHCI_PLTFM_PMOPS,
4199         },
4200         .probe          = sdhci_tegra_probe,
4201         .remove         = sdhci_tegra_remove,
4202 };
4203
4204 module_platform_driver(sdhci_tegra_driver);
4205
4206 MODULE_DESCRIPTION("SDHCI driver for Tegra");
4207 MODULE_AUTHOR("Google, Inc.");
4208 MODULE_LICENSE("GPL v2");