df32e42f93dd42e2876b77e50b568a74055d89ce
[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                         parent_clk = pll_p;
1305                 } else {
1306                         desired_rate = pll_c_freq;
1307                         parent_clk = pll_c;
1308                 }
1309                 rc = clk_set_rate(pltfm_host->clk, desired_rate);
1310                 goto set_clk_parent;
1311         }
1312
1313         if (pll_c_freq > pll_p_freq) {
1314                 if (!tegra_host->is_parent_pllc) {
1315                         parent_clk = pll_c;
1316                         tegra_host->is_parent_pllc = true;
1317                         clk_set_rate(pltfm_host->clk, DEFAULT_SDHOST_FREQ);
1318                 } else
1319                         return;
1320         } else if (tegra_host->is_parent_pllc) {
1321                 parent_clk = pll_p;
1322                 tegra_host->is_parent_pllc = false;
1323         } else
1324                 return;
1325
1326 set_clk_parent:
1327         rc = clk_set_parent(pltfm_host->clk, parent_clk);
1328         if (rc)
1329                 pr_err("%s: failed to set pll parent clock %d\n",
1330                         mmc_hostname(host->mmc), rc);
1331 }
1332
1333 static void tegra_sdhci_set_clk_rate(struct sdhci_host *sdhci,
1334         unsigned int clock)
1335 {
1336         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1337         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1338         unsigned int clk_rate;
1339 #ifdef CONFIG_MMC_FREQ_SCALING
1340         unsigned int tap_value;
1341         struct tegra_tuning_data *tuning_data;
1342 #endif
1343
1344         if (sdhci->mmc->ios.timing == MMC_TIMING_UHS_DDR50) {
1345                 /*
1346                  * In ddr mode, tegra sdmmc controller clock frequency
1347                  * should be double the card clock frequency.
1348                  */
1349                 if (tegra_host->ddr_clk_limit)
1350                         clk_rate = tegra_host->ddr_clk_limit * 2;
1351                 else
1352                         clk_rate = clock * 2;
1353         } else {
1354                 clk_rate = clock;
1355         }
1356
1357         if (tegra_host->max_clk_limit &&
1358                 (clk_rate > tegra_host->max_clk_limit))
1359                 clk_rate = tegra_host->max_clk_limit;
1360
1361         tegra_sdhci_clock_set_parent(sdhci, clk_rate);
1362         clk_set_rate(pltfm_host->clk, clk_rate);
1363         sdhci->max_clk = clk_get_rate(pltfm_host->clk);
1364
1365         /* FPGA supports 26MHz of clock for SDMMC. */
1366         if (tegra_platform_is_fpga())
1367                 sdhci->max_clk = 26000000;
1368
1369 #ifdef CONFIG_MMC_FREQ_SCALING
1370         /* Set the tap delay if tuning is done and dfs is enabled */
1371         if (sdhci->mmc->df &&
1372                 (tegra_host->tuning_status == TUNING_STATUS_DONE)) {
1373                 tuning_data = sdhci_tegra_get_tuning_data(sdhci, clock);
1374                 tap_value = (tegra_host->tap_cmd == TAP_CMD_TRIM_HIGH_VOLTAGE) ?
1375                         tuning_data->nom_best_tap_value :
1376                         tuning_data->best_tap_value;
1377                 sdhci_tegra_set_tap_delay(sdhci, tap_value);
1378         }
1379 #endif
1380 }
1381
1382 static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
1383 {
1384         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1385         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1386         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
1387         u8 ctrl;
1388         int ret = 0;
1389
1390         mutex_lock(&tegra_host->set_clock_mutex);
1391         pr_debug("%s %s %u enabled=%u\n", __func__,
1392                 mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
1393         if (clock) {
1394                 if (!tegra_host->clk_enabled) {
1395                         pm_runtime_get_sync(&pdev->dev);
1396                         ret = clk_prepare_enable(pltfm_host->clk);
1397                         if (ret) {
1398                                 dev_err(mmc_dev(sdhci->mmc),
1399                                 "clock enable is failed, ret: %d\n", ret);
1400                                 return;
1401                         }
1402                         tegra_host->clk_enabled = true;
1403                         sdhci->is_clk_on = tegra_host->clk_enabled;
1404                         ctrl = sdhci_readb(sdhci, SDHCI_VNDR_CLK_CTRL);
1405                         ctrl |= SDHCI_VNDR_CLK_CTRL_SDMMC_CLK;
1406                         sdhci_writeb(sdhci, ctrl, SDHCI_VNDR_CLK_CTRL);
1407                 }
1408                 tegra_sdhci_set_clk_rate(sdhci, clock);
1409
1410                 if (tegra_host->emc_clk && (!tegra_host->is_sdmmc_emc_clk_on)) {
1411                         ret = clk_prepare_enable(tegra_host->emc_clk);
1412                         if (ret) {
1413                                 dev_err(mmc_dev(sdhci->mmc),
1414                                 "clock enable is failed, ret: %d\n", ret);
1415                                 return;
1416                         }
1417                         tegra_host->is_sdmmc_emc_clk_on = true;
1418                 }
1419                 if (tegra_host->sclk && (!tegra_host->is_sdmmc_sclk_on)) {
1420                         ret = clk_prepare_enable(tegra_host->sclk);
1421                         if (ret) {
1422                                 dev_err(mmc_dev(sdhci->mmc),
1423                                 "clock enable is failed, ret: %d\n", ret);
1424                                 return;
1425                         }
1426                         tegra_host->is_sdmmc_sclk_on = true;
1427                 }
1428         } else if (!clock && tegra_host->clk_enabled) {
1429                 if (tegra_host->emc_clk && tegra_host->is_sdmmc_emc_clk_on) {
1430                         clk_disable_unprepare(tegra_host->emc_clk);
1431                         tegra_host->is_sdmmc_emc_clk_on = false;
1432                 }
1433                 if (tegra_host->sclk && tegra_host->is_sdmmc_sclk_on) {
1434                         clk_disable_unprepare(tegra_host->sclk);
1435                         tegra_host->is_sdmmc_sclk_on = false;
1436                 }
1437                 ctrl = sdhci_readb(sdhci, SDHCI_VNDR_CLK_CTRL);
1438                 ctrl &= ~SDHCI_VNDR_CLK_CTRL_SDMMC_CLK;
1439                 sdhci_writeb(sdhci, ctrl, SDHCI_VNDR_CLK_CTRL);
1440                 clk_disable_unprepare(pltfm_host->clk);
1441                 tegra_host->clk_enabled = false;
1442                 sdhci->is_clk_on = tegra_host->clk_enabled;
1443                 pm_runtime_put_sync(&pdev->dev);
1444         }
1445         mutex_unlock(&tegra_host->set_clock_mutex);
1446 }
1447
1448 static unsigned int get_calibration_offsets(struct sdhci_host *sdhci)
1449 {
1450         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1451         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1452         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
1453         unsigned int offsets = 0;
1454
1455         if (sdhci->mmc->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330)
1456                 offsets = plat->calib_3v3_offsets;
1457         else if (sdhci->mmc->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_180)
1458                 offsets = plat->calib_1v8_offsets;
1459
1460         return offsets;
1461 }
1462
1463 static void tegra_sdhci_do_calibration(struct sdhci_host *sdhci)
1464 {
1465         unsigned int val;
1466         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1467         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1468         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1469         unsigned int timeout = 10;
1470         unsigned int calib_offsets;
1471
1472         /* No Calibration for sdmmc4 */
1473         if (unlikely(soc_data->nvquirks & NVQUIRK_DISABLE_SDMMC4_CALIB) &&
1474                 (tegra_host->instance == 3))
1475                 return;
1476
1477         if (unlikely(soc_data->nvquirks & NVQUIRK_DISABLE_AUTO_CALIBRATION))
1478                 return;
1479
1480         val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
1481         val &= ~SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK;
1482         if (soc_data->nvquirks & NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD)
1483                 val |= SDMMC_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD_MASK;
1484         val |= 0x7;
1485         sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
1486
1487         /* Enable Auto Calibration*/
1488         val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
1489         val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
1490         val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_START;
1491         if (unlikely(soc_data->nvquirks & NVQUIRK_SET_CALIBRATION_OFFSETS)) {
1492                 calib_offsets = get_calibration_offsets(sdhci);
1493                 if (calib_offsets) {
1494                         /* Program Auto cal PD offset(bits 8:14) */
1495                         val &= ~(0x7F <<
1496                                 SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
1497                         val |= (((calib_offsets >> 8) & 0xFF) <<
1498                                 SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
1499                         /* Program Auto cal PU offset(bits 0:6) */
1500                         val &= ~0x7F;
1501                         val |= (calib_offsets & 0xFF);
1502                 }
1503         }
1504         sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
1505
1506         /* Wait until the calibration is done */
1507         do {
1508                 if (!(sdhci_readl(sdhci, SDMMC_AUTO_CAL_STATUS) &
1509                         SDMMC_AUTO_CAL_STATUS_AUTO_CAL_ACTIVE))
1510                         break;
1511
1512                 mdelay(1);
1513                 timeout--;
1514         } while (timeout);
1515
1516         if (!timeout)
1517                 dev_err(mmc_dev(sdhci->mmc), "Auto calibration failed\n");
1518
1519         if (soc_data->nvquirks & NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD) {
1520                 val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
1521                 val &= ~SDMMC_SDMEMCOMPPADCTRL_PAD_E_INPUT_OR_E_PWRD_MASK;
1522                 sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
1523         }
1524
1525         if (unlikely(soc_data->nvquirks & NVQUIRK_SET_DRIVE_STRENGTH)) {
1526                 unsigned int pulldown_code;
1527                 unsigned int pullup_code;
1528                 int pg;
1529                 int err;
1530
1531                 /* Disable Auto calibration */
1532                 val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
1533                 val &= ~SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
1534                 sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
1535
1536                 pg = tegra_drive_get_pingroup(mmc_dev(sdhci->mmc));
1537                 if (pg != -1) {
1538                         /* Get the pull down codes from auto cal status reg */
1539                         pulldown_code = (
1540                                 sdhci_readl(sdhci, SDMMC_AUTO_CAL_STATUS) >>
1541                                 SDMMC_AUTO_CAL_STATUS_PULLDOWN_OFFSET);
1542                         /* Set the pull down in the pinmux reg */
1543                         err = tegra_drive_pinmux_set_pull_down(pg,
1544                                 pulldown_code);
1545                         if (err)
1546                                 dev_err(mmc_dev(sdhci->mmc),
1547                                 "Failed to set pulldown codes %d err %d\n",
1548                                 pulldown_code, err);
1549
1550                         /* Calculate the pull up codes */
1551                         pullup_code = pulldown_code + PULLUP_ADJUSTMENT_OFFSET;
1552                         if (pullup_code >= TEGRA_MAX_PULL)
1553                                 pullup_code = TEGRA_MAX_PULL - 1;
1554                         /* Set the pull up code in the pinmux reg */
1555                         err = tegra_drive_pinmux_set_pull_up(pg, pullup_code);
1556                         if (err)
1557                                 dev_err(mmc_dev(sdhci->mmc),
1558                                 "Failed to set pullup codes %d err %d\n",
1559                                 pullup_code, err);
1560                 }
1561         }
1562 }
1563
1564 static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
1565         unsigned int signal_voltage)
1566 {
1567         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1568         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1569         unsigned int min_uV = tegra_host->vddio_min_uv;
1570         unsigned int max_uV = tegra_host->vddio_max_uv;
1571         unsigned int rc = 0;
1572         u16 ctrl;
1573
1574
1575         ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
1576         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
1577                 ctrl |= SDHCI_CTRL_VDD_180;
1578                 min_uV = SDHOST_LOW_VOLT_MIN;
1579                 max_uV = SDHOST_LOW_VOLT_MAX;
1580         } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1581                 if (ctrl & SDHCI_CTRL_VDD_180)
1582                         ctrl &= ~SDHCI_CTRL_VDD_180;
1583         }
1584
1585         /* Check if the slot can support the required voltage */
1586         if (min_uV > tegra_host->vddio_max_uv)
1587                 return 0;
1588
1589         /* Set/clear the 1.8V signalling */
1590         sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
1591
1592         /* Switch the I/O rail voltage */
1593         rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_SET_VOLT,
1594                 min_uV, max_uV);
1595         if (rc && (signal_voltage == MMC_SIGNAL_VOLTAGE_180)) {
1596                 dev_err(mmc_dev(sdhci->mmc),
1597                         "setting 1.8V failed %d. Revert to 3.3V\n", rc);
1598                 rc = tegra_sdhci_configure_regulators(tegra_host,
1599                         CONFIG_REG_SET_VOLT, SDHOST_HIGH_VOLT_MIN,
1600                         SDHOST_HIGH_VOLT_MAX);
1601         }
1602
1603         return rc;
1604 }
1605
1606 static int tegra_sdhci_configure_regulators(struct sdhci_tegra *tegra_host,
1607         u8 option, int min_uV, int max_uV)
1608 {
1609         int rc = 0;
1610
1611         switch (option) {
1612         case CONFIG_REG_EN:
1613                 if (!tegra_host->is_rail_enabled) {
1614                         if (tegra_host->vdd_slot_reg)
1615                                 rc = regulator_enable(tegra_host->vdd_slot_reg);
1616                         if (tegra_host->vdd_io_reg)
1617                                 rc = regulator_enable(tegra_host->vdd_io_reg);
1618                         tegra_host->is_rail_enabled = true;
1619                 }
1620         break;
1621         case CONFIG_REG_DIS:
1622                 if (tegra_host->is_rail_enabled) {
1623                         if (tegra_host->vdd_io_reg)
1624                                 rc = regulator_disable(tegra_host->vdd_io_reg);
1625                         if (tegra_host->vdd_slot_reg)
1626                                 rc = regulator_disable(
1627                                         tegra_host->vdd_slot_reg);
1628                         tegra_host->is_rail_enabled = false;
1629                 }
1630         break;
1631         case CONFIG_REG_SET_VOLT:
1632                 if (tegra_host->vdd_io_reg)
1633                         rc = regulator_set_voltage(tegra_host->vdd_io_reg,
1634                                 min_uV, max_uV);
1635         break;
1636         default:
1637                 pr_err("Invalid argument passed to reg config %d\n", option);
1638         }
1639
1640         return rc;
1641 }
1642
1643 static void tegra_sdhci_reset(struct sdhci_host *sdhci, u8 mask)
1644 {
1645         unsigned long timeout;
1646
1647         sdhci_writeb(sdhci, mask, SDHCI_SOFTWARE_RESET);
1648
1649         /* Wait max 100 ms */
1650         timeout = 100;
1651
1652         /* hw clears the bit when it's done */
1653         while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & mask) {
1654                 if (timeout == 0) {
1655                         dev_err(mmc_dev(sdhci->mmc), "Reset 0x%x never"
1656                                 "completed.\n", (int)mask);
1657                         return;
1658                 }
1659                 timeout--;
1660                 mdelay(1);
1661         }
1662
1663         tegra_sdhci_reset_exit(sdhci, mask);
1664 }
1665
1666 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
1667         unsigned int tap_delay)
1668 {
1669         u32 vendor_ctrl;
1670
1671         /* Max tap delay value is 255 */
1672         if (tap_delay > MAX_TAP_VALUES) {
1673                 dev_err(mmc_dev(sdhci->mmc),
1674                         "Valid tap range (0-255). Setting tap value %d\n",
1675                         tap_delay);
1676                 dump_stack();
1677                 return;
1678         }
1679
1680         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_CLK_CTRL);
1681         vendor_ctrl &= ~(0xFF << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1682         vendor_ctrl |= (tap_delay << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1683         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VNDR_CLK_CTRL);
1684 }
1685
1686 static int sdhci_tegra_sd_error_stats(struct sdhci_host *host, u32 int_status)
1687 {
1688         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1689         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1690         struct sdhci_tegra_sd_stats *head = tegra_host->sd_stat_head;
1691
1692         if (int_status & SDHCI_INT_DATA_CRC)
1693                 head->data_crc_count++;
1694         if (int_status & SDHCI_INT_CRC)
1695                 head->cmd_crc_count++;
1696         if (int_status & SDHCI_INT_TIMEOUT)
1697                 head->cmd_to_count++;
1698         if (int_status & SDHCI_INT_DATA_TIMEOUT)
1699                 head->data_to_count++;
1700         return 0;
1701 }
1702
1703 static struct tegra_tuning_data *sdhci_tegra_get_tuning_data(
1704         struct sdhci_host *sdhci, unsigned int clock)
1705 {
1706         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1707         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1708         struct tegra_tuning_data *tuning_data;
1709         unsigned int low_freq;
1710         u8 i = 0;
1711
1712         if (tegra_host->tuning_freq_count == 1) {
1713                 tuning_data = &tegra_host->tuning_data[0];
1714                 goto out;
1715         }
1716
1717         /* Get the lowest supported freq */
1718         for (i = 0; i < TUNING_FREQ_COUNT; ++i) {
1719                 low_freq = tegra_host->soc_data->tuning_freq_list[i];
1720                 if (low_freq)
1721                         break;
1722         }
1723
1724         if (clock <= low_freq)
1725                 tuning_data = &tegra_host->tuning_data[0];
1726         else
1727                 tuning_data = &tegra_host->tuning_data[1];
1728
1729 out:
1730         return tuning_data;
1731 }
1732
1733 static void calculate_vmin_values(struct sdhci_host *sdhci,
1734         struct tegra_tuning_data *tuning_data, int vmin, int boot_mv)
1735 {
1736         struct tuning_values *est_values = &tuning_data->est_values;
1737         struct tuning_values *calc_values = &tuning_data->calc_values;
1738         struct tuning_t2t_coeffs *t2t_coeffs = tuning_data->t2t_coeffs;
1739         struct tap_hole_coeffs *thole_coeffs = tuning_data->thole_coeffs;
1740         int vmin_slope, vmin_int, temp_calc_vmin;
1741         int t2t_vmax, t2t_vmin;
1742         int vmax_thole, vmin_thole;
1743
1744         /*
1745          * If current vmin is equal to vmin or vmax of tuning data, use the
1746          * previously calculated estimated T2T values directly. Note that the
1747          * estimated T2T_vmax is not at Vmax specified in tuning data. It is
1748          * the T2T at the boot or max voltage for the current SKU. Hence,
1749          * boot_mv is used in place of t2t_coeffs->vmax.
1750          */
1751         if (vmin == t2t_coeffs->vmin) {
1752                 t2t_vmin = est_values->t2t_vmin;
1753         } else if (vmin == boot_mv) {
1754                 t2t_vmin = est_values->t2t_vmax;
1755         } else {
1756                 /*
1757                  * For any intermediate voltage between boot voltage and vmin
1758                  * of tuning data, calculate the slope and intercept from the
1759                  * t2t at boot_mv and vmin and calculate the actual values.
1760                  */
1761                 t2t_vmax = 1000 / est_values->t2t_vmax;
1762                 t2t_vmin = 1000 / est_values->t2t_vmin;
1763                 vmin_slope = ((t2t_vmax - t2t_vmin) * 1000) /
1764                         (boot_mv - t2t_coeffs->vmin);
1765                 vmin_int = (t2t_vmax * 1000 - (vmin_slope * boot_mv)) / 1000;
1766                 t2t_vmin = (vmin_slope * vmin) / 1000 + vmin_int;
1767                 t2t_vmin = (1000 / t2t_vmin);
1768         }
1769
1770         calc_values->t2t_vmin = (t2t_vmin * calc_values->t2t_vmax) /
1771                 est_values->t2t_vmax;
1772
1773         calc_values->ui_vmin = (1000000 / (tuning_data->freq_hz / 1000000)) /
1774                 calc_values->t2t_vmin;
1775
1776         /* Calculate the vmin tap hole at vmin of tuning data */
1777         temp_calc_vmin = (est_values->t2t_vmin * calc_values->t2t_vmax) /
1778                 est_values->t2t_vmax;
1779         vmin_thole = (thole_coeffs->thole_vmin_int -
1780                 (thole_coeffs->thole_vmin_slope * temp_calc_vmin)) /
1781                 1000;
1782         vmax_thole = calc_values->vmax_thole;
1783
1784         if (vmin == t2t_coeffs->vmin) {
1785                 calc_values->vmin_thole = vmin_thole;
1786         } else if (vmin == boot_mv) {
1787                 calc_values->vmin_thole = vmax_thole;
1788         } else {
1789                 /*
1790                  * Interpolate the tap hole for any intermediate voltage.
1791                  * Calculate the slope and intercept from the available data
1792                  * and use them to calculate the actual values.
1793                  */
1794                 vmin_slope = ((vmax_thole - vmin_thole) * 1000) /
1795                         (boot_mv - t2t_coeffs->vmin);
1796                 vmin_int = (vmax_thole * 1000 - (vmin_slope * boot_mv)) / 1000;
1797                 calc_values->vmin_thole = (vmin_slope * vmin) / 1000 + vmin_int;
1798         }
1799
1800         /* Adjust the partial win start for Vmin boundary */
1801         if (tuning_data->is_partial_win_valid)
1802                 tuning_data->final_tap_data[0].win_start =
1803                         (tuning_data->final_tap_data[0].win_start *
1804                         tuning_data->calc_values.t2t_vmax) /
1805                         tuning_data->calc_values.t2t_vmin;
1806
1807         pr_info("**********Tuning values*********\n");
1808         pr_info("**estimated values**\n");
1809         pr_info("T2T_Vmax %d, T2T_Vmin %d, 1'st_hole_Vmax %d, UI_Vmax %d\n",
1810                 est_values->t2t_vmax, est_values->t2t_vmin,
1811                 est_values->vmax_thole, est_values->ui);
1812         pr_info("**Calculated values**\n");
1813         pr_info("T2T_Vmax %d, 1'st_hole_Vmax %d, UI_Vmax %d\n",
1814                 calc_values->t2t_vmax, calc_values->vmax_thole,
1815                 calc_values->ui);
1816         pr_info("T2T_Vmin %d, 1'st_hole_Vmin %d, UI_Vmin %d\n",
1817                 calc_values->t2t_vmin, calc_values->vmin_thole,
1818                 calc_values->ui_vmin);
1819         pr_info("***********************************\n");
1820 }
1821
1822 static int slide_window_start(struct sdhci_host *sdhci,
1823         struct tegra_tuning_data *tuning_data,
1824         int tap_value, enum tap_win_edge_attr edge_attr, int tap_hole)
1825 {
1826         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1827         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1828         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1829
1830         if (edge_attr == WIN_EDGE_BOUN_START) {
1831                 if (tap_value < 0)
1832                         tap_value += (1000 / tuning_data->calc_values.t2t_vmin);
1833                 else
1834                         tap_value += (1000 / tuning_data->calc_values.t2t_vmax);
1835         } else if (edge_attr == WIN_EDGE_HOLE) {
1836                 if (soc_data->nvquirks & NVQUIRK_TMP_VAR_1_5_TAP_MARGIN)
1837                         tap_value += ((7 * tap_hole) / 100) + 2;
1838                 else
1839                         tap_value += ((7 * tap_hole) / 100) +
1840                         (((2 * (450 / tuning_data->calc_values.t2t_vmax))
1841                         + 1) / 2);
1842         }
1843
1844         if (tap_value > MAX_TAP_VALUES)
1845                 tap_value = MAX_TAP_VALUES;
1846
1847         return tap_value;
1848 }
1849
1850 static int slide_window_end(struct sdhci_host *sdhci,
1851         struct tegra_tuning_data *tuning_data,
1852         int tap_value, enum tap_win_edge_attr edge_attr, int tap_hole)
1853 {
1854         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1855         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1856         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1857
1858         if (edge_attr == WIN_EDGE_BOUN_END) {
1859                 tap_value = (tap_value * tuning_data->calc_values.t2t_vmax) /
1860                         tuning_data->calc_values.t2t_vmin;
1861                 tap_value -= (1000 / tuning_data->calc_values.t2t_vmin);
1862         } else if (edge_attr == WIN_EDGE_HOLE) {
1863                 if (tap_hole > 0)
1864                         tap_value = tap_hole;
1865                 if (soc_data->nvquirks & NVQUIRK_TMP_VAR_1_5_TAP_MARGIN)
1866                         tap_value -= ((7 * tap_hole) / 100) + 2;
1867                 else
1868                         tap_value -= ((7 * tap_hole) / 100) +
1869                         (((2 * (450 / tuning_data->calc_values.t2t_vmin))
1870                         + 1) / 2);
1871         }
1872
1873         return tap_value;
1874 }
1875
1876 static int adjust_window_boundaries(struct sdhci_host *sdhci,
1877         struct tegra_tuning_data *tuning_data,
1878         struct tap_window_data *temp_tap_data)
1879 {
1880         struct tap_window_data *tap_data;
1881         int vmin_tap_hole;
1882         int vmax_tap_hole;
1883         u8 i = 0;
1884
1885         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
1886                 tap_data = &temp_tap_data[i];
1887                 /* Update with next hole if first hole is taken care of */
1888                 if (tap_data->win_start_attr == WIN_EDGE_HOLE)
1889                         vmax_tap_hole = tuning_data->calc_values.vmax_thole +
1890                                 (tap_data->hole_pos - 1) *
1891                                 tuning_data->calc_values.ui;
1892                 tap_data->win_start = slide_window_start(sdhci, tuning_data,
1893                         tap_data->win_start, tap_data->win_start_attr,
1894                         vmax_tap_hole);
1895
1896                 /* Update with next hole if first hole is taken care of */
1897                 if (tap_data->win_end_attr == WIN_EDGE_HOLE)
1898                         vmin_tap_hole = tuning_data->calc_values.vmin_thole +
1899                                 (tap_data->hole_pos - 1) *
1900                                 tuning_data->calc_values.ui_vmin;
1901                 tap_data->win_end = slide_window_end(sdhci, tuning_data,
1902                         tap_data->win_end, tap_data->win_end_attr,
1903                         vmin_tap_hole);
1904         }
1905
1906         pr_info("***********final tuning windows**********\n");
1907         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
1908                 tap_data = &temp_tap_data[i];
1909                 pr_info("win[%d]: %d - %d\n", i, tap_data->win_start,
1910                         tap_data->win_end);
1911         }
1912         pr_info("********************************\n");
1913         return 0;
1914 }
1915
1916 static int find_best_tap_value(struct tegra_tuning_data *tuning_data,
1917         struct tap_window_data *temp_tap_data, int vmin)
1918 {
1919         struct tap_window_data *tap_data;
1920         u8 i = 0, sel_win = 0;
1921         int pref_win = 0, curr_win_size = 0;
1922         int best_tap_value = 0;
1923
1924         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
1925                 tap_data = &temp_tap_data[i];
1926                 if (!i && tuning_data->is_partial_win_valid) {
1927                         pref_win = tap_data->win_end - tap_data->win_start;
1928                         if ((tap_data->win_end * 2) < pref_win)
1929                                 pref_win = tap_data->win_end * 2;
1930                         sel_win = 0;
1931                 } else {
1932                         curr_win_size = tap_data->win_end - tap_data->win_start;
1933                         if ((curr_win_size > 0) && (curr_win_size > pref_win)) {
1934                                 pref_win = curr_win_size;
1935                                 sel_win = i;
1936                         }
1937                 }
1938         }
1939
1940         if (pref_win <= 0) {
1941                 pr_err("No window opening for %d vmin\n", vmin);
1942                 return -1;
1943         }
1944
1945         tap_data = &temp_tap_data[sel_win];
1946         if (!sel_win && tuning_data->is_partial_win_valid) {
1947                 i = sel_win;
1948                 best_tap_value = tap_data->win_end - (pref_win / 2);
1949                 if (best_tap_value < 0)
1950                         best_tap_value = 0;
1951         } else {
1952                 best_tap_value = tap_data->win_start +
1953                         ((tap_data->win_end - tap_data->win_start) *
1954                         tuning_data->calc_values.t2t_vmin) /
1955                         (tuning_data->calc_values.t2t_vmin +
1956                         tuning_data->calc_values.t2t_vmax);
1957         }
1958
1959         pr_err("best tap win - (%d-%d), best tap value %d\n",
1960                 tap_data->win_start, tap_data->win_end, best_tap_value);
1961         return best_tap_value;
1962 }
1963
1964 static int sdhci_tegra_calculate_best_tap(struct sdhci_host *sdhci,
1965         struct tegra_tuning_data *tuning_data)
1966 {
1967         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1968         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1969         struct tap_window_data *temp_tap_data = NULL;
1970         int vmin, curr_vmin, best_tap_value = 0;
1971         int err = 0;
1972
1973         curr_vmin = tegra_dvfs_predict_millivolts(pltfm_host->clk,
1974                 tuning_data->freq_hz);
1975         vmin = curr_vmin;
1976
1977         do {
1978                 SDHCI_TEGRA_DBG("%s: checking for win opening with vmin %d\n",
1979                         mmc_hostname(sdhci->mmc), vmin);
1980                 if ((best_tap_value < 0) &&
1981                         (vmin > tegra_host->boot_vcore_mv)) {
1982                         dev_err(mmc_dev(sdhci->mmc),
1983                                 "No best tap for any vcore range\n");
1984                         return -EINVAL;
1985                 }
1986
1987                 calculate_vmin_values(sdhci, tuning_data, vmin,
1988                         tegra_host->boot_vcore_mv);
1989
1990                 if (temp_tap_data == NULL) {
1991                         temp_tap_data = kzalloc(sizeof(struct tap_window_data) *
1992                                 tuning_data->num_of_valid_tap_wins, GFP_KERNEL);
1993                         if (IS_ERR_OR_NULL(temp_tap_data)) {
1994                                 dev_err(mmc_dev(sdhci->mmc),
1995                                 "No memory for final tap value calculation\n");
1996                                 return -ENOMEM;
1997                         }
1998                 }
1999
2000                 memcpy(temp_tap_data, tuning_data->final_tap_data,
2001                         sizeof(struct tap_window_data) *
2002                         tuning_data->num_of_valid_tap_wins);
2003
2004                 adjust_window_boundaries(sdhci, tuning_data, temp_tap_data);
2005
2006                 best_tap_value = find_best_tap_value(tuning_data,
2007                         temp_tap_data, vmin);
2008
2009                 if (best_tap_value < 0)
2010                         vmin += 50;
2011         } while (best_tap_value < 0);
2012
2013         tuning_data->best_tap_value = best_tap_value;
2014         tuning_data->nom_best_tap_value = best_tap_value;
2015
2016         /* Set the new vmin if there is any change. */
2017         if ((tuning_data->best_tap_value >= 0) && (curr_vmin != vmin))
2018                 err = tegra_dvfs_set_fmax_at_vmin(pltfm_host->clk,
2019                         tuning_data->freq_hz, vmin);
2020
2021         kfree(temp_tap_data);
2022         return err;
2023 }
2024
2025 static int sdhci_tegra_issue_tuning_cmd(struct sdhci_host *sdhci)
2026 {
2027         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2028         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2029         int err = 0;
2030         u8 ctrl;
2031         u32 mask;
2032         unsigned int timeout = 10;
2033         int flags;
2034         u32 intstatus;
2035
2036         mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
2037         while (sdhci_readl(sdhci, SDHCI_PRESENT_STATE) & mask) {
2038                 if (timeout == 0) {
2039                         dev_err(mmc_dev(sdhci->mmc), "Controller never"
2040                                 "released inhibit bit(s).\n");
2041                         err = -ETIMEDOUT;
2042                         goto out;
2043                 }
2044                 timeout--;
2045                 mdelay(1);
2046         }
2047
2048         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
2049         ctrl &= ~SDHCI_CTRL_TUNED_CLK;
2050         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
2051
2052         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
2053         ctrl |= SDHCI_CTRL_EXEC_TUNING;
2054         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
2055
2056         /*
2057          * In response to CMD19, the card sends 64 bytes of tuning
2058          * block to the Host Controller. So we set the block size
2059          * to 64 here.
2060          * In response to CMD21, the card sends 128 bytes of tuning
2061          * block for MMC_BUS_WIDTH_8 and 64 bytes for MMC_BUS_WIDTH_4
2062          * to the Host Controller. So we set the block size to 64 here.
2063          */
2064         sdhci_writew(sdhci, SDHCI_MAKE_BLKSZ(7, tegra_host->tuning_bsize),
2065                 SDHCI_BLOCK_SIZE);
2066
2067         sdhci_writeb(sdhci, 0xE, SDHCI_TIMEOUT_CONTROL);
2068
2069         sdhci_writew(sdhci, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
2070
2071         sdhci_writel(sdhci, 0x0, SDHCI_ARGUMENT);
2072
2073         /* Set the cmd flags */
2074         flags = SDHCI_CMD_RESP_SHORT | SDHCI_CMD_CRC | SDHCI_CMD_DATA;
2075         /* Issue the command */
2076         sdhci_writew(sdhci, SDHCI_MAKE_CMD(
2077                 tegra_host->tuning_opcode, flags), SDHCI_COMMAND);
2078
2079         timeout = 5;
2080         do {
2081                 timeout--;
2082                 mdelay(1);
2083                 intstatus = sdhci_readl(sdhci, SDHCI_INT_STATUS);
2084                 if (intstatus) {
2085                         sdhci_writel(sdhci, intstatus, SDHCI_INT_STATUS);
2086                         break;
2087                 }
2088         } while(timeout);
2089
2090         if ((intstatus & SDHCI_INT_DATA_AVAIL) &&
2091                 !(intstatus & SDHCI_INT_DATA_CRC)) {
2092                 err = 0;
2093                 sdhci->tuning_done = 1;
2094         } else {
2095                 tegra_sdhci_reset(sdhci, SDHCI_RESET_CMD);
2096                 tegra_sdhci_reset(sdhci, SDHCI_RESET_DATA);
2097                 err = -EIO;
2098         }
2099
2100         if (sdhci->tuning_done) {
2101                 sdhci->tuning_done = 0;
2102                 ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
2103                 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING) &&
2104                         (ctrl & SDHCI_CTRL_TUNED_CLK))
2105                         err = 0;
2106                 else
2107                         err = -EIO;
2108         }
2109         mdelay(1);
2110 out:
2111         return err;
2112 }
2113
2114 static int sdhci_tegra_scan_tap_values(struct sdhci_host *sdhci,
2115         unsigned int starting_tap, bool expect_failure)
2116 {
2117         unsigned int tap_value = starting_tap;
2118         int err;
2119         unsigned int retry = TUNING_RETRIES;
2120
2121         do {
2122                 /* Set the tap delay */
2123                 sdhci_tegra_set_tap_delay(sdhci, tap_value);
2124
2125                 /* Run frequency tuning */
2126                 err = sdhci_tegra_issue_tuning_cmd(sdhci);
2127                 if (err && retry) {
2128                         retry--;
2129                         continue;
2130                 } else {
2131                         retry = TUNING_RETRIES;
2132                         if ((expect_failure && !err) ||
2133                                 (!expect_failure && err))
2134                                 break;
2135                 }
2136                 tap_value++;
2137         } while (tap_value <= MAX_TAP_VALUES);
2138
2139         return tap_value;
2140 }
2141
2142 static int calculate_actual_tuning_values(int speedo,
2143         struct tegra_tuning_data *tuning_data, int voltage_mv)
2144 {
2145         struct tuning_t2t_coeffs *t2t_coeffs = tuning_data->t2t_coeffs;
2146         struct tap_hole_coeffs *thole_coeffs = tuning_data->thole_coeffs;
2147         struct tuning_values *calc_values = &tuning_data->calc_values;
2148         int slope, inpt;
2149         int vmax_thole, vmin_thole;
2150
2151         /* T2T_Vmax = (1000000/freq_MHz)/Calc_UI */
2152         calc_values->t2t_vmax = (1000000 / (tuning_data->freq_hz / 1000000)) /
2153                 calc_values->ui;
2154
2155         /*
2156          * Interpolate the tap hole.
2157          * Vmax_1'st_hole = (Calc_T2T_Vmax*(-thole_slope)+thole_tint.
2158          */
2159         vmax_thole = (thole_coeffs->thole_vmax_int -
2160                 (thole_coeffs->thole_vmax_slope * calc_values->t2t_vmax)) /
2161                 1000;
2162         vmin_thole = (thole_coeffs->thole_vmin_int -
2163                 (thole_coeffs->thole_vmin_slope * calc_values->t2t_vmax)) /
2164                 1000;
2165         if (voltage_mv == t2t_coeffs->vmin) {
2166                 calc_values->vmax_thole = vmin_thole;
2167         } else if (voltage_mv == t2t_coeffs->vmax) {
2168                 calc_values->vmax_thole = vmax_thole;
2169         } else {
2170                 slope = (vmax_thole - vmin_thole) /
2171                         (t2t_coeffs->vmax - t2t_coeffs->vmin);
2172                 inpt = ((vmax_thole * 1000) - (slope * 1250)) / 1000;
2173                 calc_values->vmax_thole = slope * voltage_mv + inpt;
2174         }
2175
2176         return 0;
2177 }
2178
2179 /*
2180  * All coeffs are filled up in the table after multiplying by 1000. So, all
2181  * calculations should have a divide by 1000 at the end.
2182  */
2183 static int calculate_estimated_tuning_values(int speedo,
2184         struct tegra_tuning_data *tuning_data, int voltage_mv)
2185 {
2186         struct tuning_t2t_coeffs *t2t_coeffs = tuning_data->t2t_coeffs;
2187         struct tap_hole_coeffs *thole_coeffs = tuning_data->thole_coeffs;
2188         struct tuning_values *est_values = &tuning_data->est_values;
2189         int slope, inpt;
2190         int vmax_t2t, vmin_t2t;
2191         int vmax_thole, vmin_thole;
2192
2193         /* Est_T2T_Vmax = (speedo*(-t2t_slope)+t2t_int */
2194         vmax_t2t = (t2t_coeffs->t2t_vmax_int - (speedo *
2195                 t2t_coeffs->t2t_vmax_slope)) / 1000;
2196         vmin_t2t = (t2t_coeffs->t2t_vmin_int - (speedo *
2197                 t2t_coeffs->t2t_vmin_slope)) / 1000;
2198         est_values->t2t_vmin = vmin_t2t;
2199
2200         if (voltage_mv == t2t_coeffs->vmin) {
2201                 est_values->t2t_vmax = vmin_t2t;
2202         } else if (voltage_mv == t2t_coeffs->vmax) {
2203                 est_values->t2t_vmax = vmax_t2t;
2204         } else {
2205                 vmax_t2t = 1000 / vmax_t2t;
2206                 vmin_t2t = 1000 / vmin_t2t;
2207                 /*
2208                  * For any intermediate voltage between 0.95V and 1.25V,
2209                  * calculate the slope and intercept from the T2T and tap hole
2210                  * values of 0.95V and 1.25V and use them to calculate the
2211                  * actual values. 1/T2T is a linear function of voltage.
2212                  */
2213                 slope = ((vmax_t2t - vmin_t2t) * 1000) /
2214                         (t2t_coeffs->vmax - t2t_coeffs->vmin);
2215                 inpt = (vmax_t2t * 1000 - (slope * t2t_coeffs->vmax)) / 1000;
2216                 est_values->t2t_vmax = (slope * voltage_mv) / 1000 + inpt;
2217                 est_values->t2t_vmax = (1000 / est_values->t2t_vmax);
2218         }
2219
2220         /* Est_UI  = (1000000/freq_MHz)/Est_T2T_Vmax */
2221         est_values->ui = (1000000 / (thole_coeffs->freq_khz / 1000)) /
2222                 est_values->t2t_vmax;
2223
2224         /*
2225          * Est_1'st_hole = (Est_T2T_Vmax*(-thole_slope)) + thole_int.
2226          */
2227         vmax_thole = (thole_coeffs->thole_vmax_int -
2228                 (thole_coeffs->thole_vmax_slope * est_values->t2t_vmax)) / 1000;
2229         vmin_thole = (thole_coeffs->thole_vmin_int -
2230                 (thole_coeffs->thole_vmin_slope * est_values->t2t_vmax)) / 1000;
2231
2232         if (voltage_mv == t2t_coeffs->vmin) {
2233                 est_values->vmax_thole = vmin_thole;
2234         } else if (voltage_mv == t2t_coeffs->vmax) {
2235                 est_values->vmax_thole = vmax_thole;
2236         } else {
2237                 /*
2238                  * For any intermediate voltage between 0.95V and 1.25V,
2239                  * calculate the slope and intercept from the t2t and tap hole
2240                  * values of 0.95V and 1.25V and use them to calculate the
2241                  * actual values. Tap hole is a linear function of voltage.
2242                  */
2243                 slope = ((vmax_thole - vmin_thole) * 1000) /
2244                         (t2t_coeffs->vmax - t2t_coeffs->vmin);
2245                 inpt = (vmax_thole * 1000 - (slope * t2t_coeffs->vmax)) / 1000;
2246                 est_values->vmax_thole = (slope * voltage_mv) / 1000 + inpt;
2247         }
2248         est_values->vmin_thole = vmin_thole;
2249
2250         return 0;
2251 }
2252
2253 /*
2254  * Insert the calculated holes and get the final tap windows
2255  * with the boundaries and holes set.
2256  */
2257 static int adjust_holes_in_tap_windows(struct sdhci_host *sdhci,
2258         struct tegra_tuning_data *tuning_data)
2259 {
2260         struct tap_window_data *tap_data;
2261         struct tap_window_data *final_tap_data;
2262         struct tuning_values *calc_values = &tuning_data->calc_values;
2263         int tap_hole, size = 0;
2264         u8 i = 0, j = 0, num_of_wins, hole_pos = 0;
2265
2266         tuning_data->final_tap_data =
2267                 devm_kzalloc(mmc_dev(sdhci->mmc),
2268                         sizeof(struct tap_window_data) * 42, GFP_KERNEL);
2269         if (IS_ERR_OR_NULL(tuning_data->final_tap_data)) {
2270                 dev_err(mmc_dev(sdhci->mmc), "No mem for final tap wins\n");
2271                 return -ENOMEM;
2272         }
2273
2274         num_of_wins = tuning_data->num_of_valid_tap_wins;
2275         tap_hole = calc_values->vmax_thole;
2276         hole_pos++;
2277         do {
2278                 tap_data = &tuning_data->tap_data[i];
2279                 final_tap_data = &tuning_data->final_tap_data[j];
2280                 if (tap_hole < tap_data->win_start) {
2281                         tap_hole += calc_values->ui;
2282                         hole_pos++;
2283                         continue;
2284                 } else if (tap_hole > tap_data->win_end) {
2285                         memcpy(final_tap_data, tap_data,
2286                                 sizeof(struct tap_window_data));
2287                         i++;
2288                         j++;
2289                         num_of_wins--;
2290                         continue;
2291                 } else if ((tap_hole >= tap_data->win_start) &&
2292                         (tap_hole <= tap_data->win_end)) {
2293                         size = tap_data->win_end - tap_data->win_start;
2294                         do {
2295                                 final_tap_data =
2296                                         &tuning_data->final_tap_data[j];
2297                                 if (tap_hole == tap_data->win_start) {
2298                                         final_tap_data->win_start =
2299                                                 tap_hole + 1;
2300                                         final_tap_data->win_start_attr =
2301                                                 WIN_EDGE_HOLE;
2302                                         final_tap_data->hole_pos = hole_pos;
2303                                         tap_hole += calc_values->ui;
2304                                         hole_pos++;
2305                                 } else {
2306                                         final_tap_data->win_start =
2307                                                 tap_data->win_start;
2308                                         final_tap_data->win_start_attr =
2309                                                 WIN_EDGE_BOUN_START;
2310                                 }
2311                                 if (tap_hole <= tap_data->win_end) {
2312                                         final_tap_data->win_end = tap_hole - 1;
2313                                         final_tap_data->win_end_attr =
2314                                                 WIN_EDGE_HOLE;
2315                                         final_tap_data->hole_pos = hole_pos;
2316                                         tap_data->win_start = tap_hole;
2317                                 } else if (tap_hole > tap_data->win_end) {
2318                                         final_tap_data->win_end =
2319                                                 tap_data->win_end;
2320                                         final_tap_data->win_end_attr =
2321                                                 WIN_EDGE_BOUN_END;
2322                                         tap_data->win_start =
2323                                                 tap_data->win_end;
2324                                 }
2325                                 size = tap_data->win_end - tap_data->win_start;
2326                                 j++;
2327                         } while (size > 0);
2328                         i++;
2329                         num_of_wins--;
2330                 }
2331         } while (num_of_wins > 0);
2332
2333         /* Update the num of valid wins count after tap holes insertion */
2334         tuning_data->num_of_valid_tap_wins = j;
2335
2336         pr_info("********tuning windows after inserting holes*****\n");
2337         pr_info("WIN_ATTR legend: 0-BOUN_ST, 1-BOUN_END, 2-HOLE\n");
2338         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
2339                 final_tap_data = &tuning_data->final_tap_data[i];
2340                 pr_info("win[%d]:%d(%d) - %d(%d)\n", i,
2341                         final_tap_data->win_start,
2342                         final_tap_data->win_start_attr,
2343                         final_tap_data->win_end, final_tap_data->win_end_attr);
2344         }
2345         pr_info("***********************************************\n");
2346
2347         return 0;
2348 }
2349
2350 /*
2351  * Insert the boundaries from negative margin calculations into the windows
2352  * from auto tuning.
2353  */
2354 static int insert_boundaries_in_tap_windows(struct sdhci_host *sdhci,
2355         struct tegra_tuning_data *tuning_data, u8 boun_end)
2356 {
2357         struct tap_window_data *tap_data;
2358         struct tap_window_data *new_tap_data;
2359         struct tap_window_data *temp_tap_data;
2360         struct tuning_values *calc_values = &tuning_data->calc_values;
2361         int curr_boun;
2362         u8 i = 0, j = 0, num_of_wins;
2363         bool get_next_boun = false;
2364
2365         temp_tap_data = devm_kzalloc(mmc_dev(sdhci->mmc),
2366                         sizeof(struct tap_window_data) * 42, GFP_KERNEL);
2367         if (IS_ERR_OR_NULL(temp_tap_data)) {
2368                 dev_err(mmc_dev(sdhci->mmc), "No mem for final tap wins\n");
2369                 return -ENOMEM;
2370         }
2371
2372         num_of_wins = tuning_data->num_of_valid_tap_wins;
2373         curr_boun = boun_end % calc_values->ui;
2374         do {
2375                 if (get_next_boun) {
2376                         curr_boun += calc_values->ui;
2377                         /*
2378                          * If the boun_end exceeds the intial boundary end,
2379                          * just copy remaining windows and return.
2380                          */
2381                         if (curr_boun >= boun_end)
2382                                 curr_boun += MAX_TAP_VALUES;
2383                 }
2384
2385                 tap_data = &tuning_data->tap_data[i];
2386                 new_tap_data = &temp_tap_data[j];
2387                 if (curr_boun <= tap_data->win_start) {
2388                         get_next_boun = true;
2389                         continue;
2390                 } else if (curr_boun >= tap_data->win_end) {
2391                         memcpy(new_tap_data, tap_data,
2392                                 sizeof(struct tap_window_data));
2393                         i++;
2394                         j++;
2395                         num_of_wins--;
2396                         get_next_boun = false;
2397                         continue;
2398                 } else if ((curr_boun >= tap_data->win_start) &&
2399                         (curr_boun <= tap_data->win_end)) {
2400                                 new_tap_data->win_start = tap_data->win_start;
2401                                 new_tap_data->win_start_attr =
2402                                         tap_data->win_start_attr;
2403                                 new_tap_data->win_end = curr_boun - 1;
2404                                 new_tap_data->win_end_attr =
2405                                         tap_data->win_end_attr;
2406                                 j++;
2407                                 new_tap_data = &temp_tap_data[j];
2408                                 new_tap_data->win_start = curr_boun;
2409                                 new_tap_data->win_end = curr_boun;
2410                                 new_tap_data->win_start_attr =
2411                                         WIN_EDGE_BOUN_START;
2412                                 new_tap_data->win_end_attr =
2413                                         WIN_EDGE_BOUN_END;
2414                                 j++;
2415                                 new_tap_data = &temp_tap_data[j];
2416                                 new_tap_data->win_start = curr_boun + 1;
2417                                 new_tap_data->win_start_attr = WIN_EDGE_BOUN_START;
2418                                 new_tap_data->win_end = tap_data->win_end;
2419                                 new_tap_data->win_end_attr =
2420                                         tap_data->win_end_attr;
2421                                 i++;
2422                                 j++;
2423                                 num_of_wins--;
2424                                 get_next_boun = true;
2425                 }
2426         } while (num_of_wins > 0);
2427
2428         /* Update the num of valid wins count after tap holes insertion */
2429         tuning_data->num_of_valid_tap_wins = j;
2430
2431         memcpy(tuning_data->tap_data, temp_tap_data,
2432                 j * sizeof(struct tap_window_data));
2433         SDHCI_TEGRA_DBG("***tuning windows after inserting boundaries***\n");
2434         SDHCI_TEGRA_DBG("WIN_ATTR legend: 0-BOUN_ST, 1-BOUN_END, 2-HOLE\n");
2435         for (i = 0; i < tuning_data->num_of_valid_tap_wins; i++) {
2436                 new_tap_data = &tuning_data->tap_data[i];
2437                 SDHCI_TEGRA_DBG("win[%d]:%d(%d) - %d(%d)\n", i,
2438                         new_tap_data->win_start,
2439                         new_tap_data->win_start_attr,
2440                         new_tap_data->win_end, new_tap_data->win_end_attr);
2441         }
2442         SDHCI_TEGRA_DBG("***********************************************\n");
2443
2444         return 0;
2445 }
2446
2447 /*
2448  * Scan for all tap values and get all passing tap windows.
2449  */
2450 static int sdhci_tegra_get_tap_window_data(struct sdhci_host *sdhci,
2451         struct tegra_tuning_data *tuning_data)
2452 {
2453         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2454         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2455         struct tap_window_data *tap_data;
2456         struct tuning_ui tuning_ui[10];
2457         int err = 0, partial_win_start = 0, temp_margin = 0;
2458         unsigned int tap_value, calc_ui = 0;
2459         u8 prev_boundary_end = 0, num_of_wins = 0;
2460         u8 num_of_uis = 0, valid_num_uis = 0;
2461         u8 ref_ui, first_valid_full_win = 0;
2462         u8 boun_end = 0, next_boun_end = 0;
2463         u8 j = 0;
2464         bool valid_ui_found = false;
2465
2466         /*
2467          * Assume there are a max of 10 windows and allocate tap window
2468          * structures for the same. If there are more windows, the array
2469          * size can be adjusted later using realloc.
2470          */
2471         tuning_data->tap_data = devm_kzalloc(mmc_dev(sdhci->mmc),
2472                 sizeof(struct tap_window_data) * 42, GFP_KERNEL);
2473         if (IS_ERR_OR_NULL(tuning_data->tap_data)) {
2474                 dev_err(mmc_dev(sdhci->mmc), "No memory for tap data\n");
2475                 return -ENOMEM;
2476         }
2477
2478         spin_lock(&sdhci->lock);
2479         tap_value = 0;
2480         do {
2481                 tap_data = &tuning_data->tap_data[num_of_wins];
2482                 /* Get the window start */
2483                 tap_value = sdhci_tegra_scan_tap_values(sdhci, tap_value, true);
2484                 tap_data->win_start = min_t(u8, tap_value, MAX_TAP_VALUES);
2485                 tap_value++;
2486                 if (tap_value >= MAX_TAP_VALUES) {
2487                         /* If it's first iteration, then all taps failed */
2488                         if (!num_of_wins) {
2489                                 dev_err(mmc_dev(sdhci->mmc),
2490                                         "All tap values(0-255) failed\n");
2491                                 spin_unlock(&sdhci->lock);
2492                                 return -EINVAL;
2493                         } else {
2494                                 /* All windows obtained */
2495                                 break;
2496                         }
2497                 }
2498
2499                 /* Get the window end */
2500                 tap_value = sdhci_tegra_scan_tap_values(sdhci,
2501                                 tap_value, false);
2502                 tap_data->win_end = min_t(u8, (tap_value - 1), MAX_TAP_VALUES);
2503                 tap_data->win_size = tap_data->win_end - tap_data->win_start;
2504                 tap_value++;
2505
2506                 /*
2507                  * If the size of window is more than 4 taps wide, then it is a
2508                  * valid window. If tap value 0 has passed, then a partial
2509                  * window exists. Mark all the window edges as boundary edges.
2510                  */
2511                 if (tap_data->win_size > 4) {
2512                         if (tap_data->win_start == 0)
2513                                 tuning_data->is_partial_win_valid = true;
2514                         tap_data->win_start_attr = WIN_EDGE_BOUN_START;
2515                         tap_data->win_end_attr = WIN_EDGE_BOUN_END;
2516                 } else {
2517                         /* Invalid window as size is less than 5 taps */
2518                         SDHCI_TEGRA_DBG("Invalid tuning win (%d-%d) ignored\n",
2519                                 tap_data->win_start, tap_data->win_end);
2520                         continue;
2521                 }
2522
2523                 /* Ignore first and last partial UIs */
2524                 if (tap_data->win_end_attr == WIN_EDGE_BOUN_END) {
2525                                 tuning_ui[num_of_uis].ui = tap_data->win_end -
2526                                         prev_boundary_end;
2527                                 tuning_ui[num_of_uis].is_valid_ui = true;
2528                                 num_of_uis++;
2529                         prev_boundary_end = tap_data->win_end;
2530                 }
2531                 num_of_wins++;
2532         } while (tap_value < MAX_TAP_VALUES);
2533         spin_unlock(&sdhci->lock);
2534
2535         tuning_data->num_of_valid_tap_wins = num_of_wins;
2536         valid_num_uis = num_of_uis;
2537
2538         /* Print info of all tap windows */
2539         pr_info("**********Auto tuning windows*************\n");
2540         pr_info("WIN_ATTR legend: 0-BOUN_ST, 1-BOUN_END, 2-HOLE\n");
2541         for (j = 0; j < tuning_data->num_of_valid_tap_wins; j++) {
2542                 tap_data = &tuning_data->tap_data[j];
2543                 pr_info("win[%d]: %d(%d) - %d(%d)\n",
2544                         j, tap_data->win_start, tap_data->win_start_attr,
2545                         tap_data->win_end, tap_data->win_end_attr);
2546         }
2547         pr_info("***************************************\n");
2548
2549         /* Mark the first last partial UIs as invalid */
2550         tuning_ui[0].is_valid_ui = false;
2551         tuning_ui[num_of_uis - 1].is_valid_ui = false;
2552         valid_num_uis -= 2;
2553
2554         /* Discredit all uis at either end with size less than 30% of est ui */
2555         ref_ui = (30 * tuning_data->est_values.ui) / 100;
2556         for (j = 0; j < num_of_uis; j++) {
2557                 if (tuning_ui[j].is_valid_ui) {
2558                         tuning_ui[j].is_valid_ui = false;
2559                         valid_num_uis--;
2560                 }
2561                 if (tuning_ui[j].ui > ref_ui)
2562                         break;
2563         }
2564
2565         for (j = num_of_uis; j > 0; j--) {
2566                 if (tuning_ui[j - 1].ui < ref_ui) {
2567                         if (tuning_ui[j - 1].is_valid_ui) {
2568                                 tuning_ui[j - 1].is_valid_ui = false;
2569                                 valid_num_uis--;
2570                         }
2571                 } else
2572                         break;
2573         }
2574
2575         /* Calculate 0.75*est_UI */
2576         ref_ui = (75 * tuning_data->est_values.ui) / 100;
2577
2578         /*
2579          * Check for valid UIs and discredit invalid UIs. A UI is considered
2580          * valid if it's greater than (0.75*est_UI). If an invalid UI is found,
2581          * also discredit the smaller of the two adjacent windows.
2582          */
2583         for (j = 1; j < (num_of_uis - 1); j++) {
2584                 if (tuning_ui[j].ui > ref_ui && tuning_ui[j].is_valid_ui) {
2585                         tuning_ui[j].is_valid_ui = true;
2586                 } else {
2587                         if (tuning_ui[j].is_valid_ui) {
2588                                 tuning_ui[j].is_valid_ui = false;
2589                                 valid_num_uis--;
2590                         }
2591                         if (!tuning_ui[j + 1].is_valid_ui ||
2592                                 !tuning_ui[j - 1].is_valid_ui) {
2593                                 if (tuning_ui[j - 1].is_valid_ui) {
2594                                         tuning_ui[j - 1].is_valid_ui = false;
2595                                         valid_num_uis--;
2596                                 } else if (tuning_ui[j + 1].is_valid_ui) {
2597                                         tuning_ui[j + 1].is_valid_ui = false;
2598                                         valid_num_uis--;
2599                                 }
2600                         } else {
2601
2602                                 if (tuning_ui[j - 1].ui > tuning_ui[j + 1].ui)
2603                                         tuning_ui[j + 1].is_valid_ui = false;
2604                                 else
2605                                         tuning_ui[j - 1].is_valid_ui = false;
2606                                 valid_num_uis--;
2607                         }
2608                 }
2609         }
2610
2611         /* Calculate the cumulative UI if there are valid UIs left */
2612         if (valid_num_uis) {
2613                 for (j = 0; j < num_of_uis; j++)
2614                         if (tuning_ui[j].is_valid_ui) {
2615                                 calc_ui += tuning_ui[j].ui;
2616                                 if (!first_valid_full_win)
2617                                         first_valid_full_win = j;
2618                         }
2619         }
2620
2621         if (calc_ui) {
2622                 tuning_data->calc_values.ui = (calc_ui / valid_num_uis);
2623                 valid_ui_found = true;
2624         } else {
2625                 tuning_data->calc_values.ui = tuning_data->est_values.ui;
2626                 valid_ui_found = false;
2627         }
2628
2629         SDHCI_TEGRA_DBG("****Tuning UIs***********\n");
2630         for (j = 0; j < num_of_uis; j++)
2631                 SDHCI_TEGRA_DBG("Tuning UI[%d] : %d, Is valid[%d]\n",
2632                         j, tuning_ui[j].ui, tuning_ui[j].is_valid_ui);
2633         SDHCI_TEGRA_DBG("*************************\n");
2634
2635         /* Get the calculated tuning values */
2636         err = calculate_actual_tuning_values(tegra_host->speedo, tuning_data,
2637                 tegra_host->boot_vcore_mv);
2638
2639         /*
2640          * Calculate negative margin if partial win is valid. There are two
2641          * cases here.
2642          * Case 1: If Avg_UI is found, then keep subtracting avg_ui from start
2643          * of first valid full window until a value <=0 is obtained.
2644          * Case 2: If Avg_UI is not found, subtract avg_ui from all boundary
2645          * starts until a value <=0 is found.
2646          */
2647         if (tuning_data->is_partial_win_valid && (num_of_wins > 1)) {
2648                 if (valid_ui_found) {
2649                         partial_win_start =
2650                         tuning_data->tap_data[first_valid_full_win].win_start;
2651                         boun_end = partial_win_start;
2652                         partial_win_start %= tuning_data->calc_values.ui;
2653                         partial_win_start -= tuning_data->calc_values.ui;
2654                 } else {
2655                         for (j = 0; j < NEG_MAR_CHK_WIN_COUNT; j++) {
2656                                 temp_margin =
2657                                         tuning_data->tap_data[j + 1].win_start;
2658                                 if (!boun_end)
2659                                         boun_end = temp_margin;
2660                                 else if (!next_boun_end)
2661                                         next_boun_end = temp_margin;
2662                                 temp_margin %= tuning_data->calc_values.ui;
2663                                 temp_margin -= tuning_data->calc_values.ui;
2664                                 if (!partial_win_start ||
2665                                         (temp_margin > partial_win_start))
2666                                         partial_win_start = temp_margin;
2667                         }
2668                 }
2669                 if (partial_win_start <= 0)
2670                         tuning_data->tap_data[0].win_start = partial_win_start;
2671         }
2672
2673         if (boun_end)
2674                 insert_boundaries_in_tap_windows(sdhci, tuning_data, boun_end);
2675         if (next_boun_end)
2676                 insert_boundaries_in_tap_windows(sdhci, tuning_data, next_boun_end);
2677
2678         /* Insert calculated holes into the windows */
2679         err = adjust_holes_in_tap_windows(sdhci, tuning_data);
2680
2681         return err;
2682 }
2683
2684 static void sdhci_tegra_dump_tuning_constraints(struct sdhci_host *sdhci)
2685 {
2686         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2687         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2688         struct tegra_tuning_data *tuning_data;
2689         u8 i;
2690
2691         SDHCI_TEGRA_DBG("%s: Num of tuning frequencies%d\n",
2692                 mmc_hostname(sdhci->mmc), tegra_host->tuning_freq_count);
2693         for (i = 0; i < tegra_host->tuning_freq_count; ++i) {
2694                 tuning_data = &tegra_host->tuning_data[i];
2695                 SDHCI_TEGRA_DBG("%s: Tuning freq[%d]: %d, freq band %d\n",
2696                         mmc_hostname(sdhci->mmc), i,
2697                         tuning_data->freq_hz, tuning_data->freq_band);
2698         }
2699 }
2700
2701 static unsigned int get_tuning_voltage(struct sdhci_tegra *tegra_host, u8 *mask)
2702 {
2703         u8 i = 0;
2704
2705         i = ffs(*mask) - 1;
2706         *mask &= ~(1 << i);
2707         switch (BIT(i)) {
2708         case NOMINAL_VCORE_TUN:
2709                 return tegra_host->nominal_vcore_mv;
2710         case BOOT_VCORE_TUN:
2711                 return tegra_host->boot_vcore_mv;
2712         case MIN_OVERRIDE_VCORE_TUN:
2713                 return tegra_host->min_vcore_override_mv;
2714         }
2715
2716         return tegra_host->boot_vcore_mv;
2717 }
2718
2719 static u8 sdhci_tegra_get_freq_point(struct sdhci_host *sdhci)
2720 {
2721         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2722         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2723         const unsigned int *freq_list;
2724         u32 curr_clock;
2725         u8 i;
2726
2727         curr_clock = sdhci->max_clk;
2728         freq_list = tegra_host->soc_data->tuning_freq_list;
2729
2730         for (i = 0; i < TUNING_FREQ_COUNT; ++i)
2731                 if (curr_clock <= freq_list[i])
2732                         return i;
2733
2734         return TUNING_MAX_FREQ;
2735 }
2736
2737 /*
2738  * The frequency tuning algorithm tries to calculate the tap-to-tap delay
2739  * UI and estimate holes using equations and predetermined coefficients from
2740  * the characterization data. The algorithm will not work without this data.
2741  */
2742 static int find_tuning_coeffs_data(struct sdhci_host *sdhci,
2743                                         bool force_retuning)
2744 {
2745         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2746         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2747         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
2748         struct tegra_tuning_data *tuning_data;
2749         struct tuning_t2t_coeffs *t2t_coeffs;
2750         struct tap_hole_coeffs *thole_coeffs;
2751         const char *dev_id;
2752         unsigned int freq_khz;
2753         u8 i, j;
2754         bool coeffs_set = false;
2755
2756         dev_id = dev_name(mmc_dev(sdhci->mmc));
2757         /* Find the coeffs data for all supported frequencies */
2758         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
2759                 tuning_data = &tegra_host->tuning_data[i];
2760
2761                 /* Skip if T2T coeffs are already found */
2762                 if (tuning_data->t2t_coeffs == NULL || force_retuning) {
2763                         t2t_coeffs = soc_data->t2t_coeffs;
2764                         for (j = 0; j < soc_data->t2t_coeffs_count; j++) {
2765                                 if (!strcmp(dev_id, t2t_coeffs->dev_id)) {
2766                                         tuning_data->t2t_coeffs = t2t_coeffs;
2767                                         coeffs_set = true;
2768                                         dev_info(mmc_dev(sdhci->mmc),
2769                                                 "Found T2T coeffs data\n");
2770                                         break;
2771                                 }
2772                                 t2t_coeffs++;
2773                         }
2774                         if (!coeffs_set) {
2775                                 dev_err(mmc_dev(sdhci->mmc),
2776                                         "T2T coeffs data missing\n");
2777                                 tuning_data->t2t_coeffs = NULL;
2778                                 return -ENODATA;
2779                         }
2780                 }
2781
2782                 coeffs_set = false;
2783                 /* Skip if tap hole coeffs are already found */
2784                 if (tuning_data->thole_coeffs == NULL || force_retuning) {
2785                         thole_coeffs = soc_data->tap_hole_coeffs;
2786                         freq_khz = tuning_data->freq_hz / 1000;
2787                         for (j = 0; j < soc_data->tap_hole_coeffs_count; j++) {
2788                                 if (!strcmp(dev_id, thole_coeffs->dev_id) &&
2789                                         (freq_khz == thole_coeffs->freq_khz)) {
2790                                         tuning_data->thole_coeffs =
2791                                                 thole_coeffs;
2792                                         coeffs_set = true;
2793                                         dev_info(mmc_dev(sdhci->mmc),
2794                                                 "%dMHz tap hole coeffs found\n",
2795                                                 (freq_khz / 1000));
2796                                         break;
2797                                 }
2798                                 thole_coeffs++;
2799                         }
2800
2801                         if (!coeffs_set) {
2802                                 dev_err(mmc_dev(sdhci->mmc),
2803                                         "%dMHz Tap hole coeffs data missing\n",
2804                                         (freq_khz / 1000));
2805                                 tuning_data->thole_coeffs = NULL;
2806                                 return -ENODATA;
2807                         }
2808                 }
2809         }
2810
2811         return 0;
2812 }
2813
2814 /*
2815  * Determines the numbers of frequencies required and then fills up the tuning
2816  * constraints for each of the frequencies. The data of lower frequency is
2817  * filled first and then the higher frequency data. Max supported frequencies
2818  * is currently two.
2819  */
2820 static int setup_freq_constraints(struct sdhci_host *sdhci,
2821         const unsigned int *freq_list)
2822 {
2823         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2824         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2825         struct tegra_tuning_data *tuning_data;
2826         int i, freq_count;
2827         u8 freq_band;
2828
2829         if ((sdhci->mmc->ios.timing != MMC_TIMING_UHS_SDR50) &&
2830                 (sdhci->mmc->caps2 & MMC_CAP2_FREQ_SCALING))
2831                 freq_count = DFS_FREQ_COUNT;
2832         else
2833                 freq_count = 1;
2834
2835         freq_band = sdhci_tegra_get_freq_point(sdhci);
2836         /* Fill up the req frequencies */
2837         switch (freq_count) {
2838         case 1:
2839                 tuning_data = &tegra_host->tuning_data[0];
2840                 tuning_data->freq_hz = sdhci->max_clk;
2841                 tuning_data->freq_band = freq_band;
2842                 tuning_data->constraints.vcore_mask =
2843                         tuning_vcore_constraints[freq_band].vcore_mask;
2844                 tuning_data->nr_voltages =
2845                         hweight32(tuning_data->constraints.vcore_mask);
2846         break;
2847         case 2:
2848                 tuning_data = &tegra_host->tuning_data[1];
2849                 tuning_data->freq_hz = sdhci->max_clk;
2850                 tuning_data->freq_band = freq_band;
2851                 tuning_data->constraints.vcore_mask =
2852                         tuning_vcore_constraints[freq_band].vcore_mask;
2853                 tuning_data->nr_voltages =
2854                         hweight32(tuning_data->constraints.vcore_mask);
2855
2856                 tuning_data = &tegra_host->tuning_data[0];
2857                 for (i = (freq_band - 1); i >= 0; i--) {
2858                         if (!freq_list[i])
2859                                 continue;
2860                         tuning_data->freq_hz = freq_list[i];
2861                         tuning_data->freq_band = i;
2862                         tuning_data->nr_voltages = 1;
2863                         tuning_data->constraints.vcore_mask =
2864                                 tuning_vcore_constraints[i].vcore_mask;
2865                         tuning_data->nr_voltages =
2866                                 hweight32(tuning_data->constraints.vcore_mask);
2867                 }
2868         break;
2869         default:
2870                 dev_err(mmc_dev(sdhci->mmc), "Unsupported freq count\n");
2871                 freq_count = -1;
2872         }
2873
2874         return freq_count;
2875 }
2876
2877 /*
2878  * Get the supported frequencies and other tuning related constraints for each
2879  * frequency. The supported frequencies should be determined from the list of
2880  * frequencies in the soc data and also consider the platform clock limits as
2881  * well as any DFS related restrictions.
2882  */
2883 static int sdhci_tegra_get_tuning_constraints(struct sdhci_host *sdhci,
2884                                                         bool force_retuning)
2885 {
2886         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2887         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2888         const unsigned int *freq_list;
2889         int err = 0;
2890
2891         /* A valid freq count means freq constraints are already set up */
2892         if (!tegra_host->tuning_freq_count || force_retuning) {
2893                 freq_list = tegra_host->soc_data->tuning_freq_list;
2894                 tegra_host->tuning_freq_count =
2895                         setup_freq_constraints(sdhci, freq_list);
2896                 if (tegra_host->tuning_freq_count < 0) {
2897                         dev_err(mmc_dev(sdhci->mmc),
2898                                 "Invalid tuning freq count\n");
2899                         return -EINVAL;
2900                 }
2901         }
2902
2903         err = find_tuning_coeffs_data(sdhci, force_retuning);
2904         if (err)
2905                 return err;
2906
2907         sdhci_tegra_dump_tuning_constraints(sdhci);
2908
2909         return err;
2910 }
2911
2912 /*
2913  * During boot, only boot voltage for vcore can be set. Check if the current
2914  * voltage is allowed to be used. Nominal and min override voltages can be
2915  * set once boot is done. This will be notified through late subsys init call.
2916  */
2917 static int sdhci_tegra_set_tuning_voltage(struct sdhci_host *sdhci,
2918         unsigned int voltage)
2919 {
2920         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2921         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2922         int err = 0;
2923         bool nom_emc_freq_set = false;
2924
2925         if (voltage && (voltage != tegra_host->boot_vcore_mv) &&
2926                 !vcore_overrides_allowed) {
2927                 SDHCI_TEGRA_DBG("%s: Override vcore %dmv not allowed\n",
2928                         mmc_hostname(sdhci->mmc), voltage);
2929                 return -EPERM;
2930         }
2931
2932         SDHCI_TEGRA_DBG("%s: Setting vcore override %d\n",
2933                 mmc_hostname(sdhci->mmc), voltage);
2934         /* First clear any previous dvfs override settings */
2935         err = tegra_dvfs_override_core_voltage(pltfm_host->clk, 0);
2936         if (!voltage)
2937                 return err;
2938
2939         /* EMC clock freq boost might be required for nominal core voltage */
2940         if ((voltage == tegra_host->nominal_vcore_mv) &&
2941                 tegra_host->plat->en_nominal_vcore_tuning &&
2942                 tegra_host->emc_clk) {
2943                 err = clk_set_rate(tegra_host->emc_clk,
2944                         SDMMC_EMC_NOM_VOLT_FREQ);
2945                 if (err)
2946                         dev_err(mmc_dev(sdhci->mmc),
2947                                 "Failed to set emc nom clk freq %d\n", err);
2948                 else
2949                         nom_emc_freq_set = true;
2950         }
2951
2952         err = tegra_dvfs_override_core_voltage(pltfm_host->clk, voltage);
2953         if (err)
2954                 dev_err(mmc_dev(sdhci->mmc),
2955                         "failed to set vcore override %dmv\n", voltage);
2956
2957         /* Revert emc clock to normal freq */
2958         if (nom_emc_freq_set) {
2959                 err = clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_MAX_FREQ);
2960                 if (err)
2961                         dev_err(mmc_dev(sdhci->mmc),
2962                                 "Failed to revert emc nom clk freq %d\n", err);
2963         }
2964
2965         return err;
2966 }
2967
2968 static int sdhci_tegra_run_tuning(struct sdhci_host *sdhci,
2969         struct tegra_tuning_data *tuning_data)
2970 {
2971         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2972         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2973         int err = 0;
2974         int voltage = 0;
2975         u8 i, vcore_mask = 0;
2976
2977         vcore_mask = tuning_data->constraints.vcore_mask;
2978         for (i = 0; i < tuning_data->nr_voltages; i++) {
2979                 voltage = get_tuning_voltage(tegra_host, &vcore_mask);
2980                 err = sdhci_tegra_set_tuning_voltage(sdhci, voltage);
2981                 if (err) {
2982                         dev_err(mmc_dev(sdhci->mmc),
2983                                 "Unable to set override voltage.\n");
2984                         return err;
2985                 }
2986
2987                 /* Get the tuning window info */
2988                 SDHCI_TEGRA_DBG("Getting tuning windows...\n");
2989                 err = sdhci_tegra_get_tap_window_data(sdhci, tuning_data);
2990                 if (err) {
2991                         dev_err(mmc_dev(sdhci->mmc),
2992                                 "Failed to get tap win %d\n", err);
2993                         return err;
2994                 }
2995                 SDHCI_TEGRA_DBG("%s: %d tuning window data obtained\n",
2996                         mmc_hostname(sdhci->mmc), tuning_data->freq_hz);
2997         }
2998         return err;
2999 }
3000
3001 static int sdhci_tegra_verify_best_tap(struct sdhci_host *sdhci)
3002 {
3003         struct tegra_tuning_data *tuning_data;
3004         int err = 0;
3005
3006         tuning_data = sdhci_tegra_get_tuning_data(sdhci, sdhci->max_clk);
3007         if ((tuning_data->best_tap_value < 0) ||
3008                 (tuning_data->best_tap_value > MAX_TAP_VALUES)) {
3009                 dev_err(mmc_dev(sdhci->mmc),
3010                         "Trying to verify invalid best tap value\n");
3011                 return -EINVAL;
3012         } else {
3013                 dev_err(mmc_dev(sdhci->mmc),
3014                         "%s: tuning freq %dhz, best tap %d\n",
3015                         __func__, tuning_data->freq_hz,
3016                         tuning_data->best_tap_value);
3017         }
3018
3019         /* Set the best tap value */
3020         sdhci_tegra_set_tap_delay(sdhci, tuning_data->best_tap_value);
3021
3022         /* Run tuning after setting the best tap value */
3023         err = sdhci_tegra_issue_tuning_cmd(sdhci);
3024         if (err)
3025                 dev_err(mmc_dev(sdhci->mmc),
3026                         "%dMHz best tap value verification failed %d\n",
3027                         tuning_data->freq_hz, err);
3028         return err;
3029 }
3030
3031 static int sdhci_tegra_execute_tuning(struct sdhci_host *sdhci, u32 opcode)
3032 {
3033         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3034         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3035         struct tegra_tuning_data *tuning_data;
3036         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
3037         int err;
3038         u16 ctrl_2;
3039         u32 misc_ctrl;
3040         u32 ier;
3041         u8 i, set_retuning = 0;
3042         bool force_retuning = false;
3043         bool enable_lb_clk;
3044
3045         /* Tuning is valid only in SDR104 and SDR50 modes */
3046         ctrl_2 = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
3047         if (!(((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
3048                 (((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
3049                 (sdhci->flags & SDHCI_SDR50_NEEDS_TUNING))))
3050                         return 0;
3051
3052         /* Tuning should be done only for MMC_BUS_WIDTH_8 and MMC_BUS_WIDTH_4 */
3053         if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
3054                 tegra_host->tuning_bsize = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_8;
3055         else if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
3056                 tegra_host->tuning_bsize = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_4;
3057         else
3058                 return -EINVAL;
3059
3060         SDHCI_TEGRA_DBG("%s: Starting freq tuning\n", mmc_hostname(sdhci->mmc));
3061         enable_lb_clk = (soc_data->nvquirks &
3062                         NVQUIRK_DISABLE_EXTERNAL_LOOPBACK) &&
3063                         (tegra_host->instance == 2);
3064         if (enable_lb_clk) {
3065                 misc_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_MISC_CTRL);
3066                 misc_ctrl &= ~(1 <<
3067                         SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
3068                 sdhci_writel(sdhci, misc_ctrl, SDHCI_VNDR_MISC_CTRL);
3069         }
3070         mutex_lock(&tuning_mutex);
3071
3072         /* Set the tuning command to be used */
3073         tegra_host->tuning_opcode = opcode;
3074
3075         /*
3076          * Disable all interrupts signalling.Enable interrupt status
3077          * detection for buffer read ready and data crc. We use
3078          * polling for tuning as it involves less overhead.
3079          */
3080         ier = sdhci_readl(sdhci, SDHCI_INT_ENABLE);
3081         sdhci_writel(sdhci, 0, SDHCI_SIGNAL_ENABLE);
3082         sdhci_writel(sdhci, SDHCI_INT_DATA_AVAIL |
3083                 SDHCI_INT_DATA_CRC, SDHCI_INT_ENABLE);
3084
3085         /*
3086          * If tuning is already done and retune request is not set, then skip
3087          * best tap value calculation and use the old best tap value. If the
3088          * previous best tap value verification failed, force retuning.
3089          */
3090         if (tegra_host->tuning_status == TUNING_STATUS_DONE) {
3091                 err = sdhci_tegra_verify_best_tap(sdhci);
3092                 if (err) {
3093                         dev_err(mmc_dev(sdhci->mmc),
3094                                 "Prev best tap failed. Re-running tuning\n");
3095                         force_retuning = true;
3096                 } else {
3097                         goto out;
3098                 }
3099         }
3100
3101         if (tegra_host->force_retune == true) {
3102                 force_retuning = true;
3103                 tegra_host->force_retune = false;
3104         }
3105
3106         tegra_host->tuning_status = 0;
3107         err = sdhci_tegra_get_tuning_constraints(sdhci, force_retuning);
3108         if (err) {
3109                 dev_err(mmc_dev(sdhci->mmc),
3110                         "Failed to get tuning constraints\n");
3111                 goto out;
3112         }
3113
3114         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
3115                 tuning_data = &tegra_host->tuning_data[i];
3116                 if (tuning_data->tuning_done && !force_retuning)
3117                         continue;
3118
3119                 SDHCI_TEGRA_DBG("%s: Setting tuning freq%d\n",
3120                         mmc_hostname(sdhci->mmc), tuning_data->freq_hz);
3121                 tegra_sdhci_set_clock(sdhci, tuning_data->freq_hz);
3122
3123                 SDHCI_TEGRA_DBG("%s: Calculating estimated tuning values\n",
3124                         mmc_hostname(sdhci->mmc));
3125                 err = calculate_estimated_tuning_values(tegra_host->speedo,
3126                         tuning_data, tegra_host->boot_vcore_mv);
3127                 if (err)
3128                         goto out;
3129
3130                 SDHCI_TEGRA_DBG("Running tuning...\n");
3131                 err = sdhci_tegra_run_tuning(sdhci, tuning_data);
3132                 if (err)
3133                         goto out;
3134
3135                 SDHCI_TEGRA_DBG("calculating best tap value\n");
3136                 err = sdhci_tegra_calculate_best_tap(sdhci, tuning_data);
3137                 if (err)
3138                         goto out;
3139
3140                 err = sdhci_tegra_verify_best_tap(sdhci);
3141                 if (!err && !set_retuning) {
3142                         tuning_data->tuning_done = true;
3143                         tegra_host->tuning_status |= TUNING_STATUS_DONE;
3144                 } else {
3145                         tegra_host->tuning_status |= TUNING_STATUS_RETUNE;
3146                 }
3147         }
3148 out:
3149         /* Release any override core voltages set */
3150         sdhci_tegra_set_tuning_voltage(sdhci, 0);
3151
3152         /* Enable interrupts. Enable full range for core voltage */
3153         sdhci_writel(sdhci, ier, SDHCI_INT_ENABLE);
3154         sdhci_writel(sdhci, ier, SDHCI_SIGNAL_ENABLE);
3155         mutex_unlock(&tuning_mutex);
3156
3157         SDHCI_TEGRA_DBG("%s: Freq tuning done\n", mmc_hostname(sdhci->mmc));
3158         if (enable_lb_clk) {
3159                 misc_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_MISC_CTRL);
3160                 if (err) {
3161                         /* Tuning is failed and card will try to enumerate in
3162                          * Legacy High Speed mode. So, Enable External Loopback
3163                          * for SDMMC3.
3164                          */
3165                         misc_ctrl |= (1 <<
3166                                 SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
3167                 } else {
3168                         misc_ctrl &= ~(1 <<
3169                                 SDHCI_VNDR_MISC_CTRL_EN_EXT_LOOPBACK_SHIFT);
3170                 }
3171                 sdhci_writel(sdhci, misc_ctrl, SDHCI_VNDR_MISC_CTRL);
3172         }
3173         return err;
3174 }
3175
3176 static int __init sdhci_tegra_enable_vcore_override_tuning(void)
3177 {
3178         vcore_overrides_allowed = true;
3179         maintain_boot_voltage = false;
3180         return 0;
3181 }
3182 late_initcall(sdhci_tegra_enable_vcore_override_tuning);
3183
3184 static int tegra_sdhci_suspend(struct sdhci_host *sdhci)
3185 {
3186         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3187         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3188         int err = 0;
3189
3190         tegra_sdhci_set_clock(sdhci, 0);
3191
3192         /* Disable the power rails if any */
3193         if (tegra_host->card_present) {
3194                 err = tegra_sdhci_configure_regulators(tegra_host,
3195                         CONFIG_REG_DIS, 0, 0);
3196                 if (err)
3197                         dev_err(mmc_dev(sdhci->mmc),
3198                         "Regulators disable in suspend failed %d\n", err);
3199         }
3200         return err;
3201 }
3202
3203 static int tegra_sdhci_resume(struct sdhci_host *sdhci)
3204 {
3205         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3206         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3207         struct platform_device *pdev;
3208         struct tegra_sdhci_platform_data *plat;
3209         int err;
3210
3211         pdev = to_platform_device(mmc_dev(sdhci->mmc));
3212         plat = pdev->dev.platform_data;
3213
3214         if (gpio_is_valid(plat->cd_gpio)) {
3215                 tegra_host->card_present =
3216                         (gpio_get_value_cansleep(plat->cd_gpio) == 0);
3217         }
3218
3219         /* Setting the min identification clock of freq 400KHz */
3220         tegra_sdhci_set_clock(sdhci, 400000);
3221
3222         /* Enable the power rails if any */
3223         if (tegra_host->card_present) {
3224                 err = tegra_sdhci_configure_regulators(tegra_host,
3225                         CONFIG_REG_EN, 0, 0);
3226                 if (err) {
3227                         dev_err(mmc_dev(sdhci->mmc),
3228                                 "Regulators enable in resume failed %d\n", err);
3229                         return err;
3230                 }
3231                 if (tegra_host->vdd_io_reg) {
3232                         if (plat->mmc_data.ocr_mask &
3233                                                 SDHOST_1V8_OCR_MASK)
3234                                 tegra_sdhci_signal_voltage_switch(sdhci,
3235                                                 MMC_SIGNAL_VOLTAGE_180);
3236                         else
3237                                 tegra_sdhci_signal_voltage_switch(sdhci,
3238                                                 MMC_SIGNAL_VOLTAGE_330);
3239                 }
3240         }
3241
3242         /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
3243         if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
3244                 tegra_sdhci_reset(sdhci, SDHCI_RESET_ALL);
3245                 sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
3246                 sdhci->pwr = 0;
3247         }
3248
3249         return 0;
3250 }
3251
3252 static void tegra_sdhci_post_resume(struct sdhci_host *sdhci)
3253 {
3254         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3255         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3256
3257         /* Turn OFF the clocks if the device is not present */
3258         if ((!tegra_host->card_present || !sdhci->mmc->card) &&
3259                 tegra_host->clk_enabled)
3260                 tegra_sdhci_set_clock(sdhci, 0);
3261 }
3262
3263 /*
3264  * For tegra specific tuning, core voltage has to be fixed at different
3265  * voltages to get the tap values. Fixing the core voltage during tuning for one
3266  * device might affect transfers of other SDMMC devices. Check if tuning mutex
3267  * is locked before starting a data transfer. The new tuning procedure might
3268  * take at max 1.5s for completion for a single run. Taking DFS into count,
3269  * setting the max timeout for tuning mutex check a 3 secs. Since tuning is
3270  * run only during boot or the first time device is inserted, there wouldn't
3271  * be any delays in cmd/xfer execution once devices enumeration is done.
3272  */
3273 static void tegra_sdhci_get_bus(struct sdhci_host *sdhci)
3274 {
3275         unsigned int timeout = 300;
3276
3277         while (mutex_is_locked(&tuning_mutex)) {
3278                 msleep(10);
3279                 --timeout;
3280                 if (!timeout) {
3281                         dev_err(mmc_dev(sdhci->mmc),
3282                                 "Tuning mutex locked for long time\n");
3283                         return;
3284                 }
3285         };
3286 }
3287
3288 /*
3289  * The host/device can be powered off before the retuning request is handled in
3290  * case of SDIDO being off if Wifi is turned off, sd card removal etc. In such
3291  * cases, cancel the pending tuning timer and remove any core voltage
3292  * constraints that are set earlier.
3293  */
3294 static void tegra_sdhci_power_off(struct sdhci_host *sdhci, u8 power_mode)
3295 {
3296         int retuning_req_set = 0;
3297
3298         retuning_req_set = (timer_pending(&sdhci->tuning_timer) ||
3299                 (sdhci->flags & SDHCI_NEEDS_RETUNING));
3300
3301         if (retuning_req_set) {
3302                 del_timer_sync(&sdhci->tuning_timer);
3303
3304                 if (boot_volt_req_refcount)
3305                         --boot_volt_req_refcount;
3306
3307                 if (!boot_volt_req_refcount) {
3308                         sdhci_tegra_set_tuning_voltage(sdhci, 0);
3309                         SDHCI_TEGRA_DBG("%s: Release override as host is off\n",
3310                                 mmc_hostname(sdhci->mmc));
3311                 }
3312         }
3313 }
3314
3315 static int show_polling_period(void *data, u64 *value)
3316 {
3317         struct sdhci_host *host = (struct sdhci_host *)data;
3318
3319         if (host->mmc->dev_stats != NULL)
3320                 *value = host->mmc->dev_stats->polling_interval;
3321
3322         return 0;
3323 }
3324
3325 static int set_polling_period(void *data, u64 value)
3326 {
3327         struct sdhci_host *host = (struct sdhci_host *)data;
3328
3329         if (host->mmc->dev_stats != NULL) {
3330                 /* Limiting the maximum polling period to 1 sec */
3331                 if (value > 1000)
3332                         value = 1000;
3333                 host->mmc->dev_stats->polling_interval = value;
3334         }
3335
3336         return 0;
3337 }
3338 static int show_active_load_high_threshold(void *data, u64 *value)
3339 {
3340         struct sdhci_host *host = (struct sdhci_host *)data;
3341         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3342         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3343         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
3344
3345         if (gov_data != NULL)
3346                 *value = gov_data->act_load_high_threshold;
3347
3348         return 0;
3349 }
3350
3351 static int set_active_load_high_threshold(void *data, u64 value)
3352 {
3353         struct sdhci_host *host = (struct sdhci_host *)data;
3354         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3355         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3356         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
3357
3358         if (gov_data != NULL) {
3359                 /* Maximum threshold load percentage is 100.*/
3360                 if (value > 100)
3361                         value = 100;
3362                 gov_data->act_load_high_threshold = value;
3363         }
3364
3365         return 0;
3366 }
3367
3368 DEFINE_SIMPLE_ATTRIBUTE(sdhci_polling_period_fops, show_polling_period,
3369                 set_polling_period, "%llu\n");
3370 DEFINE_SIMPLE_ATTRIBUTE(sdhci_active_load_high_threshold_fops,
3371                 show_active_load_high_threshold,
3372                 set_active_load_high_threshold, "%llu\n");
3373
3374 static void sdhci_tegra_error_stats_debugfs(struct sdhci_host *host)
3375 {
3376         struct dentry *root = host->debugfs_root;
3377         struct dentry *dfs_root;
3378         unsigned saved_line;
3379
3380         if (!root) {
3381                 root = debugfs_create_dir(dev_name(mmc_dev(host->mmc)), NULL);
3382                 if (IS_ERR_OR_NULL(root)) {
3383                         saved_line = __LINE__;
3384                         goto err_root;
3385                 }
3386                 host->debugfs_root = root;
3387         }
3388
3389         dfs_root = debugfs_create_dir("dfs_stats_dir", root);
3390         if (IS_ERR_OR_NULL(dfs_root)) {
3391                 saved_line = __LINE__;
3392                 goto err_node;
3393         }
3394
3395         if (!debugfs_create_file("error_stats", S_IRUSR, root, host,
3396                                 &sdhci_host_fops)) {
3397                 saved_line = __LINE__;
3398                 goto err_node;
3399         }
3400         if (!debugfs_create_file("dfs_stats", S_IRUSR, dfs_root, host,
3401                                 &sdhci_host_dfs_fops)) {
3402                 saved_line = __LINE__;
3403                 goto err_node;
3404         }
3405         if (!debugfs_create_file("polling_period", 0644, dfs_root, (void *)host,
3406                                 &sdhci_polling_period_fops)) {
3407                 saved_line = __LINE__;
3408                 goto err_node;
3409         }
3410         if (!debugfs_create_file("active_load_high_threshold", 0644,
3411                                 dfs_root, (void *)host,
3412                                 &sdhci_active_load_high_threshold_fops)) {
3413                 saved_line = __LINE__;
3414                 goto err_node;
3415         }
3416         return;
3417
3418 err_node:
3419         debugfs_remove_recursive(root);
3420         host->debugfs_root = NULL;
3421 err_root:
3422         pr_err("%s %s: Failed to initialize debugfs functionality at line=%d\n", __func__,
3423                 mmc_hostname(host->mmc), saved_line);
3424         return;
3425 }
3426
3427 static ssize_t sdhci_handle_boost_mode_tap(struct device *dev,
3428         struct device_attribute *attr, const char *buf, size_t count)
3429 {
3430         int tap_cmd;
3431         struct mmc_card *card;
3432         char *p = (char *)buf;
3433         struct sdhci_host *host = dev_get_drvdata(dev);
3434         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3435         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3436         struct tegra_tuning_data *tuning_data;
3437         u32 present_state;
3438         u8 timeout;
3439         bool clk_set_for_tap_prog = false;
3440
3441         tap_cmd = memparse(p, &p);
3442
3443         card = host->mmc->card;
3444         if (!card)
3445                 return -ENODEV;
3446
3447         /* if not uhs -- no tuning and no tap value to set */
3448         if (!mmc_sd_card_uhs(card) && !mmc_card_hs200(card))
3449                 return count;
3450
3451         /* if no change in tap value -- just exit */
3452         if (tap_cmd == tegra_host->tap_cmd)
3453                 return count;
3454
3455         if ((tap_cmd != TAP_CMD_TRIM_DEFAULT_VOLTAGE) &&
3456                 (tap_cmd != TAP_CMD_TRIM_HIGH_VOLTAGE)) {
3457                 pr_info("echo 1 > cmd_state  # to set normal voltage\n");
3458                 pr_info("echo 2 > cmd_state  # to set high voltage\n");
3459                 return -EINVAL;
3460         }
3461
3462         tegra_host->tap_cmd = tap_cmd;
3463         tuning_data = sdhci_tegra_get_tuning_data(host, host->max_clk);
3464         /* Check if host clock is enabled */
3465         if (!tegra_host->clk_enabled) {
3466                 /* Nothing to do if the host is not powered ON */
3467                 if (host->mmc->ios.power_mode != MMC_POWER_ON)
3468                         return count;
3469                 else {
3470                         tegra_sdhci_set_clock(host, host->mmc->ios.clock);
3471                         clk_set_for_tap_prog = true;
3472                 }
3473         } else {
3474                 timeout = 10;
3475                 /* Wait for any on-going data transfers */
3476                 present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
3477                 while (present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ)) {
3478                         if (!timeout)
3479                                 break;
3480                         timeout--;
3481                         mdelay(1);
3482                         present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
3483                 };
3484         }
3485         spin_lock(&host->lock);
3486         switch (tap_cmd) {
3487         case TAP_CMD_TRIM_DEFAULT_VOLTAGE:
3488                 /* set tap value for voltage range 1.1 to 1.25 */
3489                 sdhci_tegra_set_tap_delay(host, tuning_data->best_tap_value);
3490                 break;
3491
3492         case TAP_CMD_TRIM_HIGH_VOLTAGE:
3493                 /* set tap value for voltage range 1.25 to 1.39 */
3494                 sdhci_tegra_set_tap_delay(host,
3495                         tuning_data->nom_best_tap_value);
3496                 break;
3497         }
3498         spin_unlock(&host->lock);
3499         if (clk_set_for_tap_prog) {
3500                 tegra_sdhci_set_clock(host, 0);
3501                 clk_set_for_tap_prog = false;
3502         }
3503         return count;
3504 }
3505
3506 static ssize_t sdhci_show_turbo_mode(struct device *dev,
3507                         struct device_attribute *attr, char *buf)
3508 {
3509         struct sdhci_host *host = dev_get_drvdata(dev);
3510         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3511         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3512
3513         return sprintf(buf, "%d\n", tegra_host->tap_cmd);
3514 }
3515
3516 static DEVICE_ATTR(cmd_state, 0644, sdhci_show_turbo_mode,
3517                         sdhci_handle_boost_mode_tap);
3518
3519 static int tegra_sdhci_reboot_notify(struct notifier_block *nb,
3520                                 unsigned long event, void *data)
3521 {
3522         struct sdhci_tegra *tegra_host =
3523                 container_of(nb, struct sdhci_tegra, reboot_notify);
3524         int err;
3525
3526         switch (event) {
3527         case SYS_RESTART:
3528         case SYS_POWER_OFF:
3529                 err = tegra_sdhci_configure_regulators(tegra_host,
3530                         CONFIG_REG_DIS, 0, 0);
3531                 if (err)
3532                         pr_err("Disable regulator in reboot notify failed %d\n",
3533                                 err);
3534                 return NOTIFY_OK;
3535         }
3536         return NOTIFY_DONE;
3537 }
3538
3539 void tegra_sdhci_ios_config_enter(struct sdhci_host *sdhci, struct mmc_ios *ios)
3540 {
3541         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
3542         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3543         struct clk *new_mode_clk;
3544         bool change_clk = false;
3545
3546         /*
3547          * Tegra sdmmc controllers require clock to be enabled for any register
3548          * access. Set the minimum controller clock if no clock is requested.
3549          */
3550         if (!sdhci->clock && !ios->clock) {
3551                 tegra_sdhci_set_clock(sdhci, sdhci->mmc->f_min);
3552                 sdhci->clock = sdhci->mmc->f_min;
3553         } else if (ios->clock && (ios->clock != sdhci->clock)) {
3554                 tegra_sdhci_set_clock(sdhci, ios->clock);
3555         }
3556
3557         /*
3558          * Check for DDR50 mode setting and set ddr_clk if not already
3559          * done. Return if only one clock option is available.
3560          */
3561         if (!tegra_host->ddr_clk || !tegra_host->sdr_clk) {
3562                 return;
3563         } else {
3564                 if ((ios->timing == MMC_TIMING_UHS_DDR50) &&
3565                         !tegra_host->is_ddr_clk_set) {
3566                         change_clk = true;
3567                         new_mode_clk = tegra_host->ddr_clk;
3568                 } else if ((ios->timing != MMC_TIMING_UHS_DDR50) &&
3569                         tegra_host->is_ddr_clk_set) {
3570                         change_clk = true;
3571                         new_mode_clk = tegra_host->sdr_clk;
3572                 }
3573
3574                 if (change_clk) {
3575                         tegra_sdhci_set_clock(sdhci, 0);
3576                         pltfm_host->clk = new_mode_clk;
3577                         /* Restore the previous frequency */
3578                         tegra_sdhci_set_clock(sdhci, sdhci->max_clk);
3579                         tegra_host->is_ddr_clk_set =
3580                                 !tegra_host->is_ddr_clk_set;
3581                 }
3582         }
3583 }
3584
3585 void tegra_sdhci_ios_config_exit(struct sdhci_host *sdhci, struct mmc_ios *ios)
3586 {
3587         /*
3588          * Do any required handling for retuning requests before powering off
3589          * the host.
3590          */
3591         if (ios->power_mode == MMC_POWER_OFF)
3592                 tegra_sdhci_power_off(sdhci, ios->power_mode);
3593
3594         /*
3595          * In case of power off, turn off controller clock now as all the
3596          * required register accesses are already done.
3597          */
3598         if (!ios->clock && !sdhci->mmc->skip_host_clkgate)
3599                 tegra_sdhci_set_clock(sdhci, 0);
3600 }
3601
3602 static const struct sdhci_ops tegra_sdhci_ops = {
3603         .get_ro     = tegra_sdhci_get_ro,
3604         .get_cd     = tegra_sdhci_get_cd,
3605         .read_l     = tegra_sdhci_readl,
3606         .read_w     = tegra_sdhci_readw,
3607         .write_l    = tegra_sdhci_writel,
3608         .write_w    = tegra_sdhci_writew,
3609         .platform_bus_width = tegra_sdhci_buswidth,
3610         .set_clock              = tegra_sdhci_set_clock,
3611         .suspend                = tegra_sdhci_suspend,
3612         .resume                 = tegra_sdhci_resume,
3613         .platform_resume        = tegra_sdhci_post_resume,
3614         .platform_reset_exit    = tegra_sdhci_reset_exit,
3615         .platform_get_bus       = tegra_sdhci_get_bus,
3616         .platform_ios_config_enter      = tegra_sdhci_ios_config_enter,
3617         .platform_ios_config_exit       = tegra_sdhci_ios_config_exit,
3618         .set_uhs_signaling      = tegra_sdhci_set_uhs_signaling,
3619         .switch_signal_voltage  = tegra_sdhci_signal_voltage_switch,
3620         .switch_signal_voltage_exit = tegra_sdhci_do_calibration,
3621         .execute_freq_tuning    = sdhci_tegra_execute_tuning,
3622         .sd_error_stats         = sdhci_tegra_sd_error_stats,
3623 #ifdef CONFIG_MMC_FREQ_SCALING
3624         .dfs_gov_init           = sdhci_tegra_freq_gov_init,
3625         .dfs_gov_get_target_freq        = sdhci_tegra_get_target_freq,
3626 #endif
3627 };
3628
3629 static struct sdhci_pltfm_data sdhci_tegra11_pdata = {
3630         .quirks = TEGRA_SDHCI_QUIRKS,
3631         .quirks2 = TEGRA_SDHCI_QUIRKS2,
3632         .ops  = &tegra_sdhci_ops,
3633 };
3634
3635 static struct sdhci_tegra_soc_data soc_data_tegra11 = {
3636         .pdata = &sdhci_tegra11_pdata,
3637         .nvquirks = TEGRA_SDHCI_NVQUIRKS |
3638                     NVQUIRK_SET_DRIVE_STRENGTH |
3639                     NVQUIRK_SET_TRIM_DELAY |
3640                     NVQUIRK_ENABLE_DDR50 |
3641                     NVQUIRK_ENABLE_HS200 |
3642                     NVQUIRK_INFINITE_ERASE_TIMEOUT |
3643                     NVQUIRK_DISABLE_EXTERNAL_LOOPBACK |
3644                     NVQUIRK_DISABLE_SDMMC4_CALIB,
3645         .parent_clk_list = {"pll_p", "pll_c"},
3646         .tuning_freq_list = {81600000, 156000000, 200000000},
3647         .t2t_coeffs = t11x_tuning_coeffs,
3648         .t2t_coeffs_count = 3,
3649         .tap_hole_coeffs = t11x_tap_hole_coeffs,
3650         .tap_hole_coeffs_count = 12,
3651 };
3652
3653 static struct sdhci_pltfm_data sdhci_tegra12_pdata = {
3654         .quirks = TEGRA_SDHCI_QUIRKS,
3655         .quirks2 = TEGRA_SDHCI_QUIRKS2 |
3656                 SDHCI_QUIRK2_SUPPORT_64BIT_DMA,
3657         .ops  = &tegra_sdhci_ops,
3658 };
3659
3660 static struct sdhci_tegra_soc_data soc_data_tegra12 = {
3661         .pdata = &sdhci_tegra12_pdata,
3662         .nvquirks = TEGRA_SDHCI_NVQUIRKS |
3663                     NVQUIRK_SET_TRIM_DELAY |
3664                     NVQUIRK_ENABLE_DDR50 |
3665                     NVQUIRK_ENABLE_HS200 |
3666                     NVQUIRK_INFINITE_ERASE_TIMEOUT |
3667                     NVQUIRK_SET_PAD_E_INPUT_OR_E_PWRD |
3668                     NVQUIRK_HIGH_FREQ_TAP_PROCEDURE |
3669                     NVQUIRK_SET_CALIBRATION_OFFSETS |
3670                     NVQUIRK_DISABLE_EXTERNAL_LOOPBACK,
3671         .parent_clk_list = {"pll_p", "pll_c"},
3672         .tuning_freq_list = {81600000, 136000000, 200000000},
3673         .t2t_coeffs = t12x_tuning_coeffs,
3674         .t2t_coeffs_count = 3,
3675         .tap_hole_coeffs = t12x_tap_hole_coeffs,
3676         .tap_hole_coeffs_count = 13,
3677 };
3678
3679 static const struct of_device_id sdhci_tegra_dt_match[] = {
3680         { .compatible = "nvidia,tegra124-sdhci", .data = &soc_data_tegra12 },
3681         { .compatible = "nvidia,tegra114-sdhci", .data = &soc_data_tegra11 },
3682         {}
3683 };
3684 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
3685
3686 static struct tegra_sdhci_platform_data *sdhci_tegra_dt_parse_pdata(
3687                                                 struct platform_device *pdev)
3688 {
3689         int val;
3690         struct tegra_sdhci_platform_data *plat;
3691         struct device_node *np = pdev->dev.of_node;
3692         u32 bus_width;
3693
3694         if (!np)
3695                 return NULL;
3696
3697         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
3698         if (!plat) {
3699                 dev_err(&pdev->dev, "Can't allocate platform data\n");
3700                 return NULL;
3701         }
3702
3703         plat->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
3704         plat->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
3705         plat->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
3706
3707         if (of_property_read_u32(np, "bus-width", &bus_width) == 0 &&
3708             bus_width == 8)
3709                 plat->is_8bit = 1;
3710
3711         of_property_read_u32(np, "tap-delay", &plat->tap_delay);
3712         of_property_read_u32(np, "trim-delay", &plat->trim_delay);
3713         of_property_read_u32(np, "ddr-clk-limit", &plat->ddr_clk_limit);
3714         of_property_read_u32(np, "max-clk-limit", &plat->max_clk_limit);
3715
3716         of_property_read_u32(np, "uhs_mask", &plat->uhs_mask);
3717
3718         if (of_find_property(np, "built-in", NULL))
3719                 plat->mmc_data.built_in = 1;
3720
3721         if (!of_property_read_u32(np, "mmc-ocr-mask", &val)) {
3722                 if (val == 0)
3723                         plat->mmc_data.ocr_mask = MMC_OCR_1V8_MASK;
3724                 else if (val == 1)
3725                         plat->mmc_data.ocr_mask = MMC_OCR_2V8_MASK;
3726                 else if (val == 2)
3727                         plat->mmc_data.ocr_mask = MMC_OCR_3V2_MASK;
3728                 else if (val == 3)
3729                         plat->mmc_data.ocr_mask = MMC_OCR_3V3_MASK;
3730         }
3731         return plat;
3732 }
3733
3734 static int sdhci_tegra_probe(struct platform_device *pdev)
3735 {
3736         const struct of_device_id *match;
3737         const struct sdhci_tegra_soc_data *soc_data;
3738         struct sdhci_host *host;
3739         struct sdhci_pltfm_host *pltfm_host;
3740         struct tegra_sdhci_platform_data *plat;
3741         struct sdhci_tegra *tegra_host;
3742         unsigned int low_freq;
3743         int rc;
3744         u8 i;
3745
3746         match = of_match_device(sdhci_tegra_dt_match, &pdev->dev);
3747         if (match) {
3748                 soc_data = match->data;
3749         } else {
3750                 /* Use id tables and remove the following chip defines */
3751 #if defined(CONFIG_ARCH_TEGRA_11x_SOC)
3752                 soc_data = &soc_data_tegra11;
3753 #else
3754                 soc_data = &soc_data_tegra12;
3755 #endif
3756         }
3757
3758         host = sdhci_pltfm_init(pdev, soc_data->pdata);
3759
3760         /* sdio delayed clock gate quirk in sdhci_host used */
3761         host->quirks2 |= SDHCI_QUIRK2_DELAYED_CLK_GATE;
3762
3763         if (IS_ERR(host))
3764                 return PTR_ERR(host);
3765
3766         pltfm_host = sdhci_priv(host);
3767
3768         plat = pdev->dev.platform_data;
3769
3770         if (plat == NULL)
3771                 plat = sdhci_tegra_dt_parse_pdata(pdev);
3772
3773         if (plat == NULL) {
3774                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
3775                 rc = -ENXIO;
3776                 goto err_no_plat;
3777         }
3778
3779         tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL);
3780         if (!tegra_host) {
3781                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n");
3782                 rc = -ENOMEM;
3783                 goto err_no_plat;
3784         }
3785
3786         tegra_host->plat = plat;
3787         pdev->dev.platform_data = plat;
3788
3789         tegra_host->sd_stat_head = devm_kzalloc(&pdev->dev,
3790                 sizeof(struct sdhci_tegra_sd_stats), GFP_KERNEL);
3791         if (!tegra_host->sd_stat_head) {
3792                 dev_err(mmc_dev(host->mmc), "failed to allocate sd_stat_head\n");
3793                 rc = -ENOMEM;
3794                 goto err_power_req;
3795         }
3796
3797         tegra_host->soc_data = soc_data;
3798         pltfm_host->priv = tegra_host;
3799
3800         for (i = 0; i < ARRAY_SIZE(soc_data->parent_clk_list); i++) {
3801                 if (!soc_data->parent_clk_list[i])
3802                         continue;
3803                 if (!strcmp(soc_data->parent_clk_list[i], "pll_c")) {
3804                         pll_c = clk_get_sys(NULL, "pll_c");
3805                         if (IS_ERR(pll_c)) {
3806                                 rc = PTR_ERR(pll_c);
3807                                 dev_err(mmc_dev(host->mmc),
3808                                         "clk error in getting pll_c: %d\n", rc);
3809                         }
3810                         pll_c_rate = clk_get_rate(pll_c);
3811                 }
3812
3813                 if (!strcmp(soc_data->parent_clk_list[i], "pll_p")) {
3814                         pll_p = clk_get_sys(NULL, "pll_p");
3815                         if (IS_ERR(pll_p)) {
3816                                 rc = PTR_ERR(pll_p);
3817                                 dev_err(mmc_dev(host->mmc),
3818                                         "clk error in getting pll_p: %d\n", rc);
3819                         }
3820                         pll_p_rate = clk_get_rate(pll_p);
3821                 }
3822         }
3823
3824 #ifdef CONFIG_MMC_EMBEDDED_SDIO
3825         if (plat->mmc_data.embedded_sdio)
3826                 mmc_set_embedded_sdio_data(host->mmc,
3827                         &plat->mmc_data.embedded_sdio->cis,
3828                         &plat->mmc_data.embedded_sdio->cccr,
3829                         plat->mmc_data.embedded_sdio->funcs,
3830                         plat->mmc_data.embedded_sdio->num_funcs);
3831 #endif
3832
3833         if (gpio_is_valid(plat->power_gpio)) {
3834                 rc = gpio_request(plat->power_gpio, "sdhci_power");
3835                 if (rc) {
3836                         dev_err(mmc_dev(host->mmc),
3837                                 "failed to allocate power gpio\n");
3838                         goto err_power_req;
3839                 }
3840                 gpio_direction_output(plat->power_gpio, 1);
3841         }
3842
3843         if (gpio_is_valid(plat->cd_gpio)) {
3844                 rc = gpio_request(plat->cd_gpio, "sdhci_cd");
3845                 if (rc) {
3846                         dev_err(mmc_dev(host->mmc),
3847                                 "failed to allocate cd gpio\n");
3848                         goto err_cd_req;
3849                 }
3850                 gpio_direction_input(plat->cd_gpio);
3851
3852                 tegra_host->card_present =
3853                         (gpio_get_value_cansleep(plat->cd_gpio) == 0);
3854
3855         } else if (plat->mmc_data.register_status_notify) {
3856                 plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
3857         }
3858
3859         if (plat->mmc_data.status) {
3860                 plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
3861         }
3862
3863         if (gpio_is_valid(plat->wp_gpio)) {
3864                 rc = gpio_request(plat->wp_gpio, "sdhci_wp");
3865                 if (rc) {
3866                         dev_err(mmc_dev(host->mmc),
3867                                 "failed to allocate wp gpio\n");
3868                         goto err_wp_req;
3869                 }
3870                 gpio_direction_input(plat->wp_gpio);
3871         }
3872
3873         /*
3874          * If there is no card detect gpio, assume that the
3875          * card is always present.
3876          */
3877         if (!gpio_is_valid(plat->cd_gpio))
3878                 tegra_host->card_present = 1;
3879
3880         if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
3881                 tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
3882                 tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
3883         } else if (plat->mmc_data.ocr_mask & MMC_OCR_2V8_MASK) {
3884                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_2V8;
3885                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3886         } else if (plat->mmc_data.ocr_mask & MMC_OCR_3V2_MASK) {
3887                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_3V2;
3888                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3889         } else if (plat->mmc_data.ocr_mask & MMC_OCR_3V3_MASK) {
3890                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_3V3;
3891                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3892         } else {
3893                 /*
3894                  * Set the minV and maxV to default
3895                  * voltage range of 2.7V - 3.6V
3896                  */
3897                 tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
3898                 tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
3899         }
3900
3901         tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc),
3902                                                         "vddio_sdmmc");
3903         if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
3904                 dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
3905                         "Assuming vddio_sdmmc is not required.\n",
3906                         "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
3907                 tegra_host->vdd_io_reg = NULL;
3908         } else {
3909                 rc = tegra_sdhci_configure_regulators(tegra_host,
3910                         CONFIG_REG_SET_VOLT,
3911                         tegra_host->vddio_min_uv,
3912                         tegra_host->vddio_max_uv);
3913                 if (rc) {
3914                         dev_err(mmc_dev(host->mmc),
3915                                 "Init volt(%duV-%duV) setting failed %d\n",
3916                                 tegra_host->vddio_min_uv,
3917                                 tegra_host->vddio_max_uv, rc);
3918                         regulator_put(tegra_host->vdd_io_reg);
3919                         tegra_host->vdd_io_reg = NULL;
3920                 }
3921         }
3922
3923         tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc),
3924                                                         "vddio_sd_slot");
3925         if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
3926                 dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
3927                         " Assuming vddio_sd_slot is not required.\n",
3928                         "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
3929                 tegra_host->vdd_slot_reg = NULL;
3930         }
3931
3932         if (tegra_host->card_present) {
3933                 rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_EN,
3934                         0, 0);
3935                 if (rc) {
3936                         dev_err(mmc_dev(host->mmc),
3937                                 "Enable regulators failed in probe %d\n", rc);
3938                         goto err_clk_get;
3939                 }
3940         }
3941
3942         tegra_pd_add_device(&pdev->dev);
3943         pm_runtime_enable(&pdev->dev);
3944
3945         /* Get the ddr clock */
3946         tegra_host->ddr_clk = clk_get(mmc_dev(host->mmc), "ddr");
3947         if (IS_ERR(tegra_host->ddr_clk)) {
3948                 dev_err(mmc_dev(host->mmc), "ddr clk err\n");
3949                 tegra_host->ddr_clk = NULL;
3950         }
3951
3952         /* Get high speed clock */
3953         tegra_host->sdr_clk = clk_get(mmc_dev(host->mmc), NULL);
3954         if (IS_ERR(tegra_host->sdr_clk)) {
3955                 dev_err(mmc_dev(host->mmc), "sdr clk err\n");
3956                 tegra_host->sdr_clk = NULL;
3957                 /* If both ddr and sdr clks are missing, then fail probe */
3958                 if (!tegra_host->ddr_clk && !tegra_host->sdr_clk) {
3959                         dev_err(mmc_dev(host->mmc),
3960                                 "Failed to get ddr and sdr clks\n");
3961                         rc = -EINVAL;
3962                         goto err_clk_get;
3963                 }
3964         }
3965
3966         if (tegra_host->sdr_clk) {
3967                 pltfm_host->clk = tegra_host->sdr_clk;
3968                 tegra_host->is_ddr_clk_set = false;
3969         } else {
3970                 pltfm_host->clk = tegra_host->ddr_clk;
3971                 tegra_host->is_ddr_clk_set = true;
3972         }
3973
3974         if (clk_get_parent(pltfm_host->clk) == pll_c)
3975                 tegra_host->is_parent_pllc = true;
3976
3977         pm_runtime_get_sync(&pdev->dev);
3978         rc = clk_prepare_enable(pltfm_host->clk);
3979         if (rc != 0)
3980                 goto err_clk_put;
3981
3982         tegra_host->emc_clk = devm_clk_get(mmc_dev(host->mmc), "emc");
3983         if (IS_ERR_OR_NULL(tegra_host->emc_clk)) {
3984                 dev_err(mmc_dev(host->mmc), "Can't get emc clk\n");
3985                 tegra_host->emc_clk = NULL;
3986         } else {
3987                 clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_MAX_FREQ);
3988         }
3989
3990         tegra_host->sclk = devm_clk_get(mmc_dev(host->mmc), "sclk");
3991         if (IS_ERR_OR_NULL(tegra_host->sclk)) {
3992                 dev_err(mmc_dev(host->mmc), "Can't get sclk clock\n");
3993                 tegra_host->sclk = NULL;
3994         } else {
3995                 clk_set_rate(tegra_host->sclk, SDMMC_AHB_MAX_FREQ);
3996         }
3997         pltfm_host->priv = tegra_host;
3998         tegra_host->clk_enabled = true;
3999         host->is_clk_on = tegra_host->clk_enabled;
4000         mutex_init(&tegra_host->set_clock_mutex);
4001
4002         tegra_host->max_clk_limit = plat->max_clk_limit;
4003         tegra_host->ddr_clk_limit = plat->ddr_clk_limit;
4004         tegra_host->instance = pdev->id;
4005         tegra_host->tap_cmd = TAP_CMD_TRIM_DEFAULT_VOLTAGE;
4006         tegra_host->speedo = plat->cpu_speedo;
4007         dev_info(mmc_dev(host->mmc), "Speedo value %d\n", tegra_host->speedo);
4008         host->mmc->pm_caps |= plat->pm_caps;
4009         host->mmc->pm_flags |= plat->pm_flags;
4010
4011         host->mmc->caps |= MMC_CAP_ERASE;
4012         /* enable 1/8V DDR capable */
4013         host->mmc->caps |= MMC_CAP_1_8V_DDR;
4014         if (plat->is_8bit)
4015                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
4016         host->mmc->caps |= MMC_CAP_SDIO_IRQ;
4017         host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
4018         if (plat->mmc_data.built_in) {
4019                 host->mmc->caps |= MMC_CAP_NONREMOVABLE;
4020         }
4021         host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
4022
4023         /* disable access to boot partitions */
4024         host->mmc->caps2 |= MMC_CAP2_BOOTPART_NOACC;
4025
4026 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
4027         if (soc_data->nvquirks & NVQUIRK_ENABLE_HS200)
4028                 host->mmc->caps2 |= MMC_CAP2_HS200;
4029 #ifdef CONFIG_TEGRA_FPGA_PLATFORM
4030         /* Enable HS200 mode */
4031         host->mmc->caps2 |= MMC_CAP2_HS200;
4032 #else
4033         host->mmc->caps2 |= MMC_CAP2_CACHE_CTRL;
4034         host->mmc->caps |= MMC_CAP_CMD23;
4035         host->mmc->caps2 |= MMC_CAP2_PACKED_CMD;
4036 #endif
4037 #endif
4038
4039         /*
4040          * Enable dyamic frequency scaling support only if the platform clock
4041          * limit is higher than the lowest supported frequency by tuning.
4042          */
4043         for (i = 0; i < TUNING_FREQ_COUNT; i++) {
4044                 low_freq = soc_data->tuning_freq_list[i];
4045                 if (low_freq)
4046                         break;
4047         }
4048         if (plat->en_freq_scaling && (plat->max_clk_limit > low_freq))
4049                 host->mmc->caps2 |= MMC_CAP2_FREQ_SCALING;
4050
4051         if (!plat->disable_clock_gate)
4052                 host->mmc->caps2 |= MMC_CAP2_CLOCK_GATING;
4053
4054         if (plat->nominal_vcore_mv)
4055                 tegra_host->nominal_vcore_mv = plat->nominal_vcore_mv;
4056         if (plat->min_vcore_override_mv)
4057                 tegra_host->min_vcore_override_mv = plat->min_vcore_override_mv;
4058         if (plat->boot_vcore_mv)
4059                 tegra_host->boot_vcore_mv = plat->boot_vcore_mv;
4060         dev_info(mmc_dev(host->mmc),
4061                 "Tuning constraints: nom_mv %d, boot_mv %d, min_or_mv %d\n",
4062                 tegra_host->nominal_vcore_mv, tegra_host->boot_vcore_mv,
4063                 tegra_host->min_vcore_override_mv);
4064
4065         /*
4066          * If nominal voltage is equal to boot voltage, there is no need for
4067          * nominal voltage tuning.
4068          */
4069         if (plat->nominal_vcore_mv <= plat->boot_vcore_mv)
4070                 plat->en_nominal_vcore_tuning = false;
4071
4072         INIT_DELAYED_WORK(&host->delayed_clk_gate_wrk, delayed_clk_gate_cb);
4073         rc = sdhci_add_host(host);
4074         if (rc)
4075                 goto err_add_host;
4076
4077         if (gpio_is_valid(plat->cd_gpio)) {
4078                 rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
4079                         carddetect_irq,
4080                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
4081                         mmc_hostname(host->mmc), host);
4082                 if (rc) {
4083                         dev_err(mmc_dev(host->mmc), "request irq error\n");
4084                         goto err_cd_irq_req;
4085                 }
4086                 if (!plat->cd_wakeup_incapable) {
4087                         rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
4088                         if (rc < 0)
4089                                 dev_err(mmc_dev(host->mmc),
4090                                         "SD card wake-up event registration "
4091                                         "failed with error: %d\n", rc);
4092                 }
4093         }
4094         sdhci_tegra_error_stats_debugfs(host);
4095         device_create_file(&pdev->dev, &dev_attr_cmd_state);
4096
4097         /* Enable async suspend/resume to reduce LP0 latency */
4098         device_enable_async_suspend(&pdev->dev);
4099
4100         if (plat->power_off_rail) {
4101                 tegra_host->reboot_notify.notifier_call =
4102                         tegra_sdhci_reboot_notify;
4103                 register_reboot_notifier(&tegra_host->reboot_notify);
4104         }
4105         return 0;
4106
4107 err_cd_irq_req:
4108         if (gpio_is_valid(plat->cd_gpio))
4109                 gpio_free(plat->cd_gpio);
4110 err_add_host:
4111         if (tegra_host->is_ddr_clk_set)
4112                 clk_disable_unprepare(tegra_host->ddr_clk);
4113         else
4114                 clk_disable_unprepare(tegra_host->sdr_clk);
4115         pm_runtime_put_sync(&pdev->dev);
4116 err_clk_put:
4117         if (tegra_host->ddr_clk)
4118                 clk_put(tegra_host->ddr_clk);
4119         if (tegra_host->sdr_clk)
4120                 clk_put(tegra_host->sdr_clk);
4121 err_clk_get:
4122         if (gpio_is_valid(plat->wp_gpio))
4123                 gpio_free(plat->wp_gpio);
4124 err_wp_req:
4125         if (gpio_is_valid(plat->cd_gpio))
4126                 free_irq(gpio_to_irq(plat->cd_gpio), host);
4127 err_cd_req:
4128         if (gpio_is_valid(plat->power_gpio))
4129                 gpio_free(plat->power_gpio);
4130 err_power_req:
4131 err_no_plat:
4132         sdhci_pltfm_free(pdev);
4133         return rc;
4134 }
4135
4136 static int sdhci_tegra_remove(struct platform_device *pdev)
4137 {
4138         struct sdhci_host *host = platform_get_drvdata(pdev);
4139         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
4140         struct sdhci_tegra *tegra_host = pltfm_host->priv;
4141         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
4142         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
4143         int rc = 0;
4144
4145         sdhci_remove_host(host, dead);
4146
4147         disable_irq_wake(gpio_to_irq(plat->cd_gpio));
4148
4149         rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_DIS, 0, 0);
4150         if (rc)
4151                 dev_err(mmc_dev(host->mmc),
4152                         "Regulator disable in remove failed %d\n", rc);
4153
4154         if (tegra_host->vdd_slot_reg)
4155                 regulator_put(tegra_host->vdd_slot_reg);
4156         if (tegra_host->vdd_io_reg)
4157                 regulator_put(tegra_host->vdd_io_reg);
4158
4159         if (gpio_is_valid(plat->wp_gpio))
4160                 gpio_free(plat->wp_gpio);
4161
4162         if (gpio_is_valid(plat->cd_gpio)) {
4163                 free_irq(gpio_to_irq(plat->cd_gpio), host);
4164                 gpio_free(plat->cd_gpio);
4165         }
4166
4167         if (gpio_is_valid(plat->power_gpio))
4168                 gpio_free(plat->power_gpio);
4169
4170         if (tegra_host->clk_enabled) {
4171                 if (tegra_host->is_ddr_clk_set)
4172                         clk_disable_unprepare(tegra_host->ddr_clk);
4173                 else
4174                         clk_disable_unprepare(tegra_host->sdr_clk);
4175                 pm_runtime_put_sync(&pdev->dev);
4176         }
4177
4178         if (tegra_host->ddr_clk)
4179                 clk_put(tegra_host->ddr_clk);
4180         if (tegra_host->sdr_clk)
4181                 clk_put(tegra_host->sdr_clk);
4182
4183         if (tegra_host->emc_clk && tegra_host->is_sdmmc_emc_clk_on)
4184                 clk_disable_unprepare(tegra_host->emc_clk);
4185         if (tegra_host->sclk && tegra_host->is_sdmmc_sclk_on)
4186                 clk_disable_unprepare(tegra_host->sclk);
4187         if (plat->power_off_rail)
4188                 unregister_reboot_notifier(&tegra_host->reboot_notify);
4189
4190         sdhci_pltfm_free(pdev);
4191
4192         return rc;
4193 }
4194
4195 static struct platform_driver sdhci_tegra_driver = {
4196         .driver         = {
4197                 .name   = "sdhci-tegra",
4198                 .owner  = THIS_MODULE,
4199                 .of_match_table = sdhci_tegra_dt_match,
4200                 .pm     = SDHCI_PLTFM_PMOPS,
4201         },
4202         .probe          = sdhci_tegra_probe,
4203         .remove         = sdhci_tegra_remove,
4204 };
4205
4206 module_platform_driver(sdhci_tegra_driver);
4207
4208 MODULE_DESCRIPTION("SDHCI driver for Tegra");
4209 MODULE_AUTHOR("Google, Inc.");
4210 MODULE_LICENSE("GPL v2");