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