197fb5e8dSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 20eb0d9f4SGeorgi Djakov /* 30eb0d9f4SGeorgi Djakov * drivers/mmc/host/sdhci-msm.c - Qualcomm SDHCI Platform driver 40eb0d9f4SGeorgi Djakov * 50eb0d9f4SGeorgi Djakov * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved. 60eb0d9f4SGeorgi Djakov */ 70eb0d9f4SGeorgi Djakov 80eb0d9f4SGeorgi Djakov #include <linux/module.h> 90eb0d9f4SGeorgi Djakov #include <linux/of_device.h> 100eb0d9f4SGeorgi Djakov #include <linux/delay.h> 11415b5a75SGeorgi Djakov #include <linux/mmc/mmc.h> 1267e6db11SPramod Gurav #include <linux/pm_runtime.h> 13415b5a75SGeorgi Djakov #include <linux/slab.h> 14cc392c58SRitesh Harjani #include <linux/iopoll.h> 15ac06fba1SVijay Viswanath #include <linux/regulator/consumer.h> 160eb0d9f4SGeorgi Djakov 170eb0d9f4SGeorgi Djakov #include "sdhci-pltfm.h" 1887a8df0dSRitesh Harjani #include "cqhci.h" 190eb0d9f4SGeorgi Djakov 203a3ad3e9SGeorgi Djakov #define CORE_MCI_VERSION 0x50 213a3ad3e9SGeorgi Djakov #define CORE_VERSION_MAJOR_SHIFT 28 223a3ad3e9SGeorgi Djakov #define CORE_VERSION_MAJOR_MASK (0xf << CORE_VERSION_MAJOR_SHIFT) 233a3ad3e9SGeorgi Djakov #define CORE_VERSION_MINOR_MASK 0xff 243a3ad3e9SGeorgi Djakov 2552884f8fSBjorn Andersson #define CORE_MCI_GENERICS 0x70 2652884f8fSBjorn Andersson #define SWITCHABLE_SIGNALING_VOLTAGE BIT(29) 2752884f8fSBjorn Andersson 280eb0d9f4SGeorgi Djakov #define HC_MODE_EN 0x1 290eb0d9f4SGeorgi Djakov #define CORE_POWER 0x0 300eb0d9f4SGeorgi Djakov #define CORE_SW_RST BIT(7) 31ff06ce41SVenkat Gopalakrishnan #define FF_CLK_SW_RST_DIS BIT(13) 320eb0d9f4SGeorgi Djakov 33ad81d387SGeorgi Djakov #define CORE_PWRCTL_BUS_OFF BIT(0) 34ad81d387SGeorgi Djakov #define CORE_PWRCTL_BUS_ON BIT(1) 35ad81d387SGeorgi Djakov #define CORE_PWRCTL_IO_LOW BIT(2) 36ad81d387SGeorgi Djakov #define CORE_PWRCTL_IO_HIGH BIT(3) 37ad81d387SGeorgi Djakov #define CORE_PWRCTL_BUS_SUCCESS BIT(0) 38ad81d387SGeorgi Djakov #define CORE_PWRCTL_IO_SUCCESS BIT(2) 39ad81d387SGeorgi Djakov #define REQ_BUS_OFF BIT(0) 40ad81d387SGeorgi Djakov #define REQ_BUS_ON BIT(1) 41ad81d387SGeorgi Djakov #define REQ_IO_LOW BIT(2) 42ad81d387SGeorgi Djakov #define REQ_IO_HIGH BIT(3) 43ad81d387SGeorgi Djakov #define INT_MASK 0xf 44415b5a75SGeorgi Djakov #define MAX_PHASES 16 45415b5a75SGeorgi Djakov #define CORE_DLL_LOCK BIT(7) 4602e4293dSRitesh Harjani #define CORE_DDR_DLL_LOCK BIT(11) 47415b5a75SGeorgi Djakov #define CORE_DLL_EN BIT(16) 48415b5a75SGeorgi Djakov #define CORE_CDR_EN BIT(17) 49415b5a75SGeorgi Djakov #define CORE_CK_OUT_EN BIT(18) 50415b5a75SGeorgi Djakov #define CORE_CDR_EXT_EN BIT(19) 51415b5a75SGeorgi Djakov #define CORE_DLL_PDN BIT(29) 52415b5a75SGeorgi Djakov #define CORE_DLL_RST BIT(30) 53cc392c58SRitesh Harjani #define CORE_CMD_DAT_TRACK_SEL BIT(0) 54415b5a75SGeorgi Djakov 5502e4293dSRitesh Harjani #define CORE_DDR_CAL_EN BIT(0) 5683736352SVenkat Gopalakrishnan #define CORE_FLL_CYCLE_CNT BIT(18) 5783736352SVenkat Gopalakrishnan #define CORE_DLL_CLOCK_DISABLE BIT(21) 5883736352SVenkat Gopalakrishnan 595574ddccSVenkat Gopalakrishnan #define CORE_VENDOR_SPEC_POR_VAL 0xa1c 60415b5a75SGeorgi Djakov #define CORE_CLK_PWRSAVE BIT(1) 61ff06ce41SVenkat Gopalakrishnan #define CORE_HC_MCLK_SEL_DFLT (2 << 8) 62ff06ce41SVenkat Gopalakrishnan #define CORE_HC_MCLK_SEL_HS400 (3 << 8) 63ff06ce41SVenkat Gopalakrishnan #define CORE_HC_MCLK_SEL_MASK (3 << 8) 645c132323SVijay Viswanath #define CORE_IO_PAD_PWR_SWITCH_EN (1 << 15) 655c132323SVijay Viswanath #define CORE_IO_PAD_PWR_SWITCH (1 << 16) 66ff06ce41SVenkat Gopalakrishnan #define CORE_HC_SELECT_IN_EN BIT(18) 67ff06ce41SVenkat Gopalakrishnan #define CORE_HC_SELECT_IN_HS400 (6 << 19) 68ff06ce41SVenkat Gopalakrishnan #define CORE_HC_SELECT_IN_MASK (7 << 19) 69415b5a75SGeorgi Djakov 70ac06fba1SVijay Viswanath #define CORE_3_0V_SUPPORT (1 << 25) 71ac06fba1SVijay Viswanath #define CORE_1_8V_SUPPORT (1 << 26) 725c132323SVijay Viswanath #define CORE_VOLT_SUPPORT (CORE_3_0V_SUPPORT | CORE_1_8V_SUPPORT) 73ac06fba1SVijay Viswanath 74cc392c58SRitesh Harjani #define CORE_CSR_CDC_CTLR_CFG0 0x130 75cc392c58SRitesh Harjani #define CORE_SW_TRIG_FULL_CALIB BIT(16) 76cc392c58SRitesh Harjani #define CORE_HW_AUTOCAL_ENA BIT(17) 77cc392c58SRitesh Harjani 78cc392c58SRitesh Harjani #define CORE_CSR_CDC_CTLR_CFG1 0x134 79cc392c58SRitesh Harjani #define CORE_CSR_CDC_CAL_TIMER_CFG0 0x138 80cc392c58SRitesh Harjani #define CORE_TIMER_ENA BIT(16) 81cc392c58SRitesh Harjani 82cc392c58SRitesh Harjani #define CORE_CSR_CDC_CAL_TIMER_CFG1 0x13C 83cc392c58SRitesh Harjani #define CORE_CSR_CDC_REFCOUNT_CFG 0x140 84cc392c58SRitesh Harjani #define CORE_CSR_CDC_COARSE_CAL_CFG 0x144 85cc392c58SRitesh Harjani #define CORE_CDC_OFFSET_CFG 0x14C 86cc392c58SRitesh Harjani #define CORE_CSR_CDC_DELAY_CFG 0x150 87cc392c58SRitesh Harjani #define CORE_CDC_SLAVE_DDA_CFG 0x160 88cc392c58SRitesh Harjani #define CORE_CSR_CDC_STATUS0 0x164 89cc392c58SRitesh Harjani #define CORE_CALIBRATION_DONE BIT(0) 90cc392c58SRitesh Harjani 91cc392c58SRitesh Harjani #define CORE_CDC_ERROR_CODE_MASK 0x7000000 92cc392c58SRitesh Harjani 93cc392c58SRitesh Harjani #define CORE_CSR_CDC_GEN_CFG 0x178 94cc392c58SRitesh Harjani #define CORE_CDC_SWITCH_BYPASS_OFF BIT(0) 95cc392c58SRitesh Harjani #define CORE_CDC_SWITCH_RC_EN BIT(1) 96cc392c58SRitesh Harjani 97cc392c58SRitesh Harjani #define CORE_CDC_T4_DLY_SEL BIT(0) 9844bf2312SRitesh Harjani #define CORE_CMDIN_RCLK_EN BIT(1) 99cc392c58SRitesh Harjani #define CORE_START_CDC_TRAFFIC BIT(6) 100bc99266bSSayali Lokhande 10102e4293dSRitesh Harjani #define CORE_PWRSAVE_DLL BIT(3) 10202e4293dSRitesh Harjani 103fa56ac97SVeerabhadrarao Badiganti #define DDR_CONFIG_POR_VAL 0x80040873 104cc392c58SRitesh Harjani 1053a3ad3e9SGeorgi Djakov 106abf270e5SRitesh Harjani #define INVALID_TUNING_PHASE -1 10780031bdeSRitesh Harjani #define SDHCI_MSM_MIN_CLOCK 400000 108ff06ce41SVenkat Gopalakrishnan #define CORE_FREQ_100MHZ (100 * 1000 * 1000) 10980031bdeSRitesh Harjani 110415b5a75SGeorgi Djakov #define CDR_SELEXT_SHIFT 20 111415b5a75SGeorgi Djakov #define CDR_SELEXT_MASK (0xf << CDR_SELEXT_SHIFT) 112415b5a75SGeorgi Djakov #define CMUX_SHIFT_PHASE_SHIFT 24 113415b5a75SGeorgi Djakov #define CMUX_SHIFT_PHASE_MASK (7 << CMUX_SHIFT_PHASE_SHIFT) 114415b5a75SGeorgi Djakov 11567e6db11SPramod Gurav #define MSM_MMC_AUTOSUSPEND_DELAY_MS 50 116c0309b38SVijay Viswanath 117c0309b38SVijay Viswanath /* Timeout value to avoid infinite waiting for pwr_irq */ 118c0309b38SVijay Viswanath #define MSM_PWR_IRQ_TIMEOUT_MS 5000 119c0309b38SVijay Viswanath 120bc99266bSSayali Lokhande #define msm_host_readl(msm_host, host, offset) \ 121bc99266bSSayali Lokhande msm_host->var_ops->msm_readl_relaxed(host, offset) 122bc99266bSSayali Lokhande 123bc99266bSSayali Lokhande #define msm_host_writel(msm_host, val, host, offset) \ 124bc99266bSSayali Lokhande msm_host->var_ops->msm_writel_relaxed(val, host, offset) 125bc99266bSSayali Lokhande 12687a8df0dSRitesh Harjani /* CQHCI vendor specific registers */ 12787a8df0dSRitesh Harjani #define CQHCI_VENDOR_CFG1 0xA00 12887a8df0dSRitesh Harjani #define CQHCI_VENDOR_DIS_RST_ON_CQ_EN (0x3 << 13) 12987a8df0dSRitesh Harjani 130f1535888SSayali Lokhande struct sdhci_msm_offset { 131f1535888SSayali Lokhande u32 core_hc_mode; 132f1535888SSayali Lokhande u32 core_mci_data_cnt; 133f1535888SSayali Lokhande u32 core_mci_status; 134f1535888SSayali Lokhande u32 core_mci_fifo_cnt; 135f1535888SSayali Lokhande u32 core_mci_version; 136f1535888SSayali Lokhande u32 core_generics; 137f1535888SSayali Lokhande u32 core_testbus_config; 138f1535888SSayali Lokhande u32 core_testbus_sel2_bit; 139f1535888SSayali Lokhande u32 core_testbus_ena; 140f1535888SSayali Lokhande u32 core_testbus_sel2; 141f1535888SSayali Lokhande u32 core_pwrctl_status; 142f1535888SSayali Lokhande u32 core_pwrctl_mask; 143f1535888SSayali Lokhande u32 core_pwrctl_clear; 144f1535888SSayali Lokhande u32 core_pwrctl_ctl; 145f1535888SSayali Lokhande u32 core_sdcc_debug_reg; 146f1535888SSayali Lokhande u32 core_dll_config; 147f1535888SSayali Lokhande u32 core_dll_status; 148f1535888SSayali Lokhande u32 core_vendor_spec; 149f1535888SSayali Lokhande u32 core_vendor_spec_adma_err_addr0; 150f1535888SSayali Lokhande u32 core_vendor_spec_adma_err_addr1; 151f1535888SSayali Lokhande u32 core_vendor_spec_func2; 152f1535888SSayali Lokhande u32 core_vendor_spec_capabilities0; 153f1535888SSayali Lokhande u32 core_ddr_200_cfg; 154f1535888SSayali Lokhande u32 core_vendor_spec3; 155f1535888SSayali Lokhande u32 core_dll_config_2; 156fa56ac97SVeerabhadrarao Badiganti u32 core_dll_config_3; 157fa56ac97SVeerabhadrarao Badiganti u32 core_ddr_config_old; /* Applicable to sdcc minor ver < 0x49 */ 158f1535888SSayali Lokhande u32 core_ddr_config; 159f1535888SSayali Lokhande }; 160f1535888SSayali Lokhande 161f1535888SSayali Lokhande static const struct sdhci_msm_offset sdhci_msm_v5_offset = { 162f1535888SSayali Lokhande .core_mci_data_cnt = 0x35c, 163f1535888SSayali Lokhande .core_mci_status = 0x324, 164f1535888SSayali Lokhande .core_mci_fifo_cnt = 0x308, 165f1535888SSayali Lokhande .core_mci_version = 0x318, 166f1535888SSayali Lokhande .core_generics = 0x320, 167f1535888SSayali Lokhande .core_testbus_config = 0x32c, 168f1535888SSayali Lokhande .core_testbus_sel2_bit = 3, 169f1535888SSayali Lokhande .core_testbus_ena = (1 << 31), 170f1535888SSayali Lokhande .core_testbus_sel2 = (1 << 3), 171f1535888SSayali Lokhande .core_pwrctl_status = 0x240, 172f1535888SSayali Lokhande .core_pwrctl_mask = 0x244, 173f1535888SSayali Lokhande .core_pwrctl_clear = 0x248, 174f1535888SSayali Lokhande .core_pwrctl_ctl = 0x24c, 175f1535888SSayali Lokhande .core_sdcc_debug_reg = 0x358, 176f1535888SSayali Lokhande .core_dll_config = 0x200, 177f1535888SSayali Lokhande .core_dll_status = 0x208, 178f1535888SSayali Lokhande .core_vendor_spec = 0x20c, 179f1535888SSayali Lokhande .core_vendor_spec_adma_err_addr0 = 0x214, 180f1535888SSayali Lokhande .core_vendor_spec_adma_err_addr1 = 0x218, 181f1535888SSayali Lokhande .core_vendor_spec_func2 = 0x210, 182f1535888SSayali Lokhande .core_vendor_spec_capabilities0 = 0x21c, 183f1535888SSayali Lokhande .core_ddr_200_cfg = 0x224, 184f1535888SSayali Lokhande .core_vendor_spec3 = 0x250, 185f1535888SSayali Lokhande .core_dll_config_2 = 0x254, 186fa56ac97SVeerabhadrarao Badiganti .core_dll_config_3 = 0x258, 187fa56ac97SVeerabhadrarao Badiganti .core_ddr_config = 0x25c, 188f1535888SSayali Lokhande }; 189f1535888SSayali Lokhande 190f1535888SSayali Lokhande static const struct sdhci_msm_offset sdhci_msm_mci_offset = { 191f1535888SSayali Lokhande .core_hc_mode = 0x78, 192f1535888SSayali Lokhande .core_mci_data_cnt = 0x30, 193f1535888SSayali Lokhande .core_mci_status = 0x34, 194f1535888SSayali Lokhande .core_mci_fifo_cnt = 0x44, 195f1535888SSayali Lokhande .core_mci_version = 0x050, 196f1535888SSayali Lokhande .core_generics = 0x70, 197f1535888SSayali Lokhande .core_testbus_config = 0x0cc, 198f1535888SSayali Lokhande .core_testbus_sel2_bit = 4, 199f1535888SSayali Lokhande .core_testbus_ena = (1 << 3), 200f1535888SSayali Lokhande .core_testbus_sel2 = (1 << 4), 201f1535888SSayali Lokhande .core_pwrctl_status = 0xdc, 202f1535888SSayali Lokhande .core_pwrctl_mask = 0xe0, 203f1535888SSayali Lokhande .core_pwrctl_clear = 0xe4, 204f1535888SSayali Lokhande .core_pwrctl_ctl = 0xe8, 205f1535888SSayali Lokhande .core_sdcc_debug_reg = 0x124, 206f1535888SSayali Lokhande .core_dll_config = 0x100, 207f1535888SSayali Lokhande .core_dll_status = 0x108, 208f1535888SSayali Lokhande .core_vendor_spec = 0x10c, 209f1535888SSayali Lokhande .core_vendor_spec_adma_err_addr0 = 0x114, 210f1535888SSayali Lokhande .core_vendor_spec_adma_err_addr1 = 0x118, 211f1535888SSayali Lokhande .core_vendor_spec_func2 = 0x110, 212f1535888SSayali Lokhande .core_vendor_spec_capabilities0 = 0x11c, 213f1535888SSayali Lokhande .core_ddr_200_cfg = 0x184, 214f1535888SSayali Lokhande .core_vendor_spec3 = 0x1b0, 215f1535888SSayali Lokhande .core_dll_config_2 = 0x1b4, 216fa56ac97SVeerabhadrarao Badiganti .core_ddr_config_old = 0x1b8, 217fa56ac97SVeerabhadrarao Badiganti .core_ddr_config = 0x1bc, 218f1535888SSayali Lokhande }; 219f1535888SSayali Lokhande 2206ed4bb43SVijay Viswanath struct sdhci_msm_variant_ops { 2216ed4bb43SVijay Viswanath u32 (*msm_readl_relaxed)(struct sdhci_host *host, u32 offset); 2226ed4bb43SVijay Viswanath void (*msm_writel_relaxed)(u32 val, struct sdhci_host *host, 2236ed4bb43SVijay Viswanath u32 offset); 2246ed4bb43SVijay Viswanath }; 2256ed4bb43SVijay Viswanath 2266ed4bb43SVijay Viswanath /* 2276ed4bb43SVijay Viswanath * From V5, register spaces have changed. Wrap this info in a structure 2286ed4bb43SVijay Viswanath * and choose the data_structure based on version info mentioned in DT. 2296ed4bb43SVijay Viswanath */ 2306ed4bb43SVijay Viswanath struct sdhci_msm_variant_info { 2316ed4bb43SVijay Viswanath bool mci_removed; 23221f1e2d4SVeerabhadrarao Badiganti bool restore_dll_config; 2336ed4bb43SVijay Viswanath const struct sdhci_msm_variant_ops *var_ops; 2346ed4bb43SVijay Viswanath const struct sdhci_msm_offset *offset; 2356ed4bb43SVijay Viswanath }; 2366ed4bb43SVijay Viswanath 2370eb0d9f4SGeorgi Djakov struct sdhci_msm_host { 2380eb0d9f4SGeorgi Djakov struct platform_device *pdev; 2390eb0d9f4SGeorgi Djakov void __iomem *core_mem; /* MSM SDCC mapped address */ 240ad81d387SGeorgi Djakov int pwr_irq; /* power irq */ 2410eb0d9f4SGeorgi Djakov struct clk *bus_clk; /* SDHC bus voter clock */ 24283736352SVenkat Gopalakrishnan struct clk *xo_clk; /* TCXO clk needed for FLL feature of cm_dll*/ 2434946b3afSBjorn Andersson struct clk_bulk_data bulk_clks[4]; /* core, iface, cal, sleep clocks */ 244edc609fdSRitesh Harjani unsigned long clk_rate; 2450eb0d9f4SGeorgi Djakov struct mmc_host *mmc; 24683736352SVenkat Gopalakrishnan bool use_14lpp_dll_reset; 247ff06ce41SVenkat Gopalakrishnan bool tuning_done; 248ff06ce41SVenkat Gopalakrishnan bool calibration_done; 249abf270e5SRitesh Harjani u8 saved_tuning_phase; 25002e4293dSRitesh Harjani bool use_cdclp533; 251c0309b38SVijay Viswanath u32 curr_pwr_state; 252c0309b38SVijay Viswanath u32 curr_io_level; 253c0309b38SVijay Viswanath wait_queue_head_t pwr_irq_wait; 254c0309b38SVijay Viswanath bool pwr_irq_flag; 255ac06fba1SVijay Viswanath u32 caps_0; 2566ed4bb43SVijay Viswanath bool mci_removed; 25721f1e2d4SVeerabhadrarao Badiganti bool restore_dll_config; 2586ed4bb43SVijay Viswanath const struct sdhci_msm_variant_ops *var_ops; 2596ed4bb43SVijay Viswanath const struct sdhci_msm_offset *offset; 260a89e7bcbSLoic Poulain bool use_cdr; 261a89e7bcbSLoic Poulain u32 transfer_mode; 262fa56ac97SVeerabhadrarao Badiganti bool updated_ddr_cfg; 2630eb0d9f4SGeorgi Djakov }; 2640eb0d9f4SGeorgi Djakov 265bc99266bSSayali Lokhande static const struct sdhci_msm_offset *sdhci_priv_msm_offset(struct sdhci_host *host) 266bc99266bSSayali Lokhande { 267bc99266bSSayali Lokhande struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 268bc99266bSSayali Lokhande struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 269bc99266bSSayali Lokhande 270bc99266bSSayali Lokhande return msm_host->offset; 271bc99266bSSayali Lokhande } 272bc99266bSSayali Lokhande 2736ed4bb43SVijay Viswanath /* 2746ed4bb43SVijay Viswanath * APIs to read/write to vendor specific registers which were there in the 2756ed4bb43SVijay Viswanath * core_mem region before MCI was removed. 2766ed4bb43SVijay Viswanath */ 2776ed4bb43SVijay Viswanath static u32 sdhci_msm_mci_variant_readl_relaxed(struct sdhci_host *host, 2786ed4bb43SVijay Viswanath u32 offset) 2796ed4bb43SVijay Viswanath { 2806ed4bb43SVijay Viswanath struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 2816ed4bb43SVijay Viswanath struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 2826ed4bb43SVijay Viswanath 2836ed4bb43SVijay Viswanath return readl_relaxed(msm_host->core_mem + offset); 2846ed4bb43SVijay Viswanath } 2856ed4bb43SVijay Viswanath 2866ed4bb43SVijay Viswanath static u32 sdhci_msm_v5_variant_readl_relaxed(struct sdhci_host *host, 2876ed4bb43SVijay Viswanath u32 offset) 2886ed4bb43SVijay Viswanath { 2896ed4bb43SVijay Viswanath return readl_relaxed(host->ioaddr + offset); 2906ed4bb43SVijay Viswanath } 2916ed4bb43SVijay Viswanath 2926ed4bb43SVijay Viswanath static void sdhci_msm_mci_variant_writel_relaxed(u32 val, 2936ed4bb43SVijay Viswanath struct sdhci_host *host, u32 offset) 2946ed4bb43SVijay Viswanath { 2956ed4bb43SVijay Viswanath struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 2966ed4bb43SVijay Viswanath struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 2976ed4bb43SVijay Viswanath 2986ed4bb43SVijay Viswanath writel_relaxed(val, msm_host->core_mem + offset); 2996ed4bb43SVijay Viswanath } 3006ed4bb43SVijay Viswanath 3016ed4bb43SVijay Viswanath static void sdhci_msm_v5_variant_writel_relaxed(u32 val, 3026ed4bb43SVijay Viswanath struct sdhci_host *host, u32 offset) 3036ed4bb43SVijay Viswanath { 3046ed4bb43SVijay Viswanath writel_relaxed(val, host->ioaddr + offset); 3056ed4bb43SVijay Viswanath } 3066ed4bb43SVijay Viswanath 3070fb8a3d4SRitesh Harjani static unsigned int msm_get_clock_rate_for_bus_mode(struct sdhci_host *host, 3080fb8a3d4SRitesh Harjani unsigned int clock) 3090fb8a3d4SRitesh Harjani { 3100fb8a3d4SRitesh Harjani struct mmc_ios ios = host->mmc->ios; 3110fb8a3d4SRitesh Harjani /* 3120fb8a3d4SRitesh Harjani * The SDHC requires internal clock frequency to be double the 3130fb8a3d4SRitesh Harjani * actual clock that will be set for DDR mode. The controller 3140fb8a3d4SRitesh Harjani * uses the faster clock(100/400MHz) for some of its parts and 3150fb8a3d4SRitesh Harjani * send the actual required clock (50/200MHz) to the card. 3160fb8a3d4SRitesh Harjani */ 3170fb8a3d4SRitesh Harjani if (ios.timing == MMC_TIMING_UHS_DDR50 || 3180fb8a3d4SRitesh Harjani ios.timing == MMC_TIMING_MMC_DDR52 || 319d7507aa1SRitesh Harjani ios.timing == MMC_TIMING_MMC_HS400 || 320d7507aa1SRitesh Harjani host->flags & SDHCI_HS400_TUNING) 3210fb8a3d4SRitesh Harjani clock *= 2; 3220fb8a3d4SRitesh Harjani return clock; 3230fb8a3d4SRitesh Harjani } 3240fb8a3d4SRitesh Harjani 3250fb8a3d4SRitesh Harjani static void msm_set_clock_rate_for_bus_mode(struct sdhci_host *host, 3260fb8a3d4SRitesh Harjani unsigned int clock) 3270fb8a3d4SRitesh Harjani { 3280fb8a3d4SRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 3290fb8a3d4SRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 3300fb8a3d4SRitesh Harjani struct mmc_ios curr_ios = host->mmc->ios; 331e4bf91f6SBjorn Andersson struct clk *core_clk = msm_host->bulk_clks[0].clk; 3320fb8a3d4SRitesh Harjani int rc; 3330fb8a3d4SRitesh Harjani 3340fb8a3d4SRitesh Harjani clock = msm_get_clock_rate_for_bus_mode(host, clock); 335e4bf91f6SBjorn Andersson rc = clk_set_rate(core_clk, clock); 3360fb8a3d4SRitesh Harjani if (rc) { 3370fb8a3d4SRitesh Harjani pr_err("%s: Failed to set clock at rate %u at timing %d\n", 3380fb8a3d4SRitesh Harjani mmc_hostname(host->mmc), clock, 3390fb8a3d4SRitesh Harjani curr_ios.timing); 3400fb8a3d4SRitesh Harjani return; 3410fb8a3d4SRitesh Harjani } 3420fb8a3d4SRitesh Harjani msm_host->clk_rate = clock; 3430fb8a3d4SRitesh Harjani pr_debug("%s: Setting clock at rate %lu at timing %d\n", 344e4bf91f6SBjorn Andersson mmc_hostname(host->mmc), clk_get_rate(core_clk), 3450fb8a3d4SRitesh Harjani curr_ios.timing); 3460fb8a3d4SRitesh Harjani } 3470fb8a3d4SRitesh Harjani 3480eb0d9f4SGeorgi Djakov /* Platform specific tuning */ 349415b5a75SGeorgi Djakov static inline int msm_dll_poll_ck_out_en(struct sdhci_host *host, u8 poll) 350415b5a75SGeorgi Djakov { 351415b5a75SGeorgi Djakov u32 wait_cnt = 50; 352415b5a75SGeorgi Djakov u8 ck_out_en; 353415b5a75SGeorgi Djakov struct mmc_host *mmc = host->mmc; 354bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 355bc99266bSSayali Lokhande sdhci_priv_msm_offset(host); 356415b5a75SGeorgi Djakov 357415b5a75SGeorgi Djakov /* Poll for CK_OUT_EN bit. max. poll time = 50us */ 358bc99266bSSayali Lokhande ck_out_en = !!(readl_relaxed(host->ioaddr + 359bc99266bSSayali Lokhande msm_offset->core_dll_config) & CORE_CK_OUT_EN); 360415b5a75SGeorgi Djakov 361415b5a75SGeorgi Djakov while (ck_out_en != poll) { 362415b5a75SGeorgi Djakov if (--wait_cnt == 0) { 363415b5a75SGeorgi Djakov dev_err(mmc_dev(mmc), "%s: CK_OUT_EN bit is not %d\n", 364415b5a75SGeorgi Djakov mmc_hostname(mmc), poll); 365415b5a75SGeorgi Djakov return -ETIMEDOUT; 366415b5a75SGeorgi Djakov } 367415b5a75SGeorgi Djakov udelay(1); 368415b5a75SGeorgi Djakov 369bc99266bSSayali Lokhande ck_out_en = !!(readl_relaxed(host->ioaddr + 370bc99266bSSayali Lokhande msm_offset->core_dll_config) & CORE_CK_OUT_EN); 371415b5a75SGeorgi Djakov } 372415b5a75SGeorgi Djakov 373415b5a75SGeorgi Djakov return 0; 374415b5a75SGeorgi Djakov } 375415b5a75SGeorgi Djakov 376415b5a75SGeorgi Djakov static int msm_config_cm_dll_phase(struct sdhci_host *host, u8 phase) 377415b5a75SGeorgi Djakov { 378415b5a75SGeorgi Djakov int rc; 379415b5a75SGeorgi Djakov static const u8 grey_coded_phase_table[] = { 380415b5a75SGeorgi Djakov 0x0, 0x1, 0x3, 0x2, 0x6, 0x7, 0x5, 0x4, 381415b5a75SGeorgi Djakov 0xc, 0xd, 0xf, 0xe, 0xa, 0xb, 0x9, 0x8 382415b5a75SGeorgi Djakov }; 383415b5a75SGeorgi Djakov unsigned long flags; 384415b5a75SGeorgi Djakov u32 config; 385415b5a75SGeorgi Djakov struct mmc_host *mmc = host->mmc; 386bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 387bc99266bSSayali Lokhande sdhci_priv_msm_offset(host); 388415b5a75SGeorgi Djakov 389abf270e5SRitesh Harjani if (phase > 0xf) 390abf270e5SRitesh Harjani return -EINVAL; 391abf270e5SRitesh Harjani 392415b5a75SGeorgi Djakov spin_lock_irqsave(&host->lock, flags); 393415b5a75SGeorgi Djakov 394bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config); 395415b5a75SGeorgi Djakov config &= ~(CORE_CDR_EN | CORE_CK_OUT_EN); 396415b5a75SGeorgi Djakov config |= (CORE_CDR_EXT_EN | CORE_DLL_EN); 397bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config); 398415b5a75SGeorgi Djakov 399415b5a75SGeorgi Djakov /* Wait until CK_OUT_EN bit of DLL_CONFIG register becomes '0' */ 400415b5a75SGeorgi Djakov rc = msm_dll_poll_ck_out_en(host, 0); 401415b5a75SGeorgi Djakov if (rc) 402415b5a75SGeorgi Djakov goto err_out; 403415b5a75SGeorgi Djakov 404415b5a75SGeorgi Djakov /* 405415b5a75SGeorgi Djakov * Write the selected DLL clock output phase (0 ... 15) 406415b5a75SGeorgi Djakov * to CDR_SELEXT bit field of DLL_CONFIG register. 407415b5a75SGeorgi Djakov */ 408bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config); 409415b5a75SGeorgi Djakov config &= ~CDR_SELEXT_MASK; 410415b5a75SGeorgi Djakov config |= grey_coded_phase_table[phase] << CDR_SELEXT_SHIFT; 411bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config); 412415b5a75SGeorgi Djakov 413bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config); 41429301f40SRitesh Harjani config |= CORE_CK_OUT_EN; 415bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config); 416415b5a75SGeorgi Djakov 417415b5a75SGeorgi Djakov /* Wait until CK_OUT_EN bit of DLL_CONFIG register becomes '1' */ 418415b5a75SGeorgi Djakov rc = msm_dll_poll_ck_out_en(host, 1); 419415b5a75SGeorgi Djakov if (rc) 420415b5a75SGeorgi Djakov goto err_out; 421415b5a75SGeorgi Djakov 422bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config); 423415b5a75SGeorgi Djakov config |= CORE_CDR_EN; 424415b5a75SGeorgi Djakov config &= ~CORE_CDR_EXT_EN; 425bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config); 426415b5a75SGeorgi Djakov goto out; 427415b5a75SGeorgi Djakov 428415b5a75SGeorgi Djakov err_out: 429415b5a75SGeorgi Djakov dev_err(mmc_dev(mmc), "%s: Failed to set DLL phase: %d\n", 430415b5a75SGeorgi Djakov mmc_hostname(mmc), phase); 431415b5a75SGeorgi Djakov out: 432415b5a75SGeorgi Djakov spin_unlock_irqrestore(&host->lock, flags); 433415b5a75SGeorgi Djakov return rc; 434415b5a75SGeorgi Djakov } 435415b5a75SGeorgi Djakov 436415b5a75SGeorgi Djakov /* 437415b5a75SGeorgi Djakov * Find out the greatest range of consecuitive selected 438415b5a75SGeorgi Djakov * DLL clock output phases that can be used as sampling 439415b5a75SGeorgi Djakov * setting for SD3.0 UHS-I card read operation (in SDR104 440ff06ce41SVenkat Gopalakrishnan * timing mode) or for eMMC4.5 card read operation (in 441ff06ce41SVenkat Gopalakrishnan * HS400/HS200 timing mode). 442415b5a75SGeorgi Djakov * Select the 3/4 of the range and configure the DLL with the 443415b5a75SGeorgi Djakov * selected DLL clock output phase. 444415b5a75SGeorgi Djakov */ 445415b5a75SGeorgi Djakov 446415b5a75SGeorgi Djakov static int msm_find_most_appropriate_phase(struct sdhci_host *host, 447415b5a75SGeorgi Djakov u8 *phase_table, u8 total_phases) 448415b5a75SGeorgi Djakov { 449415b5a75SGeorgi Djakov int ret; 450415b5a75SGeorgi Djakov u8 ranges[MAX_PHASES][MAX_PHASES] = { {0}, {0} }; 451415b5a75SGeorgi Djakov u8 phases_per_row[MAX_PHASES] = { 0 }; 452415b5a75SGeorgi Djakov int row_index = 0, col_index = 0, selected_row_index = 0, curr_max = 0; 453415b5a75SGeorgi Djakov int i, cnt, phase_0_raw_index = 0, phase_15_raw_index = 0; 454415b5a75SGeorgi Djakov bool phase_0_found = false, phase_15_found = false; 455415b5a75SGeorgi Djakov struct mmc_host *mmc = host->mmc; 456415b5a75SGeorgi Djakov 457415b5a75SGeorgi Djakov if (!total_phases || (total_phases > MAX_PHASES)) { 458415b5a75SGeorgi Djakov dev_err(mmc_dev(mmc), "%s: Invalid argument: total_phases=%d\n", 459415b5a75SGeorgi Djakov mmc_hostname(mmc), total_phases); 460415b5a75SGeorgi Djakov return -EINVAL; 461415b5a75SGeorgi Djakov } 462415b5a75SGeorgi Djakov 463415b5a75SGeorgi Djakov for (cnt = 0; cnt < total_phases; cnt++) { 464415b5a75SGeorgi Djakov ranges[row_index][col_index] = phase_table[cnt]; 465415b5a75SGeorgi Djakov phases_per_row[row_index] += 1; 466415b5a75SGeorgi Djakov col_index++; 467415b5a75SGeorgi Djakov 468415b5a75SGeorgi Djakov if ((cnt + 1) == total_phases) { 469415b5a75SGeorgi Djakov continue; 470415b5a75SGeorgi Djakov /* check if next phase in phase_table is consecutive or not */ 471415b5a75SGeorgi Djakov } else if ((phase_table[cnt] + 1) != phase_table[cnt + 1]) { 472415b5a75SGeorgi Djakov row_index++; 473415b5a75SGeorgi Djakov col_index = 0; 474415b5a75SGeorgi Djakov } 475415b5a75SGeorgi Djakov } 476415b5a75SGeorgi Djakov 477415b5a75SGeorgi Djakov if (row_index >= MAX_PHASES) 478415b5a75SGeorgi Djakov return -EINVAL; 479415b5a75SGeorgi Djakov 480415b5a75SGeorgi Djakov /* Check if phase-0 is present in first valid window? */ 481415b5a75SGeorgi Djakov if (!ranges[0][0]) { 482415b5a75SGeorgi Djakov phase_0_found = true; 483415b5a75SGeorgi Djakov phase_0_raw_index = 0; 484415b5a75SGeorgi Djakov /* Check if cycle exist between 2 valid windows */ 485415b5a75SGeorgi Djakov for (cnt = 1; cnt <= row_index; cnt++) { 486415b5a75SGeorgi Djakov if (phases_per_row[cnt]) { 487415b5a75SGeorgi Djakov for (i = 0; i < phases_per_row[cnt]; i++) { 488415b5a75SGeorgi Djakov if (ranges[cnt][i] == 15) { 489415b5a75SGeorgi Djakov phase_15_found = true; 490415b5a75SGeorgi Djakov phase_15_raw_index = cnt; 491415b5a75SGeorgi Djakov break; 492415b5a75SGeorgi Djakov } 493415b5a75SGeorgi Djakov } 494415b5a75SGeorgi Djakov } 495415b5a75SGeorgi Djakov } 496415b5a75SGeorgi Djakov } 497415b5a75SGeorgi Djakov 498415b5a75SGeorgi Djakov /* If 2 valid windows form cycle then merge them as single window */ 499415b5a75SGeorgi Djakov if (phase_0_found && phase_15_found) { 500415b5a75SGeorgi Djakov /* number of phases in raw where phase 0 is present */ 501415b5a75SGeorgi Djakov u8 phases_0 = phases_per_row[phase_0_raw_index]; 502415b5a75SGeorgi Djakov /* number of phases in raw where phase 15 is present */ 503415b5a75SGeorgi Djakov u8 phases_15 = phases_per_row[phase_15_raw_index]; 504415b5a75SGeorgi Djakov 505415b5a75SGeorgi Djakov if (phases_0 + phases_15 >= MAX_PHASES) 506415b5a75SGeorgi Djakov /* 507415b5a75SGeorgi Djakov * If there are more than 1 phase windows then total 508415b5a75SGeorgi Djakov * number of phases in both the windows should not be 509415b5a75SGeorgi Djakov * more than or equal to MAX_PHASES. 510415b5a75SGeorgi Djakov */ 511415b5a75SGeorgi Djakov return -EINVAL; 512415b5a75SGeorgi Djakov 513415b5a75SGeorgi Djakov /* Merge 2 cyclic windows */ 514415b5a75SGeorgi Djakov i = phases_15; 515415b5a75SGeorgi Djakov for (cnt = 0; cnt < phases_0; cnt++) { 516415b5a75SGeorgi Djakov ranges[phase_15_raw_index][i] = 517415b5a75SGeorgi Djakov ranges[phase_0_raw_index][cnt]; 518415b5a75SGeorgi Djakov if (++i >= MAX_PHASES) 519415b5a75SGeorgi Djakov break; 520415b5a75SGeorgi Djakov } 521415b5a75SGeorgi Djakov 522415b5a75SGeorgi Djakov phases_per_row[phase_0_raw_index] = 0; 523415b5a75SGeorgi Djakov phases_per_row[phase_15_raw_index] = phases_15 + phases_0; 524415b5a75SGeorgi Djakov } 525415b5a75SGeorgi Djakov 526415b5a75SGeorgi Djakov for (cnt = 0; cnt <= row_index; cnt++) { 527415b5a75SGeorgi Djakov if (phases_per_row[cnt] > curr_max) { 528415b5a75SGeorgi Djakov curr_max = phases_per_row[cnt]; 529415b5a75SGeorgi Djakov selected_row_index = cnt; 530415b5a75SGeorgi Djakov } 531415b5a75SGeorgi Djakov } 532415b5a75SGeorgi Djakov 533415b5a75SGeorgi Djakov i = (curr_max * 3) / 4; 534415b5a75SGeorgi Djakov if (i) 535415b5a75SGeorgi Djakov i--; 536415b5a75SGeorgi Djakov 537415b5a75SGeorgi Djakov ret = ranges[selected_row_index][i]; 538415b5a75SGeorgi Djakov 539415b5a75SGeorgi Djakov if (ret >= MAX_PHASES) { 540415b5a75SGeorgi Djakov ret = -EINVAL; 541415b5a75SGeorgi Djakov dev_err(mmc_dev(mmc), "%s: Invalid phase selected=%d\n", 542415b5a75SGeorgi Djakov mmc_hostname(mmc), ret); 543415b5a75SGeorgi Djakov } 544415b5a75SGeorgi Djakov 545415b5a75SGeorgi Djakov return ret; 546415b5a75SGeorgi Djakov } 547415b5a75SGeorgi Djakov 548415b5a75SGeorgi Djakov static inline void msm_cm_dll_set_freq(struct sdhci_host *host) 549415b5a75SGeorgi Djakov { 550415b5a75SGeorgi Djakov u32 mclk_freq = 0, config; 551bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 552bc99266bSSayali Lokhande sdhci_priv_msm_offset(host); 553415b5a75SGeorgi Djakov 554415b5a75SGeorgi Djakov /* Program the MCLK value to MCLK_FREQ bit field */ 555415b5a75SGeorgi Djakov if (host->clock <= 112000000) 556415b5a75SGeorgi Djakov mclk_freq = 0; 557415b5a75SGeorgi Djakov else if (host->clock <= 125000000) 558415b5a75SGeorgi Djakov mclk_freq = 1; 559415b5a75SGeorgi Djakov else if (host->clock <= 137000000) 560415b5a75SGeorgi Djakov mclk_freq = 2; 561415b5a75SGeorgi Djakov else if (host->clock <= 150000000) 562415b5a75SGeorgi Djakov mclk_freq = 3; 563415b5a75SGeorgi Djakov else if (host->clock <= 162000000) 564415b5a75SGeorgi Djakov mclk_freq = 4; 565415b5a75SGeorgi Djakov else if (host->clock <= 175000000) 566415b5a75SGeorgi Djakov mclk_freq = 5; 567415b5a75SGeorgi Djakov else if (host->clock <= 187000000) 568415b5a75SGeorgi Djakov mclk_freq = 6; 569415b5a75SGeorgi Djakov else if (host->clock <= 200000000) 570415b5a75SGeorgi Djakov mclk_freq = 7; 571415b5a75SGeorgi Djakov 572bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config); 573415b5a75SGeorgi Djakov config &= ~CMUX_SHIFT_PHASE_MASK; 574415b5a75SGeorgi Djakov config |= mclk_freq << CMUX_SHIFT_PHASE_SHIFT; 575bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config); 576415b5a75SGeorgi Djakov } 577415b5a75SGeorgi Djakov 578415b5a75SGeorgi Djakov /* Initialize the DLL (Programmable Delay Line) */ 579415b5a75SGeorgi Djakov static int msm_init_cm_dll(struct sdhci_host *host) 580415b5a75SGeorgi Djakov { 581415b5a75SGeorgi Djakov struct mmc_host *mmc = host->mmc; 58283736352SVenkat Gopalakrishnan struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 58383736352SVenkat Gopalakrishnan struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 584415b5a75SGeorgi Djakov int wait_cnt = 50; 5855e6b6651SJorge Ramirez-Ortiz unsigned long flags, xo_clk = 0; 58629301f40SRitesh Harjani u32 config; 587bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 588bc99266bSSayali Lokhande msm_host->offset; 589415b5a75SGeorgi Djakov 5905e6b6651SJorge Ramirez-Ortiz if (msm_host->use_14lpp_dll_reset && !IS_ERR_OR_NULL(msm_host->xo_clk)) 5915e6b6651SJorge Ramirez-Ortiz xo_clk = clk_get_rate(msm_host->xo_clk); 5925e6b6651SJorge Ramirez-Ortiz 593415b5a75SGeorgi Djakov spin_lock_irqsave(&host->lock, flags); 594415b5a75SGeorgi Djakov 595415b5a75SGeorgi Djakov /* 596415b5a75SGeorgi Djakov * Make sure that clock is always enabled when DLL 597415b5a75SGeorgi Djakov * tuning is in progress. Keeping PWRSAVE ON may 598415b5a75SGeorgi Djakov * turn off the clock. 599415b5a75SGeorgi Djakov */ 600bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_vendor_spec); 60129301f40SRitesh Harjani config &= ~CORE_CLK_PWRSAVE; 602bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_vendor_spec); 603415b5a75SGeorgi Djakov 60483736352SVenkat Gopalakrishnan if (msm_host->use_14lpp_dll_reset) { 605bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 606bc99266bSSayali Lokhande msm_offset->core_dll_config); 60783736352SVenkat Gopalakrishnan config &= ~CORE_CK_OUT_EN; 608bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 609bc99266bSSayali Lokhande msm_offset->core_dll_config); 61083736352SVenkat Gopalakrishnan 611bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 612bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 61383736352SVenkat Gopalakrishnan config |= CORE_DLL_CLOCK_DISABLE; 614bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 615bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 61683736352SVenkat Gopalakrishnan } 61783736352SVenkat Gopalakrishnan 618bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 619bc99266bSSayali Lokhande msm_offset->core_dll_config); 62029301f40SRitesh Harjani config |= CORE_DLL_RST; 621bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 622bc99266bSSayali Lokhande msm_offset->core_dll_config); 623415b5a75SGeorgi Djakov 624bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 625bc99266bSSayali Lokhande msm_offset->core_dll_config); 62629301f40SRitesh Harjani config |= CORE_DLL_PDN; 627bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 628bc99266bSSayali Lokhande msm_offset->core_dll_config); 629415b5a75SGeorgi Djakov msm_cm_dll_set_freq(host); 630415b5a75SGeorgi Djakov 63183736352SVenkat Gopalakrishnan if (msm_host->use_14lpp_dll_reset && 63283736352SVenkat Gopalakrishnan !IS_ERR_OR_NULL(msm_host->xo_clk)) { 63383736352SVenkat Gopalakrishnan u32 mclk_freq = 0; 63483736352SVenkat Gopalakrishnan 635bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 636bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 63783736352SVenkat Gopalakrishnan config &= CORE_FLL_CYCLE_CNT; 63883736352SVenkat Gopalakrishnan if (config) 63983736352SVenkat Gopalakrishnan mclk_freq = DIV_ROUND_CLOSEST_ULL((host->clock * 8), 6405e6b6651SJorge Ramirez-Ortiz xo_clk); 64183736352SVenkat Gopalakrishnan else 64283736352SVenkat Gopalakrishnan mclk_freq = DIV_ROUND_CLOSEST_ULL((host->clock * 4), 6435e6b6651SJorge Ramirez-Ortiz xo_clk); 64483736352SVenkat Gopalakrishnan 645bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 646bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 64783736352SVenkat Gopalakrishnan config &= ~(0xFF << 10); 64883736352SVenkat Gopalakrishnan config |= mclk_freq << 10; 64983736352SVenkat Gopalakrishnan 650bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 651bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 65283736352SVenkat Gopalakrishnan /* wait for 5us before enabling DLL clock */ 65383736352SVenkat Gopalakrishnan udelay(5); 65483736352SVenkat Gopalakrishnan } 65583736352SVenkat Gopalakrishnan 656bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 657bc99266bSSayali Lokhande msm_offset->core_dll_config); 65829301f40SRitesh Harjani config &= ~CORE_DLL_RST; 659bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 660bc99266bSSayali Lokhande msm_offset->core_dll_config); 661415b5a75SGeorgi Djakov 662bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 663bc99266bSSayali Lokhande msm_offset->core_dll_config); 66429301f40SRitesh Harjani config &= ~CORE_DLL_PDN; 665bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 666bc99266bSSayali Lokhande msm_offset->core_dll_config); 667415b5a75SGeorgi Djakov 66883736352SVenkat Gopalakrishnan if (msm_host->use_14lpp_dll_reset) { 66983736352SVenkat Gopalakrishnan msm_cm_dll_set_freq(host); 670bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 671bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 67283736352SVenkat Gopalakrishnan config &= ~CORE_DLL_CLOCK_DISABLE; 673bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 674bc99266bSSayali Lokhande msm_offset->core_dll_config_2); 67583736352SVenkat Gopalakrishnan } 67683736352SVenkat Gopalakrishnan 677bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 678bc99266bSSayali Lokhande msm_offset->core_dll_config); 67929301f40SRitesh Harjani config |= CORE_DLL_EN; 680bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 681bc99266bSSayali Lokhande msm_offset->core_dll_config); 682415b5a75SGeorgi Djakov 683bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 684bc99266bSSayali Lokhande msm_offset->core_dll_config); 68529301f40SRitesh Harjani config |= CORE_CK_OUT_EN; 686bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 687bc99266bSSayali Lokhande msm_offset->core_dll_config); 688415b5a75SGeorgi Djakov 689415b5a75SGeorgi Djakov /* Wait until DLL_LOCK bit of DLL_STATUS register becomes '1' */ 690bc99266bSSayali Lokhande while (!(readl_relaxed(host->ioaddr + msm_offset->core_dll_status) & 691415b5a75SGeorgi Djakov CORE_DLL_LOCK)) { 692415b5a75SGeorgi Djakov /* max. wait for 50us sec for LOCK bit to be set */ 693415b5a75SGeorgi Djakov if (--wait_cnt == 0) { 694415b5a75SGeorgi Djakov dev_err(mmc_dev(mmc), "%s: DLL failed to LOCK\n", 695415b5a75SGeorgi Djakov mmc_hostname(mmc)); 696415b5a75SGeorgi Djakov spin_unlock_irqrestore(&host->lock, flags); 697415b5a75SGeorgi Djakov return -ETIMEDOUT; 698415b5a75SGeorgi Djakov } 699415b5a75SGeorgi Djakov udelay(1); 700415b5a75SGeorgi Djakov } 701415b5a75SGeorgi Djakov 702415b5a75SGeorgi Djakov spin_unlock_irqrestore(&host->lock, flags); 703415b5a75SGeorgi Djakov return 0; 704415b5a75SGeorgi Djakov } 705415b5a75SGeorgi Djakov 706b54aaa8aSRitesh Harjani static void msm_hc_select_default(struct sdhci_host *host) 707b54aaa8aSRitesh Harjani { 708b54aaa8aSRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 709b54aaa8aSRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 710b54aaa8aSRitesh Harjani u32 config; 711bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 712bc99266bSSayali Lokhande msm_host->offset; 713b54aaa8aSRitesh Harjani 714b54aaa8aSRitesh Harjani if (!msm_host->use_cdclp533) { 715b54aaa8aSRitesh Harjani config = readl_relaxed(host->ioaddr + 716bc99266bSSayali Lokhande msm_offset->core_vendor_spec3); 717b54aaa8aSRitesh Harjani config &= ~CORE_PWRSAVE_DLL; 718b54aaa8aSRitesh Harjani writel_relaxed(config, host->ioaddr + 719bc99266bSSayali Lokhande msm_offset->core_vendor_spec3); 720b54aaa8aSRitesh Harjani } 721b54aaa8aSRitesh Harjani 722bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_vendor_spec); 723b54aaa8aSRitesh Harjani config &= ~CORE_HC_MCLK_SEL_MASK; 724b54aaa8aSRitesh Harjani config |= CORE_HC_MCLK_SEL_DFLT; 725bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_vendor_spec); 726b54aaa8aSRitesh Harjani 727b54aaa8aSRitesh Harjani /* 728b54aaa8aSRitesh Harjani * Disable HC_SELECT_IN to be able to use the UHS mode select 729b54aaa8aSRitesh Harjani * configuration from Host Control2 register for all other 730b54aaa8aSRitesh Harjani * modes. 731b54aaa8aSRitesh Harjani * Write 0 to HC_SELECT_IN and HC_SELECT_IN_EN field 732b54aaa8aSRitesh Harjani * in VENDOR_SPEC_FUNC 733b54aaa8aSRitesh Harjani */ 734bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_vendor_spec); 735b54aaa8aSRitesh Harjani config &= ~CORE_HC_SELECT_IN_EN; 736b54aaa8aSRitesh Harjani config &= ~CORE_HC_SELECT_IN_MASK; 737bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_vendor_spec); 738b54aaa8aSRitesh Harjani 739b54aaa8aSRitesh Harjani /* 740b54aaa8aSRitesh Harjani * Make sure above writes impacting free running MCLK are completed 741b54aaa8aSRitesh Harjani * before changing the clk_rate at GCC. 742b54aaa8aSRitesh Harjani */ 743b54aaa8aSRitesh Harjani wmb(); 744b54aaa8aSRitesh Harjani } 745b54aaa8aSRitesh Harjani 746b54aaa8aSRitesh Harjani static void msm_hc_select_hs400(struct sdhci_host *host) 747b54aaa8aSRitesh Harjani { 748b54aaa8aSRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 749b54aaa8aSRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 75044bf2312SRitesh Harjani struct mmc_ios ios = host->mmc->ios; 751b54aaa8aSRitesh Harjani u32 config, dll_lock; 752b54aaa8aSRitesh Harjani int rc; 753bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 754bc99266bSSayali Lokhande msm_host->offset; 755b54aaa8aSRitesh Harjani 756b54aaa8aSRitesh Harjani /* Select the divided clock (free running MCLK/2) */ 757bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_vendor_spec); 758b54aaa8aSRitesh Harjani config &= ~CORE_HC_MCLK_SEL_MASK; 759b54aaa8aSRitesh Harjani config |= CORE_HC_MCLK_SEL_HS400; 760b54aaa8aSRitesh Harjani 761bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_vendor_spec); 762b54aaa8aSRitesh Harjani /* 763b54aaa8aSRitesh Harjani * Select HS400 mode using the HC_SELECT_IN from VENDOR SPEC 764b54aaa8aSRitesh Harjani * register 765b54aaa8aSRitesh Harjani */ 76644bf2312SRitesh Harjani if ((msm_host->tuning_done || ios.enhanced_strobe) && 76744bf2312SRitesh Harjani !msm_host->calibration_done) { 768bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 769bc99266bSSayali Lokhande msm_offset->core_vendor_spec); 770b54aaa8aSRitesh Harjani config |= CORE_HC_SELECT_IN_HS400; 771b54aaa8aSRitesh Harjani config |= CORE_HC_SELECT_IN_EN; 772bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 773bc99266bSSayali Lokhande msm_offset->core_vendor_spec); 774b54aaa8aSRitesh Harjani } 775b54aaa8aSRitesh Harjani if (!msm_host->clk_rate && !msm_host->use_cdclp533) { 776b54aaa8aSRitesh Harjani /* 777b54aaa8aSRitesh Harjani * Poll on DLL_LOCK or DDR_DLL_LOCK bits in 778bc99266bSSayali Lokhande * core_dll_status to be set. This should get set 779b54aaa8aSRitesh Harjani * within 15 us at 200 MHz. 780b54aaa8aSRitesh Harjani */ 781b54aaa8aSRitesh Harjani rc = readl_relaxed_poll_timeout(host->ioaddr + 782bc99266bSSayali Lokhande msm_offset->core_dll_status, 783b54aaa8aSRitesh Harjani dll_lock, 784b54aaa8aSRitesh Harjani (dll_lock & 785b54aaa8aSRitesh Harjani (CORE_DLL_LOCK | 786b54aaa8aSRitesh Harjani CORE_DDR_DLL_LOCK)), 10, 787b54aaa8aSRitesh Harjani 1000); 788b54aaa8aSRitesh Harjani if (rc == -ETIMEDOUT) 789b54aaa8aSRitesh Harjani pr_err("%s: Unable to get DLL_LOCK/DDR_DLL_LOCK, dll_status: 0x%08x\n", 790b54aaa8aSRitesh Harjani mmc_hostname(host->mmc), dll_lock); 791b54aaa8aSRitesh Harjani } 792b54aaa8aSRitesh Harjani /* 793b54aaa8aSRitesh Harjani * Make sure above writes impacting free running MCLK are completed 794b54aaa8aSRitesh Harjani * before changing the clk_rate at GCC. 795b54aaa8aSRitesh Harjani */ 796b54aaa8aSRitesh Harjani wmb(); 797b54aaa8aSRitesh Harjani } 798b54aaa8aSRitesh Harjani 799b54aaa8aSRitesh Harjani /* 800b54aaa8aSRitesh Harjani * sdhci_msm_hc_select_mode :- In general all timing modes are 801b54aaa8aSRitesh Harjani * controlled via UHS mode select in Host Control2 register. 802b54aaa8aSRitesh Harjani * eMMC specific HS200/HS400 doesn't have their respective modes 803b54aaa8aSRitesh Harjani * defined here, hence we use these values. 804b54aaa8aSRitesh Harjani * 805b54aaa8aSRitesh Harjani * HS200 - SDR104 (Since they both are equivalent in functionality) 806b54aaa8aSRitesh Harjani * HS400 - This involves multiple configurations 807b54aaa8aSRitesh Harjani * Initially SDR104 - when tuning is required as HS200 808b54aaa8aSRitesh Harjani * Then when switching to DDR @ 400MHz (HS400) we use 809b54aaa8aSRitesh Harjani * the vendor specific HC_SELECT_IN to control the mode. 810b54aaa8aSRitesh Harjani * 811b54aaa8aSRitesh Harjani * In addition to controlling the modes we also need to select the 812b54aaa8aSRitesh Harjani * correct input clock for DLL depending on the mode. 813b54aaa8aSRitesh Harjani * 814b54aaa8aSRitesh Harjani * HS400 - divided clock (free running MCLK/2) 815b54aaa8aSRitesh Harjani * All other modes - default (free running MCLK) 816b54aaa8aSRitesh Harjani */ 81730de038dSMasahiro Yamada static void sdhci_msm_hc_select_mode(struct sdhci_host *host) 818b54aaa8aSRitesh Harjani { 819b54aaa8aSRitesh Harjani struct mmc_ios ios = host->mmc->ios; 820b54aaa8aSRitesh Harjani 821d7507aa1SRitesh Harjani if (ios.timing == MMC_TIMING_MMC_HS400 || 822d7507aa1SRitesh Harjani host->flags & SDHCI_HS400_TUNING) 823b54aaa8aSRitesh Harjani msm_hc_select_hs400(host); 824b54aaa8aSRitesh Harjani else 825b54aaa8aSRitesh Harjani msm_hc_select_default(host); 826b54aaa8aSRitesh Harjani } 827b54aaa8aSRitesh Harjani 828cc392c58SRitesh Harjani static int sdhci_msm_cdclp533_calibration(struct sdhci_host *host) 829cc392c58SRitesh Harjani { 830cc392c58SRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 831cc392c58SRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 832cc392c58SRitesh Harjani u32 config, calib_done; 833cc392c58SRitesh Harjani int ret; 834bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 835bc99266bSSayali Lokhande msm_host->offset; 836cc392c58SRitesh Harjani 837cc392c58SRitesh Harjani pr_debug("%s: %s: Enter\n", mmc_hostname(host->mmc), __func__); 838cc392c58SRitesh Harjani 839cc392c58SRitesh Harjani /* 840cc392c58SRitesh Harjani * Retuning in HS400 (DDR mode) will fail, just reset the 841cc392c58SRitesh Harjani * tuning block and restore the saved tuning phase. 842cc392c58SRitesh Harjani */ 843cc392c58SRitesh Harjani ret = msm_init_cm_dll(host); 844cc392c58SRitesh Harjani if (ret) 845cc392c58SRitesh Harjani goto out; 846cc392c58SRitesh Harjani 847cc392c58SRitesh Harjani /* Set the selected phase in delay line hw block */ 848cc392c58SRitesh Harjani ret = msm_config_cm_dll_phase(host, msm_host->saved_tuning_phase); 849cc392c58SRitesh Harjani if (ret) 850cc392c58SRitesh Harjani goto out; 851cc392c58SRitesh Harjani 852bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config); 853cc392c58SRitesh Harjani config |= CORE_CMD_DAT_TRACK_SEL; 854bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config); 855cc392c58SRitesh Harjani 856bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_ddr_200_cfg); 857cc392c58SRitesh Harjani config &= ~CORE_CDC_T4_DLY_SEL; 858bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_ddr_200_cfg); 859cc392c58SRitesh Harjani 860cc392c58SRitesh Harjani config = readl_relaxed(host->ioaddr + CORE_CSR_CDC_GEN_CFG); 861cc392c58SRitesh Harjani config &= ~CORE_CDC_SWITCH_BYPASS_OFF; 862cc392c58SRitesh Harjani writel_relaxed(config, host->ioaddr + CORE_CSR_CDC_GEN_CFG); 863cc392c58SRitesh Harjani 864cc392c58SRitesh Harjani config = readl_relaxed(host->ioaddr + CORE_CSR_CDC_GEN_CFG); 865cc392c58SRitesh Harjani config |= CORE_CDC_SWITCH_RC_EN; 866cc392c58SRitesh Harjani writel_relaxed(config, host->ioaddr + CORE_CSR_CDC_GEN_CFG); 867cc392c58SRitesh Harjani 868bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_ddr_200_cfg); 869cc392c58SRitesh Harjani config &= ~CORE_START_CDC_TRAFFIC; 870bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_ddr_200_cfg); 871cc392c58SRitesh Harjani 872543c576dSRitesh Harjani /* Perform CDC Register Initialization Sequence */ 873cc392c58SRitesh Harjani 874cc392c58SRitesh Harjani writel_relaxed(0x11800EC, host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 875cc392c58SRitesh Harjani writel_relaxed(0x3011111, host->ioaddr + CORE_CSR_CDC_CTLR_CFG1); 876cc392c58SRitesh Harjani writel_relaxed(0x1201000, host->ioaddr + CORE_CSR_CDC_CAL_TIMER_CFG0); 877cc392c58SRitesh Harjani writel_relaxed(0x4, host->ioaddr + CORE_CSR_CDC_CAL_TIMER_CFG1); 878cc392c58SRitesh Harjani writel_relaxed(0xCB732020, host->ioaddr + CORE_CSR_CDC_REFCOUNT_CFG); 879cc392c58SRitesh Harjani writel_relaxed(0xB19, host->ioaddr + CORE_CSR_CDC_COARSE_CAL_CFG); 880083c9aa0SSubhash Jadavani writel_relaxed(0x4E2, host->ioaddr + CORE_CSR_CDC_DELAY_CFG); 881cc392c58SRitesh Harjani writel_relaxed(0x0, host->ioaddr + CORE_CDC_OFFSET_CFG); 882cc392c58SRitesh Harjani writel_relaxed(0x16334, host->ioaddr + CORE_CDC_SLAVE_DDA_CFG); 883cc392c58SRitesh Harjani 884cc392c58SRitesh Harjani /* CDC HW Calibration */ 885cc392c58SRitesh Harjani 886cc392c58SRitesh Harjani config = readl_relaxed(host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 887cc392c58SRitesh Harjani config |= CORE_SW_TRIG_FULL_CALIB; 888cc392c58SRitesh Harjani writel_relaxed(config, host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 889cc392c58SRitesh Harjani 890cc392c58SRitesh Harjani config = readl_relaxed(host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 891cc392c58SRitesh Harjani config &= ~CORE_SW_TRIG_FULL_CALIB; 892cc392c58SRitesh Harjani writel_relaxed(config, host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 893cc392c58SRitesh Harjani 894cc392c58SRitesh Harjani config = readl_relaxed(host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 895cc392c58SRitesh Harjani config |= CORE_HW_AUTOCAL_ENA; 896cc392c58SRitesh Harjani writel_relaxed(config, host->ioaddr + CORE_CSR_CDC_CTLR_CFG0); 897cc392c58SRitesh Harjani 898cc392c58SRitesh Harjani config = readl_relaxed(host->ioaddr + CORE_CSR_CDC_CAL_TIMER_CFG0); 899cc392c58SRitesh Harjani config |= CORE_TIMER_ENA; 900cc392c58SRitesh Harjani writel_relaxed(config, host->ioaddr + CORE_CSR_CDC_CAL_TIMER_CFG0); 901cc392c58SRitesh Harjani 902cc392c58SRitesh Harjani ret = readl_relaxed_poll_timeout(host->ioaddr + CORE_CSR_CDC_STATUS0, 903cc392c58SRitesh Harjani calib_done, 904cc392c58SRitesh Harjani (calib_done & CORE_CALIBRATION_DONE), 905cc392c58SRitesh Harjani 1, 50); 906cc392c58SRitesh Harjani 907cc392c58SRitesh Harjani if (ret == -ETIMEDOUT) { 908cc392c58SRitesh Harjani pr_err("%s: %s: CDC calibration was not completed\n", 909cc392c58SRitesh Harjani mmc_hostname(host->mmc), __func__); 910cc392c58SRitesh Harjani goto out; 911cc392c58SRitesh Harjani } 912cc392c58SRitesh Harjani 913cc392c58SRitesh Harjani ret = readl_relaxed(host->ioaddr + CORE_CSR_CDC_STATUS0) 914cc392c58SRitesh Harjani & CORE_CDC_ERROR_CODE_MASK; 915cc392c58SRitesh Harjani if (ret) { 916cc392c58SRitesh Harjani pr_err("%s: %s: CDC error code %d\n", 917cc392c58SRitesh Harjani mmc_hostname(host->mmc), __func__, ret); 918cc392c58SRitesh Harjani ret = -EINVAL; 919cc392c58SRitesh Harjani goto out; 920cc392c58SRitesh Harjani } 921cc392c58SRitesh Harjani 922bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_ddr_200_cfg); 923cc392c58SRitesh Harjani config |= CORE_START_CDC_TRAFFIC; 924bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_ddr_200_cfg); 925cc392c58SRitesh Harjani out: 926cc392c58SRitesh Harjani pr_debug("%s: %s: Exit, ret %d\n", mmc_hostname(host->mmc), 927cc392c58SRitesh Harjani __func__, ret); 928cc392c58SRitesh Harjani return ret; 929cc392c58SRitesh Harjani } 930cc392c58SRitesh Harjani 93102e4293dSRitesh Harjani static int sdhci_msm_cm_dll_sdc4_calibration(struct sdhci_host *host) 93202e4293dSRitesh Harjani { 93344bf2312SRitesh Harjani struct mmc_host *mmc = host->mmc; 934fa56ac97SVeerabhadrarao Badiganti u32 dll_status, config, ddr_cfg_offset; 93502e4293dSRitesh Harjani int ret; 936fa56ac97SVeerabhadrarao Badiganti struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 937fa56ac97SVeerabhadrarao Badiganti struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 938bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 939bc99266bSSayali Lokhande sdhci_priv_msm_offset(host); 94002e4293dSRitesh Harjani 94102e4293dSRitesh Harjani pr_debug("%s: %s: Enter\n", mmc_hostname(host->mmc), __func__); 94202e4293dSRitesh Harjani 94302e4293dSRitesh Harjani /* 944bc99266bSSayali Lokhande * Currently the core_ddr_config register defaults to desired 94502e4293dSRitesh Harjani * configuration on reset. Currently reprogramming the power on 94602e4293dSRitesh Harjani * reset (POR) value in case it might have been modified by 94702e4293dSRitesh Harjani * bootloaders. In the future, if this changes, then the desired 94802e4293dSRitesh Harjani * values will need to be programmed appropriately. 94902e4293dSRitesh Harjani */ 950fa56ac97SVeerabhadrarao Badiganti if (msm_host->updated_ddr_cfg) 951fa56ac97SVeerabhadrarao Badiganti ddr_cfg_offset = msm_offset->core_ddr_config; 952fa56ac97SVeerabhadrarao Badiganti else 953fa56ac97SVeerabhadrarao Badiganti ddr_cfg_offset = msm_offset->core_ddr_config_old; 954fa56ac97SVeerabhadrarao Badiganti writel_relaxed(DDR_CONFIG_POR_VAL, host->ioaddr + ddr_cfg_offset); 95502e4293dSRitesh Harjani 95644bf2312SRitesh Harjani if (mmc->ios.enhanced_strobe) { 957bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 958bc99266bSSayali Lokhande msm_offset->core_ddr_200_cfg); 95944bf2312SRitesh Harjani config |= CORE_CMDIN_RCLK_EN; 960bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 961bc99266bSSayali Lokhande msm_offset->core_ddr_200_cfg); 96244bf2312SRitesh Harjani } 96344bf2312SRitesh Harjani 964bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + msm_offset->core_dll_config_2); 96502e4293dSRitesh Harjani config |= CORE_DDR_CAL_EN; 966bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + msm_offset->core_dll_config_2); 96702e4293dSRitesh Harjani 968bc99266bSSayali Lokhande ret = readl_relaxed_poll_timeout(host->ioaddr + 969bc99266bSSayali Lokhande msm_offset->core_dll_status, 97002e4293dSRitesh Harjani dll_status, 97102e4293dSRitesh Harjani (dll_status & CORE_DDR_DLL_LOCK), 97202e4293dSRitesh Harjani 10, 1000); 97302e4293dSRitesh Harjani 97402e4293dSRitesh Harjani if (ret == -ETIMEDOUT) { 97502e4293dSRitesh Harjani pr_err("%s: %s: CM_DLL_SDC4 calibration was not completed\n", 97602e4293dSRitesh Harjani mmc_hostname(host->mmc), __func__); 97702e4293dSRitesh Harjani goto out; 97802e4293dSRitesh Harjani } 97902e4293dSRitesh Harjani 980219c02caSRitesh Harjani /* 981219c02caSRitesh Harjani * Set CORE_PWRSAVE_DLL bit in CORE_VENDOR_SPEC3. 982219c02caSRitesh Harjani * When MCLK is gated OFF, it is not gated for less than 0.5us 983219c02caSRitesh Harjani * and MCLK must be switched on for at-least 1us before DATA 984219c02caSRitesh Harjani * starts coming. Controllers with 14lpp and later tech DLL cannot 985219c02caSRitesh Harjani * guarantee above requirement. So PWRSAVE_DLL should not be 986219c02caSRitesh Harjani * turned on for host controllers using this DLL. 987219c02caSRitesh Harjani */ 988219c02caSRitesh Harjani if (!msm_host->use_14lpp_dll_reset) { 989219c02caSRitesh Harjani config = readl_relaxed(host->ioaddr + 990219c02caSRitesh Harjani msm_offset->core_vendor_spec3); 99102e4293dSRitesh Harjani config |= CORE_PWRSAVE_DLL; 992219c02caSRitesh Harjani writel_relaxed(config, host->ioaddr + 993219c02caSRitesh Harjani msm_offset->core_vendor_spec3); 994219c02caSRitesh Harjani } 99502e4293dSRitesh Harjani 99602e4293dSRitesh Harjani /* 99702e4293dSRitesh Harjani * Drain writebuffer to ensure above DLL calibration 99802e4293dSRitesh Harjani * and PWRSAVE DLL is enabled. 99902e4293dSRitesh Harjani */ 100002e4293dSRitesh Harjani wmb(); 100102e4293dSRitesh Harjani out: 100202e4293dSRitesh Harjani pr_debug("%s: %s: Exit, ret %d\n", mmc_hostname(host->mmc), 100302e4293dSRitesh Harjani __func__, ret); 100402e4293dSRitesh Harjani return ret; 100502e4293dSRitesh Harjani } 100602e4293dSRitesh Harjani 100702e4293dSRitesh Harjani static int sdhci_msm_hs400_dll_calibration(struct sdhci_host *host) 100802e4293dSRitesh Harjani { 100902e4293dSRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 101002e4293dSRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 101144bf2312SRitesh Harjani struct mmc_host *mmc = host->mmc; 101202e4293dSRitesh Harjani int ret; 101302e4293dSRitesh Harjani u32 config; 1014bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 1015bc99266bSSayali Lokhande msm_host->offset; 101602e4293dSRitesh Harjani 101702e4293dSRitesh Harjani pr_debug("%s: %s: Enter\n", mmc_hostname(host->mmc), __func__); 101802e4293dSRitesh Harjani 101902e4293dSRitesh Harjani /* 102002e4293dSRitesh Harjani * Retuning in HS400 (DDR mode) will fail, just reset the 102102e4293dSRitesh Harjani * tuning block and restore the saved tuning phase. 102202e4293dSRitesh Harjani */ 102302e4293dSRitesh Harjani ret = msm_init_cm_dll(host); 102402e4293dSRitesh Harjani if (ret) 102502e4293dSRitesh Harjani goto out; 102602e4293dSRitesh Harjani 102744bf2312SRitesh Harjani if (!mmc->ios.enhanced_strobe) { 102802e4293dSRitesh Harjani /* Set the selected phase in delay line hw block */ 102944bf2312SRitesh Harjani ret = msm_config_cm_dll_phase(host, 103044bf2312SRitesh Harjani msm_host->saved_tuning_phase); 103102e4293dSRitesh Harjani if (ret) 103202e4293dSRitesh Harjani goto out; 1033bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 1034bc99266bSSayali Lokhande msm_offset->core_dll_config); 103502e4293dSRitesh Harjani config |= CORE_CMD_DAT_TRACK_SEL; 1036bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 1037bc99266bSSayali Lokhande msm_offset->core_dll_config); 103844bf2312SRitesh Harjani } 103944bf2312SRitesh Harjani 104002e4293dSRitesh Harjani if (msm_host->use_cdclp533) 104102e4293dSRitesh Harjani ret = sdhci_msm_cdclp533_calibration(host); 104202e4293dSRitesh Harjani else 104302e4293dSRitesh Harjani ret = sdhci_msm_cm_dll_sdc4_calibration(host); 104402e4293dSRitesh Harjani out: 104502e4293dSRitesh Harjani pr_debug("%s: %s: Exit, ret %d\n", mmc_hostname(host->mmc), 104602e4293dSRitesh Harjani __func__, ret); 104702e4293dSRitesh Harjani return ret; 104802e4293dSRitesh Harjani } 104902e4293dSRitesh Harjani 105021f1e2d4SVeerabhadrarao Badiganti static bool sdhci_msm_is_tuning_needed(struct sdhci_host *host) 105121f1e2d4SVeerabhadrarao Badiganti { 105221f1e2d4SVeerabhadrarao Badiganti struct mmc_ios *ios = &host->mmc->ios; 105321f1e2d4SVeerabhadrarao Badiganti 105421f1e2d4SVeerabhadrarao Badiganti /* 105521f1e2d4SVeerabhadrarao Badiganti * Tuning is required for SDR104, HS200 and HS400 cards and 105621f1e2d4SVeerabhadrarao Badiganti * if clock frequency is greater than 100MHz in these modes. 105721f1e2d4SVeerabhadrarao Badiganti */ 105821f1e2d4SVeerabhadrarao Badiganti if (host->clock <= CORE_FREQ_100MHZ || 105921f1e2d4SVeerabhadrarao Badiganti !(ios->timing == MMC_TIMING_MMC_HS400 || 106021f1e2d4SVeerabhadrarao Badiganti ios->timing == MMC_TIMING_MMC_HS200 || 106121f1e2d4SVeerabhadrarao Badiganti ios->timing == MMC_TIMING_UHS_SDR104) || 106221f1e2d4SVeerabhadrarao Badiganti ios->enhanced_strobe) 106321f1e2d4SVeerabhadrarao Badiganti return false; 106421f1e2d4SVeerabhadrarao Badiganti 106521f1e2d4SVeerabhadrarao Badiganti return true; 106621f1e2d4SVeerabhadrarao Badiganti } 106721f1e2d4SVeerabhadrarao Badiganti 106821f1e2d4SVeerabhadrarao Badiganti static int sdhci_msm_restore_sdr_dll_config(struct sdhci_host *host) 106921f1e2d4SVeerabhadrarao Badiganti { 107021f1e2d4SVeerabhadrarao Badiganti struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 107121f1e2d4SVeerabhadrarao Badiganti struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 107221f1e2d4SVeerabhadrarao Badiganti int ret; 107321f1e2d4SVeerabhadrarao Badiganti 107421f1e2d4SVeerabhadrarao Badiganti /* 107521f1e2d4SVeerabhadrarao Badiganti * SDR DLL comes into picture only for timing modes which needs 107621f1e2d4SVeerabhadrarao Badiganti * tuning. 107721f1e2d4SVeerabhadrarao Badiganti */ 107821f1e2d4SVeerabhadrarao Badiganti if (!sdhci_msm_is_tuning_needed(host)) 107921f1e2d4SVeerabhadrarao Badiganti return 0; 108021f1e2d4SVeerabhadrarao Badiganti 108121f1e2d4SVeerabhadrarao Badiganti /* Reset the tuning block */ 108221f1e2d4SVeerabhadrarao Badiganti ret = msm_init_cm_dll(host); 108321f1e2d4SVeerabhadrarao Badiganti if (ret) 108421f1e2d4SVeerabhadrarao Badiganti return ret; 108521f1e2d4SVeerabhadrarao Badiganti 108621f1e2d4SVeerabhadrarao Badiganti /* Restore the tuning block */ 108721f1e2d4SVeerabhadrarao Badiganti ret = msm_config_cm_dll_phase(host, msm_host->saved_tuning_phase); 108821f1e2d4SVeerabhadrarao Badiganti 108921f1e2d4SVeerabhadrarao Badiganti return ret; 109021f1e2d4SVeerabhadrarao Badiganti } 109121f1e2d4SVeerabhadrarao Badiganti 1092a89e7bcbSLoic Poulain static void sdhci_msm_set_cdr(struct sdhci_host *host, bool enable) 1093a89e7bcbSLoic Poulain { 1094a89e7bcbSLoic Poulain const struct sdhci_msm_offset *msm_offset = sdhci_priv_msm_offset(host); 1095a89e7bcbSLoic Poulain u32 config, oldconfig = readl_relaxed(host->ioaddr + 1096a89e7bcbSLoic Poulain msm_offset->core_dll_config); 1097a89e7bcbSLoic Poulain 1098a89e7bcbSLoic Poulain config = oldconfig; 1099a89e7bcbSLoic Poulain if (enable) { 1100a89e7bcbSLoic Poulain config |= CORE_CDR_EN; 1101a89e7bcbSLoic Poulain config &= ~CORE_CDR_EXT_EN; 1102a89e7bcbSLoic Poulain } else { 1103a89e7bcbSLoic Poulain config &= ~CORE_CDR_EN; 1104a89e7bcbSLoic Poulain config |= CORE_CDR_EXT_EN; 1105a89e7bcbSLoic Poulain } 1106a89e7bcbSLoic Poulain 1107a89e7bcbSLoic Poulain if (config != oldconfig) { 1108a89e7bcbSLoic Poulain writel_relaxed(config, host->ioaddr + 1109a89e7bcbSLoic Poulain msm_offset->core_dll_config); 1110a89e7bcbSLoic Poulain } 1111a89e7bcbSLoic Poulain } 1112a89e7bcbSLoic Poulain 11134436c535SRitesh Harjani static int sdhci_msm_execute_tuning(struct mmc_host *mmc, u32 opcode) 11140eb0d9f4SGeorgi Djakov { 11154436c535SRitesh Harjani struct sdhci_host *host = mmc_priv(mmc); 1116415b5a75SGeorgi Djakov int tuning_seq_cnt = 3; 111733d73935SUlf Hansson u8 phase, tuned_phases[16], tuned_phase_cnt = 0; 1118415b5a75SGeorgi Djakov int rc; 1119415b5a75SGeorgi Djakov struct mmc_ios ios = host->mmc->ios; 1120abf270e5SRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1121abf270e5SRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1122415b5a75SGeorgi Djakov 1123a89e7bcbSLoic Poulain if (!sdhci_msm_is_tuning_needed(host)) { 1124a89e7bcbSLoic Poulain msm_host->use_cdr = false; 1125a89e7bcbSLoic Poulain sdhci_msm_set_cdr(host, false); 11260eb0d9f4SGeorgi Djakov return 0; 1127a89e7bcbSLoic Poulain } 1128a89e7bcbSLoic Poulain 1129a89e7bcbSLoic Poulain /* Clock-Data-Recovery used to dynamically adjust RX sampling point */ 1130a89e7bcbSLoic Poulain msm_host->use_cdr = true; 1131415b5a75SGeorgi Djakov 1132d7507aa1SRitesh Harjani /* 1133d7507aa1SRitesh Harjani * For HS400 tuning in HS200 timing requires: 1134d7507aa1SRitesh Harjani * - select MCLK/2 in VENDOR_SPEC 1135d7507aa1SRitesh Harjani * - program MCLK to 400MHz (or nearest supported) in GCC 1136d7507aa1SRitesh Harjani */ 1137d7507aa1SRitesh Harjani if (host->flags & SDHCI_HS400_TUNING) { 1138d7507aa1SRitesh Harjani sdhci_msm_hc_select_mode(host); 1139d7507aa1SRitesh Harjani msm_set_clock_rate_for_bus_mode(host, ios.clock); 11404436c535SRitesh Harjani host->flags &= ~SDHCI_HS400_TUNING; 1141d7507aa1SRitesh Harjani } 1142d7507aa1SRitesh Harjani 1143415b5a75SGeorgi Djakov retry: 1144415b5a75SGeorgi Djakov /* First of all reset the tuning block */ 1145415b5a75SGeorgi Djakov rc = msm_init_cm_dll(host); 1146415b5a75SGeorgi Djakov if (rc) 114733d73935SUlf Hansson return rc; 1148415b5a75SGeorgi Djakov 1149415b5a75SGeorgi Djakov phase = 0; 1150415b5a75SGeorgi Djakov do { 1151415b5a75SGeorgi Djakov /* Set the phase in delay line hw block */ 1152415b5a75SGeorgi Djakov rc = msm_config_cm_dll_phase(host, phase); 1153415b5a75SGeorgi Djakov if (rc) 115433d73935SUlf Hansson return rc; 1155415b5a75SGeorgi Djakov 11569979dbe5SChaotian Jing rc = mmc_send_tuning(mmc, opcode, NULL); 115733d73935SUlf Hansson if (!rc) { 1158415b5a75SGeorgi Djakov /* Tuning is successful at this tuning point */ 1159415b5a75SGeorgi Djakov tuned_phases[tuned_phase_cnt++] = phase; 1160415b5a75SGeorgi Djakov dev_dbg(mmc_dev(mmc), "%s: Found good phase = %d\n", 1161415b5a75SGeorgi Djakov mmc_hostname(mmc), phase); 1162415b5a75SGeorgi Djakov } 1163415b5a75SGeorgi Djakov } while (++phase < ARRAY_SIZE(tuned_phases)); 1164415b5a75SGeorgi Djakov 1165415b5a75SGeorgi Djakov if (tuned_phase_cnt) { 1166415b5a75SGeorgi Djakov rc = msm_find_most_appropriate_phase(host, tuned_phases, 1167415b5a75SGeorgi Djakov tuned_phase_cnt); 1168415b5a75SGeorgi Djakov if (rc < 0) 116933d73935SUlf Hansson return rc; 1170415b5a75SGeorgi Djakov else 1171415b5a75SGeorgi Djakov phase = rc; 1172415b5a75SGeorgi Djakov 1173415b5a75SGeorgi Djakov /* 1174415b5a75SGeorgi Djakov * Finally set the selected phase in delay 1175415b5a75SGeorgi Djakov * line hw block. 1176415b5a75SGeorgi Djakov */ 1177415b5a75SGeorgi Djakov rc = msm_config_cm_dll_phase(host, phase); 1178415b5a75SGeorgi Djakov if (rc) 117933d73935SUlf Hansson return rc; 118021f1e2d4SVeerabhadrarao Badiganti msm_host->saved_tuning_phase = phase; 1181415b5a75SGeorgi Djakov dev_dbg(mmc_dev(mmc), "%s: Setting the tuning phase to %d\n", 1182415b5a75SGeorgi Djakov mmc_hostname(mmc), phase); 1183415b5a75SGeorgi Djakov } else { 1184415b5a75SGeorgi Djakov if (--tuning_seq_cnt) 1185415b5a75SGeorgi Djakov goto retry; 1186415b5a75SGeorgi Djakov /* Tuning failed */ 1187415b5a75SGeorgi Djakov dev_dbg(mmc_dev(mmc), "%s: No tuning point found\n", 1188415b5a75SGeorgi Djakov mmc_hostname(mmc)); 1189415b5a75SGeorgi Djakov rc = -EIO; 1190415b5a75SGeorgi Djakov } 1191415b5a75SGeorgi Djakov 1192ff06ce41SVenkat Gopalakrishnan if (!rc) 1193ff06ce41SVenkat Gopalakrishnan msm_host->tuning_done = true; 1194415b5a75SGeorgi Djakov return rc; 11950eb0d9f4SGeorgi Djakov } 11960eb0d9f4SGeorgi Djakov 1197db9bd163SRitesh Harjani /* 1198db9bd163SRitesh Harjani * sdhci_msm_hs400 - Calibrate the DLL for HS400 bus speed mode operation. 119944bf2312SRitesh Harjani * This needs to be done for both tuning and enhanced_strobe mode. 1200db9bd163SRitesh Harjani * DLL operation is only needed for clock > 100MHz. For clock <= 100MHz 1201db9bd163SRitesh Harjani * fixed feedback clock is used. 1202db9bd163SRitesh Harjani */ 1203db9bd163SRitesh Harjani static void sdhci_msm_hs400(struct sdhci_host *host, struct mmc_ios *ios) 1204db9bd163SRitesh Harjani { 1205db9bd163SRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1206db9bd163SRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1207db9bd163SRitesh Harjani int ret; 1208db9bd163SRitesh Harjani 1209db9bd163SRitesh Harjani if (host->clock > CORE_FREQ_100MHZ && 121044bf2312SRitesh Harjani (msm_host->tuning_done || ios->enhanced_strobe) && 121144bf2312SRitesh Harjani !msm_host->calibration_done) { 1212db9bd163SRitesh Harjani ret = sdhci_msm_hs400_dll_calibration(host); 1213db9bd163SRitesh Harjani if (!ret) 1214db9bd163SRitesh Harjani msm_host->calibration_done = true; 1215db9bd163SRitesh Harjani else 1216db9bd163SRitesh Harjani pr_err("%s: Failed to calibrate DLL for hs400 mode (%d)\n", 1217db9bd163SRitesh Harjani mmc_hostname(host->mmc), ret); 1218db9bd163SRitesh Harjani } 1219db9bd163SRitesh Harjani } 1220db9bd163SRitesh Harjani 1221ee320674SRitesh Harjani static void sdhci_msm_set_uhs_signaling(struct sdhci_host *host, 1222ee320674SRitesh Harjani unsigned int uhs) 1223ee320674SRitesh Harjani { 1224ee320674SRitesh Harjani struct mmc_host *mmc = host->mmc; 1225ff06ce41SVenkat Gopalakrishnan struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1226ff06ce41SVenkat Gopalakrishnan struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1227ee320674SRitesh Harjani u16 ctrl_2; 1228ff06ce41SVenkat Gopalakrishnan u32 config; 1229bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 1230bc99266bSSayali Lokhande msm_host->offset; 1231ee320674SRitesh Harjani 1232ee320674SRitesh Harjani ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); 1233ee320674SRitesh Harjani /* Select Bus Speed Mode for host */ 1234ee320674SRitesh Harjani ctrl_2 &= ~SDHCI_CTRL_UHS_MASK; 1235ee320674SRitesh Harjani switch (uhs) { 1236ee320674SRitesh Harjani case MMC_TIMING_UHS_SDR12: 1237ee320674SRitesh Harjani ctrl_2 |= SDHCI_CTRL_UHS_SDR12; 1238ee320674SRitesh Harjani break; 1239ee320674SRitesh Harjani case MMC_TIMING_UHS_SDR25: 1240ee320674SRitesh Harjani ctrl_2 |= SDHCI_CTRL_UHS_SDR25; 1241ee320674SRitesh Harjani break; 1242ee320674SRitesh Harjani case MMC_TIMING_UHS_SDR50: 1243ee320674SRitesh Harjani ctrl_2 |= SDHCI_CTRL_UHS_SDR50; 1244ee320674SRitesh Harjani break; 1245ff06ce41SVenkat Gopalakrishnan case MMC_TIMING_MMC_HS400: 1246ee320674SRitesh Harjani case MMC_TIMING_MMC_HS200: 1247ee320674SRitesh Harjani case MMC_TIMING_UHS_SDR104: 1248ee320674SRitesh Harjani ctrl_2 |= SDHCI_CTRL_UHS_SDR104; 1249ee320674SRitesh Harjani break; 1250ee320674SRitesh Harjani case MMC_TIMING_UHS_DDR50: 1251ee320674SRitesh Harjani case MMC_TIMING_MMC_DDR52: 1252ee320674SRitesh Harjani ctrl_2 |= SDHCI_CTRL_UHS_DDR50; 1253ee320674SRitesh Harjani break; 1254ee320674SRitesh Harjani } 1255ee320674SRitesh Harjani 1256ee320674SRitesh Harjani /* 1257ee320674SRitesh Harjani * When clock frequency is less than 100MHz, the feedback clock must be 1258ee320674SRitesh Harjani * provided and DLL must not be used so that tuning can be skipped. To 1259ee320674SRitesh Harjani * provide feedback clock, the mode selection can be any value less 1260ee320674SRitesh Harjani * than 3'b011 in bits [2:0] of HOST CONTROL2 register. 1261ee320674SRitesh Harjani */ 1262ff06ce41SVenkat Gopalakrishnan if (host->clock <= CORE_FREQ_100MHZ) { 1263ff06ce41SVenkat Gopalakrishnan if (uhs == MMC_TIMING_MMC_HS400 || 1264ee320674SRitesh Harjani uhs == MMC_TIMING_MMC_HS200 || 1265ff06ce41SVenkat Gopalakrishnan uhs == MMC_TIMING_UHS_SDR104) 1266ee320674SRitesh Harjani ctrl_2 &= ~SDHCI_CTRL_UHS_MASK; 1267ff06ce41SVenkat Gopalakrishnan /* 1268ff06ce41SVenkat Gopalakrishnan * DLL is not required for clock <= 100MHz 1269ff06ce41SVenkat Gopalakrishnan * Thus, make sure DLL it is disabled when not required 1270ff06ce41SVenkat Gopalakrishnan */ 1271bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 1272bc99266bSSayali Lokhande msm_offset->core_dll_config); 1273ff06ce41SVenkat Gopalakrishnan config |= CORE_DLL_RST; 1274bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 1275bc99266bSSayali Lokhande msm_offset->core_dll_config); 1276ff06ce41SVenkat Gopalakrishnan 1277bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 1278bc99266bSSayali Lokhande msm_offset->core_dll_config); 1279ff06ce41SVenkat Gopalakrishnan config |= CORE_DLL_PDN; 1280bc99266bSSayali Lokhande writel_relaxed(config, host->ioaddr + 1281bc99266bSSayali Lokhande msm_offset->core_dll_config); 1282ff06ce41SVenkat Gopalakrishnan 1283ff06ce41SVenkat Gopalakrishnan /* 1284ff06ce41SVenkat Gopalakrishnan * The DLL needs to be restored and CDCLP533 recalibrated 1285ff06ce41SVenkat Gopalakrishnan * when the clock frequency is set back to 400MHz. 1286ff06ce41SVenkat Gopalakrishnan */ 1287ff06ce41SVenkat Gopalakrishnan msm_host->calibration_done = false; 1288ff06ce41SVenkat Gopalakrishnan } 1289ee320674SRitesh Harjani 1290ee320674SRitesh Harjani dev_dbg(mmc_dev(mmc), "%s: clock=%u uhs=%u ctrl_2=0x%x\n", 1291ee320674SRitesh Harjani mmc_hostname(host->mmc), host->clock, uhs, ctrl_2); 1292ee320674SRitesh Harjani sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2); 1293cc392c58SRitesh Harjani 1294db9bd163SRitesh Harjani if (mmc->ios.timing == MMC_TIMING_MMC_HS400) 1295db9bd163SRitesh Harjani sdhci_msm_hs400(host, &mmc->ios); 1296ee320674SRitesh Harjani } 1297ee320674SRitesh Harjani 1298c0309b38SVijay Viswanath static inline void sdhci_msm_init_pwr_irq_wait(struct sdhci_msm_host *msm_host) 1299c0309b38SVijay Viswanath { 1300c0309b38SVijay Viswanath init_waitqueue_head(&msm_host->pwr_irq_wait); 1301c0309b38SVijay Viswanath } 1302c0309b38SVijay Viswanath 1303c0309b38SVijay Viswanath static inline void sdhci_msm_complete_pwr_irq_wait( 1304c0309b38SVijay Viswanath struct sdhci_msm_host *msm_host) 1305c0309b38SVijay Viswanath { 1306c0309b38SVijay Viswanath wake_up(&msm_host->pwr_irq_wait); 1307c0309b38SVijay Viswanath } 1308c0309b38SVijay Viswanath 1309c0309b38SVijay Viswanath /* 1310c0309b38SVijay Viswanath * sdhci_msm_check_power_status API should be called when registers writes 1311c0309b38SVijay Viswanath * which can toggle sdhci IO bus ON/OFF or change IO lines HIGH/LOW happens. 1312c0309b38SVijay Viswanath * To what state the register writes will change the IO lines should be passed 1313c0309b38SVijay Viswanath * as the argument req_type. This API will check whether the IO line's state 1314c0309b38SVijay Viswanath * is already the expected state and will wait for power irq only if 1315c0309b38SVijay Viswanath * power irq is expected to be trigerred based on the current IO line state 1316c0309b38SVijay Viswanath * and expected IO line state. 1317c0309b38SVijay Viswanath */ 1318c0309b38SVijay Viswanath static void sdhci_msm_check_power_status(struct sdhci_host *host, u32 req_type) 1319c0309b38SVijay Viswanath { 1320c0309b38SVijay Viswanath struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1321c0309b38SVijay Viswanath struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1322c0309b38SVijay Viswanath bool done = false; 1323bc99266bSSayali Lokhande u32 val = SWITCHABLE_SIGNALING_VOLTAGE; 1324bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 1325bc99266bSSayali Lokhande msm_host->offset; 1326c0309b38SVijay Viswanath 1327c0309b38SVijay Viswanath pr_debug("%s: %s: request %d curr_pwr_state %x curr_io_level %x\n", 1328c0309b38SVijay Viswanath mmc_hostname(host->mmc), __func__, req_type, 1329c0309b38SVijay Viswanath msm_host->curr_pwr_state, msm_host->curr_io_level); 1330c0309b38SVijay Viswanath 1331c0309b38SVijay Viswanath /* 133252884f8fSBjorn Andersson * The power interrupt will not be generated for signal voltage 133352884f8fSBjorn Andersson * switches if SWITCHABLE_SIGNALING_VOLTAGE in MCI_GENERICS is not set. 1334bc99266bSSayali Lokhande * Since sdhci-msm-v5, this bit has been removed and SW must consider 1335bc99266bSSayali Lokhande * it as always set. 133652884f8fSBjorn Andersson */ 1337bc99266bSSayali Lokhande if (!msm_host->mci_removed) 1338bc99266bSSayali Lokhande val = msm_host_readl(msm_host, host, 1339bc99266bSSayali Lokhande msm_offset->core_generics); 134052884f8fSBjorn Andersson if ((req_type & REQ_IO_HIGH || req_type & REQ_IO_LOW) && 134152884f8fSBjorn Andersson !(val & SWITCHABLE_SIGNALING_VOLTAGE)) { 134252884f8fSBjorn Andersson return; 134352884f8fSBjorn Andersson } 134452884f8fSBjorn Andersson 134552884f8fSBjorn Andersson /* 1346c0309b38SVijay Viswanath * The IRQ for request type IO High/LOW will be generated when - 1347c0309b38SVijay Viswanath * there is a state change in 1.8V enable bit (bit 3) of 1348c0309b38SVijay Viswanath * SDHCI_HOST_CONTROL2 register. The reset state of that bit is 0 1349c0309b38SVijay Viswanath * which indicates 3.3V IO voltage. So, when MMC core layer tries 1350c0309b38SVijay Viswanath * to set it to 3.3V before card detection happens, the 1351c0309b38SVijay Viswanath * IRQ doesn't get triggered as there is no state change in this bit. 1352c0309b38SVijay Viswanath * The driver already handles this case by changing the IO voltage 1353c0309b38SVijay Viswanath * level to high as part of controller power up sequence. Hence, check 1354c0309b38SVijay Viswanath * for host->pwr to handle a case where IO voltage high request is 1355c0309b38SVijay Viswanath * issued even before controller power up. 1356c0309b38SVijay Viswanath */ 1357c0309b38SVijay Viswanath if ((req_type & REQ_IO_HIGH) && !host->pwr) { 1358c0309b38SVijay Viswanath pr_debug("%s: do not wait for power IRQ that never comes, req_type: %d\n", 1359c0309b38SVijay Viswanath mmc_hostname(host->mmc), req_type); 1360c0309b38SVijay Viswanath return; 1361c0309b38SVijay Viswanath } 1362c0309b38SVijay Viswanath if ((req_type & msm_host->curr_pwr_state) || 1363c0309b38SVijay Viswanath (req_type & msm_host->curr_io_level)) 1364c0309b38SVijay Viswanath done = true; 1365c0309b38SVijay Viswanath /* 1366c0309b38SVijay Viswanath * This is needed here to handle cases where register writes will 1367c0309b38SVijay Viswanath * not change the current bus state or io level of the controller. 1368c0309b38SVijay Viswanath * In this case, no power irq will be triggerred and we should 1369c0309b38SVijay Viswanath * not wait. 1370c0309b38SVijay Viswanath */ 1371c0309b38SVijay Viswanath if (!done) { 1372c0309b38SVijay Viswanath if (!wait_event_timeout(msm_host->pwr_irq_wait, 1373c0309b38SVijay Viswanath msm_host->pwr_irq_flag, 1374c0309b38SVijay Viswanath msecs_to_jiffies(MSM_PWR_IRQ_TIMEOUT_MS))) 13759ccfa817SArnd Bergmann dev_warn(&msm_host->pdev->dev, 13769ccfa817SArnd Bergmann "%s: pwr_irq for req: (%d) timed out\n", 1377c0309b38SVijay Viswanath mmc_hostname(host->mmc), req_type); 1378c0309b38SVijay Viswanath } 1379c0309b38SVijay Viswanath pr_debug("%s: %s: request %d done\n", mmc_hostname(host->mmc), 1380c0309b38SVijay Viswanath __func__, req_type); 1381c0309b38SVijay Viswanath } 1382c0309b38SVijay Viswanath 1383401b2d06SSahitya Tummala static void sdhci_msm_dump_pwr_ctrl_regs(struct sdhci_host *host) 1384401b2d06SSahitya Tummala { 1385401b2d06SSahitya Tummala struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1386401b2d06SSahitya Tummala struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1387bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = 1388bc99266bSSayali Lokhande msm_host->offset; 1389401b2d06SSahitya Tummala 1390401b2d06SSahitya Tummala pr_err("%s: PWRCTL_STATUS: 0x%08x | PWRCTL_MASK: 0x%08x | PWRCTL_CTL: 0x%08x\n", 1391401b2d06SSahitya Tummala mmc_hostname(host->mmc), 1392bc99266bSSayali Lokhande msm_host_readl(msm_host, host, msm_offset->core_pwrctl_status), 1393bc99266bSSayali Lokhande msm_host_readl(msm_host, host, msm_offset->core_pwrctl_mask), 1394bc99266bSSayali Lokhande msm_host_readl(msm_host, host, msm_offset->core_pwrctl_ctl)); 1395401b2d06SSahitya Tummala } 1396401b2d06SSahitya Tummala 1397401b2d06SSahitya Tummala static void sdhci_msm_handle_pwr_irq(struct sdhci_host *host, int irq) 1398ad81d387SGeorgi Djakov { 1399ad81d387SGeorgi Djakov struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1400ad81d387SGeorgi Djakov struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1401ad81d387SGeorgi Djakov u32 irq_status, irq_ack = 0; 1402401b2d06SSahitya Tummala int retry = 10; 1403ac06fba1SVijay Viswanath u32 pwr_state = 0, io_level = 0; 14045c132323SVijay Viswanath u32 config; 1405bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = msm_host->offset; 1406ad81d387SGeorgi Djakov 1407bc99266bSSayali Lokhande irq_status = msm_host_readl(msm_host, host, 1408bc99266bSSayali Lokhande msm_offset->core_pwrctl_status); 1409ad81d387SGeorgi Djakov irq_status &= INT_MASK; 1410ad81d387SGeorgi Djakov 1411bc99266bSSayali Lokhande msm_host_writel(msm_host, irq_status, host, 1412bc99266bSSayali Lokhande msm_offset->core_pwrctl_clear); 1413ad81d387SGeorgi Djakov 1414401b2d06SSahitya Tummala /* 1415401b2d06SSahitya Tummala * There is a rare HW scenario where the first clear pulse could be 1416401b2d06SSahitya Tummala * lost when actual reset and clear/read of status register is 1417401b2d06SSahitya Tummala * happening at a time. Hence, retry for at least 10 times to make 1418401b2d06SSahitya Tummala * sure status register is cleared. Otherwise, this will result in 1419401b2d06SSahitya Tummala * a spurious power IRQ resulting in system instability. 1420401b2d06SSahitya Tummala */ 1421bc99266bSSayali Lokhande while (irq_status & msm_host_readl(msm_host, host, 1422bc99266bSSayali Lokhande msm_offset->core_pwrctl_status)) { 1423401b2d06SSahitya Tummala if (retry == 0) { 1424401b2d06SSahitya Tummala pr_err("%s: Timedout clearing (0x%x) pwrctl status register\n", 1425401b2d06SSahitya Tummala mmc_hostname(host->mmc), irq_status); 1426401b2d06SSahitya Tummala sdhci_msm_dump_pwr_ctrl_regs(host); 1427401b2d06SSahitya Tummala WARN_ON(1); 1428401b2d06SSahitya Tummala break; 1429401b2d06SSahitya Tummala } 1430bc99266bSSayali Lokhande msm_host_writel(msm_host, irq_status, host, 1431bc99266bSSayali Lokhande msm_offset->core_pwrctl_clear); 1432401b2d06SSahitya Tummala retry--; 1433401b2d06SSahitya Tummala udelay(10); 1434401b2d06SSahitya Tummala } 1435401b2d06SSahitya Tummala 1436c0309b38SVijay Viswanath /* Handle BUS ON/OFF*/ 1437c0309b38SVijay Viswanath if (irq_status & CORE_PWRCTL_BUS_ON) { 1438c0309b38SVijay Viswanath pwr_state = REQ_BUS_ON; 1439c0309b38SVijay Viswanath io_level = REQ_IO_HIGH; 1440ad81d387SGeorgi Djakov irq_ack |= CORE_PWRCTL_BUS_SUCCESS; 1441c0309b38SVijay Viswanath } 1442c0309b38SVijay Viswanath if (irq_status & CORE_PWRCTL_BUS_OFF) { 1443c0309b38SVijay Viswanath pwr_state = REQ_BUS_OFF; 1444c0309b38SVijay Viswanath io_level = REQ_IO_LOW; 1445c0309b38SVijay Viswanath irq_ack |= CORE_PWRCTL_BUS_SUCCESS; 1446c0309b38SVijay Viswanath } 1447c0309b38SVijay Viswanath /* Handle IO LOW/HIGH */ 1448c0309b38SVijay Viswanath if (irq_status & CORE_PWRCTL_IO_LOW) { 1449c0309b38SVijay Viswanath io_level = REQ_IO_LOW; 1450ad81d387SGeorgi Djakov irq_ack |= CORE_PWRCTL_IO_SUCCESS; 1451c0309b38SVijay Viswanath } 1452c0309b38SVijay Viswanath if (irq_status & CORE_PWRCTL_IO_HIGH) { 1453c0309b38SVijay Viswanath io_level = REQ_IO_HIGH; 1454c0309b38SVijay Viswanath irq_ack |= CORE_PWRCTL_IO_SUCCESS; 1455c0309b38SVijay Viswanath } 1456ad81d387SGeorgi Djakov 1457ad81d387SGeorgi Djakov /* 1458ad81d387SGeorgi Djakov * The driver has to acknowledge the interrupt, switch voltages and 1459ad81d387SGeorgi Djakov * report back if it succeded or not to this register. The voltage 1460ad81d387SGeorgi Djakov * switches are handled by the sdhci core, so just report success. 1461ad81d387SGeorgi Djakov */ 1462bc99266bSSayali Lokhande msm_host_writel(msm_host, irq_ack, host, 1463bc99266bSSayali Lokhande msm_offset->core_pwrctl_ctl); 1464401b2d06SSahitya Tummala 14655c132323SVijay Viswanath /* 14665c132323SVijay Viswanath * If we don't have info regarding the voltage levels supported by 14675c132323SVijay Viswanath * regulators, don't change the IO PAD PWR SWITCH. 14685c132323SVijay Viswanath */ 14695c132323SVijay Viswanath if (msm_host->caps_0 & CORE_VOLT_SUPPORT) { 14705c132323SVijay Viswanath u32 new_config; 14715c132323SVijay Viswanath /* 14725c132323SVijay Viswanath * We should unset IO PAD PWR switch only if the register write 14735c132323SVijay Viswanath * can set IO lines high and the regulator also switches to 3 V. 14745c132323SVijay Viswanath * Else, we should keep the IO PAD PWR switch set. 14755c132323SVijay Viswanath * This is applicable to certain targets where eMMC vccq supply 14765c132323SVijay Viswanath * is only 1.8V. In such targets, even during REQ_IO_HIGH, the 14775c132323SVijay Viswanath * IO PAD PWR switch must be kept set to reflect actual 14785c132323SVijay Viswanath * regulator voltage. This way, during initialization of 14795c132323SVijay Viswanath * controllers with only 1.8V, we will set the IO PAD bit 14805c132323SVijay Viswanath * without waiting for a REQ_IO_LOW. 14815c132323SVijay Viswanath */ 1482bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 1483bc99266bSSayali Lokhande msm_offset->core_vendor_spec); 14845c132323SVijay Viswanath new_config = config; 14855c132323SVijay Viswanath 14865c132323SVijay Viswanath if ((io_level & REQ_IO_HIGH) && 14875c132323SVijay Viswanath (msm_host->caps_0 & CORE_3_0V_SUPPORT)) 14885c132323SVijay Viswanath new_config &= ~CORE_IO_PAD_PWR_SWITCH; 14895c132323SVijay Viswanath else if ((io_level & REQ_IO_LOW) || 14905c132323SVijay Viswanath (msm_host->caps_0 & CORE_1_8V_SUPPORT)) 14915c132323SVijay Viswanath new_config |= CORE_IO_PAD_PWR_SWITCH; 14925c132323SVijay Viswanath 14935c132323SVijay Viswanath if (config ^ new_config) 1494bc99266bSSayali Lokhande writel_relaxed(new_config, host->ioaddr + 1495bc99266bSSayali Lokhande msm_offset->core_vendor_spec); 14965c132323SVijay Viswanath } 14975c132323SVijay Viswanath 1498c0309b38SVijay Viswanath if (pwr_state) 1499c0309b38SVijay Viswanath msm_host->curr_pwr_state = pwr_state; 1500c0309b38SVijay Viswanath if (io_level) 1501c0309b38SVijay Viswanath msm_host->curr_io_level = io_level; 1502c0309b38SVijay Viswanath 1503401b2d06SSahitya Tummala pr_debug("%s: %s: Handled IRQ(%d), irq_status=0x%x, ack=0x%x\n", 1504401b2d06SSahitya Tummala mmc_hostname(msm_host->mmc), __func__, irq, irq_status, 1505401b2d06SSahitya Tummala irq_ack); 1506ad81d387SGeorgi Djakov } 1507ad81d387SGeorgi Djakov 1508ad81d387SGeorgi Djakov static irqreturn_t sdhci_msm_pwr_irq(int irq, void *data) 1509ad81d387SGeorgi Djakov { 1510ad81d387SGeorgi Djakov struct sdhci_host *host = (struct sdhci_host *)data; 1511c0309b38SVijay Viswanath struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1512c0309b38SVijay Viswanath struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1513ad81d387SGeorgi Djakov 1514401b2d06SSahitya Tummala sdhci_msm_handle_pwr_irq(host, irq); 1515c0309b38SVijay Viswanath msm_host->pwr_irq_flag = 1; 1516c0309b38SVijay Viswanath sdhci_msm_complete_pwr_irq_wait(msm_host); 1517c0309b38SVijay Viswanath 1518ad81d387SGeorgi Djakov 1519ad81d387SGeorgi Djakov return IRQ_HANDLED; 1520ad81d387SGeorgi Djakov } 1521ad81d387SGeorgi Djakov 152280031bdeSRitesh Harjani static unsigned int sdhci_msm_get_max_clock(struct sdhci_host *host) 152380031bdeSRitesh Harjani { 152480031bdeSRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 152580031bdeSRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1526e4bf91f6SBjorn Andersson struct clk *core_clk = msm_host->bulk_clks[0].clk; 152780031bdeSRitesh Harjani 1528e4bf91f6SBjorn Andersson return clk_round_rate(core_clk, ULONG_MAX); 152980031bdeSRitesh Harjani } 153080031bdeSRitesh Harjani 153180031bdeSRitesh Harjani static unsigned int sdhci_msm_get_min_clock(struct sdhci_host *host) 153280031bdeSRitesh Harjani { 153380031bdeSRitesh Harjani return SDHCI_MSM_MIN_CLOCK; 153480031bdeSRitesh Harjani } 153580031bdeSRitesh Harjani 1536edc609fdSRitesh Harjani /** 1537edc609fdSRitesh Harjani * __sdhci_msm_set_clock - sdhci_msm clock control. 1538edc609fdSRitesh Harjani * 1539edc609fdSRitesh Harjani * Description: 1540edc609fdSRitesh Harjani * MSM controller does not use internal divider and 1541edc609fdSRitesh Harjani * instead directly control the GCC clock as per 1542edc609fdSRitesh Harjani * HW recommendation. 1543edc609fdSRitesh Harjani **/ 154430de038dSMasahiro Yamada static void __sdhci_msm_set_clock(struct sdhci_host *host, unsigned int clock) 1545edc609fdSRitesh Harjani { 1546edc609fdSRitesh Harjani u16 clk; 1547edc609fdSRitesh Harjani /* 1548edc609fdSRitesh Harjani * Keep actual_clock as zero - 1549edc609fdSRitesh Harjani * - since there is no divider used so no need of having actual_clock. 1550edc609fdSRitesh Harjani * - MSM controller uses SDCLK for data timeout calculation. If 1551edc609fdSRitesh Harjani * actual_clock is zero, host->clock is taken for calculation. 1552edc609fdSRitesh Harjani */ 1553edc609fdSRitesh Harjani host->mmc->actual_clock = 0; 1554edc609fdSRitesh Harjani 1555edc609fdSRitesh Harjani sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); 1556edc609fdSRitesh Harjani 1557edc609fdSRitesh Harjani if (clock == 0) 1558edc609fdSRitesh Harjani return; 1559edc609fdSRitesh Harjani 1560edc609fdSRitesh Harjani /* 1561edc609fdSRitesh Harjani * MSM controller do not use clock divider. 1562edc609fdSRitesh Harjani * Thus read SDHCI_CLOCK_CONTROL and only enable 1563edc609fdSRitesh Harjani * clock with no divider value programmed. 1564edc609fdSRitesh Harjani */ 1565edc609fdSRitesh Harjani clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL); 1566edc609fdSRitesh Harjani sdhci_enable_clk(host, clk); 1567edc609fdSRitesh Harjani } 1568edc609fdSRitesh Harjani 1569edc609fdSRitesh Harjani /* sdhci_msm_set_clock - Called with (host->lock) spinlock held. */ 1570edc609fdSRitesh Harjani static void sdhci_msm_set_clock(struct sdhci_host *host, unsigned int clock) 1571edc609fdSRitesh Harjani { 1572edc609fdSRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1573edc609fdSRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1574edc609fdSRitesh Harjani 1575edc609fdSRitesh Harjani if (!clock) { 1576edc609fdSRitesh Harjani msm_host->clk_rate = clock; 1577edc609fdSRitesh Harjani goto out; 1578edc609fdSRitesh Harjani } 1579edc609fdSRitesh Harjani 1580b54aaa8aSRitesh Harjani sdhci_msm_hc_select_mode(host); 1581edc609fdSRitesh Harjani 15820fb8a3d4SRitesh Harjani msm_set_clock_rate_for_bus_mode(host, clock); 1583edc609fdSRitesh Harjani out: 1584edc609fdSRitesh Harjani __sdhci_msm_set_clock(host, clock); 1585edc609fdSRitesh Harjani } 1586edc609fdSRitesh Harjani 158787a8df0dSRitesh Harjani /*****************************************************************************\ 158887a8df0dSRitesh Harjani * * 158987a8df0dSRitesh Harjani * MSM Command Queue Engine (CQE) * 159087a8df0dSRitesh Harjani * * 159187a8df0dSRitesh Harjani \*****************************************************************************/ 159287a8df0dSRitesh Harjani 159387a8df0dSRitesh Harjani static u32 sdhci_msm_cqe_irq(struct sdhci_host *host, u32 intmask) 159487a8df0dSRitesh Harjani { 159587a8df0dSRitesh Harjani int cmd_error = 0; 159687a8df0dSRitesh Harjani int data_error = 0; 159787a8df0dSRitesh Harjani 159887a8df0dSRitesh Harjani if (!sdhci_cqe_irq(host, intmask, &cmd_error, &data_error)) 159987a8df0dSRitesh Harjani return intmask; 160087a8df0dSRitesh Harjani 160187a8df0dSRitesh Harjani cqhci_irq(host->mmc, intmask, cmd_error, data_error); 160287a8df0dSRitesh Harjani return 0; 160387a8df0dSRitesh Harjani } 160487a8df0dSRitesh Harjani 16059051db38SStephen Boyd static void sdhci_msm_cqe_disable(struct mmc_host *mmc, bool recovery) 160687a8df0dSRitesh Harjani { 160787a8df0dSRitesh Harjani struct sdhci_host *host = mmc_priv(mmc); 160887a8df0dSRitesh Harjani unsigned long flags; 160987a8df0dSRitesh Harjani u32 ctrl; 161087a8df0dSRitesh Harjani 161187a8df0dSRitesh Harjani /* 161287a8df0dSRitesh Harjani * When CQE is halted, the legacy SDHCI path operates only 161387a8df0dSRitesh Harjani * on 16-byte descriptors in 64bit mode. 161487a8df0dSRitesh Harjani */ 161587a8df0dSRitesh Harjani if (host->flags & SDHCI_USE_64_BIT_DMA) 161687a8df0dSRitesh Harjani host->desc_sz = 16; 161787a8df0dSRitesh Harjani 161887a8df0dSRitesh Harjani spin_lock_irqsave(&host->lock, flags); 161987a8df0dSRitesh Harjani 162087a8df0dSRitesh Harjani /* 162187a8df0dSRitesh Harjani * During CQE command transfers, command complete bit gets latched. 162287a8df0dSRitesh Harjani * So s/w should clear command complete interrupt status when CQE is 162387a8df0dSRitesh Harjani * either halted or disabled. Otherwise unexpected SDCHI legacy 162487a8df0dSRitesh Harjani * interrupt gets triggered when CQE is halted/disabled. 162587a8df0dSRitesh Harjani */ 162687a8df0dSRitesh Harjani ctrl = sdhci_readl(host, SDHCI_INT_ENABLE); 162787a8df0dSRitesh Harjani ctrl |= SDHCI_INT_RESPONSE; 162887a8df0dSRitesh Harjani sdhci_writel(host, ctrl, SDHCI_INT_ENABLE); 162987a8df0dSRitesh Harjani sdhci_writel(host, SDHCI_INT_RESPONSE, SDHCI_INT_STATUS); 163087a8df0dSRitesh Harjani 163187a8df0dSRitesh Harjani spin_unlock_irqrestore(&host->lock, flags); 163287a8df0dSRitesh Harjani 163387a8df0dSRitesh Harjani sdhci_cqe_disable(mmc, recovery); 163487a8df0dSRitesh Harjani } 163587a8df0dSRitesh Harjani 163687a8df0dSRitesh Harjani static const struct cqhci_host_ops sdhci_msm_cqhci_ops = { 163787a8df0dSRitesh Harjani .enable = sdhci_cqe_enable, 163887a8df0dSRitesh Harjani .disable = sdhci_msm_cqe_disable, 163987a8df0dSRitesh Harjani }; 164087a8df0dSRitesh Harjani 164187a8df0dSRitesh Harjani static int sdhci_msm_cqe_add_host(struct sdhci_host *host, 164287a8df0dSRitesh Harjani struct platform_device *pdev) 164387a8df0dSRitesh Harjani { 164487a8df0dSRitesh Harjani struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 164587a8df0dSRitesh Harjani struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 164687a8df0dSRitesh Harjani struct cqhci_host *cq_host; 164787a8df0dSRitesh Harjani bool dma64; 164887a8df0dSRitesh Harjani u32 cqcfg; 164987a8df0dSRitesh Harjani int ret; 165087a8df0dSRitesh Harjani 165187a8df0dSRitesh Harjani /* 165287a8df0dSRitesh Harjani * When CQE is halted, SDHC operates only on 16byte ADMA descriptors. 165387a8df0dSRitesh Harjani * So ensure ADMA table is allocated for 16byte descriptors. 165487a8df0dSRitesh Harjani */ 165587a8df0dSRitesh Harjani if (host->caps & SDHCI_CAN_64BIT) 165687a8df0dSRitesh Harjani host->alloc_desc_sz = 16; 165787a8df0dSRitesh Harjani 165887a8df0dSRitesh Harjani ret = sdhci_setup_host(host); 165987a8df0dSRitesh Harjani if (ret) 166087a8df0dSRitesh Harjani return ret; 166187a8df0dSRitesh Harjani 166287a8df0dSRitesh Harjani cq_host = cqhci_pltfm_init(pdev); 166387a8df0dSRitesh Harjani if (IS_ERR(cq_host)) { 166487a8df0dSRitesh Harjani ret = PTR_ERR(cq_host); 166587a8df0dSRitesh Harjani dev_err(&pdev->dev, "cqhci-pltfm init: failed: %d\n", ret); 166687a8df0dSRitesh Harjani goto cleanup; 166787a8df0dSRitesh Harjani } 166887a8df0dSRitesh Harjani 166987a8df0dSRitesh Harjani msm_host->mmc->caps2 |= MMC_CAP2_CQE | MMC_CAP2_CQE_DCMD; 167087a8df0dSRitesh Harjani cq_host->ops = &sdhci_msm_cqhci_ops; 167187a8df0dSRitesh Harjani 167287a8df0dSRitesh Harjani dma64 = host->flags & SDHCI_USE_64_BIT_DMA; 167387a8df0dSRitesh Harjani 167487a8df0dSRitesh Harjani ret = cqhci_init(cq_host, host->mmc, dma64); 167587a8df0dSRitesh Harjani if (ret) { 167687a8df0dSRitesh Harjani dev_err(&pdev->dev, "%s: CQE init: failed (%d)\n", 167787a8df0dSRitesh Harjani mmc_hostname(host->mmc), ret); 167887a8df0dSRitesh Harjani goto cleanup; 167987a8df0dSRitesh Harjani } 168087a8df0dSRitesh Harjani 168187a8df0dSRitesh Harjani /* Disable cqe reset due to cqe enable signal */ 168287a8df0dSRitesh Harjani cqcfg = cqhci_readl(cq_host, CQHCI_VENDOR_CFG1); 168387a8df0dSRitesh Harjani cqcfg |= CQHCI_VENDOR_DIS_RST_ON_CQ_EN; 168487a8df0dSRitesh Harjani cqhci_writel(cq_host, cqcfg, CQHCI_VENDOR_CFG1); 168587a8df0dSRitesh Harjani 168687a8df0dSRitesh Harjani /* 168787a8df0dSRitesh Harjani * SDHC expects 12byte ADMA descriptors till CQE is enabled. 168887a8df0dSRitesh Harjani * So limit desc_sz to 12 so that the data commands that are sent 168987a8df0dSRitesh Harjani * during card initialization (before CQE gets enabled) would 169087a8df0dSRitesh Harjani * get executed without any issues. 169187a8df0dSRitesh Harjani */ 169287a8df0dSRitesh Harjani if (host->flags & SDHCI_USE_64_BIT_DMA) 169387a8df0dSRitesh Harjani host->desc_sz = 12; 169487a8df0dSRitesh Harjani 169587a8df0dSRitesh Harjani ret = __sdhci_add_host(host); 169687a8df0dSRitesh Harjani if (ret) 169787a8df0dSRitesh Harjani goto cleanup; 169887a8df0dSRitesh Harjani 169987a8df0dSRitesh Harjani dev_info(&pdev->dev, "%s: CQE init: success\n", 170087a8df0dSRitesh Harjani mmc_hostname(host->mmc)); 170187a8df0dSRitesh Harjani return ret; 170287a8df0dSRitesh Harjani 170387a8df0dSRitesh Harjani cleanup: 170487a8df0dSRitesh Harjani sdhci_cleanup_host(host); 170587a8df0dSRitesh Harjani return ret; 170687a8df0dSRitesh Harjani } 170787a8df0dSRitesh Harjani 1708c0309b38SVijay Viswanath /* 1709c0309b38SVijay Viswanath * Platform specific register write functions. This is so that, if any 1710c0309b38SVijay Viswanath * register write needs to be followed up by platform specific actions, 1711c0309b38SVijay Viswanath * they can be added here. These functions can go to sleep when writes 1712c0309b38SVijay Viswanath * to certain registers are done. 1713c0309b38SVijay Viswanath * These functions are relying on sdhci_set_ios not using spinlock. 1714c0309b38SVijay Viswanath */ 1715c0309b38SVijay Viswanath static int __sdhci_msm_check_write(struct sdhci_host *host, u16 val, int reg) 1716c0309b38SVijay Viswanath { 1717c0309b38SVijay Viswanath struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 1718c0309b38SVijay Viswanath struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 1719c0309b38SVijay Viswanath u32 req_type = 0; 1720c0309b38SVijay Viswanath 1721c0309b38SVijay Viswanath switch (reg) { 1722c0309b38SVijay Viswanath case SDHCI_HOST_CONTROL2: 1723c0309b38SVijay Viswanath req_type = (val & SDHCI_CTRL_VDD_180) ? REQ_IO_LOW : 1724c0309b38SVijay Viswanath REQ_IO_HIGH; 1725c0309b38SVijay Viswanath break; 1726c0309b38SVijay Viswanath case SDHCI_SOFTWARE_RESET: 1727c0309b38SVijay Viswanath if (host->pwr && (val & SDHCI_RESET_ALL)) 1728c0309b38SVijay Viswanath req_type = REQ_BUS_OFF; 1729c0309b38SVijay Viswanath break; 1730c0309b38SVijay Viswanath case SDHCI_POWER_CONTROL: 1731c0309b38SVijay Viswanath req_type = !val ? REQ_BUS_OFF : REQ_BUS_ON; 1732c0309b38SVijay Viswanath break; 1733a89e7bcbSLoic Poulain case SDHCI_TRANSFER_MODE: 1734a89e7bcbSLoic Poulain msm_host->transfer_mode = val; 1735a89e7bcbSLoic Poulain break; 1736a89e7bcbSLoic Poulain case SDHCI_COMMAND: 1737a89e7bcbSLoic Poulain if (!msm_host->use_cdr) 1738a89e7bcbSLoic Poulain break; 1739a89e7bcbSLoic Poulain if ((msm_host->transfer_mode & SDHCI_TRNS_READ) && 1740a89e7bcbSLoic Poulain SDHCI_GET_CMD(val) != MMC_SEND_TUNING_BLOCK_HS200 && 1741a89e7bcbSLoic Poulain SDHCI_GET_CMD(val) != MMC_SEND_TUNING_BLOCK) 1742a89e7bcbSLoic Poulain sdhci_msm_set_cdr(host, true); 1743a89e7bcbSLoic Poulain else 1744a89e7bcbSLoic Poulain sdhci_msm_set_cdr(host, false); 1745a89e7bcbSLoic Poulain break; 1746c0309b38SVijay Viswanath } 1747c0309b38SVijay Viswanath 1748c0309b38SVijay Viswanath if (req_type) { 1749c0309b38SVijay Viswanath msm_host->pwr_irq_flag = 0; 1750c0309b38SVijay Viswanath /* 1751c0309b38SVijay Viswanath * Since this register write may trigger a power irq, ensure 1752c0309b38SVijay Viswanath * all previous register writes are complete by this point. 1753c0309b38SVijay Viswanath */ 1754c0309b38SVijay Viswanath mb(); 1755c0309b38SVijay Viswanath } 1756c0309b38SVijay Viswanath return req_type; 1757c0309b38SVijay Viswanath } 1758c0309b38SVijay Viswanath 1759c0309b38SVijay Viswanath /* This function may sleep*/ 1760c0309b38SVijay Viswanath static void sdhci_msm_writew(struct sdhci_host *host, u16 val, int reg) 1761c0309b38SVijay Viswanath { 1762c0309b38SVijay Viswanath u32 req_type = 0; 1763c0309b38SVijay Viswanath 1764c0309b38SVijay Viswanath req_type = __sdhci_msm_check_write(host, val, reg); 1765c0309b38SVijay Viswanath writew_relaxed(val, host->ioaddr + reg); 1766c0309b38SVijay Viswanath 1767c0309b38SVijay Viswanath if (req_type) 1768c0309b38SVijay Viswanath sdhci_msm_check_power_status(host, req_type); 1769c0309b38SVijay Viswanath } 1770c0309b38SVijay Viswanath 1771c0309b38SVijay Viswanath /* This function may sleep*/ 1772c0309b38SVijay Viswanath static void sdhci_msm_writeb(struct sdhci_host *host, u8 val, int reg) 1773c0309b38SVijay Viswanath { 1774c0309b38SVijay Viswanath u32 req_type = 0; 1775c0309b38SVijay Viswanath 1776c0309b38SVijay Viswanath req_type = __sdhci_msm_check_write(host, val, reg); 1777c0309b38SVijay Viswanath 1778c0309b38SVijay Viswanath writeb_relaxed(val, host->ioaddr + reg); 1779c0309b38SVijay Viswanath 1780c0309b38SVijay Viswanath if (req_type) 1781c0309b38SVijay Viswanath sdhci_msm_check_power_status(host, req_type); 1782c0309b38SVijay Viswanath } 1783c0309b38SVijay Viswanath 1784ac06fba1SVijay Viswanath static void sdhci_msm_set_regulator_caps(struct sdhci_msm_host *msm_host) 1785ac06fba1SVijay Viswanath { 1786ac06fba1SVijay Viswanath struct mmc_host *mmc = msm_host->mmc; 1787ac06fba1SVijay Viswanath struct regulator *supply = mmc->supply.vqmmc; 17885c132323SVijay Viswanath u32 caps = 0, config; 17895c132323SVijay Viswanath struct sdhci_host *host = mmc_priv(mmc); 1790bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset = msm_host->offset; 1791ac06fba1SVijay Viswanath 1792ac06fba1SVijay Viswanath if (!IS_ERR(mmc->supply.vqmmc)) { 1793ac06fba1SVijay Viswanath if (regulator_is_supported_voltage(supply, 1700000, 1950000)) 1794ac06fba1SVijay Viswanath caps |= CORE_1_8V_SUPPORT; 1795ac06fba1SVijay Viswanath if (regulator_is_supported_voltage(supply, 2700000, 3600000)) 1796ac06fba1SVijay Viswanath caps |= CORE_3_0V_SUPPORT; 1797ac06fba1SVijay Viswanath 1798ac06fba1SVijay Viswanath if (!caps) 1799ac06fba1SVijay Viswanath pr_warn("%s: 1.8/3V not supported for vqmmc\n", 1800ac06fba1SVijay Viswanath mmc_hostname(mmc)); 1801ac06fba1SVijay Viswanath } 1802ac06fba1SVijay Viswanath 18035c132323SVijay Viswanath if (caps) { 18045c132323SVijay Viswanath /* 18055c132323SVijay Viswanath * Set the PAD_PWR_SWITCH_EN bit so that the PAD_PWR_SWITCH 18065c132323SVijay Viswanath * bit can be used as required later on. 18075c132323SVijay Viswanath */ 18085c132323SVijay Viswanath u32 io_level = msm_host->curr_io_level; 18095c132323SVijay Viswanath 1810bc99266bSSayali Lokhande config = readl_relaxed(host->ioaddr + 1811bc99266bSSayali Lokhande msm_offset->core_vendor_spec); 18125c132323SVijay Viswanath config |= CORE_IO_PAD_PWR_SWITCH_EN; 18135c132323SVijay Viswanath 18145c132323SVijay Viswanath if ((io_level & REQ_IO_HIGH) && (caps & CORE_3_0V_SUPPORT)) 18155c132323SVijay Viswanath config &= ~CORE_IO_PAD_PWR_SWITCH; 18165c132323SVijay Viswanath else if ((io_level & REQ_IO_LOW) || (caps & CORE_1_8V_SUPPORT)) 18175c132323SVijay Viswanath config |= CORE_IO_PAD_PWR_SWITCH; 18185c132323SVijay Viswanath 1819bc99266bSSayali Lokhande writel_relaxed(config, 1820bc99266bSSayali Lokhande host->ioaddr + msm_offset->core_vendor_spec); 18215c132323SVijay Viswanath } 1822ac06fba1SVijay Viswanath msm_host->caps_0 |= caps; 1823ac06fba1SVijay Viswanath pr_debug("%s: supported caps: 0x%08x\n", mmc_hostname(mmc), caps); 1824ac06fba1SVijay Viswanath } 1825ac06fba1SVijay Viswanath 18266ed4bb43SVijay Viswanath static const struct sdhci_msm_variant_ops mci_var_ops = { 18276ed4bb43SVijay Viswanath .msm_readl_relaxed = sdhci_msm_mci_variant_readl_relaxed, 18286ed4bb43SVijay Viswanath .msm_writel_relaxed = sdhci_msm_mci_variant_writel_relaxed, 18296ed4bb43SVijay Viswanath }; 18306ed4bb43SVijay Viswanath 18316ed4bb43SVijay Viswanath static const struct sdhci_msm_variant_ops v5_var_ops = { 18326ed4bb43SVijay Viswanath .msm_readl_relaxed = sdhci_msm_v5_variant_readl_relaxed, 18336ed4bb43SVijay Viswanath .msm_writel_relaxed = sdhci_msm_v5_variant_writel_relaxed, 18346ed4bb43SVijay Viswanath }; 18356ed4bb43SVijay Viswanath 18366ed4bb43SVijay Viswanath static const struct sdhci_msm_variant_info sdhci_msm_mci_var = { 18376ed4bb43SVijay Viswanath .var_ops = &mci_var_ops, 18386ed4bb43SVijay Viswanath .offset = &sdhci_msm_mci_offset, 18396ed4bb43SVijay Viswanath }; 18406ed4bb43SVijay Viswanath 18416ed4bb43SVijay Viswanath static const struct sdhci_msm_variant_info sdhci_msm_v5_var = { 18426ed4bb43SVijay Viswanath .mci_removed = true, 18436ed4bb43SVijay Viswanath .var_ops = &v5_var_ops, 18446ed4bb43SVijay Viswanath .offset = &sdhci_msm_v5_offset, 18456ed4bb43SVijay Viswanath }; 18466ed4bb43SVijay Viswanath 184721f1e2d4SVeerabhadrarao Badiganti static const struct sdhci_msm_variant_info sdm845_sdhci_var = { 184821f1e2d4SVeerabhadrarao Badiganti .mci_removed = true, 184921f1e2d4SVeerabhadrarao Badiganti .restore_dll_config = true, 185021f1e2d4SVeerabhadrarao Badiganti .var_ops = &v5_var_ops, 185121f1e2d4SVeerabhadrarao Badiganti .offset = &sdhci_msm_v5_offset, 185221f1e2d4SVeerabhadrarao Badiganti }; 185321f1e2d4SVeerabhadrarao Badiganti 18540eb0d9f4SGeorgi Djakov static const struct of_device_id sdhci_msm_dt_match[] = { 1855bc99266bSSayali Lokhande {.compatible = "qcom,sdhci-msm-v4", .data = &sdhci_msm_mci_var}, 1856bc99266bSSayali Lokhande {.compatible = "qcom,sdhci-msm-v5", .data = &sdhci_msm_v5_var}, 185721f1e2d4SVeerabhadrarao Badiganti {.compatible = "qcom,sdm845-sdhci", .data = &sdm845_sdhci_var}, 18580eb0d9f4SGeorgi Djakov {}, 18590eb0d9f4SGeorgi Djakov }; 18600eb0d9f4SGeorgi Djakov 18610eb0d9f4SGeorgi Djakov MODULE_DEVICE_TABLE(of, sdhci_msm_dt_match); 18620eb0d9f4SGeorgi Djakov 1863a50396a4SJisheng Zhang static const struct sdhci_ops sdhci_msm_ops = { 1864ed1761d7SStephen Boyd .reset = sdhci_reset, 1865edc609fdSRitesh Harjani .set_clock = sdhci_msm_set_clock, 186680031bdeSRitesh Harjani .get_min_clock = sdhci_msm_get_min_clock, 186780031bdeSRitesh Harjani .get_max_clock = sdhci_msm_get_max_clock, 1868ed1761d7SStephen Boyd .set_bus_width = sdhci_set_bus_width, 1869ee320674SRitesh Harjani .set_uhs_signaling = sdhci_msm_set_uhs_signaling, 1870c0309b38SVijay Viswanath .write_w = sdhci_msm_writew, 1871c0309b38SVijay Viswanath .write_b = sdhci_msm_writeb, 187287a8df0dSRitesh Harjani .irq = sdhci_msm_cqe_irq, 18730eb0d9f4SGeorgi Djakov }; 18740eb0d9f4SGeorgi Djakov 1875a50396a4SJisheng Zhang static const struct sdhci_pltfm_data sdhci_msm_pdata = { 1876a50396a4SJisheng Zhang .quirks = SDHCI_QUIRK_BROKEN_CARD_DETECTION | 1877a0e31428SRitesh Harjani SDHCI_QUIRK_SINGLE_POWER_WRITE | 1878a0e31428SRitesh Harjani SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN, 1879a0e31428SRitesh Harjani .quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN, 1880a50396a4SJisheng Zhang .ops = &sdhci_msm_ops, 1881a50396a4SJisheng Zhang }; 1882a50396a4SJisheng Zhang 18830eb0d9f4SGeorgi Djakov static int sdhci_msm_probe(struct platform_device *pdev) 18840eb0d9f4SGeorgi Djakov { 18850eb0d9f4SGeorgi Djakov struct sdhci_host *host; 18860eb0d9f4SGeorgi Djakov struct sdhci_pltfm_host *pltfm_host; 18870eb0d9f4SGeorgi Djakov struct sdhci_msm_host *msm_host; 1888e4bf91f6SBjorn Andersson struct clk *clk; 18890eb0d9f4SGeorgi Djakov int ret; 18903a3ad3e9SGeorgi Djakov u16 host_version, core_minor; 189129301f40SRitesh Harjani u32 core_version, config; 18923a3ad3e9SGeorgi Djakov u8 core_major; 1893bc99266bSSayali Lokhande const struct sdhci_msm_offset *msm_offset; 1894bc99266bSSayali Lokhande const struct sdhci_msm_variant_info *var_info; 189587a8df0dSRitesh Harjani struct device_node *node = pdev->dev.of_node; 18960eb0d9f4SGeorgi Djakov 18976f699531SJisheng Zhang host = sdhci_pltfm_init(pdev, &sdhci_msm_pdata, sizeof(*msm_host)); 18980eb0d9f4SGeorgi Djakov if (IS_ERR(host)) 18990eb0d9f4SGeorgi Djakov return PTR_ERR(host); 19000eb0d9f4SGeorgi Djakov 19012a641e53SSrinivas Kandagatla host->sdma_boundary = 0; 19020eb0d9f4SGeorgi Djakov pltfm_host = sdhci_priv(host); 19036f699531SJisheng Zhang msm_host = sdhci_pltfm_priv(pltfm_host); 19040eb0d9f4SGeorgi Djakov msm_host->mmc = host->mmc; 19050eb0d9f4SGeorgi Djakov msm_host->pdev = pdev; 19060eb0d9f4SGeorgi Djakov 19070eb0d9f4SGeorgi Djakov ret = mmc_of_parse(host->mmc); 19080eb0d9f4SGeorgi Djakov if (ret) 19090eb0d9f4SGeorgi Djakov goto pltfm_free; 19100eb0d9f4SGeorgi Djakov 1911bc99266bSSayali Lokhande /* 1912bc99266bSSayali Lokhande * Based on the compatible string, load the required msm host info from 1913bc99266bSSayali Lokhande * the data associated with the version info. 1914bc99266bSSayali Lokhande */ 1915bc99266bSSayali Lokhande var_info = of_device_get_match_data(&pdev->dev); 1916bc99266bSSayali Lokhande 1917bc99266bSSayali Lokhande msm_host->mci_removed = var_info->mci_removed; 191821f1e2d4SVeerabhadrarao Badiganti msm_host->restore_dll_config = var_info->restore_dll_config; 1919bc99266bSSayali Lokhande msm_host->var_ops = var_info->var_ops; 1920bc99266bSSayali Lokhande msm_host->offset = var_info->offset; 1921bc99266bSSayali Lokhande 1922bc99266bSSayali Lokhande msm_offset = msm_host->offset; 1923bc99266bSSayali Lokhande 19240eb0d9f4SGeorgi Djakov sdhci_get_of_property(pdev); 19250eb0d9f4SGeorgi Djakov 1926abf270e5SRitesh Harjani msm_host->saved_tuning_phase = INVALID_TUNING_PHASE; 1927abf270e5SRitesh Harjani 19280eb0d9f4SGeorgi Djakov /* Setup SDCC bus voter clock. */ 19290eb0d9f4SGeorgi Djakov msm_host->bus_clk = devm_clk_get(&pdev->dev, "bus"); 19300eb0d9f4SGeorgi Djakov if (!IS_ERR(msm_host->bus_clk)) { 19310eb0d9f4SGeorgi Djakov /* Vote for max. clk rate for max. performance */ 19320eb0d9f4SGeorgi Djakov ret = clk_set_rate(msm_host->bus_clk, INT_MAX); 19330eb0d9f4SGeorgi Djakov if (ret) 19340eb0d9f4SGeorgi Djakov goto pltfm_free; 19350eb0d9f4SGeorgi Djakov ret = clk_prepare_enable(msm_host->bus_clk); 19360eb0d9f4SGeorgi Djakov if (ret) 19370eb0d9f4SGeorgi Djakov goto pltfm_free; 19380eb0d9f4SGeorgi Djakov } 19390eb0d9f4SGeorgi Djakov 19400eb0d9f4SGeorgi Djakov /* Setup main peripheral bus clock */ 1941e4bf91f6SBjorn Andersson clk = devm_clk_get(&pdev->dev, "iface"); 1942e4bf91f6SBjorn Andersson if (IS_ERR(clk)) { 1943e4bf91f6SBjorn Andersson ret = PTR_ERR(clk); 19442801b95eSColin Ian King dev_err(&pdev->dev, "Peripheral clk setup failed (%d)\n", ret); 19450eb0d9f4SGeorgi Djakov goto bus_clk_disable; 19460eb0d9f4SGeorgi Djakov } 1947e4bf91f6SBjorn Andersson msm_host->bulk_clks[1].clk = clk; 19480eb0d9f4SGeorgi Djakov 19490eb0d9f4SGeorgi Djakov /* Setup SDC MMC clock */ 1950e4bf91f6SBjorn Andersson clk = devm_clk_get(&pdev->dev, "core"); 1951e4bf91f6SBjorn Andersson if (IS_ERR(clk)) { 1952e4bf91f6SBjorn Andersson ret = PTR_ERR(clk); 19530eb0d9f4SGeorgi Djakov dev_err(&pdev->dev, "SDC MMC clk setup failed (%d)\n", ret); 1954e4bf91f6SBjorn Andersson goto bus_clk_disable; 19550eb0d9f4SGeorgi Djakov } 1956e4bf91f6SBjorn Andersson msm_host->bulk_clks[0].clk = clk; 1957e4bf91f6SBjorn Andersson 1958e4bf91f6SBjorn Andersson /* Vote for maximum clock rate for maximum performance */ 1959e4bf91f6SBjorn Andersson ret = clk_set_rate(clk, INT_MAX); 1960e4bf91f6SBjorn Andersson if (ret) 1961e4bf91f6SBjorn Andersson dev_warn(&pdev->dev, "core clock boost failed\n"); 1962e4bf91f6SBjorn Andersson 19634946b3afSBjorn Andersson clk = devm_clk_get(&pdev->dev, "cal"); 19644946b3afSBjorn Andersson if (IS_ERR(clk)) 19654946b3afSBjorn Andersson clk = NULL; 19664946b3afSBjorn Andersson msm_host->bulk_clks[2].clk = clk; 19674946b3afSBjorn Andersson 19684946b3afSBjorn Andersson clk = devm_clk_get(&pdev->dev, "sleep"); 19694946b3afSBjorn Andersson if (IS_ERR(clk)) 19704946b3afSBjorn Andersson clk = NULL; 19714946b3afSBjorn Andersson msm_host->bulk_clks[3].clk = clk; 19724946b3afSBjorn Andersson 1973e4bf91f6SBjorn Andersson ret = clk_bulk_prepare_enable(ARRAY_SIZE(msm_host->bulk_clks), 1974e4bf91f6SBjorn Andersson msm_host->bulk_clks); 1975e4bf91f6SBjorn Andersson if (ret) 1976e4bf91f6SBjorn Andersson goto bus_clk_disable; 19770eb0d9f4SGeorgi Djakov 197883736352SVenkat Gopalakrishnan /* 197983736352SVenkat Gopalakrishnan * xo clock is needed for FLL feature of cm_dll. 198083736352SVenkat Gopalakrishnan * In case if xo clock is not mentioned in DT, warn and proceed. 198183736352SVenkat Gopalakrishnan */ 198283736352SVenkat Gopalakrishnan msm_host->xo_clk = devm_clk_get(&pdev->dev, "xo"); 198383736352SVenkat Gopalakrishnan if (IS_ERR(msm_host->xo_clk)) { 198483736352SVenkat Gopalakrishnan ret = PTR_ERR(msm_host->xo_clk); 198583736352SVenkat Gopalakrishnan dev_warn(&pdev->dev, "TCXO clk not present (%d)\n", ret); 198683736352SVenkat Gopalakrishnan } 198783736352SVenkat Gopalakrishnan 1988bc99266bSSayali Lokhande if (!msm_host->mci_removed) { 1989cb064b50SYangtao Li msm_host->core_mem = devm_platform_ioremap_resource(pdev, 1); 19900eb0d9f4SGeorgi Djakov if (IS_ERR(msm_host->core_mem)) { 19910eb0d9f4SGeorgi Djakov ret = PTR_ERR(msm_host->core_mem); 19920eb0d9f4SGeorgi Djakov goto clk_disable; 19930eb0d9f4SGeorgi Djakov } 1994bc99266bSSayali Lokhande } 19950eb0d9f4SGeorgi Djakov 19965574ddccSVenkat Gopalakrishnan /* Reset the vendor spec register to power on reset state */ 19975574ddccSVenkat Gopalakrishnan writel_relaxed(CORE_VENDOR_SPEC_POR_VAL, 1998bc99266bSSayali Lokhande host->ioaddr + msm_offset->core_vendor_spec); 19990eb0d9f4SGeorgi Djakov 2000bc99266bSSayali Lokhande if (!msm_host->mci_removed) { 20010eb0d9f4SGeorgi Djakov /* Set HC_MODE_EN bit in HC_MODE register */ 2002bc99266bSSayali Lokhande msm_host_writel(msm_host, HC_MODE_EN, host, 2003bc99266bSSayali Lokhande msm_offset->core_hc_mode); 2004bc99266bSSayali Lokhande config = msm_host_readl(msm_host, host, 2005bc99266bSSayali Lokhande msm_offset->core_hc_mode); 2006ff06ce41SVenkat Gopalakrishnan config |= FF_CLK_SW_RST_DIS; 2007bc99266bSSayali Lokhande msm_host_writel(msm_host, config, host, 2008bc99266bSSayali Lokhande msm_offset->core_hc_mode); 2009bc99266bSSayali Lokhande } 2010ff06ce41SVenkat Gopalakrishnan 20110eb0d9f4SGeorgi Djakov host_version = readw_relaxed((host->ioaddr + SDHCI_HOST_VERSION)); 20120eb0d9f4SGeorgi Djakov dev_dbg(&pdev->dev, "Host Version: 0x%x Vendor Version 0x%x\n", 20130eb0d9f4SGeorgi Djakov host_version, ((host_version & SDHCI_VENDOR_VER_MASK) >> 20140eb0d9f4SGeorgi Djakov SDHCI_VENDOR_VER_SHIFT)); 20150eb0d9f4SGeorgi Djakov 2016bc99266bSSayali Lokhande core_version = msm_host_readl(msm_host, host, 2017bc99266bSSayali Lokhande msm_offset->core_mci_version); 20183a3ad3e9SGeorgi Djakov core_major = (core_version & CORE_VERSION_MAJOR_MASK) >> 20193a3ad3e9SGeorgi Djakov CORE_VERSION_MAJOR_SHIFT; 20203a3ad3e9SGeorgi Djakov core_minor = core_version & CORE_VERSION_MINOR_MASK; 20213a3ad3e9SGeorgi Djakov dev_dbg(&pdev->dev, "MCI Version: 0x%08x, major: 0x%04x, minor: 0x%02x\n", 20223a3ad3e9SGeorgi Djakov core_version, core_major, core_minor); 20233a3ad3e9SGeorgi Djakov 202483736352SVenkat Gopalakrishnan if (core_major == 1 && core_minor >= 0x42) 202583736352SVenkat Gopalakrishnan msm_host->use_14lpp_dll_reset = true; 202683736352SVenkat Gopalakrishnan 20273a3ad3e9SGeorgi Djakov /* 202802e4293dSRitesh Harjani * SDCC 5 controller with major version 1, minor version 0x34 and later 202902e4293dSRitesh Harjani * with HS 400 mode support will use CM DLL instead of CDC LP 533 DLL. 203002e4293dSRitesh Harjani */ 203102e4293dSRitesh Harjani if (core_major == 1 && core_minor < 0x34) 203202e4293dSRitesh Harjani msm_host->use_cdclp533 = true; 203302e4293dSRitesh Harjani 203402e4293dSRitesh Harjani /* 20353a3ad3e9SGeorgi Djakov * Support for some capabilities is not advertised by newer 20363a3ad3e9SGeorgi Djakov * controller versions and must be explicitly enabled. 20373a3ad3e9SGeorgi Djakov */ 20383a3ad3e9SGeorgi Djakov if (core_major >= 1 && core_minor != 0x11 && core_minor != 0x12) { 203929301f40SRitesh Harjani config = readl_relaxed(host->ioaddr + SDHCI_CAPABILITIES); 204029301f40SRitesh Harjani config |= SDHCI_CAN_VDD_300 | SDHCI_CAN_DO_8BIT; 204129301f40SRitesh Harjani writel_relaxed(config, host->ioaddr + 2042bc99266bSSayali Lokhande msm_offset->core_vendor_spec_capabilities0); 20433a3ad3e9SGeorgi Djakov } 20443a3ad3e9SGeorgi Djakov 2045fa56ac97SVeerabhadrarao Badiganti if (core_major == 1 && core_minor >= 0x49) 2046fa56ac97SVeerabhadrarao Badiganti msm_host->updated_ddr_cfg = true; 2047fa56ac97SVeerabhadrarao Badiganti 2048c7ccee22SSubhash Jadavani /* 2049c7ccee22SSubhash Jadavani * Power on reset state may trigger power irq if previous status of 2050c7ccee22SSubhash Jadavani * PWRCTL was either BUS_ON or IO_HIGH_V. So before enabling pwr irq 2051c7ccee22SSubhash Jadavani * interrupt in GIC, any pending power irq interrupt should be 2052c7ccee22SSubhash Jadavani * acknowledged. Otherwise power irq interrupt handler would be 2053c7ccee22SSubhash Jadavani * fired prematurely. 2054c7ccee22SSubhash Jadavani */ 2055401b2d06SSahitya Tummala sdhci_msm_handle_pwr_irq(host, 0); 2056c7ccee22SSubhash Jadavani 2057c7ccee22SSubhash Jadavani /* 2058c7ccee22SSubhash Jadavani * Ensure that above writes are propogated before interrupt enablement 2059c7ccee22SSubhash Jadavani * in GIC. 2060c7ccee22SSubhash Jadavani */ 2061c7ccee22SSubhash Jadavani mb(); 2062c7ccee22SSubhash Jadavani 2063ad81d387SGeorgi Djakov /* Setup IRQ for handling power/voltage tasks with PMIC */ 2064ad81d387SGeorgi Djakov msm_host->pwr_irq = platform_get_irq_byname(pdev, "pwr_irq"); 2065ad81d387SGeorgi Djakov if (msm_host->pwr_irq < 0) { 2066d1f63f0cSWei Yongjun ret = msm_host->pwr_irq; 2067ad81d387SGeorgi Djakov goto clk_disable; 2068ad81d387SGeorgi Djakov } 2069ad81d387SGeorgi Djakov 2070c0309b38SVijay Viswanath sdhci_msm_init_pwr_irq_wait(msm_host); 2071c7ccee22SSubhash Jadavani /* Enable pwr irq interrupts */ 2072bc99266bSSayali Lokhande msm_host_writel(msm_host, INT_MASK, host, 2073bc99266bSSayali Lokhande msm_offset->core_pwrctl_mask); 2074c7ccee22SSubhash Jadavani 2075ad81d387SGeorgi Djakov ret = devm_request_threaded_irq(&pdev->dev, msm_host->pwr_irq, NULL, 2076ad81d387SGeorgi Djakov sdhci_msm_pwr_irq, IRQF_ONESHOT, 2077ad81d387SGeorgi Djakov dev_name(&pdev->dev), host); 2078ad81d387SGeorgi Djakov if (ret) { 2079ad81d387SGeorgi Djakov dev_err(&pdev->dev, "Request IRQ failed (%d)\n", ret); 2080ad81d387SGeorgi Djakov goto clk_disable; 2081ad81d387SGeorgi Djakov } 2082ad81d387SGeorgi Djakov 208367e6db11SPramod Gurav pm_runtime_get_noresume(&pdev->dev); 208467e6db11SPramod Gurav pm_runtime_set_active(&pdev->dev); 208567e6db11SPramod Gurav pm_runtime_enable(&pdev->dev); 208667e6db11SPramod Gurav pm_runtime_set_autosuspend_delay(&pdev->dev, 208767e6db11SPramod Gurav MSM_MMC_AUTOSUSPEND_DELAY_MS); 208867e6db11SPramod Gurav pm_runtime_use_autosuspend(&pdev->dev); 208967e6db11SPramod Gurav 20904436c535SRitesh Harjani host->mmc_host_ops.execute_tuning = sdhci_msm_execute_tuning; 209187a8df0dSRitesh Harjani if (of_property_read_bool(node, "supports-cqe")) 209287a8df0dSRitesh Harjani ret = sdhci_msm_cqe_add_host(host, pdev); 209387a8df0dSRitesh Harjani else 20940eb0d9f4SGeorgi Djakov ret = sdhci_add_host(host); 20950eb0d9f4SGeorgi Djakov if (ret) 209667e6db11SPramod Gurav goto pm_runtime_disable; 2097ac06fba1SVijay Viswanath sdhci_msm_set_regulator_caps(msm_host); 209867e6db11SPramod Gurav 209967e6db11SPramod Gurav pm_runtime_mark_last_busy(&pdev->dev); 210067e6db11SPramod Gurav pm_runtime_put_autosuspend(&pdev->dev); 21010eb0d9f4SGeorgi Djakov 21020eb0d9f4SGeorgi Djakov return 0; 21030eb0d9f4SGeorgi Djakov 210467e6db11SPramod Gurav pm_runtime_disable: 210567e6db11SPramod Gurav pm_runtime_disable(&pdev->dev); 210667e6db11SPramod Gurav pm_runtime_set_suspended(&pdev->dev); 210767e6db11SPramod Gurav pm_runtime_put_noidle(&pdev->dev); 21080eb0d9f4SGeorgi Djakov clk_disable: 2109e4bf91f6SBjorn Andersson clk_bulk_disable_unprepare(ARRAY_SIZE(msm_host->bulk_clks), 2110e4bf91f6SBjorn Andersson msm_host->bulk_clks); 21110eb0d9f4SGeorgi Djakov bus_clk_disable: 21120eb0d9f4SGeorgi Djakov if (!IS_ERR(msm_host->bus_clk)) 21130eb0d9f4SGeorgi Djakov clk_disable_unprepare(msm_host->bus_clk); 21140eb0d9f4SGeorgi Djakov pltfm_free: 21150eb0d9f4SGeorgi Djakov sdhci_pltfm_free(pdev); 21160eb0d9f4SGeorgi Djakov return ret; 21170eb0d9f4SGeorgi Djakov } 21180eb0d9f4SGeorgi Djakov 21190eb0d9f4SGeorgi Djakov static int sdhci_msm_remove(struct platform_device *pdev) 21200eb0d9f4SGeorgi Djakov { 21210eb0d9f4SGeorgi Djakov struct sdhci_host *host = platform_get_drvdata(pdev); 21220eb0d9f4SGeorgi Djakov struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 21236f699531SJisheng Zhang struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 21240eb0d9f4SGeorgi Djakov int dead = (readl_relaxed(host->ioaddr + SDHCI_INT_STATUS) == 21250eb0d9f4SGeorgi Djakov 0xffffffff); 21260eb0d9f4SGeorgi Djakov 21270eb0d9f4SGeorgi Djakov sdhci_remove_host(host, dead); 212867e6db11SPramod Gurav 212967e6db11SPramod Gurav pm_runtime_get_sync(&pdev->dev); 213067e6db11SPramod Gurav pm_runtime_disable(&pdev->dev); 213167e6db11SPramod Gurav pm_runtime_put_noidle(&pdev->dev); 213267e6db11SPramod Gurav 2133e4bf91f6SBjorn Andersson clk_bulk_disable_unprepare(ARRAY_SIZE(msm_host->bulk_clks), 2134e4bf91f6SBjorn Andersson msm_host->bulk_clks); 21350eb0d9f4SGeorgi Djakov if (!IS_ERR(msm_host->bus_clk)) 21360eb0d9f4SGeorgi Djakov clk_disable_unprepare(msm_host->bus_clk); 21376f699531SJisheng Zhang sdhci_pltfm_free(pdev); 21380eb0d9f4SGeorgi Djakov return 0; 21390eb0d9f4SGeorgi Djakov } 21400eb0d9f4SGeorgi Djakov 21416809a5f7SArnd Bergmann static __maybe_unused int sdhci_msm_runtime_suspend(struct device *dev) 214267e6db11SPramod Gurav { 214367e6db11SPramod Gurav struct sdhci_host *host = dev_get_drvdata(dev); 214467e6db11SPramod Gurav struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 214567e6db11SPramod Gurav struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 214667e6db11SPramod Gurav 2147e4bf91f6SBjorn Andersson clk_bulk_disable_unprepare(ARRAY_SIZE(msm_host->bulk_clks), 2148e4bf91f6SBjorn Andersson msm_host->bulk_clks); 214967e6db11SPramod Gurav 215067e6db11SPramod Gurav return 0; 215167e6db11SPramod Gurav } 215267e6db11SPramod Gurav 21536809a5f7SArnd Bergmann static __maybe_unused int sdhci_msm_runtime_resume(struct device *dev) 215467e6db11SPramod Gurav { 215567e6db11SPramod Gurav struct sdhci_host *host = dev_get_drvdata(dev); 215667e6db11SPramod Gurav struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 215767e6db11SPramod Gurav struct sdhci_msm_host *msm_host = sdhci_pltfm_priv(pltfm_host); 215821f1e2d4SVeerabhadrarao Badiganti int ret; 215967e6db11SPramod Gurav 216021f1e2d4SVeerabhadrarao Badiganti ret = clk_bulk_prepare_enable(ARRAY_SIZE(msm_host->bulk_clks), 2161e4bf91f6SBjorn Andersson msm_host->bulk_clks); 216221f1e2d4SVeerabhadrarao Badiganti if (ret) 216321f1e2d4SVeerabhadrarao Badiganti return ret; 216421f1e2d4SVeerabhadrarao Badiganti /* 216521f1e2d4SVeerabhadrarao Badiganti * Whenever core-clock is gated dynamically, it's needed to 216621f1e2d4SVeerabhadrarao Badiganti * restore the SDR DLL settings when the clock is ungated. 216721f1e2d4SVeerabhadrarao Badiganti */ 216821f1e2d4SVeerabhadrarao Badiganti if (msm_host->restore_dll_config && msm_host->clk_rate) 216921f1e2d4SVeerabhadrarao Badiganti return sdhci_msm_restore_sdr_dll_config(host); 217021f1e2d4SVeerabhadrarao Badiganti 217121f1e2d4SVeerabhadrarao Badiganti return 0; 217267e6db11SPramod Gurav } 217367e6db11SPramod Gurav 217467e6db11SPramod Gurav static const struct dev_pm_ops sdhci_msm_pm_ops = { 217567e6db11SPramod Gurav SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 217667e6db11SPramod Gurav pm_runtime_force_resume) 217767e6db11SPramod Gurav SET_RUNTIME_PM_OPS(sdhci_msm_runtime_suspend, 217867e6db11SPramod Gurav sdhci_msm_runtime_resume, 217967e6db11SPramod Gurav NULL) 218067e6db11SPramod Gurav }; 218167e6db11SPramod Gurav 21820eb0d9f4SGeorgi Djakov static struct platform_driver sdhci_msm_driver = { 21830eb0d9f4SGeorgi Djakov .probe = sdhci_msm_probe, 21840eb0d9f4SGeorgi Djakov .remove = sdhci_msm_remove, 21850eb0d9f4SGeorgi Djakov .driver = { 21860eb0d9f4SGeorgi Djakov .name = "sdhci_msm", 21870eb0d9f4SGeorgi Djakov .of_match_table = sdhci_msm_dt_match, 218867e6db11SPramod Gurav .pm = &sdhci_msm_pm_ops, 21890eb0d9f4SGeorgi Djakov }, 21900eb0d9f4SGeorgi Djakov }; 21910eb0d9f4SGeorgi Djakov 21920eb0d9f4SGeorgi Djakov module_platform_driver(sdhci_msm_driver); 21930eb0d9f4SGeorgi Djakov 21940eb0d9f4SGeorgi Djakov MODULE_DESCRIPTION("Qualcomm Secure Digital Host Controller Interface driver"); 21950eb0d9f4SGeorgi Djakov MODULE_LICENSE("GPL v2"); 2196