8b9c89673e810320b2485f91ddacefea840e9016
[linux-2.6.git] / drivers / mmc / host / sdhci-tegra.c
1 /*
2  * Copyright (C) 2010 Google, Inc.
3  *
4  * Copyright (c) 2012-2013, 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/mmc/mmc.h>
33 #include <linux/mmc/card.h>
34 #include <linux/regulator/consumer.h>
35 #include <linux/delay.h>
36 #include <linux/pm_runtime.h>
37 #include <asm/gpio.h>
38 #include <linux/debugfs.h>
39 #include <linux/seq_file.h>
40 #include <linux/reboot.h>
41 #include <linux/devfreq.h>
42
43 #include <mach/gpio-tegra.h>
44 #include <mach/sdhci.h>
45 #include <mach/pinmux.h>
46 #include <mach/clk.h>
47
48 #include "sdhci-pltfm.h"
49
50 #if 0
51 #define SDHCI_TEGRA_DBG(stuff...)       pr_info(stuff)
52 #else
53 #define SDHCI_TEGRA_DBG(stuff...)       do {} while (0)
54 #endif
55
56 /* Tegra SDMMC controller vendor register defines */
57 #define SDHCI_VNDR_CLK_CTRL     0x100
58 #define SDHCI_VNDR_CLK_CTRL_SDMMC_CLK   0x1
59 #define SDHCI_VNDR_CLK_CTRL_PADPIPE_CLKEN_OVERRIDE      0x8
60 #define SDHCI_VNDR_CLK_CTRL_SPI_MODE_CLKEN_OVERRIDE     0x4
61 #define SDHCI_VNDR_CLK_CNTL_INPUT_IO_CLK                0x2
62 #define SDHCI_VNDR_CLK_CTRL_BASE_CLK_FREQ_SHIFT 8
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
67 #define SDHCI_VNDR_MISC_CTRL            0x120
68 #define SDHCI_VNDR_MISC_CTRL_ENABLE_SDR104_SUPPORT      0x8
69 #define SDHCI_VNDR_MISC_CTRL_ENABLE_SDR50_SUPPORT       0x10
70 #define SDHCI_VNDR_MISC_CTRL_ENABLE_DDR50_SUPPORT       0x200
71 #define SDHCI_VNDR_MISC_CTRL_ENABLE_SD_3_0      0x20
72 #define SDHCI_VNDR_MISC_CTRL_INFINITE_ERASE_TIMEOUT     0x1
73
74 #define SDMMC_SDMEMCOMPPADCTRL  0x1E0
75 #define SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK    0xF
76
77 #define SDMMC_AUTO_CAL_CONFIG   0x1E4
78 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_START    0x80000000
79 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE   0x20000000
80 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT  0x8
81 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET        0x70
82 #define SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET        0x62
83
84 #define SDMMC_AUTO_CAL_STATUS   0x1EC
85 #define SDMMC_AUTO_CAL_STATUS_AUTO_CAL_ACTIVE   0x80000000
86 #define SDMMC_AUTO_CAL_STATUS_PULLDOWN_OFFSET   24
87 #define PULLUP_ADJUSTMENT_OFFSET        20
88
89 /* Erratum: Version register is invalid in HW */
90 #define NVQUIRK_FORCE_SDHCI_SPEC_200            BIT(0)
91 /* Erratum: Enable block gap interrupt detection */
92 #define NVQUIRK_ENABLE_BLOCK_GAP_DET            BIT(1)
93 /* Do not enable auto calibration if the platform doesn't support */
94 #define NVQUIRK_DISABLE_AUTO_CALIBRATION        BIT(2)
95 /* Set Calibration Offsets */
96 #define NVQUIRK_SET_CALIBRATION_OFFSETS         BIT(3)
97 /* Set Drive Strengths */
98 #define NVQUIRK_SET_DRIVE_STRENGTH              BIT(4)
99 /* Enable PADPIPE CLKEN */
100 #define NVQUIRK_ENABLE_PADPIPE_CLKEN            BIT(5)
101 /* DISABLE SPI_MODE CLKEN */
102 #define NVQUIRK_DISABLE_SPI_MODE_CLKEN          BIT(6)
103 /* Set tap delay */
104 #define NVQUIRK_SET_TAP_DELAY                   BIT(7)
105 /* Set trim delay */
106 #define NVQUIRK_SET_TRIM_DELAY                  BIT(8)
107 /* Enable SDHOST v3.0 support */
108 #define NVQUIRK_ENABLE_SD_3_0                   BIT(9)
109 /* Enable SDR50 mode */
110 #define NVQUIRK_ENABLE_SDR50                    BIT(10)
111 /* Enable SDR104 mode */
112 #define NVQUIRK_ENABLE_SDR104                   BIT(11)
113 /*Enable DDR50 mode */
114 #define NVQUIRK_ENABLE_DDR50                    BIT(12)
115 /* Enable Frequency Tuning for SDR50 mode */
116 #define NVQUIRK_ENABLE_SDR50_TUNING             BIT(13)
117 /* Enable HS200 mode */
118 #define NVQUIRK_ENABLE_HS200                    BIT(14)
119 /* Enable Infinite Erase Timeout*/
120 #define NVQUIRK_INFINITE_ERASE_TIMEOUT          BIT(15)
121 /* Disable AUTO CMD23 */
122 #define NVQUIRK_DISABLE_AUTO_CMD23              BIT(16)
123 /* ENAABLE FEEDBACK IO CLOCK */
124 #define NVQUIRK_EN_FEEDBACK_CLK                 BIT(17)
125 /* Shadow write xfer mode reg and write it alongwith CMD register */
126 #define NVQUIRK_SHADOW_XFER_MODE_REG            BIT(18)
127
128 /* Common subset of quirks for Tegra3 and later sdmmc controllers */
129 #define TEGRA_SDHCI_NVQUIRKS    (NVQUIRK_ENABLE_PADPIPE_CLKEN | \
130                   NVQUIRK_DISABLE_SPI_MODE_CLKEN | \
131                   NVQUIRK_EN_FEEDBACK_CLK | \
132                   NVQUIRK_SET_TAP_DELAY | \
133                   NVQUIRK_ENABLE_SDR50_TUNING | \
134                   NVQUIRK_ENABLE_SDR50 | \
135                   NVQUIRK_ENABLE_SDR104 | \
136                   NVQUIRK_SHADOW_XFER_MODE_REG | \
137                   NVQUIRK_DISABLE_AUTO_CMD23)
138
139 #define TEGRA_SDHCI_QUIRKS              (SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | \
140                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | \
141                   SDHCI_QUIRK_SINGLE_POWER_WRITE | \
142                   SDHCI_QUIRK_NO_HISPD_BIT | \
143                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC | \
144                   SDHCI_QUIRK_BROKEN_CARD_DETECTION)
145
146 #define TEGRA_SDHCI_QUIRKS2     (SDHCI_QUIRK2_BROKEN_PRESET_VALUES | \
147                   SDHCI_QUIRK2_NON_STD_VOLTAGE_SWITCHING | \
148                   SDHCI_QUIRK2_NON_STANDARD_TUNING | \
149                   SDHCI_QUIRK2_NO_CALC_MAX_DISCARD_TO)
150
151 /* Interface voltages */
152 #define SDHOST_1V8_OCR_MASK     0x8
153 #define SDHOST_HIGH_VOLT_MIN    2700000
154 #define SDHOST_HIGH_VOLT_MAX    3600000
155 #define SDHOST_HIGH_VOLT_2V8    2800000
156 #define SDHOST_LOW_VOLT_MIN     1800000
157 #define SDHOST_LOW_VOLT_MAX     1800000
158
159 /* Clock related definitions */
160 #define MAX_DIVISOR_VALUE       128
161 #define DEFAULT_SDHOST_FREQ     50000000
162 #define SDMMC_AHB_MAX_FREQ      150000000
163 #define SDMMC_EMC_MAX_FREQ      150000000
164 #define SDMMC_EMC_NOM_VOLT_FREQ 900000000
165
166 /* Tuning related definitions */
167 #define MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_8       128
168 #define MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_4       64
169 #define MAX_TAP_VALUES  255
170 #define TUNING_FREQ_COUNT       3
171 #define TUNING_VOLTAGES_COUNT   3
172 #define TUNING_RETRIES  1
173 #define DFS_FREQ_COUNT  2
174
175 /* Tuning core voltage requirements */
176 #define NOMINAL_VCORE_TUN       BIT(0)
177 #define BOOT_VCORE_TUN  BIT(1)
178 #define MIN_OVERRIDE_VCORE_TUN  BIT(2)
179
180 /* Tap cmd sysfs commands */
181 #define TAP_CMD_TRIM_DEFAULT_VOLTAGE    1
182 #define TAP_CMD_TRIM_HIGH_VOLTAGE       2
183
184 /*
185  * Defined the chip specific quirks and clock sources. For now, the used clock
186  * sources vary only from chip to chip. If the sources allowed varies from
187  * platform to platform, then move the clock sources list to platform data.
188  * When filling the tuning_freq_list in soc_data, the number of entries should
189  * be equal to TUNNG_FREQ_COUNT. Depending on number DFS frequencies supported,
190  * set the desired low, high or max frequencies and set the remaining entries
191  * as 0s. The number of entries should always be equal to TUNING_FREQ_COUNT
192  * inorder to get the right tuning data.
193  */
194 struct sdhci_tegra_soc_data {
195         struct sdhci_pltfm_data *pdata;
196         u32 nvquirks;
197         const char *parent_clk_list[2];
198         unsigned int tuning_freq_list[TUNING_FREQ_COUNT];
199 };
200
201
202 enum tegra_regulator_config_ops {
203         CONFIG_REG_EN,
204         CONFIG_REG_DIS,
205         CONFIG_REG_SET_VOLT,
206 };
207
208 static unsigned int uhs_max_freq_MHz[] = {
209         [MMC_TIMING_UHS_SDR50] = 100,
210         [MMC_TIMING_UHS_SDR104] = 208,
211         [MMC_TIMING_MMC_HS200] = 200,
212 };
213
214 enum tegra_tuning_freq {
215         TUNING_LOW_FREQ,
216         TUNING_HIGH_FREQ,
217         TUNING_MAX_FREQ,
218 };
219
220
221 struct freq_tuning_constraints {
222         unsigned int vcore_mask;
223 };
224
225 static struct freq_tuning_constraints tuning_vcore_constraints[3] = {
226         [0] = {
227                 .vcore_mask = BOOT_VCORE_TUN,
228         },
229         [1] = {
230                 .vcore_mask = BOOT_VCORE_TUN | MIN_OVERRIDE_VCORE_TUN |
231                         NOMINAL_VCORE_TUN,
232         },
233         [2] = {
234                 .vcore_mask = BOOT_VCORE_TUN | NOMINAL_VCORE_TUN,
235         },
236 };
237
238 struct tap_window_data {
239         bool            abandon_partial_win;
240         bool            abandon_full_win;
241         unsigned int voltage;
242         u8 partial_win;
243         u8 full_win_begin;
244         u8 full_win_end;
245         u8 vcore_set_status;
246         u8 found_tuning_window;
247         u8 tuning_done;
248 };
249
250 struct tegra_tuning_data {
251         unsigned int freq_hz;
252         unsigned int best_tap_value;
253         unsigned int nom_best_tap_value;
254         struct freq_tuning_constraints constraints;
255         struct tap_window_data *tap_data[TUNING_VOLTAGES_COUNT];
256         u8 nr_voltages;
257         u8 freq_band;
258         bool tuning_done;
259 };
260
261 #ifdef CONFIG_MMC_FREQ_SCALING
262 struct freq_gov_params {
263         u8      idle_mon_cycles;
264         u8      polling_interval_ms;
265         u8      active_load_threshold;
266 };
267
268 static struct freq_gov_params gov_params[3] = {
269         [MMC_TYPE_MMC] = {
270                 .idle_mon_cycles = 3,
271                 .polling_interval_ms = 50,
272                 .active_load_threshold = 25,
273         },
274         [MMC_TYPE_SDIO] = {
275                 .idle_mon_cycles = 3,
276                 .polling_interval_ms = 50,
277                 .active_load_threshold = 25,
278         },
279         [MMC_TYPE_SD] = {
280                 .idle_mon_cycles = 3,
281                 .polling_interval_ms = 50,
282                 .active_load_threshold = 25,
283         },
284 };
285 #endif
286
287 struct tegra_freq_gov_data {
288         unsigned int            curr_active_load;
289         unsigned int            avg_active_load;
290         unsigned int            act_load_high_threshold;
291         unsigned int            max_idle_monitor_cycles;
292         unsigned int            curr_freq;
293         unsigned int            freqs[DFS_FREQ_COUNT];
294         unsigned int            freq_switch_count;
295         bool                    monitor_idle_load;
296 };
297
298 struct sdhci_tegra_sd_stats {
299         unsigned int data_crc_count;
300         unsigned int cmd_crc_count;
301         unsigned int data_to_count;
302         unsigned int cmd_to_count;
303 };
304
305 struct sdhci_tegra {
306         const struct tegra_sdhci_platform_data *plat;
307         struct sdhci_tegra_soc_data *soc_data;
308         bool    clk_enabled;
309         struct regulator *vdd_io_reg;
310         struct regulator *vdd_slot_reg;
311         struct regulator *vcore_reg;
312         /* Host controller instance */
313         unsigned int instance;
314         /* vddio_min */
315         unsigned int vddio_min_uv;
316         /* vddio_max */
317         unsigned int vddio_max_uv;
318         /* max clk supported by the platform */
319         unsigned int max_clk_limit;
320         /* max ddr clk supported by the platform */
321         unsigned int ddr_clk_limit;
322         /* SD Hot Plug in Suspend State */
323         unsigned int sd_detect_in_suspend;
324         bool card_present;
325         bool is_rail_enabled;
326         struct clk *emc_clk;
327         bool emc_clk_enabled;
328         struct clk *sclk;
329         bool is_sdmmc_sclk_on;
330         struct sdhci_tegra_sd_stats *sd_stat_head;
331         int nominal_vcore_mv;
332         int min_vcore_override_mv;
333         int boot_vcore_mv;
334         /* Tuning related structures and variables */
335         /* Tuning opcode to be used */
336         unsigned int tuning_opcode;
337         /* Tuning packet size */
338         unsigned int tuning_bsize;
339         /* Num of tuning freqs selected */
340         unsigned int tuning_freq_count;
341         unsigned int tap_cmd;
342         /* Tuning status */
343         unsigned int tuning_status;
344         bool force_retune;
345 #define TUNING_STATUS_DONE      1
346 #define TUNING_STATUS_RETUNE    2
347         /* Freq tuning information for each sampling clock freq */
348         struct tegra_tuning_data tuning_data[DFS_FREQ_COUNT];
349         bool is_parent_pllc;
350         struct notifier_block reboot_notify;
351         struct tegra_freq_gov_data *gov_data;
352 };
353
354 static struct clk *pll_c;
355 static struct clk *pll_p;
356 static unsigned long pll_c_rate;
357 static unsigned long pll_p_rate;
358 static bool vcore_overrides_allowed;
359 static bool maintain_boot_voltage;
360 static unsigned int boot_volt_req_refcount;
361 DEFINE_MUTEX(tuning_mutex);
362
363 static struct tegra_tuning_data *sdhci_tegra_get_tuning_data(
364         struct sdhci_host *sdhci, unsigned int clock);
365 static unsigned long get_nearest_clock_freq(unsigned long pll_rate,
366                 unsigned long desired_rate);
367 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
368         unsigned int tap_delay);
369 static int tegra_sdhci_configure_regulators(struct sdhci_tegra *tegra_host,
370         u8 option, int min_uV, int max_uV);
371
372 static int show_error_stats_dump(struct seq_file *s, void *data)
373 {
374         struct sdhci_host *host = s->private;
375         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
376         struct sdhci_tegra *tegra_host = pltfm_host->priv;
377         struct sdhci_tegra_sd_stats *head;
378
379         seq_printf(s, "ErrorStatistics:\n");
380         seq_printf(s, "DataCRC\tCmdCRC\tDataTimeout\tCmdTimeout\n");
381         head = tegra_host->sd_stat_head;
382         if (head != NULL)
383                 seq_printf(s, "%d\t%d\t%d\t%d\n", head->data_crc_count,
384                         head->cmd_crc_count, head->data_to_count,
385                         head->cmd_to_count);
386         return 0;
387 }
388
389 static int show_dfs_stats_dump(struct seq_file *s, void *data)
390 {
391         struct sdhci_host *host = s->private;
392         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
393         struct sdhci_tegra *tegra_host = pltfm_host->priv;
394         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
395
396         seq_printf(s, "DFS statistics:\n");
397
398         if (host->mmc->dev_stats != NULL)
399                 seq_printf(s, "Polling_period: %d\n",
400                         host->mmc->dev_stats->polling_interval);
401
402         if (gov_data != NULL) {
403                 seq_printf(s, "cur_active_load: %d\n",
404                         gov_data->curr_active_load);
405                 seq_printf(s, "avg_active_load: %d\n",
406                         gov_data->avg_active_load);
407                 seq_printf(s, "act_load_high_threshold: %d\n",
408                         gov_data->act_load_high_threshold);
409                 seq_printf(s, "freq_switch_count: %d\n",
410                         gov_data->freq_switch_count);
411         }
412         return 0;
413 }
414
415 static int sdhci_error_stats_dump(struct inode *inode, struct file *file)
416 {
417         return single_open(file, show_error_stats_dump, inode->i_private);
418 }
419
420 static int sdhci_dfs_stats_dump(struct inode *inode, struct file *file)
421 {
422         return single_open(file, show_dfs_stats_dump, inode->i_private);
423 }
424
425
426 static const struct file_operations sdhci_host_fops = {
427         .open           = sdhci_error_stats_dump,
428         .read           = seq_read,
429         .llseek         = seq_lseek,
430         .release        = single_release,
431 };
432
433 static const struct file_operations sdhci_host_dfs_fops = {
434         .open           = sdhci_dfs_stats_dump,
435         .read           = seq_read,
436         .llseek         = seq_lseek,
437         .release        = single_release,
438 };
439
440 static u32 tegra_sdhci_readl(struct sdhci_host *host, int reg)
441 {
442         u32 val;
443
444         if (unlikely(reg == SDHCI_PRESENT_STATE)) {
445                 /* Use wp_gpio here instead? */
446                 val = readl(host->ioaddr + reg);
447                 return val | SDHCI_WRITE_PROTECT;
448         }
449         return readl(host->ioaddr + reg);
450 }
451
452 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg)
453 {
454         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
455         struct sdhci_tegra *tegra_host = pltfm_host->priv;
456         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
457
458         if (unlikely((soc_data->nvquirks & NVQUIRK_FORCE_SDHCI_SPEC_200) &&
459                         (reg == SDHCI_HOST_VERSION))) {
460                 return SDHCI_SPEC_200;
461         }
462         return readw(host->ioaddr + reg);
463 }
464
465 static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg)
466 {
467         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
468         struct sdhci_tegra *tegra_host = pltfm_host->priv;
469         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
470
471         /* Seems like we're getting spurious timeout and crc errors, so
472          * disable signalling of them. In case of real errors software
473          * timers should take care of eventually detecting them.
474          */
475         if (unlikely(reg == SDHCI_SIGNAL_ENABLE))
476                 val &= ~(SDHCI_INT_TIMEOUT|SDHCI_INT_CRC);
477
478         writel(val, host->ioaddr + reg);
479
480         if (unlikely((soc_data->nvquirks & NVQUIRK_ENABLE_BLOCK_GAP_DET) &&
481                         (reg == SDHCI_INT_ENABLE))) {
482                 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
483                 if (val & SDHCI_INT_CARD_INT)
484                         gap_ctrl |= 0x8;
485                 else
486                         gap_ctrl &= ~0x8;
487                 writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL);
488         }
489 }
490
491 static void tegra_sdhci_writew(struct sdhci_host *host, u16 val, int reg)
492 {
493         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
494         struct sdhci_tegra *tegra_host = pltfm_host->priv;
495         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
496
497         if (soc_data->nvquirks & NVQUIRK_SHADOW_XFER_MODE_REG) {
498                 switch (reg) {
499                 case SDHCI_TRANSFER_MODE:
500                         /*
501                          * Postpone this write, we must do it together with a
502                          * command write that is down below.
503                          */
504                         pltfm_host->xfer_mode_shadow = val;
505                         return;
506                 case SDHCI_COMMAND:
507                         writel((val << 16) | pltfm_host->xfer_mode_shadow,
508                                 host->ioaddr + SDHCI_TRANSFER_MODE);
509                         pltfm_host->xfer_mode_shadow = 0;
510                         return;
511                 }
512         }
513
514         writew(val, host->ioaddr + reg);
515 }
516
517 #ifdef CONFIG_MMC_FREQ_SCALING
518 /*
519  * Dynamic frequency calculation.
520  * The active load for the current period and the average active load
521  * are calculated at the end of each polling interval.
522  *
523  * If the current active load is greater than the threshold load, then the
524  * frequency is boosted(156MHz).
525  * If the active load is lower than the threshold, then the load is monitored
526  * for a max of three cycles before reducing the frequency(82MHz). If the
527  * average active load is lower, then the monitoring cycles is reduced.
528  *
529  * The active load threshold value for both eMMC and SDIO is set to 25 which
530  * is found to give the optimal power and performance. The polling interval is
531  * set to 50 msec.
532  *
533  * The polling interval and active load threshold values can be changed by
534  * the user through sysfs.
535 */
536 static unsigned long calculate_mmc_target_freq(
537         struct tegra_freq_gov_data *gov_data)
538 {
539         unsigned long desired_freq = gov_data->curr_freq;
540         unsigned int type = MMC_TYPE_MMC;
541
542         if (gov_data->curr_active_load >= gov_data->act_load_high_threshold) {
543                 desired_freq = gov_data->freqs[TUNING_HIGH_FREQ];
544                 gov_data->monitor_idle_load = false;
545                 gov_data->max_idle_monitor_cycles =
546                         gov_params[type].idle_mon_cycles;
547         } else {
548                 if (gov_data->monitor_idle_load) {
549                         if (!gov_data->max_idle_monitor_cycles) {
550                                 desired_freq = gov_data->freqs[TUNING_LOW_FREQ];
551                                 gov_data->max_idle_monitor_cycles =
552                                         gov_params[type].idle_mon_cycles;
553                         } else {
554                                 gov_data->max_idle_monitor_cycles--;
555                         }
556                 } else {
557                         gov_data->monitor_idle_load = true;
558                         gov_data->max_idle_monitor_cycles *=
559                                 gov_data->avg_active_load;
560                         gov_data->max_idle_monitor_cycles /= 100;
561                 }
562         }
563
564         return desired_freq;
565 }
566
567 static unsigned long calculate_sdio_target_freq(
568         struct tegra_freq_gov_data *gov_data)
569 {
570         unsigned long desired_freq = gov_data->curr_freq;
571         unsigned int type = MMC_TYPE_SDIO;
572
573         if (gov_data->curr_active_load >= gov_data->act_load_high_threshold) {
574                 desired_freq = gov_data->freqs[TUNING_HIGH_FREQ];
575                 gov_data->monitor_idle_load = false;
576                 gov_data->max_idle_monitor_cycles =
577                         gov_params[type].idle_mon_cycles;
578         } else {
579                 if (gov_data->monitor_idle_load) {
580                         if (!gov_data->max_idle_monitor_cycles) {
581                                 desired_freq = gov_data->freqs[TUNING_LOW_FREQ];
582                                 gov_data->max_idle_monitor_cycles =
583                                         gov_params[type].idle_mon_cycles;
584                         } else {
585                                 gov_data->max_idle_monitor_cycles--;
586                         }
587                 } else {
588                         gov_data->monitor_idle_load = true;
589                         gov_data->max_idle_monitor_cycles *=
590                                 gov_data->avg_active_load;
591                         gov_data->max_idle_monitor_cycles /= 100;
592                 }
593         }
594
595         return desired_freq;
596 }
597
598 static unsigned long calculate_sd_target_freq(
599         struct tegra_freq_gov_data *gov_data)
600 {
601         unsigned long desired_freq = gov_data->curr_freq;
602         unsigned int type = MMC_TYPE_SD;
603
604         if (gov_data->curr_active_load >= gov_data->act_load_high_threshold) {
605                 desired_freq = gov_data->freqs[TUNING_HIGH_FREQ];
606                 gov_data->monitor_idle_load = false;
607                 gov_data->max_idle_monitor_cycles =
608                         gov_params[type].idle_mon_cycles;
609         } else {
610                 if (gov_data->monitor_idle_load) {
611                         if (!gov_data->max_idle_monitor_cycles) {
612                                 desired_freq = gov_data->freqs[TUNING_LOW_FREQ];
613                                 gov_data->max_idle_monitor_cycles =
614                                         gov_params[type].idle_mon_cycles;
615                         } else {
616                                 gov_data->max_idle_monitor_cycles--;
617                         }
618                 } else {
619                         gov_data->monitor_idle_load = true;
620                         gov_data->max_idle_monitor_cycles *=
621                                 gov_data->avg_active_load;
622                         gov_data->max_idle_monitor_cycles /= 100;
623                 }
624         }
625
626         return desired_freq;
627 }
628
629 static unsigned long sdhci_tegra_get_target_freq(struct sdhci_host *sdhci,
630         struct devfreq_dev_status *dfs_stats)
631 {
632         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
633         struct sdhci_tegra *tegra_host = pltfm_host->priv;
634         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
635         unsigned long freq = sdhci->mmc->actual_clock;
636
637         if (!gov_data) {
638                 dev_err(mmc_dev(sdhci->mmc),
639                         "No gov data. Continue using current freq %ld", freq);
640                 return freq;
641         }
642
643         /*
644          * If clock gating is enabled and clock is currently disabled, then
645          * return freq as 0.
646          */
647         if (!tegra_host->clk_enabled)
648                 return 0;
649
650         if (dfs_stats->total_time) {
651                 gov_data->curr_active_load = (dfs_stats->busy_time * 100) /
652                         dfs_stats->total_time;
653         } else {
654                 gov_data->curr_active_load = 0;
655         }
656
657         gov_data->avg_active_load += gov_data->curr_active_load;
658         gov_data->avg_active_load >>= 1;
659
660         if (sdhci->mmc->card) {
661                 if (sdhci->mmc->card->type == MMC_TYPE_SDIO)
662                         freq = calculate_sdio_target_freq(gov_data);
663                 else if (sdhci->mmc->card->type == MMC_TYPE_MMC)
664                         freq = calculate_mmc_target_freq(gov_data);
665                 else if (sdhci->mmc->card->type == MMC_TYPE_SD)
666                         freq = calculate_sd_target_freq(gov_data);
667                 if (gov_data->curr_freq != freq)
668                         gov_data->freq_switch_count++;
669                 gov_data->curr_freq = freq;
670         }
671
672         return freq;
673 }
674
675 static int sdhci_tegra_freq_gov_init(struct sdhci_host *sdhci)
676 {
677         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
678         struct sdhci_tegra *tegra_host = pltfm_host->priv;
679         unsigned int i;
680         unsigned int freq;
681         unsigned int type;
682
683         if (!((sdhci->mmc->ios.timing == MMC_TIMING_UHS_SDR104) ||
684                 (sdhci->mmc->ios.timing == MMC_TIMING_MMC_HS200))) {
685                 dev_info(mmc_dev(sdhci->mmc),
686                         "DFS not required for current operating mode\n");
687                 return -EACCES;
688         }
689
690         if (!tegra_host->gov_data) {
691                 tegra_host->gov_data = devm_kzalloc(mmc_dev(sdhci->mmc),
692                         sizeof(struct tegra_freq_gov_data), GFP_KERNEL);
693                 if (!tegra_host->gov_data) {
694                         dev_err(mmc_dev(sdhci->mmc),
695                                 "Failed to allocate memory for dfs data\n");
696                         return -ENOMEM;
697                 }
698         }
699
700         /* Find the supported frequencies */
701         dev_info(mmc_dev(sdhci->mmc), "DFS supported freqs");
702         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
703                 freq = tegra_host->tuning_data[i].freq_hz;
704                 /*
705                  * Check the nearest possible clock with pll_c and pll_p as
706                  * the clock sources. Choose the higher frequency.
707                  */
708                 tegra_host->gov_data->freqs[i] =
709                         get_nearest_clock_freq(pll_c_rate, freq);
710                 freq = get_nearest_clock_freq(pll_p_rate, freq);
711                 if (freq > tegra_host->gov_data->freqs[i])
712                         tegra_host->gov_data->freqs[i] = freq;
713                 pr_err("%d,", tegra_host->gov_data->freqs[i]);
714         }
715
716         tegra_host->gov_data->monitor_idle_load = false;
717         tegra_host->gov_data->curr_freq = sdhci->mmc->actual_clock;
718         if (sdhci->mmc->card) {
719                 type = sdhci->mmc->card->type;
720                 sdhci->mmc->dev_stats->polling_interval =
721                         gov_params[type].polling_interval_ms;
722                 tegra_host->gov_data->act_load_high_threshold =
723                         gov_params[type].active_load_threshold;
724                 tegra_host->gov_data->max_idle_monitor_cycles =
725                         gov_params[type].idle_mon_cycles;
726         }
727
728         return 0;
729 }
730
731 #endif
732
733 static unsigned int tegra_sdhci_get_cd(struct sdhci_host *sdhci)
734 {
735         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
736         struct sdhci_tegra *tegra_host = pltfm_host->priv;
737
738         return tegra_host->card_present;
739 }
740
741 static unsigned int tegra_sdhci_get_ro(struct sdhci_host *sdhci)
742 {
743         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
744         struct sdhci_tegra *tegra_host = pltfm_host->priv;
745         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
746
747         if (!gpio_is_valid(plat->wp_gpio))
748                 return -1;
749
750         return gpio_get_value(plat->wp_gpio);
751 }
752
753
754 static int tegra_sdhci_set_uhs_signaling(struct sdhci_host *host,
755                 unsigned int uhs)
756 {
757         u16 clk, ctrl_2;
758         ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2);
759
760         /* Select Bus Speed Mode for host */
761         /* For HS200 we need to set UHS_MODE_SEL to SDR104.
762          * It works as SDR 104 in SD 4-bit mode and HS200 in eMMC 8-bit mode.
763          */
764         ctrl_2 &= ~SDHCI_CTRL_UHS_MASK;
765         switch (uhs) {
766         case MMC_TIMING_UHS_SDR12:
767                 ctrl_2 |= SDHCI_CTRL_UHS_SDR12;
768                 break;
769         case MMC_TIMING_UHS_SDR25:
770                 ctrl_2 |= SDHCI_CTRL_UHS_SDR25;
771                 break;
772         case MMC_TIMING_UHS_SDR50:
773                 ctrl_2 |= SDHCI_CTRL_UHS_SDR50;
774                 break;
775         case MMC_TIMING_UHS_SDR104:
776         case MMC_TIMING_MMC_HS200:
777                 ctrl_2 |= SDHCI_CTRL_UHS_SDR104;
778                 break;
779         case MMC_TIMING_UHS_DDR50:
780                 ctrl_2 |= SDHCI_CTRL_UHS_DDR50;
781                 break;
782         }
783
784         sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
785
786         if (uhs == MMC_TIMING_UHS_DDR50) {
787                 clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL);
788                 clk &= ~(0xFF << SDHCI_DIVIDER_SHIFT);
789                 clk |= 1 << SDHCI_DIVIDER_SHIFT;
790                 sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
791         }
792         return 0;
793 }
794
795 static void tegra_sdhci_reset_exit(struct sdhci_host *sdhci, u8 mask)
796 {
797         u16 misc_ctrl;
798         u32 vendor_ctrl;
799         unsigned int best_tap_value;
800         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
801         struct sdhci_tegra *tegra_host = pltfm_host->priv;
802         struct tegra_tuning_data *tuning_data;
803         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
804         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
805
806         if (mask & SDHCI_RESET_ALL) {
807                 if (tegra_host->sd_stat_head != NULL) {
808                         tegra_host->sd_stat_head->data_crc_count = 0;
809                         tegra_host->sd_stat_head->cmd_crc_count = 0;
810                         tegra_host->sd_stat_head->data_to_count = 0;
811                         tegra_host->sd_stat_head->cmd_to_count = 0;
812                 }
813
814                 if (tegra_host->gov_data != NULL)
815                         tegra_host->gov_data->freq_switch_count = 0;
816
817                 vendor_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_CLK_CTRL);
818                 if (soc_data->nvquirks & NVQUIRK_ENABLE_PADPIPE_CLKEN) {
819                         vendor_ctrl |=
820                                 SDHCI_VNDR_CLK_CTRL_PADPIPE_CLKEN_OVERRIDE;
821                 }
822                 if (soc_data->nvquirks & NVQUIRK_DISABLE_SPI_MODE_CLKEN) {
823                         vendor_ctrl &=
824                                 ~SDHCI_VNDR_CLK_CTRL_SPI_MODE_CLKEN_OVERRIDE;
825                 }
826                 if (soc_data->nvquirks & NVQUIRK_EN_FEEDBACK_CLK) {
827                         vendor_ctrl &=
828                                 ~SDHCI_VNDR_CLK_CNTL_INPUT_IO_CLK;
829                 }
830
831                 if (soc_data->nvquirks & NVQUIRK_SET_TAP_DELAY) {
832                         if ((tegra_host->tuning_status == TUNING_STATUS_DONE)
833                                 && (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER)) {
834                                 tuning_data = sdhci_tegra_get_tuning_data(sdhci,
835                                         sdhci->mmc->ios.clock);
836                                 best_tap_value = (tegra_host->tap_cmd ==
837                                         TAP_CMD_TRIM_HIGH_VOLTAGE) ?
838                                         tuning_data->nom_best_tap_value :
839                                         tuning_data->best_tap_value;
840                         } else {
841                                 best_tap_value = tegra_host->plat->tap_delay;
842                         }
843                         vendor_ctrl &= ~(0xFF <<
844                                 SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
845                         vendor_ctrl |= (best_tap_value <<
846                                 SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
847                 }
848
849                 if (soc_data->nvquirks & NVQUIRK_SET_TRIM_DELAY) {
850                         vendor_ctrl &= ~(0x1F <<
851                                 SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT);
852                         vendor_ctrl |= (plat->trim_delay <<
853                                 SDHCI_VNDR_CLK_CTRL_TRIM_VALUE_SHIFT);
854                 }
855                 if (soc_data->nvquirks & NVQUIRK_ENABLE_SDR50_TUNING)
856                         vendor_ctrl |= SDHCI_VNDR_CLK_CTRL_SDR50_TUNING;
857                 sdhci_writel(sdhci, vendor_ctrl, SDHCI_VNDR_CLK_CTRL);
858
859                 misc_ctrl = sdhci_readw(sdhci, SDHCI_VNDR_MISC_CTRL);
860                 if (soc_data->nvquirks & NVQUIRK_ENABLE_SD_3_0)
861                         misc_ctrl |= SDHCI_VNDR_MISC_CTRL_ENABLE_SD_3_0;
862                 if (soc_data->nvquirks & NVQUIRK_ENABLE_SDR104) {
863                         misc_ctrl |=
864                         SDHCI_VNDR_MISC_CTRL_ENABLE_SDR104_SUPPORT;
865                 }
866                 if (soc_data->nvquirks & NVQUIRK_ENABLE_SDR50) {
867                         misc_ctrl |=
868                         SDHCI_VNDR_MISC_CTRL_ENABLE_SDR50_SUPPORT;
869                 }
870                 if (soc_data->nvquirks & NVQUIRK_INFINITE_ERASE_TIMEOUT) {
871                         misc_ctrl |=
872                         SDHCI_VNDR_MISC_CTRL_INFINITE_ERASE_TIMEOUT;
873                 }
874
875                 /* Enable DDR mode support only if supported */
876                 if (plat->uhs_mask & MMC_UHS_MASK_DDR50)
877                         sdhci->mmc->caps &= ~MMC_CAP_UHS_DDR50;
878                 else if (soc_data->nvquirks & NVQUIRK_ENABLE_DDR50)
879                         misc_ctrl |= SDHCI_VNDR_MISC_CTRL_ENABLE_DDR50_SUPPORT;
880
881                 sdhci_writew(sdhci, misc_ctrl, SDHCI_VNDR_MISC_CTRL);
882
883                 /* Mask Auto CMD23 if CMD23 is enabled */
884                 if ((sdhci->mmc->caps & MMC_CAP_CMD23) &&
885                         (soc_data->nvquirks & NVQUIRK_DISABLE_AUTO_CMD23))
886                         sdhci->flags &= ~SDHCI_AUTO_CMD23;
887
888                 /* Mask the support for any UHS modes if specified */
889                 if (plat->uhs_mask & MMC_UHS_MASK_SDR104)
890                         sdhci->mmc->caps &= ~MMC_CAP_UHS_SDR104;
891
892                 if (plat->uhs_mask & MMC_UHS_MASK_SDR50)
893                         sdhci->mmc->caps &= ~MMC_CAP_UHS_SDR50;
894
895                 if (plat->uhs_mask & MMC_UHS_MASK_SDR25)
896                         sdhci->mmc->caps &= ~MMC_CAP_UHS_SDR25;
897
898                 if (plat->uhs_mask & MMC_UHS_MASK_SDR12)
899                         sdhci->mmc->caps &= ~MMC_CAP_UHS_SDR12;
900
901                 if (plat->uhs_mask & MMC_MASK_HS200)
902                         sdhci->mmc->caps2 &= ~MMC_CAP2_HS200;
903         }
904 }
905
906 static void sdhci_status_notify_cb(int card_present, void *dev_id)
907 {
908         struct sdhci_host *sdhci = (struct sdhci_host *)dev_id;
909         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
910         struct tegra_sdhci_platform_data *plat;
911         unsigned int status, oldstat;
912
913         pr_debug("%s: card_present %d\n", mmc_hostname(sdhci->mmc),
914                 card_present);
915
916         plat = pdev->dev.platform_data;
917         if (!plat->mmc_data.status) {
918                 mmc_detect_change(sdhci->mmc, 0);
919                 return;
920         }
921
922         status = plat->mmc_data.status(mmc_dev(sdhci->mmc));
923
924         oldstat = plat->mmc_data.card_present;
925         plat->mmc_data.card_present = status;
926         if (status ^ oldstat) {
927                 pr_debug("%s: Slot status change detected (%d -> %d)\n",
928                         mmc_hostname(sdhci->mmc), oldstat, status);
929                 if (status && !plat->mmc_data.built_in)
930                         mmc_detect_change(sdhci->mmc, (5 * HZ) / 2);
931                 else
932                         mmc_detect_change(sdhci->mmc, 0);
933         }
934 }
935
936 static irqreturn_t carddetect_irq(int irq, void *data)
937 {
938         struct sdhci_host *sdhost = (struct sdhci_host *)data;
939         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhost);
940         struct sdhci_tegra *tegra_host = pltfm_host->priv;
941         struct platform_device *pdev = to_platform_device(mmc_dev(sdhost->mmc));
942         struct tegra_sdhci_platform_data *plat;
943         int err;
944
945         plat = pdev->dev.platform_data;
946
947         tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
948
949         if (tegra_host->card_present) {
950                 err = tegra_sdhci_configure_regulators(tegra_host,
951                         CONFIG_REG_EN, 0, 0);
952                 if (err)
953                         dev_err(mmc_dev(sdhost->mmc),
954                                 "Failed to enable card regulators %d\n", err);
955         } else {
956                 err = tegra_sdhci_configure_regulators(tegra_host,
957                         CONFIG_REG_DIS, 0 , 0);
958                 if (err)
959                         dev_err(mmc_dev(sdhost->mmc),
960                                 "Failed to disable card regulators %d\n", err);
961                 /*
962                  * Set retune request as tuning should be done next time
963                  * a card is inserted.
964                  */
965                 tegra_host->tuning_status = TUNING_STATUS_RETUNE;
966                 tegra_host->force_retune = true;
967         }
968
969         tasklet_schedule(&sdhost->card_tasklet);
970         return IRQ_HANDLED;
971 };
972
973 static int tegra_sdhci_8bit(struct sdhci_host *sdhci, int bus_width)
974 {
975         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
976         const struct tegra_sdhci_platform_data *plat;
977         u32 ctrl;
978
979         plat = pdev->dev.platform_data;
980
981         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL);
982         if (plat->is_8bit && bus_width == MMC_BUS_WIDTH_8) {
983                 ctrl &= ~SDHCI_CTRL_4BITBUS;
984                 ctrl |= SDHCI_CTRL_8BITBUS;
985         } else {
986                 ctrl &= ~SDHCI_CTRL_8BITBUS;
987                 if (bus_width == MMC_BUS_WIDTH_4)
988                         ctrl |= SDHCI_CTRL_4BITBUS;
989                 else
990                         ctrl &= ~SDHCI_CTRL_4BITBUS;
991         }
992         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL);
993         return 0;
994 }
995
996 /*
997 * Calculation of nearest clock frequency for desired rate:
998 * Get the divisor value, div = p / d_rate
999 * 1. If it is nearer to ceil(p/d_rate) then increment the div value by 0.5 and
1000 * nearest_rate, i.e. result = p / (div + 0.5) = (p << 1)/((div << 1) + 1).
1001 * 2. If not, result = p / div
1002 * As the nearest clk freq should be <= to desired_rate,
1003 * 3. If result > desired_rate then increment the div by 0.5
1004 * and do, (p << 1)/((div << 1) + 1)
1005 * 4. Else return result
1006 * Here, If condtions 1 & 3 are both satisfied then to keep track of div value,
1007 * defined index variable.
1008 */
1009 static unsigned long get_nearest_clock_freq(unsigned long pll_rate,
1010                 unsigned long desired_rate)
1011 {
1012         unsigned long result;
1013         int div;
1014         int index = 1;
1015
1016         div = pll_rate / desired_rate;
1017         if (div > MAX_DIVISOR_VALUE) {
1018                 div = MAX_DIVISOR_VALUE;
1019                 result = pll_rate / div;
1020         } else {
1021                 if ((pll_rate % desired_rate) >= (desired_rate / 2))
1022                         result = (pll_rate << 1) / ((div << 1) + index++);
1023                 else
1024                         result = pll_rate / div;
1025
1026                 if (desired_rate < result) {
1027                         /*
1028                         * Trying to get lower clock freq than desired clock,
1029                         * by increasing the divisor value by 0.5
1030                         */
1031                         result = (pll_rate << 1) / ((div << 1) + index);
1032                 }
1033         }
1034
1035         return result;
1036 }
1037
1038 static void tegra_sdhci_clock_set_parent(struct sdhci_host *host,
1039                 unsigned long desired_rate)
1040 {
1041         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1042         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1043         struct clk *parent_clk;
1044         unsigned long pll_c_freq;
1045         unsigned long pll_p_freq;
1046         int rc;
1047
1048         /*
1049          * Currently pll_p and pll_c are used as clock sources for SDMMC. If clk
1050          * rate is missing for either of them, then no selection is needed and
1051          * the default parent is used.
1052          */
1053         if (!pll_c_rate || !pll_p_rate)
1054                 return ;
1055
1056         pll_c_freq = get_nearest_clock_freq(pll_c_rate, desired_rate);
1057         pll_p_freq = get_nearest_clock_freq(pll_p_rate, desired_rate);
1058
1059         if (pll_c_freq > pll_p_freq) {
1060                 if (!tegra_host->is_parent_pllc) {
1061                         parent_clk = pll_c;
1062                         tegra_host->is_parent_pllc = true;
1063                         clk_set_rate(pltfm_host->clk, DEFAULT_SDHOST_FREQ);
1064                 } else
1065                         return;
1066         } else if (tegra_host->is_parent_pllc) {
1067                 parent_clk = pll_p;
1068                 tegra_host->is_parent_pllc = false;
1069         } else
1070                 return;
1071
1072         rc = clk_set_parent(pltfm_host->clk, parent_clk);
1073         if (rc)
1074                 pr_err("%s: failed to set pll parent clock %d\n",
1075                         mmc_hostname(host->mmc), rc);
1076 }
1077
1078 static void tegra_sdhci_set_clk_rate(struct sdhci_host *sdhci,
1079         unsigned int clock)
1080 {
1081         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1082         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1083         unsigned int clk_rate;
1084 #ifdef CONFIG_MMC_FREQ_SCALING
1085         unsigned int tap_value;
1086         struct tegra_tuning_data *tuning_data;
1087 #endif
1088
1089         if (sdhci->mmc->ios.timing == MMC_TIMING_UHS_DDR50) {
1090                 /*
1091                  * In ddr mode, tegra sdmmc controller clock frequency
1092                  * should be double the card clock frequency.
1093                  */
1094                 if (tegra_host->ddr_clk_limit)
1095                         clk_rate = tegra_host->ddr_clk_limit * 2;
1096                 else
1097                         clk_rate = clock * 2;
1098         } else {
1099                 clk_rate = clock;
1100         }
1101
1102         if (tegra_host->max_clk_limit &&
1103                 (clk_rate > tegra_host->max_clk_limit))
1104                         clk_rate = tegra_host->max_clk_limit;
1105
1106         tegra_sdhci_clock_set_parent(sdhci, clk_rate);
1107         clk_set_rate(pltfm_host->clk, clk_rate);
1108         sdhci->max_clk = clk_get_rate(pltfm_host->clk);
1109 #ifdef CONFIG_TEGRA_FPGA_PLATFORM
1110         /* FPGA supports 26MHz of clock for SDMMC. */
1111         sdhci->max_clk = 26000000;
1112 #endif
1113
1114 #ifdef CONFIG_MMC_FREQ_SCALING
1115         /* Set the tap delay if tuning is done and dfs is enabled */
1116         if (sdhci->mmc->df &&
1117                 (tegra_host->tuning_status == TUNING_STATUS_DONE)) {
1118                 tuning_data = sdhci_tegra_get_tuning_data(sdhci, clock);
1119                 tap_value = (tegra_host->tap_cmd == TAP_CMD_TRIM_HIGH_VOLTAGE) ?
1120                         tuning_data->nom_best_tap_value :
1121                         tuning_data->best_tap_value;
1122                 sdhci_tegra_set_tap_delay(sdhci, tap_value);
1123         }
1124 #endif
1125 }
1126
1127 static void tegra_sdhci_set_clock(struct sdhci_host *sdhci, unsigned int clock)
1128 {
1129         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1130         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1131         struct platform_device *pdev = to_platform_device(mmc_dev(sdhci->mmc));
1132         u8 ctrl;
1133
1134         pr_debug("%s %s %u enabled=%u\n", __func__,
1135                 mmc_hostname(sdhci->mmc), clock, tegra_host->clk_enabled);
1136
1137         if (clock) {
1138                 if (!tegra_host->clk_enabled) {
1139                         pm_runtime_get_sync(&pdev->dev);
1140                         clk_prepare_enable(pltfm_host->clk);
1141                         tegra_host->clk_enabled = true;
1142                         sdhci->is_clk_on = tegra_host->clk_enabled;
1143                         ctrl = sdhci_readb(sdhci, SDHCI_VNDR_CLK_CTRL);
1144                         ctrl |= SDHCI_VNDR_CLK_CTRL_SDMMC_CLK;
1145                         sdhci_writeb(sdhci, ctrl, SDHCI_VNDR_CLK_CTRL);
1146                 }
1147                 tegra_sdhci_set_clk_rate(sdhci, clock);
1148
1149                 if (tegra_host->emc_clk && (!tegra_host->emc_clk_enabled)) {
1150                         clk_prepare_enable(tegra_host->emc_clk);
1151                         tegra_host->emc_clk_enabled = true;
1152                 }
1153
1154                 if (tegra_host->sclk && (!tegra_host->is_sdmmc_sclk_on)) {
1155                         clk_prepare_enable(tegra_host->sclk);
1156                         tegra_host->is_sdmmc_sclk_on = true;
1157                 }
1158         } else if (!clock && tegra_host->clk_enabled) {
1159                 if (tegra_host->emc_clk && tegra_host->emc_clk_enabled) {
1160                         clk_disable_unprepare(tegra_host->emc_clk);
1161                         tegra_host->emc_clk_enabled = false;
1162                 }
1163
1164                 if (tegra_host->sclk && tegra_host->is_sdmmc_sclk_on) {
1165                         clk_disable_unprepare(tegra_host->sclk);
1166                         tegra_host->is_sdmmc_sclk_on = false;
1167                 }
1168
1169                 ctrl = sdhci_readb(sdhci, SDHCI_VNDR_CLK_CTRL);
1170                 ctrl &= ~SDHCI_VNDR_CLK_CTRL_SDMMC_CLK;
1171                 sdhci_writeb(sdhci, ctrl, SDHCI_VNDR_CLK_CTRL);
1172                 clk_disable_unprepare(pltfm_host->clk);
1173                 tegra_host->clk_enabled = false;
1174                 sdhci->is_clk_on = tegra_host->clk_enabled;
1175                 pm_runtime_put_sync(&pdev->dev);
1176         }
1177         sdhci->is_clk_on = tegra_host->clk_enabled;
1178 }
1179 static void tegra_sdhci_do_calibration(struct sdhci_host *sdhci)
1180 {
1181         unsigned int val;
1182         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1183         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1184         const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data;
1185         unsigned int timeout = 10;
1186
1187         /* No Calibration for sdmmc4 -- chip bug */
1188         if (tegra_host->instance == 3)
1189                 return;
1190
1191         if (unlikely(soc_data->nvquirks & NVQUIRK_DISABLE_AUTO_CALIBRATION))
1192                 return;
1193
1194         val = sdhci_readl(sdhci, SDMMC_SDMEMCOMPPADCTRL);
1195         val &= ~SDMMC_SDMEMCOMPPADCTRL_VREF_SEL_MASK;
1196         val |= 0x7;
1197         sdhci_writel(sdhci, val, SDMMC_SDMEMCOMPPADCTRL);
1198
1199         /* Enable Auto Calibration*/
1200         val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
1201         val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
1202         val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_START;
1203         if (unlikely(soc_data->nvquirks & NVQUIRK_SET_CALIBRATION_OFFSETS)) {
1204                 /* Program Auto cal PD offset(bits 8:14) */
1205                 val &= ~(0x7F <<
1206                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
1207                 val |= (SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET <<
1208                         SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PD_OFFSET_SHIFT);
1209                 /* Program Auto cal PU offset(bits 0:6) */
1210                 val &= ~0x7F;
1211                 val |= SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_PU_OFFSET;
1212         }
1213         sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
1214
1215         /* Wait until the calibration is done */
1216         do {
1217                 if (!(sdhci_readl(sdhci, SDMMC_AUTO_CAL_STATUS) &
1218                         SDMMC_AUTO_CAL_STATUS_AUTO_CAL_ACTIVE))
1219                         break;
1220
1221                 mdelay(1);
1222                 timeout--;
1223         } while (timeout);
1224
1225         if (!timeout)
1226                 dev_err(mmc_dev(sdhci->mmc), "Auto calibration failed\n");
1227
1228         /* Disable Auto calibration */
1229         val = sdhci_readl(sdhci, SDMMC_AUTO_CAL_CONFIG);
1230         val &= ~SDMMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE;
1231         sdhci_writel(sdhci, val, SDMMC_AUTO_CAL_CONFIG);
1232
1233         if (unlikely(soc_data->nvquirks & NVQUIRK_SET_DRIVE_STRENGTH)) {
1234                 unsigned int pulldown_code;
1235                 unsigned int pullup_code;
1236                 int pg;
1237                 int err;
1238
1239                 pg = tegra_drive_get_pingroup(mmc_dev(sdhci->mmc));
1240                 if (pg != -1) {
1241                         /* Get the pull down codes from auto cal status reg */
1242                         pulldown_code = (
1243                                 sdhci_readl(sdhci, SDMMC_AUTO_CAL_STATUS) >>
1244                                 SDMMC_AUTO_CAL_STATUS_PULLDOWN_OFFSET);
1245                         /* Set the pull down in the pinmux reg */
1246                         err = tegra_drive_pinmux_set_pull_down(pg,
1247                                 pulldown_code);
1248                         if (err)
1249                                 dev_err(mmc_dev(sdhci->mmc),
1250                                 "Failed to set pulldown codes %d err %d\n",
1251                                 pulldown_code, err);
1252
1253                         /* Calculate the pull up codes */
1254                         pullup_code = pulldown_code + PULLUP_ADJUSTMENT_OFFSET;
1255                         if (pullup_code >= TEGRA_MAX_PULL)
1256                                 pullup_code = TEGRA_MAX_PULL - 1;
1257                         /* Set the pull up code in the pinmux reg */
1258                         err = tegra_drive_pinmux_set_pull_up(pg, pullup_code);
1259                         if (err)
1260                                 dev_err(mmc_dev(sdhci->mmc),
1261                                 "Failed to set pullup codes %d err %d\n",
1262                                 pullup_code, err);
1263                 }
1264         }
1265 }
1266
1267 static int tegra_sdhci_signal_voltage_switch(struct sdhci_host *sdhci,
1268         unsigned int signal_voltage)
1269 {
1270         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1271         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1272         unsigned int min_uV = tegra_host->vddio_min_uv;
1273         unsigned int max_uV = tegra_host->vddio_max_uv;
1274         unsigned int rc = 0;
1275         u16 clk, ctrl;
1276
1277
1278         ctrl = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
1279         if (signal_voltage == MMC_SIGNAL_VOLTAGE_180) {
1280                 ctrl |= SDHCI_CTRL_VDD_180;
1281                 min_uV = SDHOST_LOW_VOLT_MIN;
1282                 max_uV = SDHOST_LOW_VOLT_MAX;
1283         } else if (signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1284                 if (ctrl & SDHCI_CTRL_VDD_180)
1285                         ctrl &= ~SDHCI_CTRL_VDD_180;
1286         }
1287
1288         /* Check if the slot can support the required voltage */
1289         if (min_uV > tegra_host->vddio_max_uv)
1290                 return 0;
1291
1292         /* Switch OFF the card clock to prevent glitches on the clock line */
1293         clk = sdhci_readw(sdhci, SDHCI_CLOCK_CONTROL);
1294         clk &= ~SDHCI_CLOCK_CARD_EN;
1295         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
1296
1297         /* Set/clear the 1.8V signalling */
1298         sdhci_writew(sdhci, ctrl, SDHCI_HOST_CONTROL2);
1299
1300         /* Switch the I/O rail voltage */
1301         rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_SET_VOLT,
1302                 min_uV, max_uV);
1303         if (rc && (signal_voltage == MMC_SIGNAL_VOLTAGE_180)) {
1304                 dev_err(mmc_dev(sdhci->mmc),
1305                         "setting 1.8V failed %d. Revert to 3.3V\n", rc);
1306                 rc = tegra_sdhci_configure_regulators(tegra_host,
1307                         CONFIG_REG_SET_VOLT, SDHOST_HIGH_VOLT_MIN,
1308                         SDHOST_HIGH_VOLT_MAX);
1309         }
1310
1311         /* Wait for 10 msec for the voltage to be switched */
1312         mdelay(10);
1313
1314         /* Enable the card clock */
1315         clk |= SDHCI_CLOCK_CARD_EN;
1316         sdhci_writew(sdhci, clk, SDHCI_CLOCK_CONTROL);
1317
1318         /* Wait for 1 msec after enabling clock */
1319         mdelay(1);
1320
1321         return rc;
1322 }
1323
1324 static int tegra_sdhci_configure_regulators(struct sdhci_tegra *tegra_host,
1325         u8 option, int min_uV, int max_uV)
1326 {
1327         int rc = 0;
1328
1329         switch (option) {
1330         case CONFIG_REG_EN:
1331                 if (!tegra_host->is_rail_enabled) {
1332                         if (tegra_host->vdd_slot_reg)
1333                                 rc = regulator_enable(tegra_host->vdd_slot_reg);
1334                         if (tegra_host->vdd_io_reg)
1335                                 rc = regulator_enable(tegra_host->vdd_io_reg);
1336                         tegra_host->is_rail_enabled = true;
1337                 }
1338         break;
1339         case CONFIG_REG_DIS:
1340                 if (tegra_host->is_rail_enabled) {
1341                         if (tegra_host->vdd_io_reg)
1342                                 rc = regulator_disable(tegra_host->vdd_io_reg);
1343                         if (tegra_host->vdd_slot_reg)
1344                                 rc = regulator_disable(
1345                                         tegra_host->vdd_slot_reg);
1346                         tegra_host->is_rail_enabled = false;
1347                 }
1348         break;
1349         case CONFIG_REG_SET_VOLT:
1350                 if (tegra_host->vdd_io_reg)
1351                         rc = regulator_set_voltage(tegra_host->vdd_io_reg,
1352                                 min_uV, max_uV);
1353         break;
1354         default:
1355                 pr_err("Invalid argument passed to reg config %d\n", option);
1356         }
1357
1358         return rc;
1359 }
1360
1361 static void tegra_sdhci_reset(struct sdhci_host *sdhci, u8 mask)
1362 {
1363         unsigned long timeout;
1364
1365         sdhci_writeb(sdhci, mask, SDHCI_SOFTWARE_RESET);
1366
1367         /* Wait max 100 ms */
1368         timeout = 100;
1369
1370         /* hw clears the bit when it's done */
1371         while (sdhci_readb(sdhci, SDHCI_SOFTWARE_RESET) & mask) {
1372                 if (timeout == 0) {
1373                         dev_err(mmc_dev(sdhci->mmc), "%s: Reset 0x%x never " \
1374                                 "completed.\n", mmc_hostname(sdhci->mmc),
1375                                 (int)mask);
1376                         return;
1377                 }
1378                 timeout--;
1379                 mdelay(1);
1380         }
1381
1382         tegra_sdhci_reset_exit(sdhci, mask);
1383 }
1384
1385 static void sdhci_tegra_set_tap_delay(struct sdhci_host *sdhci,
1386         unsigned int tap_delay)
1387 {
1388         u32 vendor_ctrl;
1389
1390         /* Max tap delay value is 255 */
1391         BUG_ON(tap_delay > MAX_TAP_VALUES);
1392
1393         vendor_ctrl = sdhci_readl(sdhci, SDHCI_VNDR_CLK_CTRL);
1394         vendor_ctrl &= ~(0xFF << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1395         vendor_ctrl |= (tap_delay << SDHCI_VNDR_CLK_CTRL_TAP_VALUE_SHIFT);
1396         sdhci_writel(sdhci, vendor_ctrl, SDHCI_VNDR_CLK_CTRL);
1397 }
1398
1399 static int sdhci_tegra_sd_error_stats(struct sdhci_host *host, u32 int_status)
1400 {
1401         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
1402         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1403         struct sdhci_tegra_sd_stats *head;
1404
1405         head = tegra_host->sd_stat_head;
1406         if (int_status & SDHCI_INT_DATA_CRC)
1407                 head->data_crc_count++;
1408         if (int_status & SDHCI_INT_CRC)
1409                 head->cmd_crc_count++;
1410         if (int_status & SDHCI_INT_TIMEOUT)
1411                 head->cmd_to_count++;
1412         if (int_status & SDHCI_INT_DATA_TIMEOUT)
1413                 head->data_to_count++;
1414         return 0;
1415 }
1416
1417 static struct tegra_tuning_data *sdhci_tegra_get_tuning_data(
1418         struct sdhci_host *sdhci, unsigned int clock)
1419 {
1420         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1421         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1422         struct tegra_tuning_data *tuning_data;
1423         unsigned int low_freq;
1424         u8 i = 0;
1425
1426         if (tegra_host->tuning_freq_count == 1) {
1427                 tuning_data = &tegra_host->tuning_data[0];
1428                 goto out;
1429         }
1430
1431         /* Get the lowest supported freq */
1432         for (i = 0; i < TUNING_FREQ_COUNT; ++i) {
1433                 low_freq = tegra_host->soc_data->tuning_freq_list[i];
1434                 if (low_freq)
1435                         break;
1436         }
1437
1438         if (clock <= low_freq)
1439                 tuning_data = &tegra_host->tuning_data[0];
1440         else
1441                 tuning_data = &tegra_host->tuning_data[1];
1442
1443 out:
1444         return tuning_data;
1445 }
1446
1447 static void sdhci_tegra_dump_tuning_data(struct sdhci_host *sdhci)
1448 {
1449         struct tegra_tuning_data *tuning_data;
1450         struct tap_window_data *tap_data;
1451         u8 i;
1452
1453         pr_info("********%s: Tuning window data********\n",
1454                 mmc_hostname(sdhci->mmc));
1455         tuning_data = sdhci_tegra_get_tuning_data(sdhci, sdhci->max_clk);
1456         for (i = 0; i < tuning_data->nr_voltages; i++) {
1457                 tap_data = tuning_data->tap_data[i];
1458                 pr_info("%dHz: voltage %dmv:\n", sdhci->max_clk,
1459                         tap_data->voltage);
1460                 pr_info("Partial Win %d, Full win start %d, full win end %d\n",
1461                         tap_data->partial_win,
1462                         tap_data->full_win_begin,
1463                         tap_data->full_win_end);
1464         }
1465         pr_info("Best tap value %d, best nom voltage tap value %d\n",
1466                 tuning_data->best_tap_value,
1467                 tuning_data->nom_best_tap_value);
1468         pr_info("*****************************\n");
1469 }
1470
1471 /*
1472  * Calculation of best tap value for low frequencies(82MHz).
1473  * X = Partial win, Y = Full win start, Z = Full win end.
1474  * UI = Z - X.
1475  * Full Window = Z - Y.
1476  * Taps margin = mid-point of 1/2*(curr_freq/max_frequency)*UI
1477  *                    = (1/2)*(1/2)*(82/200)*UI
1478  *                    = (0.1025)*UI
1479  * if Partial win<(0.22)*UI
1480  * best tap = Y+(0.1025*UI)
1481  * else
1482  * best tap = (X-(Z-Y))+(0.1025*UI)
1483  * If best tap<0, best tap = 0
1484  */
1485 static unsigned int calculate_low_freq_tap_value(struct sdhci_host *sdhci,
1486         struct tap_window_data *tap_data)
1487 {
1488         unsigned int curr_clock;
1489         unsigned int max_clock;
1490         int best_tap_value;
1491         unsigned int tuning_ui;
1492         unsigned int sampling_point = 0;
1493         bool select_partial_win;
1494
1495         if (tap_data->abandon_full_win) {
1496                 if (tap_data->abandon_partial_win) {
1497                         return 0;
1498                 } else {
1499                         select_partial_win = true;
1500                         goto calculate_best_tap;
1501                 }
1502         }
1503
1504         tuning_ui = tap_data->full_win_end - tap_data->partial_win;
1505
1506         /* Calculate the sampling point */
1507         curr_clock = sdhci->max_clk / 1000000;
1508         max_clock = uhs_max_freq_MHz[sdhci->mmc->ios.timing];
1509         sampling_point = ((tuning_ui * curr_clock) / (max_clock << 2));
1510
1511         /*
1512          * Check whether partial window should be used. Use partial window
1513          * if partial window > 0.22(UI).
1514          */
1515         if ((!tap_data->abandon_partial_win) &&
1516                 (tap_data->partial_win > ((22 * tuning_ui) / 100)))
1517                         select_partial_win = true;
1518
1519 calculate_best_tap:
1520         if (select_partial_win)
1521                 best_tap_value = (tap_data->partial_win -
1522                         (tap_data->full_win_end - tap_data->full_win_begin)) +
1523                         sampling_point;
1524         else
1525                 best_tap_value = tap_data->full_win_begin +
1526                         sampling_point;
1527
1528         if (best_tap_value < 0)
1529                 best_tap_value = 0;
1530
1531         return best_tap_value;
1532 }
1533
1534 /*
1535  * Calculation of best tap value for high frequencies(156MHz).
1536  * Tap window data at 1.25V core voltage
1537  * X = Partial win, Y = Full win start, Z = Full win end.
1538  * Full Window = Z-Y.
1539  * UI = Z-X.
1540  * Tap_margin = (0.20375)UI
1541  *
1542  * Tap window data at 1.1V core voltage
1543  * X' = Partial win, Y' = Full win start, Z' = Full win end.
1544  * UI' = Z'-X'.
1545  * Full Window' = Z'-Y'.
1546  * Tap_margin' = (0.20375)UI'
1547  *
1548  * Full_window_tap=[(Z'-0.20375UI')+(Y+0.20375UI)]/2
1549  * Partial_window_tap=[(X'-0.20375UI')+(X-(Z-Y)+0x20375UI)]/2
1550  * if(Partial_window_tap < 0), Partial_window_tap=0
1551  *
1552  * Full_window_quality=[(Z'-0.20375UI')-(Y+0.20375UI)]/2
1553  * Partial_window_quality=(X'-0.20375UI')-Partial_window_tap
1554  * if(Full_window_quality>Partial_window_quality) choose full window,
1555  * else choose partial window.
1556  * If there is no margin window for both cases,
1557  * best tap=(Y+Z')/2.
1558  */
1559 static unsigned int calculate_high_freq_tap_value(struct sdhci_host *sdhci,
1560         struct tap_window_data *vmax_tap_data,
1561         struct tap_window_data *vmid_tap_data)
1562 {
1563         unsigned int curr_clock;
1564         unsigned int max_clock;
1565         unsigned int vmax_tuning_ui;
1566         unsigned int vmax_sampling_point;
1567         unsigned int vmid_tuning_ui;
1568         unsigned int vmid_sampling_point;
1569         unsigned int full_win_tap;
1570         int partial_win_start;
1571         int partial_win_tap;
1572         int full_win_quality;
1573         int partial_win_quality;
1574         int best_tap_value;
1575
1576         curr_clock = sdhci->max_clk / 1000000;
1577         max_clock = uhs_max_freq_MHz[sdhci->mmc->ios.timing];
1578
1579         /*
1580          * Calculate the tuning_ui and sampling points for tap windows found
1581          * at all core voltages.
1582          */
1583         vmax_tuning_ui = vmax_tap_data->full_win_end -
1584                 vmax_tap_data->partial_win;
1585         vmax_sampling_point = (vmax_tuning_ui * curr_clock) / (max_clock << 2);
1586
1587         vmid_tuning_ui = vmid_tap_data->full_win_end -
1588                 vmid_tap_data->partial_win;
1589         vmid_sampling_point = (vmid_tuning_ui * curr_clock) / (max_clock << 2);
1590
1591         full_win_tap = ((vmid_tap_data->full_win_end - vmid_sampling_point) +
1592                 (vmax_tap_data->full_win_begin + vmax_sampling_point));
1593         full_win_tap >>= 1;
1594         full_win_quality = (vmid_tap_data->full_win_end -
1595                 vmid_sampling_point) - (vmax_tap_data->full_win_begin +
1596                 vmax_sampling_point);
1597         full_win_quality >>= 1;
1598
1599         partial_win_start = (vmax_tap_data->partial_win -
1600                 (vmax_tap_data->full_win_end -
1601                 vmax_tap_data->full_win_begin));
1602
1603         partial_win_tap = ((vmid_tap_data->partial_win - vmid_sampling_point) +
1604                 (partial_win_start + vmax_sampling_point));
1605         partial_win_tap >>= 1;
1606         if (partial_win_tap < 0)
1607                 partial_win_tap = 0;
1608         partial_win_quality = (vmid_tap_data->partial_win -
1609                 vmid_sampling_point) - partial_win_tap;
1610
1611         if ((full_win_quality <= 0) && (partial_win_quality)) {
1612                 dev_warn(mmc_dev(sdhci->mmc),
1613                         "No margin window for both windows\n");
1614                 best_tap_value = vmax_tap_data->full_win_begin +
1615                         vmid_tap_data->full_win_end;
1616                 best_tap_value >>= 1;
1617         } else {
1618                 if (full_win_quality > partial_win_quality)
1619                         best_tap_value = full_win_tap;
1620                 else
1621                         best_tap_value = partial_win_tap;
1622         }
1623
1624         if (best_tap_value < 0)
1625                 best_tap_value = 0;
1626         return best_tap_value;
1627 }
1628
1629 static void sdhci_tegra_calculate_best_tap(struct sdhci_host *sdhci,
1630         u8 freq_band)
1631 {
1632         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1633         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1634         struct tegra_tuning_data *tuning_data;
1635
1636         SDHCI_TEGRA_DBG("%s: calculating best tap for freq band %d\n",
1637                 mmc_hostname(sdhci->mmc), freq_band);
1638         SDHCI_TEGRA_DBG("%s: Best tap %s nom best tap\n",
1639                 mmc_hostname(sdhci->mmc),
1640                 (tegra_host->plat->en_nominal_vcore_tuning) ? "different from" :
1641                 "same as");
1642
1643         tuning_data = sdhci_tegra_get_tuning_data(sdhci, sdhci->max_clk);
1644         if (freq_band == TUNING_LOW_FREQ) {
1645                 tuning_data->nom_best_tap_value =
1646                         calculate_low_freq_tap_value(sdhci,
1647                                 tuning_data->tap_data[0]);
1648                 tuning_data->best_tap_value = tuning_data->nom_best_tap_value;
1649         } else if (freq_band == TUNING_HIGH_FREQ) {
1650                 tuning_data->nom_best_tap_value =
1651                         calculate_high_freq_tap_value(sdhci,
1652                         tuning_data->tap_data[0], tuning_data->tap_data[1]);
1653                 if (!tegra_host->plat->en_nominal_vcore_tuning) {
1654                         tuning_data->best_tap_value =
1655                                 tuning_data->nom_best_tap_value;
1656                 } else {
1657                         tuning_data->best_tap_value =
1658                                 calculate_high_freq_tap_value(sdhci,
1659                                 tuning_data->tap_data[1],
1660                                 tuning_data->tap_data[2]);
1661                 }
1662         } else if (freq_band == TUNING_MAX_FREQ) {
1663                 tuning_data->nom_best_tap_value = calculate_high_freq_tap_value(
1664                         sdhci, tuning_data->tap_data[0],
1665                         tuning_data->tap_data[0]);
1666                 if (!tegra_host->plat->en_nominal_vcore_tuning) {
1667                         tuning_data->best_tap_value =
1668                                 tuning_data->nom_best_tap_value;
1669                 } else {
1670                         tuning_data->best_tap_value =
1671                                 calculate_high_freq_tap_value(sdhci,
1672                                 tuning_data->tap_data[1],
1673                                 tuning_data->tap_data[1]);
1674                 }
1675         }
1676 }
1677
1678 static int sdhci_tegra_issue_tuning_cmd(struct sdhci_host *sdhci)
1679 {
1680         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1681         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1682         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
1683         int err = 0;
1684         u8 ctrl;
1685         u32 mask;
1686         unsigned int timeout = 10;
1687         int flags;
1688         u32 intstatus;
1689
1690         if (gpio_is_valid(plat->cd_gpio)
1691                         && (gpio_get_value(plat->cd_gpio) != 0))
1692                 return -ENODEV;
1693
1694         mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
1695         while (sdhci_readl(sdhci, SDHCI_PRESENT_STATE) & mask) {
1696                 if (timeout == 0) {
1697                         dev_err(mmc_dev(sdhci->mmc), "Controller never"
1698                                 "released inhibit bit(s).\n");
1699                         err = -ETIMEDOUT;
1700                         goto out;
1701                 }
1702                 timeout--;
1703                 mdelay(1);
1704         }
1705
1706         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
1707         ctrl &= ~SDHCI_CTRL_TUNED_CLK;
1708         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
1709
1710         ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
1711         ctrl |= SDHCI_CTRL_EXEC_TUNING;
1712         sdhci_writeb(sdhci, ctrl, SDHCI_HOST_CONTROL2);
1713
1714         /*
1715          * In response to CMD19, the card sends 64 bytes of tuning
1716          * block to the Host Controller. So we set the block size
1717          * to 64 here.
1718          * In response to CMD21, the card sends 128 bytes of tuning
1719          * block for MMC_BUS_WIDTH_8 and 64 bytes for MMC_BUS_WIDTH_4
1720          * to the Host Controller. So we set the block size to 64 here.
1721          */
1722         sdhci_writew(sdhci, SDHCI_MAKE_BLKSZ(7, tegra_host->tuning_bsize),
1723                 SDHCI_BLOCK_SIZE);
1724
1725         sdhci_writeb(sdhci, 0xE, SDHCI_TIMEOUT_CONTROL);
1726
1727         sdhci_writew(sdhci, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE);
1728
1729         sdhci_writel(sdhci, 0x0, SDHCI_ARGUMENT);
1730
1731         /* Set the cmd flags */
1732         flags = SDHCI_CMD_RESP_SHORT | SDHCI_CMD_CRC | SDHCI_CMD_DATA;
1733         /* Issue the command */
1734         sdhci_writew(sdhci, SDHCI_MAKE_CMD(
1735                 tegra_host->tuning_opcode, flags), SDHCI_COMMAND);
1736
1737         timeout = 5;
1738         do {
1739                 timeout--;
1740                 mdelay(1);
1741                 intstatus = sdhci_readl(sdhci, SDHCI_INT_STATUS);
1742                 if (intstatus) {
1743                         sdhci_writel(sdhci, intstatus, SDHCI_INT_STATUS);
1744                         break;
1745                 }
1746         } while(timeout);
1747
1748         if ((intstatus & SDHCI_INT_DATA_AVAIL) &&
1749                 !(intstatus & SDHCI_INT_DATA_CRC)) {
1750                 err = 0;
1751                 sdhci->tuning_done = 1;
1752         } else {
1753                 tegra_sdhci_reset(sdhci, SDHCI_RESET_CMD);
1754                 tegra_sdhci_reset(sdhci, SDHCI_RESET_DATA);
1755                 err = -EAGAIN;
1756         }
1757
1758         if (sdhci->tuning_done) {
1759                 sdhci->tuning_done = 0;
1760                 ctrl = sdhci_readb(sdhci, SDHCI_HOST_CONTROL2);
1761                 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING) &&
1762                         (ctrl & SDHCI_CTRL_TUNED_CLK))
1763                         err = 0;
1764                 else
1765                         err = -EAGAIN;
1766         }
1767         mdelay(1);
1768 out:
1769         return err;
1770 }
1771
1772 static int sdhci_tegra_scan_tap_values(struct sdhci_host *sdhci,
1773         unsigned int starting_tap, bool expect_failure)
1774 {
1775         unsigned int tap_value = starting_tap;
1776         int err;
1777         unsigned int retry = TUNING_RETRIES;
1778
1779         do {
1780                 /* Set the tap delay */
1781                 sdhci_tegra_set_tap_delay(sdhci, tap_value);
1782
1783                 /* Run frequency tuning */
1784                 err = sdhci_tegra_issue_tuning_cmd(sdhci);
1785                 if (err == -ENODEV)
1786                         return err;
1787                 if (err && retry) {
1788                         retry--;
1789                         continue;
1790                 } else {
1791                         retry = TUNING_RETRIES;
1792                         if ((expect_failure && !err) ||
1793                                 (!expect_failure && err))
1794                                 break;
1795                 }
1796                 tap_value++;
1797         } while (tap_value <= MAX_TAP_VALUES);
1798
1799         return tap_value;
1800 }
1801
1802 /*
1803  * While scanning for tap values, first get the partial window followed by the
1804  * full window. Note that, when scanning for full win start, tuning has to be
1805  * run until a passing tap value is found. Hence, failure is expected during
1806  * this process and ignored.
1807  */
1808 static int sdhci_tegra_get_tap_window_data(struct sdhci_host *sdhci,
1809         struct tap_window_data *tap_data)
1810 {
1811         unsigned int tap_value;
1812         unsigned int full_win_percentage = 0;
1813         int err = 0;
1814
1815         if (!tap_data) {
1816                 dev_err(mmc_dev(sdhci->mmc), "Invalid tap data\n");
1817                 return -ENODATA;
1818         }
1819
1820         /* Get the partial window data */
1821         tap_value = 0;
1822         tap_value = sdhci_tegra_scan_tap_values(sdhci, tap_value, false);
1823         if (tap_value < 0) {
1824                 err = -EIO;
1825                 goto out;
1826         } else if (!tap_value) {
1827                 tap_data->abandon_partial_win = true;
1828                 tap_data->partial_win = 0;
1829         } else if (tap_value > MAX_TAP_VALUES) {
1830                 /*
1831                  * If tap value is more than 0xFF, we have hit the miracle case
1832                  * of all tap values passing. Discard full window as passing
1833                  * window has covered all taps.
1834                  */
1835                 tap_data->partial_win = MAX_TAP_VALUES;
1836                 tap_data->abandon_full_win = true;
1837                 goto out;
1838         } else {
1839                 tap_data->partial_win = tap_value - 1;
1840                 if (tap_value == MAX_TAP_VALUES) {
1841                         /* All tap values exhausted. No full window */
1842                         tap_data->abandon_full_win = true;
1843                         goto out;
1844                 }
1845         }
1846
1847         do {
1848                 /* Get the full window start */
1849                 tap_value++;
1850                 tap_value = sdhci_tegra_scan_tap_values(sdhci, tap_value, true);
1851                 if (tap_value < 0) {
1852                         err = -EIO;
1853                         goto out;
1854                 } else if (tap_value > MAX_TAP_VALUES) {
1855                         /* All tap values exhausted. No full window */
1856                         tap_data->abandon_full_win = true;
1857                         goto out;
1858                 } else {
1859                         tap_data->full_win_begin = tap_value;
1860                         /*
1861                          * If full win start is 0xFF, then set that as
1862                          * full win end and exit.
1863                          */
1864                         if (tap_value == MAX_TAP_VALUES) {
1865                                 tap_data->full_win_end = tap_value;
1866                                 goto out;
1867                         }
1868                 }
1869
1870                 /* Get the full window end */
1871                 tap_value++;
1872                 tap_value = sdhci_tegra_scan_tap_values(sdhci,
1873                                 tap_value, false);
1874                 tap_data->full_win_end = tap_value - 1;
1875                 if (tap_value > MAX_TAP_VALUES)
1876                         tap_data->full_win_end = MAX_TAP_VALUES;
1877                 full_win_percentage = ((tap_data->full_win_end -
1878                                 tap_data->full_win_begin) * 100) /
1879                                 (tap_data->partial_win + 1);
1880         } while (full_win_percentage < 50 && tap_value < MAX_TAP_VALUES);
1881
1882         if (full_win_percentage < 50)
1883                 tap_data->abandon_full_win = true;
1884 out:
1885         /*
1886          * Mark tuning as failed if both partial and full windows are
1887          * abandoned.
1888          */
1889         if (tap_data->abandon_partial_win && tap_data->abandon_full_win)
1890                 err = -EIO;
1891         return err;
1892 }
1893
1894 static void sdhci_tegra_dump_tuning_constraints(struct sdhci_host *sdhci)
1895 {
1896         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1897         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1898         struct tegra_tuning_data *tuning_data;
1899         struct tap_window_data *tap_data;
1900         u8 i, j;
1901
1902         SDHCI_TEGRA_DBG("%s: Num of tuning frequencies%d\n",
1903                 mmc_hostname(sdhci->mmc), tegra_host->tuning_freq_count);
1904         for (i = 0; i < tegra_host->tuning_freq_count; ++i) {
1905                 tuning_data = &tegra_host->tuning_data[i];
1906                 SDHCI_TEGRA_DBG("%s: Tuning freq[%d]: %d, freq band %d\n",
1907                         mmc_hostname(sdhci->mmc), i,
1908                         tuning_data->freq_hz, tuning_data->freq_band);
1909                 SDHCI_TEGRA_DBG("%s: Supported voltages:",
1910                         mmc_hostname(sdhci->mmc));
1911                 for (j = 0; j < tuning_data->nr_voltages; ++j) {
1912                         tap_data = tuning_data->tap_data[j];
1913                         SDHCI_TEGRA_DBG("%d,", tap_data->voltage);
1914                 }
1915         }
1916 }
1917
1918 static unsigned int get_tuning_voltage(struct sdhci_tegra *tegra_host, u8 *mask)
1919 {
1920         u8 i = 0;
1921
1922         i = ffs(*mask) - 1;
1923         *mask &= ~(1 << i);
1924         switch (BIT(i)) {
1925         case NOMINAL_VCORE_TUN:
1926                 return tegra_host->nominal_vcore_mv;
1927         case BOOT_VCORE_TUN:
1928                 return tegra_host->boot_vcore_mv;
1929         case MIN_OVERRIDE_VCORE_TUN:
1930                 return tegra_host->min_vcore_override_mv;
1931         }
1932
1933         return tegra_host->boot_vcore_mv;
1934 }
1935
1936 static int sdhci_tegra_setup_vcore_constraints(struct sdhci_host *sdhci)
1937 {
1938         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1939         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1940         struct freq_tuning_constraints *constraints;
1941         struct tegra_tuning_data *tuning_data;
1942         struct tap_window_data *tap_data;
1943         u8 freq_count = tegra_host->tuning_freq_count;
1944         u8 nr_voltages, i, j, vcore_mask;
1945
1946         for (i = 0; i < freq_count; i++) {
1947                 tuning_data = &tegra_host->tuning_data[i];
1948                 constraints = &tuning_data->constraints;
1949                 nr_voltages = hweight32(constraints->vcore_mask);
1950                 SDHCI_TEGRA_DBG("%s: %dHz: vcore mask %#x, nr voltages %d\n",
1951                         mmc_hostname(sdhci->mmc), tuning_data->freq_hz,
1952                         constraints->vcore_mask, nr_voltages);
1953                 vcore_mask = constraints->vcore_mask;
1954                 for (j = 0; j < nr_voltages; j++) {
1955                         tap_data = devm_kzalloc(
1956                                 mmc_dev(sdhci->mmc),
1957                                 sizeof(struct tap_window_data),
1958                                 GFP_KERNEL);
1959                         if (!tap_data)
1960                                 return -ENOMEM;
1961                         tap_data->voltage = get_tuning_voltage(tegra_host,
1962                                 &vcore_mask);
1963                         tuning_data->tap_data[j] = tap_data;
1964                 }
1965                 tuning_data->nr_voltages = nr_voltages;
1966         }
1967         return 0;
1968 }
1969
1970 static u8 sdhci_tegra_get_freq_point(struct sdhci_host *sdhci)
1971 {
1972         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1973         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1974         unsigned int *freq_list;
1975         u32 curr_clock;
1976         u8 i;
1977
1978         curr_clock = sdhci->max_clk;
1979         freq_list = tegra_host->soc_data->tuning_freq_list;
1980
1981         for (i = 0; i < TUNING_FREQ_COUNT; ++i)
1982                 if (curr_clock <= freq_list[i])
1983                         return i;
1984
1985         return TUNING_MAX_FREQ;
1986 }
1987
1988 /*
1989  * Determines the numbers of frequencies required and then fills up the tuning
1990  * constraints for each of the frequencies. The data of lower frequency is
1991  * filled first and then the higher frequency data. Currently fills constraints
1992  * for number of frequencies 1 and 2.
1993  */
1994 static u8 sdhci_tegra_setup_freq_constraints(struct sdhci_host *sdhci,
1995         unsigned int *freq_list)
1996 {
1997         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
1998         struct sdhci_tegra *tegra_host = pltfm_host->priv;
1999         struct tegra_tuning_data *tuning_data;
2000         int i;
2001         u8 freq_count, freq_band;
2002
2003         if ((sdhci->mmc->ios.timing != MMC_TIMING_UHS_SDR50) &&
2004                 (sdhci->mmc->caps2 & MMC_CAP2_FREQ_SCALING))
2005                 freq_count = DFS_FREQ_COUNT;
2006         else
2007                 freq_count = 1;
2008
2009         freq_band = sdhci_tegra_get_freq_point(sdhci);
2010         /* Fill up the req frequencies */
2011         switch (freq_count) {
2012         case 1:
2013                 tuning_data = &tegra_host->tuning_data[0];
2014                 tuning_data->freq_hz = sdhci->max_clk;
2015                 tuning_data->freq_band = freq_band;
2016                 tuning_data->constraints =
2017                         tuning_vcore_constraints[freq_band];
2018                 if (!tegra_host->plat->en_nominal_vcore_tuning)
2019                         tuning_data->constraints.vcore_mask &=
2020                                 ~NOMINAL_VCORE_TUN;
2021         break;
2022         case 2:
2023                 tuning_data = &tegra_host->tuning_data[1];
2024                 tuning_data->freq_hz = sdhci->max_clk;
2025                 tuning_data->freq_band = freq_band;
2026                 tuning_data->constraints =
2027                         tuning_vcore_constraints[freq_band];
2028                 if (!tegra_host->plat->en_nominal_vcore_tuning)
2029                         tuning_data->constraints.vcore_mask &=
2030                                 ~NOMINAL_VCORE_TUN;
2031
2032                 tuning_data = &tegra_host->tuning_data[0];
2033                 for (i = (freq_band - 1); i >= 0; i--) {
2034                         if (!freq_list[i])
2035                                 continue;
2036                         tuning_data->freq_hz = freq_list[i];
2037                         tuning_data->freq_band = i;
2038                         tuning_data->constraints =
2039                                 tuning_vcore_constraints[i];
2040                         if (!tegra_host->plat->en_nominal_vcore_tuning)
2041                                 tuning_data->constraints.vcore_mask &=
2042                                         ~NOMINAL_VCORE_TUN;
2043                 }
2044         break;
2045         default:
2046                 dev_err(mmc_dev(sdhci->mmc), "Unsupported freq count\n");
2047         }
2048         return freq_count;
2049 }
2050
2051 /*
2052  * Get the supported frequencies, core voltage levels for each frequency and
2053  * other tuning related constraints.
2054  * The supported frequencies should be determined from the list of frequencies
2055  * in the soc data and also consider the platform clock limits as well as any
2056  * DFS related restrictions.
2057  * Check if tuning at nominal core voltage is required.
2058  */
2059 static int sdhci_tegra_get_tuning_constraints(struct sdhci_host *sdhci)
2060 {
2061         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2062         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2063         unsigned int *freq_list;
2064         int err = 0;
2065
2066
2067         /* Check if the constraints are already filled up */
2068         if (tegra_host->tuning_freq_count)
2069                 return err;
2070
2071         freq_list = tegra_host->soc_data->tuning_freq_list;
2072         tegra_host->tuning_freq_count =
2073                 sdhci_tegra_setup_freq_constraints(sdhci, freq_list);
2074
2075         err = sdhci_tegra_setup_vcore_constraints(sdhci);
2076
2077         sdhci_tegra_dump_tuning_constraints(sdhci);
2078
2079         return err;
2080 }
2081
2082 /*
2083  * During boot, only boot voltage for vcore can be set. Check if the current
2084  * voltage is allowed to be used. Nominal and min override voltages can be
2085  * set once boot is done. This will be notified through late subsys init call.
2086  */
2087 static int sdhci_tegra_set_tuning_voltage(struct sdhci_host *sdhci,
2088         unsigned int voltage)
2089 {
2090         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2091         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2092         int err = 0;
2093         bool nom_emc_freq_set = false;
2094
2095         if (voltage && (voltage != tegra_host->boot_vcore_mv) &&
2096                 !vcore_overrides_allowed) {
2097                 SDHCI_TEGRA_DBG("%s: Override vcore %dmv not allowed \n",
2098                         mmc_hostname(sdhci->mmc), voltage);
2099                 return -EPERM;
2100         }
2101
2102         SDHCI_TEGRA_DBG("%s: Setting vcore override %d\n",
2103                 mmc_hostname(sdhci->mmc), voltage);
2104         /* First clear any previous dvfs override settings */
2105         err = tegra_dvfs_override_core_voltage(pltfm_host->clk, 0);
2106         if (!voltage)
2107                 return err;
2108
2109         /* EMC clock freq boost might be required for nominal core voltage */
2110         if (( voltage == tegra_host->nominal_vcore_mv) &&
2111                 tegra_host->plat->en_nominal_vcore_tuning &&
2112                 tegra_host->emc_clk) {
2113                 err = clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_NOM_VOLT_FREQ);
2114                 if (err)
2115                         dev_err(mmc_dev(sdhci->mmc),
2116                                 "Failed to set emc nom clk freq %d\n", err);
2117                 else
2118                         nom_emc_freq_set = true;
2119         }
2120
2121         err = tegra_dvfs_override_core_voltage(pltfm_host->clk, voltage);
2122         if (err)
2123                 dev_err(mmc_dev(sdhci->mmc),
2124                         "failed to set vcore override %dmv\n", voltage);
2125
2126         /* Revert emc clock to normal freq */
2127         if (nom_emc_freq_set) {
2128                 err = clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_MAX_FREQ);
2129                 if (err)
2130                         dev_err(mmc_dev(sdhci->mmc),
2131                                 "Failed to revert emc nom clk freq %d\n", err);
2132         }
2133
2134         return err;
2135 }
2136
2137 static u8 get_curr_voltage_tuning_status(struct tap_window_data *tap_data)
2138 {
2139         if (!tap_data->vcore_set_status)
2140                 maintain_boot_voltage = true;
2141
2142         if (!tap_data->vcore_set_status || !tap_data->found_tuning_window)
2143                 return 1;
2144
2145         return 0;
2146 }
2147
2148 static u8 sdhci_tegra_run_tuning(struct sdhci_host *sdhci,
2149         struct tegra_tuning_data *tuning_data, bool force_retuning)
2150 {
2151         struct tap_window_data *tap_data;
2152         int err;
2153         u8 i, retuning_req = 0;
2154
2155         for (i = 0; i < tuning_data->nr_voltages; i++) {
2156                 tap_data = tuning_data->tap_data[i];
2157                 /* Skip if tuning is already completed successfully */
2158                 if (tap_data->vcore_set_status &&
2159                         tap_data->found_tuning_window && !force_retuning)
2160                         continue;
2161                 err = sdhci_tegra_set_tuning_voltage(sdhci,
2162                         tap_data->voltage);
2163                 tap_data->vcore_set_status = !err;
2164                 /* Get the tuning window info */
2165                 spin_lock(&sdhci->lock);
2166                 err = sdhci_tegra_get_tap_window_data(sdhci, tap_data);
2167                 spin_unlock(&sdhci->lock);
2168                 SDHCI_TEGRA_DBG("%s: Tap data[%d] obtained\n",
2169                         mmc_hostname(sdhci->mmc), i);
2170                 tap_data->found_tuning_window = !err;
2171                 if (err)
2172                         dev_err(mmc_dev(sdhci->mmc),
2173                                 "Invalid tap win. Retuning req\n");
2174                 retuning_req |= get_curr_voltage_tuning_status(tap_data);
2175                 SDHCI_TEGRA_DBG("%s: Retuning req %s\n",
2176                         mmc_hostname(sdhci->mmc), retuning_req ? "set" :
2177                         "not set");
2178         }
2179         return retuning_req;
2180 }
2181
2182 static int sdhci_tegra_verify_best_tap(struct sdhci_host *sdhci,
2183         u8 freq_band)
2184 {
2185         struct tegra_tuning_data *tuning_data;
2186         unsigned int best_tap_value = 0;
2187         int err;
2188
2189         tuning_data = sdhci_tegra_get_tuning_data(sdhci, sdhci->max_clk);
2190         best_tap_value = tuning_data->best_tap_value;
2191
2192         /* Set the best tap value */
2193         sdhci_tegra_set_tap_delay(sdhci, best_tap_value);
2194
2195         /* Run tuning after setting the best tap value */
2196         err = sdhci_tegra_issue_tuning_cmd(sdhci);
2197         if (err)
2198                 dev_err(mmc_dev(sdhci->mmc),
2199                         "%dMHz best tap value verification failed %d\n",
2200                         tuning_data->freq_hz, err);
2201         return err;
2202 }
2203
2204 static int sdhci_tegra_execute_tuning(struct sdhci_host *sdhci, u32 opcode)
2205 {
2206         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2207         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2208         struct tegra_tuning_data *tuning_data;
2209         unsigned int freq_band;
2210         int err;
2211         u16 ctrl_2;
2212         u32 ier;
2213         u8 i, set_retuning = 0;
2214         bool is_retuning_req = false;
2215         bool force_retuning = false;
2216
2217         /* Tuning is valid only in SDR104 and SDR50 modes */
2218         ctrl_2 = sdhci_readw(sdhci, SDHCI_HOST_CONTROL2);
2219         if (!(((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR104) ||
2220                 (((ctrl_2 & SDHCI_CTRL_UHS_MASK) == SDHCI_CTRL_UHS_SDR50) &&
2221                 (sdhci->flags & SDHCI_SDR50_NEEDS_TUNING))))
2222                         return 0;
2223
2224         /* Tuning should be done only for MMC_BUS_WIDTH_8 and MMC_BUS_WIDTH_4 */
2225         if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_8)
2226                 tegra_host->tuning_bsize = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_8;
2227         else if (sdhci->mmc->ios.bus_width == MMC_BUS_WIDTH_4)
2228                 tegra_host->tuning_bsize = MMC_TUNING_BLOCK_SIZE_BUS_WIDTH_4;
2229         else
2230                 return -EINVAL;
2231
2232         pr_err("%s: Starting freq tuning\n", mmc_hostname(sdhci->mmc));
2233         mutex_lock(&tuning_mutex);
2234         if (sdhci->flags & SDHCI_NEEDS_RETUNING)
2235                 is_retuning_req = true;
2236         sdhci->flags &= ~SDHCI_NEEDS_RETUNING;
2237
2238         /* Set the tuning command to be used */
2239         tegra_host->tuning_opcode = opcode;
2240
2241         /*
2242          * Disable all interrupts signalling.Enable interrupt status
2243          * detection for buffer read ready and data crc. We use
2244          * polling for tuning as it involves less overhead.
2245          */
2246         ier = sdhci_readl(sdhci, SDHCI_INT_ENABLE);
2247         sdhci_writel(sdhci, 0, SDHCI_SIGNAL_ENABLE);
2248         sdhci_writel(sdhci, SDHCI_INT_DATA_AVAIL |
2249                 SDHCI_INT_DATA_CRC, SDHCI_INT_ENABLE);
2250
2251         /*
2252          * If tuning is already done and retune request is not set, then skip
2253          * best tap value calculation and use the old best tap value. If the
2254          * previous best tap value verification failed, force retuning.
2255          */
2256         if (tegra_host->tuning_status == TUNING_STATUS_DONE) {
2257                 freq_band = sdhci_tegra_get_freq_point(sdhci);
2258                 dev_info(mmc_dev(sdhci->mmc),
2259                         "Tuning already done. Setting tuned tap value %d\n",
2260                         tegra_host->tuning_data[freq_band].best_tap_value);
2261                 err = sdhci_tegra_verify_best_tap(sdhci, freq_band);
2262                 if (err)
2263                         force_retuning = true;
2264                 else
2265                         goto out;
2266         }
2267
2268         if (tegra_host->force_retune == true) {
2269                 force_retuning = true;
2270                 tegra_host->force_retune = false;
2271         }
2272
2273         tegra_host->tuning_status = 0;
2274         err = sdhci_tegra_get_tuning_constraints(sdhci);
2275         if (err) {
2276                 dev_err(mmc_dev(sdhci->mmc), "Failed to get tuning constraints\n");
2277                 goto out;
2278         }
2279
2280         for (i = 0; i < tegra_host->tuning_freq_count; i++) {
2281                 tuning_data = &tegra_host->tuning_data[i];
2282                 if (tuning_data->tuning_done && !force_retuning)
2283                         continue;
2284
2285                 SDHCI_TEGRA_DBG("%s: Setting tuning freq%d\n",
2286                         mmc_hostname(sdhci->mmc), tuning_data->freq_hz);
2287                 tegra_sdhci_set_clock(sdhci, tuning_data->freq_hz);
2288
2289                 set_retuning = sdhci_tegra_run_tuning(sdhci, tuning_data, force_retuning);
2290
2291                 sdhci_tegra_calculate_best_tap(sdhci, tuning_data->freq_band);
2292
2293                 /* Dump the tuning data */
2294                 sdhci_tegra_dump_tuning_data(sdhci);
2295
2296                 err = sdhci_tegra_verify_best_tap(sdhci,
2297                                 tuning_data->freq_band);
2298                 if (!err && !set_retuning) {
2299                         tuning_data->tuning_done = true;
2300                         tegra_host->tuning_status |= TUNING_STATUS_DONE;
2301                 } else {
2302                         tegra_host->tuning_status |= TUNING_STATUS_RETUNE;
2303                 }
2304         }
2305         if (tegra_host->tuning_status & TUNING_STATUS_RETUNE)
2306                 mod_timer(&sdhci->tuning_timer, jiffies + 10 * HZ);
2307 out:
2308         if (maintain_boot_voltage) {
2309                 ++boot_volt_req_refcount;
2310                 maintain_boot_voltage = false;
2311                 SDHCI_TEGRA_DBG("%s: Need fixed core volt %d, refcount %d\n",
2312                         mmc_hostname(sdhci->mmc), tegra_host->boot_vcore_mv,
2313                         boot_volt_req_refcount);
2314
2315         } else {
2316                 if (boot_volt_req_refcount && is_retuning_req)
2317                         --boot_volt_req_refcount;
2318                 SDHCI_TEGRA_DBG("%s: Relax core volt constraint. refcount %d\n",
2319                         mmc_hostname(sdhci->mmc), boot_volt_req_refcount);
2320         }
2321
2322         if (boot_volt_req_refcount)
2323                 sdhci_tegra_set_tuning_voltage(sdhci,
2324                         tegra_host->boot_vcore_mv);
2325         else
2326                 sdhci_tegra_set_tuning_voltage(sdhci, 0);
2327
2328
2329         /* Enable interrupts. Enable full range for core voltage */
2330         sdhci_writel(sdhci, ier, SDHCI_INT_ENABLE);
2331         sdhci_writel(sdhci, ier, SDHCI_SIGNAL_ENABLE);
2332         mutex_unlock(&tuning_mutex);
2333
2334         pr_err("%s: Freq tuning done\n", mmc_hostname(sdhci->mmc));
2335         return err;
2336 }
2337
2338 static int __init sdhci_tegra_enable_vcore_override_tuning(void)
2339 {
2340         vcore_overrides_allowed = true;
2341         maintain_boot_voltage = false;
2342         return 0;
2343 }
2344 late_initcall(sdhci_tegra_enable_vcore_override_tuning);
2345
2346 static int tegra_sdhci_suspend(struct sdhci_host *sdhci)
2347 {
2348         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2349         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2350         int err = 0;
2351
2352         tegra_sdhci_set_clock(sdhci, 0);
2353
2354         /* Disable the power rails if any */
2355         if (tegra_host->card_present) {
2356                 err = tegra_sdhci_configure_regulators(tegra_host,
2357                         CONFIG_REG_DIS, 0, 0);
2358                 if (err)
2359                         dev_err(mmc_dev(sdhci->mmc),
2360                         "Regulators disable in suspend failed %d\n", err);
2361         }
2362         return err;
2363 }
2364
2365 static int tegra_sdhci_resume(struct sdhci_host *sdhci)
2366 {
2367         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2368         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2369         struct platform_device *pdev;
2370         struct tegra_sdhci_platform_data *plat;
2371         int err;
2372
2373         pdev = to_platform_device(mmc_dev(sdhci->mmc));
2374         plat = pdev->dev.platform_data;
2375
2376         if (gpio_is_valid(plat->cd_gpio))
2377                 tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
2378
2379         /* Enable the power rails if any */
2380         if (tegra_host->card_present) {
2381                 err = tegra_sdhci_configure_regulators(tegra_host,
2382                         CONFIG_REG_EN, 0, 0);
2383                 if (err) {
2384                         dev_err(mmc_dev(sdhci->mmc),
2385                                 "Regulators enable in resume failed %d\n", err);
2386                         return err;
2387                 }
2388                 if (tegra_host->vdd_io_reg) {
2389                         if (plat->mmc_data.ocr_mask &
2390                                                 SDHOST_1V8_OCR_MASK)
2391                                 tegra_sdhci_signal_voltage_switch(sdhci,
2392                                                 MMC_SIGNAL_VOLTAGE_180);
2393                         else
2394                                 tegra_sdhci_signal_voltage_switch(sdhci,
2395                                                 MMC_SIGNAL_VOLTAGE_330);
2396                 }
2397         }
2398
2399         /* Setting the min identification clock of freq 400KHz */
2400         tegra_sdhci_set_clock(sdhci, 400000);
2401
2402         /* Reset the controller and power on if MMC_KEEP_POWER flag is set*/
2403         if (sdhci->mmc->pm_flags & MMC_PM_KEEP_POWER) {
2404                 tegra_sdhci_reset(sdhci, SDHCI_RESET_ALL);
2405                 sdhci_writeb(sdhci, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
2406                 sdhci->pwr = 0;
2407         }
2408
2409         return 0;
2410 }
2411
2412 static void tegra_sdhci_post_resume(struct sdhci_host *sdhci)
2413 {
2414         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(sdhci);
2415         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2416
2417         if (tegra_host->card_present) {
2418                 if (tegra_host->sd_detect_in_suspend)
2419                         tasklet_schedule(&sdhci->card_tasklet);
2420         } else if (tegra_host->clk_enabled) {
2421                 /* Turn OFF the clocks if the card is not present */
2422                 tegra_sdhci_set_clock(sdhci, 0);
2423         }
2424 }
2425
2426 /*
2427  * For tegra specific tuning, core voltage has to be fixed at different
2428  * voltages to get the tap values. Fixing the core voltage during tuning for one
2429  * device might affect transfers of other SDMMC devices. Check if tuning mutex
2430  * is locked before starting a data transfer.
2431  */
2432 static void tegra_sdhci_get_bus(struct sdhci_host *sdhci)
2433 {
2434         unsigned int timeout = 100;
2435
2436         while (mutex_is_locked(&tuning_mutex)) {
2437                 msleep(10);
2438                 --timeout;
2439                 if (!timeout) {
2440                         dev_err(mmc_dev(sdhci->mmc),
2441                                 "Tuning mutex locked for long time\n");
2442                         return;
2443                 }
2444         };
2445 }
2446
2447 /*
2448  * The host/device can be powered off before the retuning request is handled in
2449  * case of SDIO being powered off if Wifi is turned off, sd card removal etc. In
2450  * such cases, cancel the pending tuning timer and remove any core voltage
2451  * constraints that are set earlier.
2452  */
2453
2454 static void tegra_sdhci_power_off(struct sdhci_host *sdhci, u8 power_mode)
2455 {
2456         int retuning_req_set = 0;
2457
2458         retuning_req_set = (timer_pending(&sdhci->tuning_timer) ||
2459                 (sdhci->flags & SDHCI_NEEDS_RETUNING));
2460
2461         if (retuning_req_set)
2462                 del_timer_sync(&sdhci->tuning_timer);
2463
2464         if (retuning_req_set) {
2465                 if (boot_volt_req_refcount)
2466                         --boot_volt_req_refcount;
2467                 if (!boot_volt_req_refcount) {
2468                         sdhci_tegra_set_tuning_voltage(sdhci, 0);
2469                         SDHCI_TEGRA_DBG(
2470                                 "%s:Host is off. Remove vcore constraints\n",
2471                                 mmc_hostname(sdhci->mmc));
2472                 }
2473         }
2474 }
2475
2476 static int show_polling_period(void *data, u64 *value)
2477 {
2478         struct sdhci_host *host = (struct sdhci_host *)data;
2479
2480         if (host->mmc->dev_stats != NULL)
2481                 *value = host->mmc->dev_stats->polling_interval;
2482
2483         return 0;
2484 }
2485
2486 static int set_polling_period(void *data, u64 value)
2487 {
2488         struct sdhci_host *host = (struct sdhci_host *)data;
2489
2490         if (host->mmc->dev_stats != NULL) {
2491                 /* Limiting the maximum polling period to 1 sec */
2492                 if (value > 1000)
2493                         value = 1000;
2494                 host->mmc->dev_stats->polling_interval = value;
2495         }
2496
2497         return 0;
2498 }
2499 static int show_active_load_high_threshold(void *data, u64 *value)
2500 {
2501         struct sdhci_host *host = (struct sdhci_host *)data;
2502         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
2503         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2504         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
2505
2506         if (gov_data != NULL)
2507                 *value = gov_data->act_load_high_threshold;
2508
2509         return 0;
2510 }
2511
2512 static int set_active_load_high_threshold(void *data, u64 value)
2513 {
2514         struct sdhci_host *host = (struct sdhci_host *)data;
2515         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
2516         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2517         struct tegra_freq_gov_data *gov_data = tegra_host->gov_data;
2518
2519         if (gov_data != NULL) {
2520                 /* Maximum threshold load percentage is 100.*/
2521                 if (value > 100)
2522                         value = 100;
2523                 gov_data->act_load_high_threshold = value;
2524         }
2525
2526         return 0;
2527 }
2528
2529 DEFINE_SIMPLE_ATTRIBUTE(sdhci_polling_period_fops, show_polling_period,
2530                 set_polling_period, "%llu\n");
2531 DEFINE_SIMPLE_ATTRIBUTE(sdhci_active_load_high_threshold_fops,
2532                 show_active_load_high_threshold,
2533                 set_active_load_high_threshold, "%llu\n");
2534
2535 static void sdhci_tegra_error_stats_debugfs(struct sdhci_host *host)
2536 {
2537         struct dentry *root;
2538         struct dentry *dfs_root;
2539
2540         root = debugfs_create_dir(dev_name(mmc_dev(host->mmc)), NULL);
2541         if (IS_ERR(root))
2542                 /* Don't complain -- debugfs just isn't enabled */
2543                 return;
2544         if (!root)
2545                 /* Complain -- debugfs is enabled, but it failed to
2546                  * create the directory. */
2547                 goto err_root;
2548
2549         host->debugfs_root = root;
2550
2551         dfs_root = debugfs_create_dir("dfs_stats_dir", root);
2552         if (IS_ERR_OR_NULL(dfs_root))
2553                 goto err_node;
2554
2555         if (!debugfs_create_file("error_stats", S_IRUSR, root, host,
2556                                 &sdhci_host_fops))
2557                 goto err_node;
2558         if (!debugfs_create_file("dfs_stats", S_IRUSR, dfs_root, host,
2559                                 &sdhci_host_dfs_fops))
2560                 goto err_node;
2561         if (!debugfs_create_file("polling_period", 0644, dfs_root, (void *)host,
2562                                 &sdhci_polling_period_fops))
2563                 goto err_node;
2564         if (!debugfs_create_file("active_load_high_threshold", 0644,
2565                                 dfs_root, (void *)host,
2566                                 &sdhci_active_load_high_threshold_fops))
2567                 goto err_node;
2568         return;
2569
2570 err_node:
2571         debugfs_remove_recursive(root);
2572         host->debugfs_root = NULL;
2573 err_root:
2574         pr_err("%s: Failed to initialize debugfs functionality\n", __func__);
2575         return;
2576 }
2577
2578 static ssize_t sdhci_handle_boost_mode_tap(struct device *dev,
2579         struct device_attribute *attr, const char *buf, size_t count)
2580 {
2581         int tap_cmd;
2582         struct mmc_card *card;
2583         char *p = (char *)buf;
2584         struct sdhci_host *host = dev_get_drvdata(dev);
2585         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
2586         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2587         struct tegra_tuning_data *tuning_data;
2588         u32 present_state;
2589         u8 timeout;
2590         bool clk_set_for_tap_prog = false;
2591
2592         tap_cmd = memparse(p, &p);
2593
2594         card = host->mmc->card;
2595         if (!card)
2596                 return -ENODEV;
2597
2598         /* if not uhs -- no tuning and no tap value to set */
2599         if (!mmc_sd_card_uhs(card) && !mmc_card_hs200(card))
2600                 return count;
2601
2602         /* if no change in tap value -- just exit */
2603         if (tap_cmd == tegra_host->tap_cmd)
2604                 return count;
2605
2606         if ((tap_cmd != TAP_CMD_TRIM_DEFAULT_VOLTAGE) &&
2607                 (tap_cmd != TAP_CMD_TRIM_HIGH_VOLTAGE)) {
2608                 pr_info("\necho 1 > cmd_state  # to set normal voltage\n" \
2609                           "echo 2 > cmd_state  # to set high voltage\n");
2610                 return -EINVAL;
2611         }
2612
2613         tegra_host->tap_cmd = tap_cmd;
2614         tuning_data = sdhci_tegra_get_tuning_data(host, host->max_clk);
2615         /* Check if host clock is enabled */
2616         if (!tegra_host->clk_enabled) {
2617                 /* Nothing to do if the host is not powered ON */
2618                 if (host->mmc->ios.power_mode != MMC_POWER_ON)
2619                         return count;
2620                 else {
2621                         tegra_sdhci_set_clock(host, host->mmc->ios.clock);
2622                         clk_set_for_tap_prog = true;
2623                 }
2624         } else {
2625                 timeout = 20;
2626                 /* Wait for any on-going data transfers */
2627                 do {
2628                         if (!timeout)
2629                                 break;
2630                         mdelay(1);
2631                         --timeout;
2632                         present_state = sdhci_readl(host, SDHCI_PRESENT_STATE);
2633                 } while(present_state & (SDHCI_DOING_WRITE | SDHCI_DOING_READ));
2634         }
2635         spin_lock(&host->lock);
2636         switch (tap_cmd) {
2637         case TAP_CMD_TRIM_DEFAULT_VOLTAGE:
2638                 /* set tap value for voltage range 1.1 to 1.25 */
2639                 sdhci_tegra_set_tap_delay(host, tuning_data->best_tap_value);
2640                 break;
2641
2642         case TAP_CMD_TRIM_HIGH_VOLTAGE:
2643                 /* set tap value for voltage range 1.25 to 1.39 */
2644                 sdhci_tegra_set_tap_delay(host,
2645                         tuning_data->nom_best_tap_value);
2646                 break;
2647         default:
2648                 break;
2649         }
2650         spin_unlock(&host->lock);
2651         if (clk_set_for_tap_prog) {
2652                 tegra_sdhci_set_clock(host, 0);
2653                 clk_set_for_tap_prog = false;
2654         }
2655         return count;
2656 }
2657
2658 static ssize_t sdhci_show_turbo_mode(struct device *dev,
2659                         struct device_attribute *attr, char *buf)
2660 {
2661         struct sdhci_host *host = dev_get_drvdata(dev);
2662         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
2663         struct sdhci_tegra *tegra_host = pltfm_host->priv;
2664
2665         return sprintf(buf, "%d\n", tegra_host->tap_cmd);
2666 }
2667
2668 static DEVICE_ATTR(cmd_state, 0644, sdhci_show_turbo_mode,
2669                         sdhci_handle_boost_mode_tap);
2670
2671 static int tegra_sdhci_reboot_notify(struct notifier_block *nb,
2672                                 unsigned long event, void *data)
2673 {
2674         struct sdhci_tegra *tegra_host =
2675                 container_of(nb, struct sdhci_tegra, reboot_notify);
2676         int err;
2677
2678         switch (event) {
2679         case SYS_RESTART:
2680         case SYS_POWER_OFF:
2681                 err = tegra_sdhci_configure_regulators(tegra_host,
2682                         CONFIG_REG_DIS, 0, 0);
2683                 if (err)
2684                         pr_err("Disable regulator in reboot notify failed %d\n",
2685                                 err);
2686                 return NOTIFY_OK;
2687         }
2688         return NOTIFY_DONE;
2689 }
2690
2691 static struct tegra_sdhci_platform_data * __devinit sdhci_tegra_dt_parse_pdata(
2692                                                 struct platform_device *pdev)
2693 {
2694         struct tegra_sdhci_platform_data *plat;
2695         struct device_node *np = pdev->dev.of_node;
2696
2697         if (!np)
2698                 return NULL;
2699
2700         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
2701         if (!plat) {
2702                 dev_err(&pdev->dev, "Can't allocate platform data\n");
2703                 return NULL;
2704         }
2705
2706         plat->cd_gpio = of_get_named_gpio(np, "cd-gpios", 0);
2707         plat->wp_gpio = of_get_named_gpio(np, "wp-gpios", 0);
2708         plat->power_gpio = of_get_named_gpio(np, "power-gpios", 0);
2709         if (of_find_property(np, "support-8bit", NULL))
2710                 plat->is_8bit = 1;
2711
2712         return plat;
2713 }
2714
2715 static struct sdhci_ops tegra_sdhci_ops = {
2716         .get_ro     = tegra_sdhci_get_ro,
2717         .get_cd     = tegra_sdhci_get_cd,
2718         .read_l     = tegra_sdhci_readl,
2719         .read_w     = tegra_sdhci_readw,
2720         .write_l    = tegra_sdhci_writel,
2721         .write_w    = tegra_sdhci_writew,
2722         .platform_8bit_width = tegra_sdhci_8bit,
2723         .set_clock              = tegra_sdhci_set_clock,
2724         .suspend                = tegra_sdhci_suspend,
2725         .resume                 = tegra_sdhci_resume,
2726         .platform_resume        = tegra_sdhci_post_resume,
2727         .platform_reset_exit    = tegra_sdhci_reset_exit,
2728         .platform_get_bus       = tegra_sdhci_get_bus,
2729         .platform_power_off     = tegra_sdhci_power_off,
2730         .set_uhs_signaling      = tegra_sdhci_set_uhs_signaling,
2731         .switch_signal_voltage  = tegra_sdhci_signal_voltage_switch,
2732         .switch_signal_voltage_exit = tegra_sdhci_do_calibration,
2733         .execute_freq_tuning    = sdhci_tegra_execute_tuning,
2734         .sd_error_stats         = sdhci_tegra_sd_error_stats,
2735 #ifdef CONFIG_MMC_FREQ_SCALING
2736         .dfs_gov_init           = sdhci_tegra_freq_gov_init,
2737         .dfs_gov_get_target_freq        = sdhci_tegra_get_target_freq,
2738 #endif
2739 };
2740
2741 static struct sdhci_pltfm_data sdhci_tegra20_pdata = {
2742         .quirks = SDHCI_QUIRK_SINGLE_POWER_WRITE |
2743                   SDHCI_QUIRK_NO_HISPD_BIT |
2744                   SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC |
2745                   SDHCI_QUIRK_BROKEN_CARD_DETECTION,
2746         .quirks2 = SDHCI_QUIRK2_NO_CALC_MAX_DISCARD_TO,
2747         .ops  = &tegra_sdhci_ops,
2748 };
2749
2750 static struct sdhci_tegra_soc_data soc_data_tegra20 = {
2751         .pdata = &sdhci_tegra20_pdata,
2752         .nvquirks = NVQUIRK_FORCE_SDHCI_SPEC_200 |
2753                     NVQUIRK_DISABLE_AUTO_CALIBRATION |
2754                     NVQUIRK_ENABLE_BLOCK_GAP_DET,
2755         .parent_clk_list = {"pll_p"},
2756         .tuning_freq_list = {0},
2757 };
2758
2759 static struct sdhci_pltfm_data sdhci_tegra30_pdata = {
2760         .quirks = TEGRA_SDHCI_QUIRKS,
2761         .quirks2 = TEGRA_SDHCI_QUIRKS2 |
2762                 SDHCI_QUIRK2_INT_CLK_STABLE_REQ_DUMMY_REG_WRITE,
2763         .ops  = &tegra_sdhci_ops,
2764 };
2765
2766 static struct sdhci_tegra_soc_data soc_data_tegra30 = {
2767         .pdata = &sdhci_tegra30_pdata,
2768         .nvquirks = TEGRA_SDHCI_NVQUIRKS |
2769                     NVQUIRK_SET_CALIBRATION_OFFSETS |
2770                     NVQUIRK_ENABLE_SD_3_0,
2771         .parent_clk_list = {"pll_p"},
2772         .tuning_freq_list = {208000000},
2773 };
2774
2775 static struct sdhci_pltfm_data sdhci_tegra11_pdata = {
2776         .quirks = TEGRA_SDHCI_QUIRKS,
2777         .quirks2 = TEGRA_SDHCI_QUIRKS2,
2778         .ops  = &tegra_sdhci_ops,
2779 };
2780
2781 static struct sdhci_tegra_soc_data soc_data_tegra11 = {
2782         .pdata = &sdhci_tegra11_pdata,
2783         .nvquirks = TEGRA_SDHCI_NVQUIRKS |
2784                     NVQUIRK_SET_DRIVE_STRENGTH |
2785                     NVQUIRK_SET_TRIM_DELAY |
2786                     NVQUIRK_ENABLE_DDR50 |
2787                     NVQUIRK_ENABLE_HS200 |
2788                     NVQUIRK_INFINITE_ERASE_TIMEOUT,
2789         .parent_clk_list = {"pll_p", "pll_c"},
2790         .tuning_freq_list = {81600000, 156000000, 200000000},
2791 };
2792
2793 static const struct of_device_id sdhci_tegra_dt_match[] __devinitdata = {
2794         { .compatible = "nvidia,tegra114-sdhci", .data = &soc_data_tegra11 },
2795         { .compatible = "nvidia,tegra30-sdhci", .data = &soc_data_tegra30 },
2796         { .compatible = "nvidia,tegra20-sdhci", .data = &soc_data_tegra20 },
2797         {}
2798 };
2799 MODULE_DEVICE_TABLE(of, sdhci_dt_ids);
2800
2801 static int __devinit sdhci_tegra_probe(struct platform_device *pdev)
2802 {
2803         const struct of_device_id *match;
2804         struct sdhci_tegra_soc_data *soc_data;
2805         struct sdhci_host *host;
2806         struct sdhci_pltfm_host *pltfm_host;
2807         struct tegra_sdhci_platform_data *plat;
2808         struct sdhci_tegra *tegra_host;
2809         unsigned int low_freq;
2810         int rc;
2811         u8 i;
2812
2813         match = of_match_device(sdhci_tegra_dt_match, &pdev->dev);
2814         if (match) {
2815                 soc_data = match->data;
2816         } else {
2817                 /* Use id tables and remove the following chip defines */
2818 #if defined(CONFIG_ARCH_TEGRA_2x_SOC)
2819                 soc_data = &soc_data_tegra20;
2820 #elif defined(CONFIG_ARCH_TEGRA_3x_SOC)
2821                 soc_data = &soc_data_tegra30;
2822 #else
2823                 soc_data = &soc_data_tegra11;
2824 #endif
2825         }
2826
2827         host = sdhci_pltfm_init(pdev, soc_data->pdata);
2828
2829         /* delayed clock gate quirk in sdhci_host used */
2830         host->quirks2 |= SDHCI_QUIRK2_DELAYED_CLK_GATE;
2831
2832         if (IS_ERR(host))
2833                 return PTR_ERR(host);
2834
2835         pltfm_host = sdhci_priv(host);
2836
2837         plat = pdev->dev.platform_data;
2838
2839         if (plat == NULL)
2840                 plat = sdhci_tegra_dt_parse_pdata(pdev);
2841
2842         if (plat == NULL) {
2843                 dev_err(mmc_dev(host->mmc), "missing platform data\n");
2844                 rc = -ENXIO;
2845                 goto err_no_plat;
2846         }
2847
2848         tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL);
2849         if (!tegra_host) {
2850                 dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n");
2851                 rc = -ENOMEM;
2852                 goto err_no_plat;
2853         }
2854
2855         tegra_host->plat = plat;
2856         tegra_host->sd_stat_head = devm_kzalloc(&pdev->dev, sizeof(
2857                                                 struct sdhci_tegra_sd_stats),
2858                                                 GFP_KERNEL);
2859         if (tegra_host->sd_stat_head == NULL) {
2860                 rc = -ENOMEM;
2861                 goto err_no_plat;
2862         }
2863
2864         tegra_host->soc_data = soc_data;
2865
2866         pltfm_host->priv = tegra_host;
2867
2868         for (i = 0; i < ARRAY_SIZE(soc_data->parent_clk_list); i++) {
2869                 if (!soc_data->parent_clk_list[i])
2870                         continue;
2871                 if (!strcmp(soc_data->parent_clk_list[i], "pll_c")) {
2872                         pll_c = clk_get_sys(NULL, "pll_c");
2873                         if (IS_ERR(pll_c)) {
2874                                 rc = PTR_ERR(pll_c);
2875                                 dev_err(mmc_dev(host->mmc),
2876                                         "clk error in getting pll_c: %d\n", rc);
2877                         }
2878                         pll_c_rate = clk_get_rate(pll_c);
2879                 }
2880
2881                 if (!strcmp(soc_data->parent_clk_list[i], "pll_p")) {
2882                         pll_p = clk_get_sys(NULL, "pll_p");
2883                         if (IS_ERR(pll_p)) {
2884                                 rc = PTR_ERR(pll_p);
2885                                 dev_err(mmc_dev(host->mmc),
2886                                         "clk error in getting pll_p: %d\n", rc);
2887                         }
2888                         pll_p_rate = clk_get_rate(pll_p);
2889                 }
2890         }
2891
2892 #ifdef CONFIG_MMC_EMBEDDED_SDIO
2893         if (plat->mmc_data.embedded_sdio)
2894                 mmc_set_embedded_sdio_data(host->mmc,
2895                         &plat->mmc_data.embedded_sdio->cis,
2896                         &plat->mmc_data.embedded_sdio->cccr,
2897                         plat->mmc_data.embedded_sdio->funcs,
2898                         plat->mmc_data.embedded_sdio->num_funcs);
2899 #endif
2900
2901         if (gpio_is_valid(plat->power_gpio)) {
2902                 rc = gpio_request(plat->power_gpio, "sdhci_power");
2903                 if (rc) {
2904                         dev_err(mmc_dev(host->mmc),
2905                                 "failed to allocate power gpio\n");
2906                         goto err_power_req;
2907                 }
2908                 gpio_direction_output(plat->power_gpio, 1);
2909         }
2910
2911         if (gpio_is_valid(plat->cd_gpio)) {
2912                 rc = gpio_request(plat->cd_gpio, "sdhci_cd");
2913                 if (rc) {
2914                         dev_err(mmc_dev(host->mmc),
2915                                 "failed to allocate cd gpio\n");
2916                         goto err_cd_req;
2917                 }
2918                 gpio_direction_input(plat->cd_gpio);
2919
2920                 tegra_host->card_present = (gpio_get_value(plat->cd_gpio) == 0);
2921
2922                 rc = request_threaded_irq(gpio_to_irq(plat->cd_gpio), NULL,
2923                                  carddetect_irq,
2924                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
2925                                  mmc_hostname(host->mmc), host);
2926
2927                 if (rc) {
2928                         dev_err(mmc_dev(host->mmc), "request irq error\n");
2929                         goto err_cd_irq_req;
2930                 }
2931                 rc = enable_irq_wake(gpio_to_irq(plat->cd_gpio));
2932                 if (rc < 0)
2933                         dev_err(mmc_dev(host->mmc),
2934                                 "SD card wake-up event registration"
2935                                         "failed with eroor: %d\n", rc);
2936
2937         } else if (plat->mmc_data.register_status_notify) {
2938                 plat->mmc_data.register_status_notify(sdhci_status_notify_cb, host);
2939         }
2940
2941         if (plat->mmc_data.status) {
2942                 plat->mmc_data.card_present = plat->mmc_data.status(mmc_dev(host->mmc));
2943         }
2944
2945         if (gpio_is_valid(plat->wp_gpio)) {
2946                 rc = gpio_request(plat->wp_gpio, "sdhci_wp");
2947                 if (rc) {
2948                         dev_err(mmc_dev(host->mmc),
2949                                 "failed to allocate wp gpio\n");
2950                         goto err_wp_req;
2951                 }
2952                 gpio_direction_input(plat->wp_gpio);
2953         }
2954
2955         /*
2956          * If there is no card detect gpio, assume that the
2957          * card is always present.
2958          */
2959         if (!gpio_is_valid(plat->cd_gpio))
2960                 tegra_host->card_present = 1;
2961
2962         if (plat->mmc_data.ocr_mask & SDHOST_1V8_OCR_MASK) {
2963                 tegra_host->vddio_min_uv = SDHOST_LOW_VOLT_MIN;
2964                 tegra_host->vddio_max_uv = SDHOST_LOW_VOLT_MAX;
2965         } else if (plat->mmc_data.ocr_mask & MMC_OCR_2V8_MASK) {
2966                         tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_2V8;
2967                         tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
2968         } else {
2969                 /*
2970                  * Set the minV and maxV to default
2971                  * voltage range of 2.7V - 3.6V
2972                  */
2973                 tegra_host->vddio_min_uv = SDHOST_HIGH_VOLT_MIN;
2974                 tegra_host->vddio_max_uv = SDHOST_HIGH_VOLT_MAX;
2975         }
2976
2977         tegra_host->vdd_io_reg = regulator_get(mmc_dev(host->mmc),
2978                                                         "vddio_sdmmc");
2979         if (IS_ERR_OR_NULL(tegra_host->vdd_io_reg)) {
2980                 dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
2981                         "Assuming vddio_sdmmc is not required.\n",
2982                         "vddio_sdmmc", PTR_ERR(tegra_host->vdd_io_reg));
2983                 tegra_host->vdd_io_reg = NULL;
2984         } else {
2985                 rc = tegra_sdhci_configure_regulators(tegra_host,
2986                         CONFIG_REG_SET_VOLT,
2987                         tegra_host->vddio_min_uv,
2988                         tegra_host->vddio_max_uv);
2989                 if (rc) {
2990                         dev_err(mmc_dev(host->mmc),
2991                                 "Init volt(%duV-%duV) setting failed %d\n",
2992                                 tegra_host->vddio_min_uv,
2993                                 tegra_host->vddio_max_uv, rc);
2994                         regulator_put(tegra_host->vdd_io_reg);
2995                         tegra_host->vdd_io_reg = NULL;
2996                 }
2997         }
2998
2999         tegra_host->vdd_slot_reg = regulator_get(mmc_dev(host->mmc),
3000                                                         "vddio_sd_slot");
3001         if (IS_ERR_OR_NULL(tegra_host->vdd_slot_reg)) {
3002                 dev_info(mmc_dev(host->mmc), "%s regulator not found: %ld."
3003                         " Assuming vddio_sd_slot is not required.\n",
3004                         "vddio_sd_slot", PTR_ERR(tegra_host->vdd_slot_reg));
3005                 tegra_host->vdd_slot_reg = NULL;
3006         }
3007
3008         if (tegra_host->card_present) {
3009                 rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_EN,
3010                         0, 0);
3011                 if (rc) {
3012                         dev_err(mmc_dev(host->mmc),
3013                                 "Enable regulators failed in probe %d\n", rc);
3014                         goto err_clk_get;
3015                 }
3016         }
3017
3018         pm_runtime_enable(&pdev->dev);
3019         pltfm_host->clk = clk_get(mmc_dev(host->mmc), NULL);
3020         if (IS_ERR(pltfm_host->clk)) {
3021                 dev_err(mmc_dev(host->mmc), "clk err\n");
3022                 rc = PTR_ERR(pltfm_host->clk);
3023                 goto err_clk_get;
3024         }
3025
3026         if (clk_get_parent(pltfm_host->clk) == pll_c)
3027                 tegra_host->is_parent_pllc = true;
3028
3029         pm_runtime_get_sync(&pdev->dev);
3030         rc = clk_prepare_enable(pltfm_host->clk);
3031         if (rc != 0)
3032                 goto err_clk_put;
3033
3034         if (!strcmp(dev_name(mmc_dev(host->mmc)), "sdhci-tegra.0")) {
3035                 tegra_host->emc_clk = clk_get(mmc_dev(host->mmc), "emc");
3036                 if (IS_ERR(tegra_host->emc_clk)) {
3037                         dev_err(mmc_dev(host->mmc), "clk err\n");
3038                         rc = PTR_ERR(tegra_host->emc_clk);
3039                         goto err_clk_put;
3040                 } else
3041                         clk_set_rate(tegra_host->emc_clk, SDMMC_EMC_MAX_FREQ);
3042         }
3043
3044         tegra_host->sclk = devm_clk_get(mmc_dev(host->mmc), "sclk");
3045         if (IS_ERR_OR_NULL(tegra_host->sclk)) {
3046                 dev_err(mmc_dev(host->mmc), "Can't get sclk clock\n");
3047                 tegra_host->sclk = NULL;
3048         } else {
3049                 clk_set_rate(tegra_host->sclk, SDMMC_AHB_MAX_FREQ);
3050         }
3051
3052         pltfm_host->priv = tegra_host;
3053         tegra_host->clk_enabled = true;
3054         host->is_clk_on = tegra_host->clk_enabled;
3055         tegra_host->max_clk_limit = plat->max_clk_limit;
3056         tegra_host->ddr_clk_limit = plat->ddr_clk_limit;
3057         tegra_host->sd_detect_in_suspend = plat->sd_detect_in_suspend;
3058         tegra_host->instance = pdev->id;
3059         tegra_host->tap_cmd = TAP_CMD_TRIM_DEFAULT_VOLTAGE;
3060         host->mmc->pm_caps |= plat->pm_caps;
3061         host->mmc->pm_flags |= plat->pm_flags;
3062
3063         host->mmc->caps |= MMC_CAP_ERASE;
3064         /* enable 1/8V DDR capable */
3065         host->mmc->caps |= MMC_CAP_1_8V_DDR;
3066         if (plat->is_8bit)
3067                 host->mmc->caps |= MMC_CAP_8_BIT_DATA;
3068         host->mmc->caps |= MMC_CAP_SDIO_IRQ;
3069         host->mmc->pm_caps |= MMC_PM_KEEP_POWER | MMC_PM_IGNORE_PM_NOTIFY;
3070         if (plat->mmc_data.built_in) {
3071                 host->mmc->caps |= MMC_CAP_NONREMOVABLE;
3072         }
3073         host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
3074
3075 #ifdef CONFIG_MMC_BKOPS
3076         host->mmc->caps2 |= MMC_CAP2_BKOPS;
3077 #endif
3078         if (soc_data->nvquirks & NVQUIRK_ENABLE_HS200)
3079                 host->mmc->caps2 |= MMC_CAP2_HS200;
3080         host->mmc->caps2 |= MMC_CAP2_CACHE_CTRL;
3081         host->mmc->caps |= MMC_CAP_CMD23;
3082         host->mmc->caps2 |= MMC_CAP2_PACKED_CMD;
3083
3084         /*
3085          * Enable dyamic frequency scaling support only if the platform clock
3086          * limit is higher than the lowest supported frequency by tuning.
3087          */
3088         for (i = 0; i < TUNING_FREQ_COUNT; i++) {
3089                 low_freq = soc_data->tuning_freq_list[i];
3090                 if (low_freq)
3091                         break;
3092         }
3093         if (plat->en_freq_scaling && (plat->max_clk_limit > low_freq))
3094                 host->mmc->caps2 |= MMC_CAP2_FREQ_SCALING;
3095
3096         if (plat->nominal_vcore_mv)
3097                 tegra_host->nominal_vcore_mv = plat->nominal_vcore_mv;
3098         if (plat->min_vcore_override_mv)
3099                 tegra_host->min_vcore_override_mv = plat->min_vcore_override_mv;
3100         if (plat->boot_vcore_mv)
3101                 tegra_host->boot_vcore_mv = plat->boot_vcore_mv;
3102         dev_info(mmc_dev(host->mmc),
3103                 "Tuning constraints: nom_mv %d, boot_mv %d, min_or_mv %d\n",
3104                 tegra_host->nominal_vcore_mv, tegra_host->boot_vcore_mv,
3105                 tegra_host->min_vcore_override_mv);
3106
3107         /*
3108          * If nominal voltage is equal to boot voltage, there is no need for
3109          * nominal voltage tuning.
3110          */
3111         if (plat->nominal_vcore_mv <= plat->boot_vcore_mv)
3112                 plat->en_nominal_vcore_tuning = false;
3113
3114         host->edp_support = plat->edp_support ? true : false;
3115         if (host->edp_support)
3116                 for (rc = 0; rc < SD_EDP_NUM_STATES; rc++)
3117                         host->edp_states[rc] = plat->edp_states[rc];
3118
3119         rc = sdhci_add_host(host);
3120
3121         device_create_file(&pdev->dev, &dev_attr_cmd_state);
3122
3123         INIT_DELAYED_WORK(&host->delayed_clk_gate_wrk, delayed_clk_gate_cb);
3124
3125         sdhci_tegra_error_stats_debugfs(host);
3126         if (rc)
3127                 goto err_add_host;
3128
3129         /* Enable async suspend/resume to reduce LP0 latency */
3130         device_enable_async_suspend(&pdev->dev);
3131
3132         if (plat->power_off_rail) {
3133                 tegra_host->reboot_notify.notifier_call =
3134                         tegra_sdhci_reboot_notify;
3135                 register_reboot_notifier(&tegra_host->reboot_notify);
3136         }
3137         return 0;
3138
3139 err_add_host:
3140         clk_put(tegra_host->emc_clk);
3141         clk_disable_unprepare(pltfm_host->clk);
3142         pm_runtime_put_sync(&pdev->dev);
3143 err_clk_put:
3144         clk_put(pltfm_host->clk);
3145 err_clk_get:
3146         if (gpio_is_valid(plat->wp_gpio))
3147                 gpio_free(plat->wp_gpio);
3148 err_wp_req:
3149         if (gpio_is_valid(plat->cd_gpio))
3150                 free_irq(gpio_to_irq(plat->cd_gpio), host);
3151 err_cd_irq_req:
3152         if (gpio_is_valid(plat->cd_gpio))
3153                 gpio_free(plat->cd_gpio);
3154 err_cd_req:
3155         if (gpio_is_valid(plat->power_gpio))
3156                 gpio_free(plat->power_gpio);
3157 err_power_req:
3158 err_no_plat:
3159         sdhci_pltfm_free(pdev);
3160         return rc;
3161 }
3162
3163 static int __devexit sdhci_tegra_remove(struct platform_device *pdev)
3164 {
3165         struct sdhci_host *host = platform_get_drvdata(pdev);
3166         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
3167         struct sdhci_tegra *tegra_host = pltfm_host->priv;
3168         const struct tegra_sdhci_platform_data *plat = tegra_host->plat;
3169         int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);
3170         int rc = 0;
3171
3172         sdhci_remove_host(host, dead);
3173
3174         disable_irq_wake(gpio_to_irq(plat->cd_gpio));
3175
3176         rc = tegra_sdhci_configure_regulators(tegra_host, CONFIG_REG_DIS, 0, 0);
3177         if (rc)
3178                 dev_err(mmc_dev(host->mmc),
3179                         "Regulator disable in remove failed %d\n", rc);
3180
3181         if (tegra_host->vdd_slot_reg)
3182                 regulator_put(tegra_host->vdd_slot_reg);
3183         if (tegra_host->vdd_io_reg)
3184                 regulator_put(tegra_host->vdd_io_reg);
3185
3186         if (gpio_is_valid(plat->wp_gpio))
3187                 gpio_free(plat->wp_gpio);
3188
3189         if (gpio_is_valid(plat->cd_gpio)) {
3190                 free_irq(gpio_to_irq(plat->cd_gpio), host);
3191                 gpio_free(plat->cd_gpio);
3192         }
3193
3194         if (gpio_is_valid(plat->power_gpio))
3195                 gpio_free(plat->power_gpio);
3196
3197         if (tegra_host->clk_enabled) {
3198                 clk_disable_unprepare(pltfm_host->clk);
3199                 pm_runtime_put_sync(&pdev->dev);
3200         }
3201         clk_put(pltfm_host->clk);
3202
3203         if (tegra_host->emc_clk && tegra_host->emc_clk_enabled)
3204                 clk_disable_unprepare(tegra_host->emc_clk);
3205         if (tegra_host->sclk && tegra_host->is_sdmmc_sclk_on)
3206                 clk_disable_unprepare(tegra_host->sclk);
3207
3208         if (plat->power_off_rail)
3209                 unregister_reboot_notifier(&tegra_host->reboot_notify);
3210
3211         sdhci_pltfm_free(pdev);
3212
3213         return rc;
3214 }
3215
3216 static struct platform_driver sdhci_tegra_driver = {
3217         .driver         = {
3218                 .name   = "sdhci-tegra",
3219                 .owner  = THIS_MODULE,
3220                 .of_match_table = sdhci_tegra_dt_match,
3221                 .pm     = SDHCI_PLTFM_PMOPS,
3222         },
3223         .probe          = sdhci_tegra_probe,
3224         .remove         = __devexit_p(sdhci_tegra_remove),
3225 };
3226
3227 module_platform_driver(sdhci_tegra_driver);
3228
3229 MODULE_DESCRIPTION("SDHCI driver for Tegra");
3230 MODULE_AUTHOR("Google, Inc.");
3231 MODULE_LICENSE("GPL v2");