1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2019 Genesys Logic, Inc. 4 * 5 * Authors: Ben Chuang <ben.chuang@genesyslogic.com.tw> 6 * 7 * Version: v0.9.0 (2019-08-08) 8 */ 9 10 #include <linux/bitfield.h> 11 #include <linux/bits.h> 12 #include <linux/pci.h> 13 #include <linux/mmc/mmc.h> 14 #include <linux/delay.h> 15 #include <linux/of.h> 16 #include <linux/iopoll.h> 17 #include "sdhci.h" 18 #include "sdhci-cqhci.h" 19 #include "sdhci-pci.h" 20 #include "cqhci.h" 21 22 /* Genesys Logic extra registers */ 23 #define SDHCI_GLI_9750_WT 0x800 24 #define SDHCI_GLI_9750_WT_EN BIT(0) 25 #define GLI_9750_WT_EN_ON 0x1 26 #define GLI_9750_WT_EN_OFF 0x0 27 28 #define SDHCI_GLI_9750_CFG2 0x848 29 #define SDHCI_GLI_9750_CFG2_L1DLY GENMASK(28, 24) 30 #define GLI_9750_CFG2_L1DLY_VALUE 0x1F 31 32 #define SDHCI_GLI_9750_DRIVING 0x860 33 #define SDHCI_GLI_9750_DRIVING_1 GENMASK(11, 0) 34 #define SDHCI_GLI_9750_DRIVING_2 GENMASK(27, 26) 35 #define GLI_9750_DRIVING_1_VALUE 0xFFF 36 #define GLI_9750_DRIVING_2_VALUE 0x3 37 #define SDHCI_GLI_9750_SEL_1 BIT(29) 38 #define SDHCI_GLI_9750_SEL_2 BIT(31) 39 #define SDHCI_GLI_9750_ALL_RST (BIT(24)|BIT(25)|BIT(28)|BIT(30)) 40 41 #define SDHCI_GLI_9750_PLL 0x864 42 #define SDHCI_GLI_9750_PLL_LDIV GENMASK(9, 0) 43 #define SDHCI_GLI_9750_PLL_PDIV GENMASK(14, 12) 44 #define SDHCI_GLI_9750_PLL_DIR BIT(15) 45 #define SDHCI_GLI_9750_PLL_TX2_INV BIT(23) 46 #define SDHCI_GLI_9750_PLL_TX2_DLY GENMASK(22, 20) 47 #define GLI_9750_PLL_TX2_INV_VALUE 0x1 48 #define GLI_9750_PLL_TX2_DLY_VALUE 0x0 49 #define SDHCI_GLI_9750_PLLSSC_STEP GENMASK(28, 24) 50 #define SDHCI_GLI_9750_PLLSSC_EN BIT(31) 51 52 #define SDHCI_GLI_9750_PLLSSC 0x86C 53 #define SDHCI_GLI_9750_PLLSSC_PPM GENMASK(31, 16) 54 55 #define SDHCI_GLI_9750_SW_CTRL 0x874 56 #define SDHCI_GLI_9750_SW_CTRL_4 GENMASK(7, 6) 57 #define GLI_9750_SW_CTRL_4_VALUE 0x3 58 59 #define SDHCI_GLI_9750_MISC 0x878 60 #define SDHCI_GLI_9750_MISC_TX1_INV BIT(2) 61 #define SDHCI_GLI_9750_MISC_RX_INV BIT(3) 62 #define SDHCI_GLI_9750_MISC_TX1_DLY GENMASK(6, 4) 63 #define GLI_9750_MISC_TX1_INV_VALUE 0x0 64 #define GLI_9750_MISC_RX_INV_ON 0x1 65 #define GLI_9750_MISC_RX_INV_OFF 0x0 66 #define GLI_9750_MISC_RX_INV_VALUE GLI_9750_MISC_RX_INV_OFF 67 #define GLI_9750_MISC_TX1_DLY_VALUE 0x5 68 #define SDHCI_GLI_9750_MISC_SSC_OFF BIT(26) 69 70 #define SDHCI_GLI_9750_TUNING_CONTROL 0x540 71 #define SDHCI_GLI_9750_TUNING_CONTROL_EN BIT(4) 72 #define GLI_9750_TUNING_CONTROL_EN_ON 0x1 73 #define GLI_9750_TUNING_CONTROL_EN_OFF 0x0 74 #define SDHCI_GLI_9750_TUNING_CONTROL_GLITCH_1 BIT(16) 75 #define SDHCI_GLI_9750_TUNING_CONTROL_GLITCH_2 GENMASK(20, 19) 76 #define GLI_9750_TUNING_CONTROL_GLITCH_1_VALUE 0x1 77 #define GLI_9750_TUNING_CONTROL_GLITCH_2_VALUE 0x2 78 79 #define SDHCI_GLI_9750_TUNING_PARAMETERS 0x544 80 #define SDHCI_GLI_9750_TUNING_PARAMETERS_RX_DLY GENMASK(2, 0) 81 #define GLI_9750_TUNING_PARAMETERS_RX_DLY_VALUE 0x1 82 83 #define SDHCI_GLI_9763E_CTRL_HS400 0x7 84 85 #define SDHCI_GLI_9763E_HS400_ES_REG 0x52C 86 #define SDHCI_GLI_9763E_HS400_ES_BIT BIT(8) 87 88 #define PCIE_GLI_9763E_VHS 0x884 89 #define GLI_9763E_VHS_REV GENMASK(19, 16) 90 #define GLI_9763E_VHS_REV_R 0x0 91 #define GLI_9763E_VHS_REV_M 0x1 92 #define GLI_9763E_VHS_REV_W 0x2 93 #define PCIE_GLI_9763E_MB 0x888 94 #define GLI_9763E_MB_CMDQ_OFF BIT(19) 95 #define GLI_9763E_MB_ERP_ON BIT(7) 96 #define PCIE_GLI_9763E_SCR 0x8E0 97 #define GLI_9763E_SCR_AXI_REQ BIT(9) 98 99 #define PCIE_GLI_9763E_CFG 0x8A0 100 #define GLI_9763E_CFG_LPSN_DIS BIT(12) 101 102 #define PCIE_GLI_9763E_CFG2 0x8A4 103 #define GLI_9763E_CFG2_L1DLY GENMASK(28, 19) 104 #define GLI_9763E_CFG2_L1DLY_MID 0x54 105 106 #define PCIE_GLI_9763E_MMC_CTRL 0x960 107 #define GLI_9763E_HS400_SLOW BIT(3) 108 109 #define PCIE_GLI_9763E_CLKRXDLY 0x934 110 #define GLI_9763E_HS400_RXDLY GENMASK(31, 28) 111 #define GLI_9763E_HS400_RXDLY_5 0x5 112 113 #define SDHCI_GLI_9763E_CQE_BASE_ADDR 0x200 114 #define GLI_9763E_CQE_TRNS_MODE (SDHCI_TRNS_MULTI | \ 115 SDHCI_TRNS_BLK_CNT_EN | \ 116 SDHCI_TRNS_DMA) 117 118 #define PCI_GLI_9755_WT 0x800 119 #define PCI_GLI_9755_WT_EN BIT(0) 120 #define GLI_9755_WT_EN_ON 0x1 121 #define GLI_9755_WT_EN_OFF 0x0 122 123 #define PCI_GLI_9755_PECONF 0x44 124 #define PCI_GLI_9755_LFCLK GENMASK(14, 12) 125 #define PCI_GLI_9755_DMACLK BIT(29) 126 #define PCI_GLI_9755_INVERT_CD BIT(30) 127 #define PCI_GLI_9755_INVERT_WP BIT(31) 128 129 #define PCI_GLI_9755_CFG2 0x48 130 #define PCI_GLI_9755_CFG2_L1DLY GENMASK(28, 24) 131 #define GLI_9755_CFG2_L1DLY_VALUE 0x1F 132 133 #define PCI_GLI_9755_PLL 0x64 134 #define PCI_GLI_9755_PLL_LDIV GENMASK(9, 0) 135 #define PCI_GLI_9755_PLL_PDIV GENMASK(14, 12) 136 #define PCI_GLI_9755_PLL_DIR BIT(15) 137 #define PCI_GLI_9755_PLLSSC_STEP GENMASK(28, 24) 138 #define PCI_GLI_9755_PLLSSC_EN BIT(31) 139 140 #define PCI_GLI_9755_PLLSSC 0x68 141 #define PCI_GLI_9755_PLLSSC_PPM GENMASK(15, 0) 142 143 #define PCI_GLI_9755_SerDes 0x70 144 #define PCI_GLI_9755_SCP_DIS BIT(19) 145 146 #define PCI_GLI_9755_MISC 0x78 147 #define PCI_GLI_9755_MISC_SSC_OFF BIT(26) 148 149 #define PCI_GLI_9755_PM_CTRL 0xFC 150 #define PCI_GLI_9755_PM_STATE GENMASK(1, 0) 151 152 #define SDHCI_GLI_9767_GM_BURST_SIZE 0x510 153 #define SDHCI_GLI_9767_GM_BURST_SIZE_AXI_ALWAYS_SET BIT(8) 154 155 #define PCIE_GLI_9767_VHS 0x884 156 #define GLI_9767_VHS_REV GENMASK(19, 16) 157 #define GLI_9767_VHS_REV_R 0x0 158 #define GLI_9767_VHS_REV_M 0x1 159 #define GLI_9767_VHS_REV_W 0x2 160 161 #define PCIE_GLI_9767_COM_MAILBOX 0x888 162 #define PCIE_GLI_9767_COM_MAILBOX_SSC_EN BIT(1) 163 164 #define PCIE_GLI_9767_CFG 0x8A0 165 #define PCIE_GLI_9767_CFG_LOW_PWR_OFF BIT(12) 166 167 #define PCIE_GLI_9767_COMBO_MUX_CTL 0x8C8 168 #define PCIE_GLI_9767_COMBO_MUX_CTL_RST_EN BIT(6) 169 #define PCIE_GLI_9767_COMBO_MUX_CTL_WAIT_PERST_EN BIT(10) 170 171 #define PCIE_GLI_9767_PWR_MACRO_CTL 0x8D0 172 #define PCIE_GLI_9767_PWR_MACRO_CTL_LOW_VOLTAGE GENMASK(3, 0) 173 #define PCIE_GLI_9767_PWR_MACRO_CTL_LD0_LOW_OUTPUT_VOLTAGE GENMASK(15, 12) 174 #define PCIE_GLI_9767_PWR_MACRO_CTL_LD0_LOW_OUTPUT_VOLTAGE_VALUE 0x7 175 #define PCIE_GLI_9767_PWR_MACRO_CTL_RCLK_AMPLITUDE_CTL GENMASK(29, 28) 176 #define PCIE_GLI_9767_PWR_MACRO_CTL_RCLK_AMPLITUDE_CTL_VALUE 0x3 177 178 #define PCIE_GLI_9767_SCR 0x8E0 179 #define PCIE_GLI_9767_SCR_AUTO_AXI_W_BURST BIT(6) 180 #define PCIE_GLI_9767_SCR_AUTO_AXI_R_BURST BIT(7) 181 #define PCIE_GLI_9767_SCR_AXI_REQ BIT(9) 182 #define PCIE_GLI_9767_SCR_CARD_DET_PWR_SAVING_EN BIT(10) 183 #define PCIE_GLI_9767_SCR_SYSTEM_CLK_SELECT_MODE0 BIT(16) 184 #define PCIE_GLI_9767_SCR_SYSTEM_CLK_SELECT_MODE1 BIT(17) 185 #define PCIE_GLI_9767_SCR_CORE_PWR_D3_OFF BIT(21) 186 #define PCIE_GLI_9767_SCR_CFG_RST_DATA_LINK_DOWN BIT(30) 187 188 #define PCIE_GLI_9767_SDHC_CAP 0x91C 189 #define PCIE_GLI_9767_SDHC_CAP_SDEI_RESULT BIT(5) 190 191 #define PCIE_GLI_9767_SD_PLL_CTL 0x938 192 #define PCIE_GLI_9767_SD_PLL_CTL_PLL_LDIV GENMASK(9, 0) 193 #define PCIE_GLI_9767_SD_PLL_CTL_PLL_PDIV GENMASK(15, 12) 194 #define PCIE_GLI_9767_SD_PLL_CTL_PLL_DIR_EN BIT(16) 195 #define PCIE_GLI_9767_SD_PLL_CTL_SSC_EN BIT(19) 196 #define PCIE_GLI_9767_SD_PLL_CTL_SSC_STEP_SETTING GENMASK(28, 24) 197 198 #define PCIE_GLI_9767_SD_PLL_CTL2 0x93C 199 #define PCIE_GLI_9767_SD_PLL_CTL2_PLLSSC_PPM GENMASK(31, 16) 200 201 #define PCIE_GLI_9767_SD_EXPRESS_CTL 0x940 202 #define PCIE_GLI_9767_SD_EXPRESS_CTL_SDEI_EXE BIT(0) 203 #define PCIE_GLI_9767_SD_EXPRESS_CTL_SD_EXPRESS_MODE BIT(1) 204 205 #define PCIE_GLI_9767_SD_DATA_MULTI_CTL 0x944 206 #define PCIE_GLI_9767_SD_DATA_MULTI_CTL_DISCONNECT_TIME GENMASK(23, 16) 207 #define PCIE_GLI_9767_SD_DATA_MULTI_CTL_DISCONNECT_TIME_VALUE 0x64 208 209 #define PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2 0x950 210 #define PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2_SDEI_COMPLETE BIT(0) 211 212 #define PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_EN_REG2 0x954 213 #define PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_EN_REG2_SDEI_COMPLETE_STATUS_EN BIT(0) 214 215 #define PCIE_GLI_9767_NORMAL_ERR_INT_SIGNAL_EN_REG2 0x958 216 #define PCIE_GLI_9767_NORMAL_ERR_INT_SIGNAL_EN_REG2_SDEI_COMPLETE_SIGNAL_EN BIT(0) 217 218 #define GLI_MAX_TUNING_LOOP 40 219 220 /* Genesys Logic chipset */ 221 static inline void gl9750_wt_on(struct sdhci_host *host) 222 { 223 u32 wt_value; 224 u32 wt_enable; 225 226 wt_value = sdhci_readl(host, SDHCI_GLI_9750_WT); 227 wt_enable = FIELD_GET(SDHCI_GLI_9750_WT_EN, wt_value); 228 229 if (wt_enable == GLI_9750_WT_EN_ON) 230 return; 231 232 wt_value &= ~SDHCI_GLI_9750_WT_EN; 233 wt_value |= FIELD_PREP(SDHCI_GLI_9750_WT_EN, GLI_9750_WT_EN_ON); 234 235 sdhci_writel(host, wt_value, SDHCI_GLI_9750_WT); 236 } 237 238 static inline void gl9750_wt_off(struct sdhci_host *host) 239 { 240 u32 wt_value; 241 u32 wt_enable; 242 243 wt_value = sdhci_readl(host, SDHCI_GLI_9750_WT); 244 wt_enable = FIELD_GET(SDHCI_GLI_9750_WT_EN, wt_value); 245 246 if (wt_enable == GLI_9750_WT_EN_OFF) 247 return; 248 249 wt_value &= ~SDHCI_GLI_9750_WT_EN; 250 wt_value |= FIELD_PREP(SDHCI_GLI_9750_WT_EN, GLI_9750_WT_EN_OFF); 251 252 sdhci_writel(host, wt_value, SDHCI_GLI_9750_WT); 253 } 254 255 static void gli_set_9750(struct sdhci_host *host) 256 { 257 u32 driving_value; 258 u32 pll_value; 259 u32 sw_ctrl_value; 260 u32 misc_value; 261 u32 parameter_value; 262 u32 control_value; 263 u16 ctrl2; 264 265 gl9750_wt_on(host); 266 267 driving_value = sdhci_readl(host, SDHCI_GLI_9750_DRIVING); 268 pll_value = sdhci_readl(host, SDHCI_GLI_9750_PLL); 269 sw_ctrl_value = sdhci_readl(host, SDHCI_GLI_9750_SW_CTRL); 270 misc_value = sdhci_readl(host, SDHCI_GLI_9750_MISC); 271 parameter_value = sdhci_readl(host, SDHCI_GLI_9750_TUNING_PARAMETERS); 272 control_value = sdhci_readl(host, SDHCI_GLI_9750_TUNING_CONTROL); 273 274 driving_value &= ~(SDHCI_GLI_9750_DRIVING_1); 275 driving_value &= ~(SDHCI_GLI_9750_DRIVING_2); 276 driving_value |= FIELD_PREP(SDHCI_GLI_9750_DRIVING_1, 277 GLI_9750_DRIVING_1_VALUE); 278 driving_value |= FIELD_PREP(SDHCI_GLI_9750_DRIVING_2, 279 GLI_9750_DRIVING_2_VALUE); 280 driving_value &= ~(SDHCI_GLI_9750_SEL_1|SDHCI_GLI_9750_SEL_2|SDHCI_GLI_9750_ALL_RST); 281 driving_value |= SDHCI_GLI_9750_SEL_2; 282 sdhci_writel(host, driving_value, SDHCI_GLI_9750_DRIVING); 283 284 sw_ctrl_value &= ~SDHCI_GLI_9750_SW_CTRL_4; 285 sw_ctrl_value |= FIELD_PREP(SDHCI_GLI_9750_SW_CTRL_4, 286 GLI_9750_SW_CTRL_4_VALUE); 287 sdhci_writel(host, sw_ctrl_value, SDHCI_GLI_9750_SW_CTRL); 288 289 /* reset the tuning flow after reinit and before starting tuning */ 290 pll_value &= ~SDHCI_GLI_9750_PLL_TX2_INV; 291 pll_value &= ~SDHCI_GLI_9750_PLL_TX2_DLY; 292 pll_value |= FIELD_PREP(SDHCI_GLI_9750_PLL_TX2_INV, 293 GLI_9750_PLL_TX2_INV_VALUE); 294 pll_value |= FIELD_PREP(SDHCI_GLI_9750_PLL_TX2_DLY, 295 GLI_9750_PLL_TX2_DLY_VALUE); 296 297 misc_value &= ~SDHCI_GLI_9750_MISC_TX1_INV; 298 misc_value &= ~SDHCI_GLI_9750_MISC_RX_INV; 299 misc_value &= ~SDHCI_GLI_9750_MISC_TX1_DLY; 300 misc_value |= FIELD_PREP(SDHCI_GLI_9750_MISC_TX1_INV, 301 GLI_9750_MISC_TX1_INV_VALUE); 302 misc_value |= FIELD_PREP(SDHCI_GLI_9750_MISC_RX_INV, 303 GLI_9750_MISC_RX_INV_VALUE); 304 misc_value |= FIELD_PREP(SDHCI_GLI_9750_MISC_TX1_DLY, 305 GLI_9750_MISC_TX1_DLY_VALUE); 306 307 parameter_value &= ~SDHCI_GLI_9750_TUNING_PARAMETERS_RX_DLY; 308 parameter_value |= FIELD_PREP(SDHCI_GLI_9750_TUNING_PARAMETERS_RX_DLY, 309 GLI_9750_TUNING_PARAMETERS_RX_DLY_VALUE); 310 311 control_value &= ~SDHCI_GLI_9750_TUNING_CONTROL_GLITCH_1; 312 control_value &= ~SDHCI_GLI_9750_TUNING_CONTROL_GLITCH_2; 313 control_value |= FIELD_PREP(SDHCI_GLI_9750_TUNING_CONTROL_GLITCH_1, 314 GLI_9750_TUNING_CONTROL_GLITCH_1_VALUE); 315 control_value |= FIELD_PREP(SDHCI_GLI_9750_TUNING_CONTROL_GLITCH_2, 316 GLI_9750_TUNING_CONTROL_GLITCH_2_VALUE); 317 318 sdhci_writel(host, pll_value, SDHCI_GLI_9750_PLL); 319 sdhci_writel(host, misc_value, SDHCI_GLI_9750_MISC); 320 321 /* disable tuned clk */ 322 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); 323 ctrl2 &= ~SDHCI_CTRL_TUNED_CLK; 324 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2); 325 326 /* enable tuning parameters control */ 327 control_value &= ~SDHCI_GLI_9750_TUNING_CONTROL_EN; 328 control_value |= FIELD_PREP(SDHCI_GLI_9750_TUNING_CONTROL_EN, 329 GLI_9750_TUNING_CONTROL_EN_ON); 330 sdhci_writel(host, control_value, SDHCI_GLI_9750_TUNING_CONTROL); 331 332 /* write tuning parameters */ 333 sdhci_writel(host, parameter_value, SDHCI_GLI_9750_TUNING_PARAMETERS); 334 335 /* disable tuning parameters control */ 336 control_value &= ~SDHCI_GLI_9750_TUNING_CONTROL_EN; 337 control_value |= FIELD_PREP(SDHCI_GLI_9750_TUNING_CONTROL_EN, 338 GLI_9750_TUNING_CONTROL_EN_OFF); 339 sdhci_writel(host, control_value, SDHCI_GLI_9750_TUNING_CONTROL); 340 341 /* clear tuned clk */ 342 ctrl2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); 343 ctrl2 &= ~SDHCI_CTRL_TUNED_CLK; 344 sdhci_writew(host, ctrl2, SDHCI_HOST_CONTROL2); 345 346 gl9750_wt_off(host); 347 } 348 349 static void gli_set_9750_rx_inv(struct sdhci_host *host, bool b) 350 { 351 u32 misc_value; 352 353 gl9750_wt_on(host); 354 355 misc_value = sdhci_readl(host, SDHCI_GLI_9750_MISC); 356 misc_value &= ~SDHCI_GLI_9750_MISC_RX_INV; 357 if (b) { 358 misc_value |= FIELD_PREP(SDHCI_GLI_9750_MISC_RX_INV, 359 GLI_9750_MISC_RX_INV_ON); 360 } else { 361 misc_value |= FIELD_PREP(SDHCI_GLI_9750_MISC_RX_INV, 362 GLI_9750_MISC_RX_INV_OFF); 363 } 364 sdhci_writel(host, misc_value, SDHCI_GLI_9750_MISC); 365 366 gl9750_wt_off(host); 367 } 368 369 static int __sdhci_execute_tuning_9750(struct sdhci_host *host, u32 opcode) 370 { 371 int i; 372 int rx_inv; 373 374 for (rx_inv = 0; rx_inv < 2; rx_inv++) { 375 gli_set_9750_rx_inv(host, !!rx_inv); 376 sdhci_start_tuning(host); 377 378 for (i = 0; i < GLI_MAX_TUNING_LOOP; i++) { 379 u16 ctrl; 380 381 sdhci_send_tuning(host, opcode); 382 383 if (!host->tuning_done) { 384 sdhci_abort_tuning(host, opcode); 385 break; 386 } 387 388 ctrl = sdhci_readw(host, SDHCI_HOST_CONTROL2); 389 if (!(ctrl & SDHCI_CTRL_EXEC_TUNING)) { 390 if (ctrl & SDHCI_CTRL_TUNED_CLK) 391 return 0; /* Success! */ 392 break; 393 } 394 } 395 } 396 if (!host->tuning_done) { 397 pr_info("%s: Tuning timeout, falling back to fixed sampling clock\n", 398 mmc_hostname(host->mmc)); 399 return -ETIMEDOUT; 400 } 401 402 pr_info("%s: Tuning failed, falling back to fixed sampling clock\n", 403 mmc_hostname(host->mmc)); 404 sdhci_reset_tuning(host); 405 406 return -EAGAIN; 407 } 408 409 static int gl9750_execute_tuning(struct sdhci_host *host, u32 opcode) 410 { 411 host->mmc->retune_period = 0; 412 if (host->tuning_mode == SDHCI_TUNING_MODE_1) 413 host->mmc->retune_period = host->tuning_count; 414 415 gli_set_9750(host); 416 host->tuning_err = __sdhci_execute_tuning_9750(host, opcode); 417 sdhci_end_tuning(host); 418 419 return 0; 420 } 421 422 static void gl9750_disable_ssc_pll(struct sdhci_host *host) 423 { 424 u32 pll; 425 426 gl9750_wt_on(host); 427 pll = sdhci_readl(host, SDHCI_GLI_9750_PLL); 428 pll &= ~(SDHCI_GLI_9750_PLL_DIR | SDHCI_GLI_9750_PLLSSC_EN); 429 sdhci_writel(host, pll, SDHCI_GLI_9750_PLL); 430 gl9750_wt_off(host); 431 } 432 433 static void gl9750_set_pll(struct sdhci_host *host, u8 dir, u16 ldiv, u8 pdiv) 434 { 435 u32 pll; 436 437 gl9750_wt_on(host); 438 pll = sdhci_readl(host, SDHCI_GLI_9750_PLL); 439 pll &= ~(SDHCI_GLI_9750_PLL_LDIV | 440 SDHCI_GLI_9750_PLL_PDIV | 441 SDHCI_GLI_9750_PLL_DIR); 442 pll |= FIELD_PREP(SDHCI_GLI_9750_PLL_LDIV, ldiv) | 443 FIELD_PREP(SDHCI_GLI_9750_PLL_PDIV, pdiv) | 444 FIELD_PREP(SDHCI_GLI_9750_PLL_DIR, dir); 445 sdhci_writel(host, pll, SDHCI_GLI_9750_PLL); 446 gl9750_wt_off(host); 447 448 /* wait for pll stable */ 449 mdelay(1); 450 } 451 452 static bool gl9750_ssc_enable(struct sdhci_host *host) 453 { 454 u32 misc; 455 u8 off; 456 457 gl9750_wt_on(host); 458 misc = sdhci_readl(host, SDHCI_GLI_9750_MISC); 459 off = FIELD_GET(SDHCI_GLI_9750_MISC_SSC_OFF, misc); 460 gl9750_wt_off(host); 461 462 return !off; 463 } 464 465 static void gl9750_set_ssc(struct sdhci_host *host, u8 enable, u8 step, u16 ppm) 466 { 467 u32 pll; 468 u32 ssc; 469 470 gl9750_wt_on(host); 471 pll = sdhci_readl(host, SDHCI_GLI_9750_PLL); 472 ssc = sdhci_readl(host, SDHCI_GLI_9750_PLLSSC); 473 pll &= ~(SDHCI_GLI_9750_PLLSSC_STEP | 474 SDHCI_GLI_9750_PLLSSC_EN); 475 ssc &= ~SDHCI_GLI_9750_PLLSSC_PPM; 476 pll |= FIELD_PREP(SDHCI_GLI_9750_PLLSSC_STEP, step) | 477 FIELD_PREP(SDHCI_GLI_9750_PLLSSC_EN, enable); 478 ssc |= FIELD_PREP(SDHCI_GLI_9750_PLLSSC_PPM, ppm); 479 sdhci_writel(host, ssc, SDHCI_GLI_9750_PLLSSC); 480 sdhci_writel(host, pll, SDHCI_GLI_9750_PLL); 481 gl9750_wt_off(host); 482 } 483 484 static void gl9750_set_ssc_pll_205mhz(struct sdhci_host *host) 485 { 486 bool enable = gl9750_ssc_enable(host); 487 488 /* set pll to 205MHz and ssc */ 489 gl9750_set_ssc(host, enable, 0xF, 0x5A1D); 490 gl9750_set_pll(host, 0x1, 0x246, 0x0); 491 } 492 493 static void gl9750_set_ssc_pll_100mhz(struct sdhci_host *host) 494 { 495 bool enable = gl9750_ssc_enable(host); 496 497 /* set pll to 100MHz and ssc */ 498 gl9750_set_ssc(host, enable, 0xE, 0x51EC); 499 gl9750_set_pll(host, 0x1, 0x244, 0x1); 500 } 501 502 static void gl9750_set_ssc_pll_50mhz(struct sdhci_host *host) 503 { 504 bool enable = gl9750_ssc_enable(host); 505 506 /* set pll to 50MHz and ssc */ 507 gl9750_set_ssc(host, enable, 0xE, 0x51EC); 508 gl9750_set_pll(host, 0x1, 0x244, 0x3); 509 } 510 511 static void sdhci_gl9750_set_clock(struct sdhci_host *host, unsigned int clock) 512 { 513 struct mmc_ios *ios = &host->mmc->ios; 514 u16 clk; 515 516 host->mmc->actual_clock = 0; 517 518 gl9750_disable_ssc_pll(host); 519 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); 520 521 if (clock == 0) 522 return; 523 524 clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock); 525 if (clock == 200000000 && ios->timing == MMC_TIMING_UHS_SDR104) { 526 host->mmc->actual_clock = 205000000; 527 gl9750_set_ssc_pll_205mhz(host); 528 } else if (clock == 100000000) { 529 gl9750_set_ssc_pll_100mhz(host); 530 } else if (clock == 50000000) { 531 gl9750_set_ssc_pll_50mhz(host); 532 } 533 534 sdhci_enable_clk(host, clk); 535 } 536 537 static void gl9750_hw_setting(struct sdhci_host *host) 538 { 539 u32 value; 540 541 gl9750_wt_on(host); 542 543 value = sdhci_readl(host, SDHCI_GLI_9750_CFG2); 544 value &= ~SDHCI_GLI_9750_CFG2_L1DLY; 545 /* set ASPM L1 entry delay to 7.9us */ 546 value |= FIELD_PREP(SDHCI_GLI_9750_CFG2_L1DLY, 547 GLI_9750_CFG2_L1DLY_VALUE); 548 sdhci_writel(host, value, SDHCI_GLI_9750_CFG2); 549 550 gl9750_wt_off(host); 551 } 552 553 static void gli_pcie_enable_msi(struct sdhci_pci_slot *slot) 554 { 555 int ret; 556 557 ret = pci_alloc_irq_vectors(slot->chip->pdev, 1, 1, 558 PCI_IRQ_MSI | PCI_IRQ_MSIX); 559 if (ret < 0) { 560 pr_warn("%s: enable PCI MSI failed, error=%d\n", 561 mmc_hostname(slot->host->mmc), ret); 562 return; 563 } 564 565 slot->host->irq = pci_irq_vector(slot->chip->pdev, 0); 566 } 567 568 static inline void gl9755_wt_on(struct pci_dev *pdev) 569 { 570 u32 wt_value; 571 u32 wt_enable; 572 573 pci_read_config_dword(pdev, PCI_GLI_9755_WT, &wt_value); 574 wt_enable = FIELD_GET(PCI_GLI_9755_WT_EN, wt_value); 575 576 if (wt_enable == GLI_9755_WT_EN_ON) 577 return; 578 579 wt_value &= ~PCI_GLI_9755_WT_EN; 580 wt_value |= FIELD_PREP(PCI_GLI_9755_WT_EN, GLI_9755_WT_EN_ON); 581 582 pci_write_config_dword(pdev, PCI_GLI_9755_WT, wt_value); 583 } 584 585 static inline void gl9755_wt_off(struct pci_dev *pdev) 586 { 587 u32 wt_value; 588 u32 wt_enable; 589 590 pci_read_config_dword(pdev, PCI_GLI_9755_WT, &wt_value); 591 wt_enable = FIELD_GET(PCI_GLI_9755_WT_EN, wt_value); 592 593 if (wt_enable == GLI_9755_WT_EN_OFF) 594 return; 595 596 wt_value &= ~PCI_GLI_9755_WT_EN; 597 wt_value |= FIELD_PREP(PCI_GLI_9755_WT_EN, GLI_9755_WT_EN_OFF); 598 599 pci_write_config_dword(pdev, PCI_GLI_9755_WT, wt_value); 600 } 601 602 static void gl9755_disable_ssc_pll(struct pci_dev *pdev) 603 { 604 u32 pll; 605 606 gl9755_wt_on(pdev); 607 pci_read_config_dword(pdev, PCI_GLI_9755_PLL, &pll); 608 pll &= ~(PCI_GLI_9755_PLL_DIR | PCI_GLI_9755_PLLSSC_EN); 609 pci_write_config_dword(pdev, PCI_GLI_9755_PLL, pll); 610 gl9755_wt_off(pdev); 611 } 612 613 static void gl9755_set_pll(struct pci_dev *pdev, u8 dir, u16 ldiv, u8 pdiv) 614 { 615 u32 pll; 616 617 gl9755_wt_on(pdev); 618 pci_read_config_dword(pdev, PCI_GLI_9755_PLL, &pll); 619 pll &= ~(PCI_GLI_9755_PLL_LDIV | 620 PCI_GLI_9755_PLL_PDIV | 621 PCI_GLI_9755_PLL_DIR); 622 pll |= FIELD_PREP(PCI_GLI_9755_PLL_LDIV, ldiv) | 623 FIELD_PREP(PCI_GLI_9755_PLL_PDIV, pdiv) | 624 FIELD_PREP(PCI_GLI_9755_PLL_DIR, dir); 625 pci_write_config_dword(pdev, PCI_GLI_9755_PLL, pll); 626 gl9755_wt_off(pdev); 627 628 /* wait for pll stable */ 629 mdelay(1); 630 } 631 632 static bool gl9755_ssc_enable(struct pci_dev *pdev) 633 { 634 u32 misc; 635 u8 off; 636 637 gl9755_wt_on(pdev); 638 pci_read_config_dword(pdev, PCI_GLI_9755_MISC, &misc); 639 off = FIELD_GET(PCI_GLI_9755_MISC_SSC_OFF, misc); 640 gl9755_wt_off(pdev); 641 642 return !off; 643 } 644 645 static void gl9755_set_ssc(struct pci_dev *pdev, u8 enable, u8 step, u16 ppm) 646 { 647 u32 pll; 648 u32 ssc; 649 650 gl9755_wt_on(pdev); 651 pci_read_config_dword(pdev, PCI_GLI_9755_PLL, &pll); 652 pci_read_config_dword(pdev, PCI_GLI_9755_PLLSSC, &ssc); 653 pll &= ~(PCI_GLI_9755_PLLSSC_STEP | 654 PCI_GLI_9755_PLLSSC_EN); 655 ssc &= ~PCI_GLI_9755_PLLSSC_PPM; 656 pll |= FIELD_PREP(PCI_GLI_9755_PLLSSC_STEP, step) | 657 FIELD_PREP(PCI_GLI_9755_PLLSSC_EN, enable); 658 ssc |= FIELD_PREP(PCI_GLI_9755_PLLSSC_PPM, ppm); 659 pci_write_config_dword(pdev, PCI_GLI_9755_PLLSSC, ssc); 660 pci_write_config_dword(pdev, PCI_GLI_9755_PLL, pll); 661 gl9755_wt_off(pdev); 662 } 663 664 static void gl9755_set_ssc_pll_205mhz(struct pci_dev *pdev) 665 { 666 bool enable = gl9755_ssc_enable(pdev); 667 668 /* set pll to 205MHz and ssc */ 669 gl9755_set_ssc(pdev, enable, 0xF, 0x5A1D); 670 gl9755_set_pll(pdev, 0x1, 0x246, 0x0); 671 } 672 673 static void gl9755_set_ssc_pll_100mhz(struct pci_dev *pdev) 674 { 675 bool enable = gl9755_ssc_enable(pdev); 676 677 /* set pll to 100MHz and ssc */ 678 gl9755_set_ssc(pdev, enable, 0xE, 0x51EC); 679 gl9755_set_pll(pdev, 0x1, 0x244, 0x1); 680 } 681 682 static void gl9755_set_ssc_pll_50mhz(struct pci_dev *pdev) 683 { 684 bool enable = gl9755_ssc_enable(pdev); 685 686 /* set pll to 50MHz and ssc */ 687 gl9755_set_ssc(pdev, enable, 0xE, 0x51EC); 688 gl9755_set_pll(pdev, 0x1, 0x244, 0x3); 689 } 690 691 static void sdhci_gl9755_set_clock(struct sdhci_host *host, unsigned int clock) 692 { 693 struct sdhci_pci_slot *slot = sdhci_priv(host); 694 struct mmc_ios *ios = &host->mmc->ios; 695 struct pci_dev *pdev; 696 u16 clk; 697 698 pdev = slot->chip->pdev; 699 host->mmc->actual_clock = 0; 700 701 gl9755_disable_ssc_pll(pdev); 702 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); 703 704 if (clock == 0) 705 return; 706 707 clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock); 708 if (clock == 200000000 && ios->timing == MMC_TIMING_UHS_SDR104) { 709 host->mmc->actual_clock = 205000000; 710 gl9755_set_ssc_pll_205mhz(pdev); 711 } else if (clock == 100000000) { 712 gl9755_set_ssc_pll_100mhz(pdev); 713 } else if (clock == 50000000) { 714 gl9755_set_ssc_pll_50mhz(pdev); 715 } 716 717 sdhci_enable_clk(host, clk); 718 } 719 720 static void gl9755_hw_setting(struct sdhci_pci_slot *slot) 721 { 722 struct pci_dev *pdev = slot->chip->pdev; 723 u32 value; 724 725 gl9755_wt_on(pdev); 726 727 pci_read_config_dword(pdev, PCI_GLI_9755_PECONF, &value); 728 /* 729 * Apple ARM64 platforms using these chips may have 730 * inverted CD/WP detection. 731 */ 732 if (of_property_read_bool(pdev->dev.of_node, "cd-inverted")) 733 value |= PCI_GLI_9755_INVERT_CD; 734 if (of_property_read_bool(pdev->dev.of_node, "wp-inverted")) 735 value |= PCI_GLI_9755_INVERT_WP; 736 value &= ~PCI_GLI_9755_LFCLK; 737 value &= ~PCI_GLI_9755_DMACLK; 738 pci_write_config_dword(pdev, PCI_GLI_9755_PECONF, value); 739 740 /* enable short circuit protection */ 741 pci_read_config_dword(pdev, PCI_GLI_9755_SerDes, &value); 742 value &= ~PCI_GLI_9755_SCP_DIS; 743 pci_write_config_dword(pdev, PCI_GLI_9755_SerDes, value); 744 745 pci_read_config_dword(pdev, PCI_GLI_9755_CFG2, &value); 746 value &= ~PCI_GLI_9755_CFG2_L1DLY; 747 /* set ASPM L1 entry delay to 7.9us */ 748 value |= FIELD_PREP(PCI_GLI_9755_CFG2_L1DLY, 749 GLI_9755_CFG2_L1DLY_VALUE); 750 pci_write_config_dword(pdev, PCI_GLI_9755_CFG2, value); 751 752 /* toggle PM state to allow GL9755 to enter ASPM L1.2 */ 753 pci_read_config_dword(pdev, PCI_GLI_9755_PM_CTRL, &value); 754 value |= PCI_GLI_9755_PM_STATE; 755 pci_write_config_dword(pdev, PCI_GLI_9755_PM_CTRL, value); 756 value &= ~PCI_GLI_9755_PM_STATE; 757 pci_write_config_dword(pdev, PCI_GLI_9755_PM_CTRL, value); 758 759 gl9755_wt_off(pdev); 760 } 761 762 static inline void gl9767_vhs_read(struct pci_dev *pdev) 763 { 764 u32 vhs_enable; 765 u32 vhs_value; 766 767 pci_read_config_dword(pdev, PCIE_GLI_9767_VHS, &vhs_value); 768 vhs_enable = FIELD_GET(GLI_9767_VHS_REV, vhs_value); 769 770 if (vhs_enable == GLI_9767_VHS_REV_R) 771 return; 772 773 vhs_value &= ~GLI_9767_VHS_REV; 774 vhs_value |= FIELD_PREP(GLI_9767_VHS_REV, GLI_9767_VHS_REV_R); 775 776 pci_write_config_dword(pdev, PCIE_GLI_9767_VHS, vhs_value); 777 } 778 779 static inline void gl9767_vhs_write(struct pci_dev *pdev) 780 { 781 u32 vhs_enable; 782 u32 vhs_value; 783 784 pci_read_config_dword(pdev, PCIE_GLI_9767_VHS, &vhs_value); 785 vhs_enable = FIELD_GET(GLI_9767_VHS_REV, vhs_value); 786 787 if (vhs_enable == GLI_9767_VHS_REV_W) 788 return; 789 790 vhs_value &= ~GLI_9767_VHS_REV; 791 vhs_value |= FIELD_PREP(GLI_9767_VHS_REV, GLI_9767_VHS_REV_W); 792 793 pci_write_config_dword(pdev, PCIE_GLI_9767_VHS, vhs_value); 794 } 795 796 static bool gl9767_ssc_enable(struct pci_dev *pdev) 797 { 798 u32 value; 799 u8 enable; 800 801 gl9767_vhs_write(pdev); 802 803 pci_read_config_dword(pdev, PCIE_GLI_9767_COM_MAILBOX, &value); 804 enable = FIELD_GET(PCIE_GLI_9767_COM_MAILBOX_SSC_EN, value); 805 806 gl9767_vhs_read(pdev); 807 808 return enable; 809 } 810 811 static void gl9767_set_ssc(struct pci_dev *pdev, u8 enable, u8 step, u16 ppm) 812 { 813 u32 pll; 814 u32 ssc; 815 816 gl9767_vhs_write(pdev); 817 818 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL, &pll); 819 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL2, &ssc); 820 pll &= ~(PCIE_GLI_9767_SD_PLL_CTL_SSC_STEP_SETTING | 821 PCIE_GLI_9767_SD_PLL_CTL_SSC_EN); 822 ssc &= ~PCIE_GLI_9767_SD_PLL_CTL2_PLLSSC_PPM; 823 pll |= FIELD_PREP(PCIE_GLI_9767_SD_PLL_CTL_SSC_STEP_SETTING, step) | 824 FIELD_PREP(PCIE_GLI_9767_SD_PLL_CTL_SSC_EN, enable); 825 ssc |= FIELD_PREP(PCIE_GLI_9767_SD_PLL_CTL2_PLLSSC_PPM, ppm); 826 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL2, ssc); 827 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL, pll); 828 829 gl9767_vhs_read(pdev); 830 } 831 832 static void gl9767_set_pll(struct pci_dev *pdev, u8 dir, u16 ldiv, u8 pdiv) 833 { 834 u32 pll; 835 836 gl9767_vhs_write(pdev); 837 838 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL, &pll); 839 pll &= ~(PCIE_GLI_9767_SD_PLL_CTL_PLL_LDIV | 840 PCIE_GLI_9767_SD_PLL_CTL_PLL_PDIV | 841 PCIE_GLI_9767_SD_PLL_CTL_PLL_DIR_EN); 842 pll |= FIELD_PREP(PCIE_GLI_9767_SD_PLL_CTL_PLL_LDIV, ldiv) | 843 FIELD_PREP(PCIE_GLI_9767_SD_PLL_CTL_PLL_PDIV, pdiv) | 844 FIELD_PREP(PCIE_GLI_9767_SD_PLL_CTL_PLL_DIR_EN, dir); 845 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL, pll); 846 847 gl9767_vhs_read(pdev); 848 849 /* wait for pll stable */ 850 usleep_range(1000, 1100); 851 } 852 853 static void gl9767_set_ssc_pll_205mhz(struct pci_dev *pdev) 854 { 855 bool enable = gl9767_ssc_enable(pdev); 856 857 /* set pll to 205MHz and ssc */ 858 gl9767_set_ssc(pdev, enable, 0x1F, 0xF5C3); 859 gl9767_set_pll(pdev, 0x1, 0x246, 0x0); 860 } 861 862 static void gl9767_disable_ssc_pll(struct pci_dev *pdev) 863 { 864 u32 pll; 865 866 gl9767_vhs_write(pdev); 867 868 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL, &pll); 869 pll &= ~(PCIE_GLI_9767_SD_PLL_CTL_PLL_DIR_EN | PCIE_GLI_9767_SD_PLL_CTL_SSC_EN); 870 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_PLL_CTL, pll); 871 872 gl9767_vhs_read(pdev); 873 } 874 875 static void sdhci_gl9767_set_clock(struct sdhci_host *host, unsigned int clock) 876 { 877 struct sdhci_pci_slot *slot = sdhci_priv(host); 878 struct mmc_ios *ios = &host->mmc->ios; 879 struct pci_dev *pdev; 880 u32 value; 881 u16 clk; 882 883 pdev = slot->chip->pdev; 884 host->mmc->actual_clock = 0; 885 886 gl9767_vhs_write(pdev); 887 888 pci_read_config_dword(pdev, PCIE_GLI_9767_CFG, &value); 889 value |= PCIE_GLI_9767_CFG_LOW_PWR_OFF; 890 pci_write_config_dword(pdev, PCIE_GLI_9767_CFG, value); 891 892 gl9767_disable_ssc_pll(pdev); 893 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); 894 895 if (clock == 0) 896 return; 897 898 clk = sdhci_calc_clk(host, clock, &host->mmc->actual_clock); 899 if (clock == 200000000 && ios->timing == MMC_TIMING_UHS_SDR104) { 900 host->mmc->actual_clock = 205000000; 901 gl9767_set_ssc_pll_205mhz(pdev); 902 } 903 904 sdhci_enable_clk(host, clk); 905 906 pci_read_config_dword(pdev, PCIE_GLI_9767_CFG, &value); 907 value &= ~PCIE_GLI_9767_CFG_LOW_PWR_OFF; 908 pci_write_config_dword(pdev, PCIE_GLI_9767_CFG, value); 909 910 gl9767_vhs_read(pdev); 911 } 912 913 static void gli_set_9767(struct sdhci_host *host) 914 { 915 u32 value; 916 917 value = sdhci_readl(host, SDHCI_GLI_9767_GM_BURST_SIZE); 918 value &= ~SDHCI_GLI_9767_GM_BURST_SIZE_AXI_ALWAYS_SET; 919 sdhci_writel(host, value, SDHCI_GLI_9767_GM_BURST_SIZE); 920 } 921 922 static void gl9767_hw_setting(struct sdhci_pci_slot *slot) 923 { 924 struct pci_dev *pdev = slot->chip->pdev; 925 u32 value; 926 927 gl9767_vhs_write(pdev); 928 929 pci_read_config_dword(pdev, PCIE_GLI_9767_PWR_MACRO_CTL, &value); 930 value &= ~(PCIE_GLI_9767_PWR_MACRO_CTL_LOW_VOLTAGE | 931 PCIE_GLI_9767_PWR_MACRO_CTL_LD0_LOW_OUTPUT_VOLTAGE | 932 PCIE_GLI_9767_PWR_MACRO_CTL_RCLK_AMPLITUDE_CTL); 933 934 value |= PCIE_GLI_9767_PWR_MACRO_CTL_LOW_VOLTAGE | 935 FIELD_PREP(PCIE_GLI_9767_PWR_MACRO_CTL_LD0_LOW_OUTPUT_VOLTAGE, 936 PCIE_GLI_9767_PWR_MACRO_CTL_LD0_LOW_OUTPUT_VOLTAGE_VALUE) | 937 FIELD_PREP(PCIE_GLI_9767_PWR_MACRO_CTL_RCLK_AMPLITUDE_CTL, 938 PCIE_GLI_9767_PWR_MACRO_CTL_RCLK_AMPLITUDE_CTL_VALUE); 939 pci_write_config_dword(pdev, PCIE_GLI_9767_PWR_MACRO_CTL, value); 940 941 pci_read_config_dword(pdev, PCIE_GLI_9767_SCR, &value); 942 value &= ~(PCIE_GLI_9767_SCR_SYSTEM_CLK_SELECT_MODE0 | 943 PCIE_GLI_9767_SCR_SYSTEM_CLK_SELECT_MODE1 | 944 PCIE_GLI_9767_SCR_CFG_RST_DATA_LINK_DOWN); 945 946 value |= PCIE_GLI_9767_SCR_AUTO_AXI_W_BURST | 947 PCIE_GLI_9767_SCR_AUTO_AXI_R_BURST | 948 PCIE_GLI_9767_SCR_AXI_REQ | 949 PCIE_GLI_9767_SCR_CARD_DET_PWR_SAVING_EN | 950 PCIE_GLI_9767_SCR_CORE_PWR_D3_OFF; 951 pci_write_config_dword(pdev, PCIE_GLI_9767_SCR, value); 952 953 gl9767_vhs_read(pdev); 954 } 955 956 static void sdhci_gl9767_reset(struct sdhci_host *host, u8 mask) 957 { 958 sdhci_reset(host, mask); 959 gli_set_9767(host); 960 } 961 962 static int gl9767_init_sd_express(struct mmc_host *mmc, struct mmc_ios *ios) 963 { 964 struct sdhci_host *host = mmc_priv(mmc); 965 struct sdhci_pci_slot *slot = sdhci_priv(host); 966 struct pci_dev *pdev; 967 u32 value; 968 int i; 969 970 pdev = slot->chip->pdev; 971 972 if (mmc->ops->get_ro(mmc)) { 973 mmc->ios.timing &= ~(MMC_TIMING_SD_EXP | MMC_TIMING_SD_EXP_1_2V); 974 return 0; 975 } 976 977 gl9767_vhs_write(pdev); 978 979 pci_read_config_dword(pdev, PCIE_GLI_9767_COMBO_MUX_CTL, &value); 980 value &= ~(PCIE_GLI_9767_COMBO_MUX_CTL_RST_EN | PCIE_GLI_9767_COMBO_MUX_CTL_WAIT_PERST_EN); 981 pci_write_config_dword(pdev, PCIE_GLI_9767_COMBO_MUX_CTL, value); 982 983 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_DATA_MULTI_CTL, &value); 984 value &= ~PCIE_GLI_9767_SD_DATA_MULTI_CTL_DISCONNECT_TIME; 985 value |= FIELD_PREP(PCIE_GLI_9767_SD_DATA_MULTI_CTL_DISCONNECT_TIME, 986 PCIE_GLI_9767_SD_DATA_MULTI_CTL_DISCONNECT_TIME_VALUE); 987 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_DATA_MULTI_CTL, value); 988 989 pci_read_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2, &value); 990 value |= PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2_SDEI_COMPLETE; 991 pci_write_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2, value); 992 993 pci_read_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_EN_REG2, &value); 994 value |= PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_EN_REG2_SDEI_COMPLETE_STATUS_EN; 995 pci_write_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_EN_REG2, value); 996 997 pci_read_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_SIGNAL_EN_REG2, &value); 998 value |= PCIE_GLI_9767_NORMAL_ERR_INT_SIGNAL_EN_REG2_SDEI_COMPLETE_SIGNAL_EN; 999 pci_write_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_SIGNAL_EN_REG2, value); 1000 1001 pci_read_config_dword(pdev, PCIE_GLI_9767_CFG, &value); 1002 value |= PCIE_GLI_9767_CFG_LOW_PWR_OFF; 1003 pci_write_config_dword(pdev, PCIE_GLI_9767_CFG, value); 1004 1005 value = sdhci_readw(host, SDHCI_CLOCK_CONTROL); 1006 value &= ~(SDHCI_CLOCK_CARD_EN | SDHCI_CLOCK_PLL_EN); 1007 sdhci_writew(host, value, SDHCI_CLOCK_CONTROL); 1008 1009 value = sdhci_readb(host, SDHCI_POWER_CONTROL); 1010 value |= (SDHCI_VDD2_POWER_180 | SDHCI_VDD2_POWER_ON); 1011 sdhci_writeb(host, value, SDHCI_POWER_CONTROL); 1012 1013 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_EXPRESS_CTL, &value); 1014 value |= PCIE_GLI_9767_SD_EXPRESS_CTL_SDEI_EXE; 1015 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_EXPRESS_CTL, value); 1016 1017 for (i = 0; i < 2; i++) { 1018 usleep_range(10000, 10100); 1019 pci_read_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2, &value); 1020 if (value & PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2_SDEI_COMPLETE) { 1021 pci_write_config_dword(pdev, PCIE_GLI_9767_NORMAL_ERR_INT_STATUS_REG2, 1022 value); 1023 break; 1024 } 1025 } 1026 1027 pci_read_config_dword(pdev, PCIE_GLI_9767_SDHC_CAP, &value); 1028 if (value & PCIE_GLI_9767_SDHC_CAP_SDEI_RESULT) { 1029 pci_read_config_dword(pdev, PCIE_GLI_9767_SD_EXPRESS_CTL, &value); 1030 value |= PCIE_GLI_9767_SD_EXPRESS_CTL_SD_EXPRESS_MODE; 1031 pci_write_config_dword(pdev, PCIE_GLI_9767_SD_EXPRESS_CTL, value); 1032 } else { 1033 mmc->ios.timing &= ~(MMC_TIMING_SD_EXP | MMC_TIMING_SD_EXP_1_2V); 1034 1035 value = sdhci_readb(host, SDHCI_POWER_CONTROL); 1036 value &= ~(SDHCI_VDD2_POWER_180 | SDHCI_VDD2_POWER_ON); 1037 sdhci_writeb(host, value, SDHCI_POWER_CONTROL); 1038 1039 value = sdhci_readw(host, SDHCI_CLOCK_CONTROL); 1040 value |= (SDHCI_CLOCK_CARD_EN | SDHCI_CLOCK_PLL_EN); 1041 sdhci_writew(host, value, SDHCI_CLOCK_CONTROL); 1042 } 1043 1044 gl9767_vhs_read(pdev); 1045 1046 return 0; 1047 } 1048 1049 static int gli_probe_slot_gl9750(struct sdhci_pci_slot *slot) 1050 { 1051 struct sdhci_host *host = slot->host; 1052 1053 gl9750_hw_setting(host); 1054 gli_pcie_enable_msi(slot); 1055 slot->host->mmc->caps2 |= MMC_CAP2_NO_SDIO; 1056 sdhci_enable_v4_mode(host); 1057 1058 return 0; 1059 } 1060 1061 static int gli_probe_slot_gl9755(struct sdhci_pci_slot *slot) 1062 { 1063 struct sdhci_host *host = slot->host; 1064 1065 gl9755_hw_setting(slot); 1066 gli_pcie_enable_msi(slot); 1067 slot->host->mmc->caps2 |= MMC_CAP2_NO_SDIO; 1068 sdhci_enable_v4_mode(host); 1069 1070 return 0; 1071 } 1072 1073 static int gli_probe_slot_gl9767(struct sdhci_pci_slot *slot) 1074 { 1075 struct sdhci_host *host = slot->host; 1076 1077 gli_set_9767(host); 1078 gl9767_hw_setting(slot); 1079 gli_pcie_enable_msi(slot); 1080 slot->host->mmc->caps2 |= MMC_CAP2_NO_SDIO; 1081 host->mmc->caps2 |= MMC_CAP2_SD_EXP; 1082 host->mmc_host_ops.init_sd_express = gl9767_init_sd_express; 1083 sdhci_enable_v4_mode(host); 1084 1085 return 0; 1086 } 1087 1088 static void sdhci_gli_voltage_switch(struct sdhci_host *host) 1089 { 1090 /* 1091 * According to Section 3.6.1 signal voltage switch procedure in 1092 * SD Host Controller Simplified Spec. 4.20, steps 6~8 are as 1093 * follows: 1094 * (6) Set 1.8V Signal Enable in the Host Control 2 register. 1095 * (7) Wait 5ms. 1.8V voltage regulator shall be stable within this 1096 * period. 1097 * (8) If 1.8V Signal Enable is cleared by Host Controller, go to 1098 * step (12). 1099 * 1100 * Wait 5ms after set 1.8V signal enable in Host Control 2 register 1101 * to ensure 1.8V signal enable bit is set by GL9750/GL9755. 1102 * 1103 * ...however, the controller in the NUC10i3FNK4 (a 9755) requires 1104 * slightly longer than 5ms before the control register reports that 1105 * 1.8V is ready, and far longer still before the card will actually 1106 * work reliably. 1107 */ 1108 usleep_range(100000, 110000); 1109 } 1110 1111 static void sdhci_gl9767_voltage_switch(struct sdhci_host *host) 1112 { 1113 /* 1114 * According to Section 3.6.1 signal voltage switch procedure in 1115 * SD Host Controller Simplified Spec. 4.20, steps 6~8 are as 1116 * follows: 1117 * (6) Set 1.8V Signal Enable in the Host Control 2 register. 1118 * (7) Wait 5ms. 1.8V voltage regulator shall be stable within this 1119 * period. 1120 * (8) If 1.8V Signal Enable is cleared by Host Controller, go to 1121 * step (12). 1122 * 1123 * Wait 5ms after set 1.8V signal enable in Host Control 2 register 1124 * to ensure 1.8V signal enable bit is set by GL9767. 1125 * 1126 */ 1127 usleep_range(5000, 5500); 1128 } 1129 1130 static void sdhci_gl9750_reset(struct sdhci_host *host, u8 mask) 1131 { 1132 sdhci_reset(host, mask); 1133 gli_set_9750(host); 1134 } 1135 1136 static u32 sdhci_gl9750_readl(struct sdhci_host *host, int reg) 1137 { 1138 u32 value; 1139 1140 value = readl(host->ioaddr + reg); 1141 if (unlikely(reg == SDHCI_MAX_CURRENT && !(value & 0xff))) 1142 value |= 0xc8; 1143 1144 return value; 1145 } 1146 1147 static void gl9763e_hs400_enhanced_strobe(struct mmc_host *mmc, 1148 struct mmc_ios *ios) 1149 { 1150 struct sdhci_host *host = mmc_priv(mmc); 1151 u32 val; 1152 1153 val = sdhci_readl(host, SDHCI_GLI_9763E_HS400_ES_REG); 1154 if (ios->enhanced_strobe) 1155 val |= SDHCI_GLI_9763E_HS400_ES_BIT; 1156 else 1157 val &= ~SDHCI_GLI_9763E_HS400_ES_BIT; 1158 1159 sdhci_writel(host, val, SDHCI_GLI_9763E_HS400_ES_REG); 1160 } 1161 1162 static void sdhci_set_gl9763e_signaling(struct sdhci_host *host, 1163 unsigned int timing) 1164 { 1165 u16 ctrl_2; 1166 1167 ctrl_2 = sdhci_readw(host, SDHCI_HOST_CONTROL2); 1168 ctrl_2 &= ~SDHCI_CTRL_UHS_MASK; 1169 if (timing == MMC_TIMING_MMC_HS200) 1170 ctrl_2 |= SDHCI_CTRL_UHS_SDR104; 1171 else if (timing == MMC_TIMING_MMC_HS) 1172 ctrl_2 |= SDHCI_CTRL_UHS_SDR25; 1173 else if (timing == MMC_TIMING_MMC_DDR52) 1174 ctrl_2 |= SDHCI_CTRL_UHS_DDR50; 1175 else if (timing == MMC_TIMING_MMC_HS400) 1176 ctrl_2 |= SDHCI_GLI_9763E_CTRL_HS400; 1177 1178 sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2); 1179 } 1180 1181 static void sdhci_gl9763e_dumpregs(struct mmc_host *mmc) 1182 { 1183 sdhci_dumpregs(mmc_priv(mmc)); 1184 } 1185 1186 static void sdhci_gl9763e_cqe_pre_enable(struct mmc_host *mmc) 1187 { 1188 struct cqhci_host *cq_host = mmc->cqe_private; 1189 u32 value; 1190 1191 value = cqhci_readl(cq_host, CQHCI_CFG); 1192 value |= CQHCI_ENABLE; 1193 cqhci_writel(cq_host, value, CQHCI_CFG); 1194 } 1195 1196 static void sdhci_gl9763e_cqe_enable(struct mmc_host *mmc) 1197 { 1198 struct sdhci_host *host = mmc_priv(mmc); 1199 1200 sdhci_writew(host, GLI_9763E_CQE_TRNS_MODE, SDHCI_TRANSFER_MODE); 1201 sdhci_cqe_enable(mmc); 1202 } 1203 1204 static u32 sdhci_gl9763e_cqhci_irq(struct sdhci_host *host, u32 intmask) 1205 { 1206 int cmd_error = 0; 1207 int data_error = 0; 1208 1209 if (!sdhci_cqe_irq(host, intmask, &cmd_error, &data_error)) 1210 return intmask; 1211 1212 cqhci_irq(host->mmc, intmask, cmd_error, data_error); 1213 1214 return 0; 1215 } 1216 1217 static void sdhci_gl9763e_cqe_post_disable(struct mmc_host *mmc) 1218 { 1219 struct sdhci_host *host = mmc_priv(mmc); 1220 struct cqhci_host *cq_host = mmc->cqe_private; 1221 u32 value; 1222 1223 value = cqhci_readl(cq_host, CQHCI_CFG); 1224 value &= ~CQHCI_ENABLE; 1225 cqhci_writel(cq_host, value, CQHCI_CFG); 1226 sdhci_writew(host, 0x0, SDHCI_TRANSFER_MODE); 1227 } 1228 1229 static const struct cqhci_host_ops sdhci_gl9763e_cqhci_ops = { 1230 .enable = sdhci_gl9763e_cqe_enable, 1231 .disable = sdhci_cqe_disable, 1232 .dumpregs = sdhci_gl9763e_dumpregs, 1233 .pre_enable = sdhci_gl9763e_cqe_pre_enable, 1234 .post_disable = sdhci_gl9763e_cqe_post_disable, 1235 }; 1236 1237 static int gl9763e_add_host(struct sdhci_pci_slot *slot) 1238 { 1239 struct device *dev = &slot->chip->pdev->dev; 1240 struct sdhci_host *host = slot->host; 1241 struct cqhci_host *cq_host; 1242 bool dma64; 1243 int ret; 1244 1245 ret = sdhci_setup_host(host); 1246 if (ret) 1247 return ret; 1248 1249 cq_host = devm_kzalloc(dev, sizeof(*cq_host), GFP_KERNEL); 1250 if (!cq_host) { 1251 ret = -ENOMEM; 1252 goto cleanup; 1253 } 1254 1255 cq_host->mmio = host->ioaddr + SDHCI_GLI_9763E_CQE_BASE_ADDR; 1256 cq_host->ops = &sdhci_gl9763e_cqhci_ops; 1257 1258 dma64 = host->flags & SDHCI_USE_64_BIT_DMA; 1259 if (dma64) 1260 cq_host->caps |= CQHCI_TASK_DESC_SZ_128; 1261 1262 ret = cqhci_init(cq_host, host->mmc, dma64); 1263 if (ret) 1264 goto cleanup; 1265 1266 ret = __sdhci_add_host(host); 1267 if (ret) 1268 goto cleanup; 1269 1270 return 0; 1271 1272 cleanup: 1273 sdhci_cleanup_host(host); 1274 return ret; 1275 } 1276 1277 static void gli_set_gl9763e(struct sdhci_pci_slot *slot) 1278 { 1279 struct pci_dev *pdev = slot->chip->pdev; 1280 u32 value; 1281 1282 pci_read_config_dword(pdev, PCIE_GLI_9763E_VHS, &value); 1283 value &= ~GLI_9763E_VHS_REV; 1284 value |= FIELD_PREP(GLI_9763E_VHS_REV, GLI_9763E_VHS_REV_W); 1285 pci_write_config_dword(pdev, PCIE_GLI_9763E_VHS, value); 1286 1287 pci_read_config_dword(pdev, PCIE_GLI_9763E_SCR, &value); 1288 value |= GLI_9763E_SCR_AXI_REQ; 1289 pci_write_config_dword(pdev, PCIE_GLI_9763E_SCR, value); 1290 1291 pci_read_config_dword(pdev, PCIE_GLI_9763E_MMC_CTRL, &value); 1292 value &= ~GLI_9763E_HS400_SLOW; 1293 pci_write_config_dword(pdev, PCIE_GLI_9763E_MMC_CTRL, value); 1294 1295 pci_read_config_dword(pdev, PCIE_GLI_9763E_CFG2, &value); 1296 value &= ~GLI_9763E_CFG2_L1DLY; 1297 /* set ASPM L1 entry delay to 21us */ 1298 value |= FIELD_PREP(GLI_9763E_CFG2_L1DLY, GLI_9763E_CFG2_L1DLY_MID); 1299 pci_write_config_dword(pdev, PCIE_GLI_9763E_CFG2, value); 1300 1301 pci_read_config_dword(pdev, PCIE_GLI_9763E_CLKRXDLY, &value); 1302 value &= ~GLI_9763E_HS400_RXDLY; 1303 value |= FIELD_PREP(GLI_9763E_HS400_RXDLY, GLI_9763E_HS400_RXDLY_5); 1304 pci_write_config_dword(pdev, PCIE_GLI_9763E_CLKRXDLY, value); 1305 1306 pci_read_config_dword(pdev, PCIE_GLI_9763E_VHS, &value); 1307 value &= ~GLI_9763E_VHS_REV; 1308 value |= FIELD_PREP(GLI_9763E_VHS_REV, GLI_9763E_VHS_REV_R); 1309 pci_write_config_dword(pdev, PCIE_GLI_9763E_VHS, value); 1310 } 1311 1312 #ifdef CONFIG_PM 1313 static void gl9763e_set_low_power_negotiation(struct sdhci_pci_slot *slot, bool enable) 1314 { 1315 struct pci_dev *pdev = slot->chip->pdev; 1316 u32 value; 1317 1318 pci_read_config_dword(pdev, PCIE_GLI_9763E_VHS, &value); 1319 value &= ~GLI_9763E_VHS_REV; 1320 value |= FIELD_PREP(GLI_9763E_VHS_REV, GLI_9763E_VHS_REV_W); 1321 pci_write_config_dword(pdev, PCIE_GLI_9763E_VHS, value); 1322 1323 pci_read_config_dword(pdev, PCIE_GLI_9763E_CFG, &value); 1324 1325 if (enable) 1326 value &= ~GLI_9763E_CFG_LPSN_DIS; 1327 else 1328 value |= GLI_9763E_CFG_LPSN_DIS; 1329 1330 pci_write_config_dword(pdev, PCIE_GLI_9763E_CFG, value); 1331 1332 pci_read_config_dword(pdev, PCIE_GLI_9763E_VHS, &value); 1333 value &= ~GLI_9763E_VHS_REV; 1334 value |= FIELD_PREP(GLI_9763E_VHS_REV, GLI_9763E_VHS_REV_R); 1335 pci_write_config_dword(pdev, PCIE_GLI_9763E_VHS, value); 1336 } 1337 1338 static int gl9763e_runtime_suspend(struct sdhci_pci_chip *chip) 1339 { 1340 struct sdhci_pci_slot *slot = chip->slots[0]; 1341 struct sdhci_host *host = slot->host; 1342 u16 clock; 1343 1344 /* Enable LPM negotiation to allow entering L1 state */ 1345 gl9763e_set_low_power_negotiation(slot, true); 1346 1347 clock = sdhci_readw(host, SDHCI_CLOCK_CONTROL); 1348 clock &= ~(SDHCI_CLOCK_PLL_EN | SDHCI_CLOCK_CARD_EN); 1349 sdhci_writew(host, clock, SDHCI_CLOCK_CONTROL); 1350 1351 return 0; 1352 } 1353 1354 static int gl9763e_runtime_resume(struct sdhci_pci_chip *chip) 1355 { 1356 struct sdhci_pci_slot *slot = chip->slots[0]; 1357 struct sdhci_host *host = slot->host; 1358 u16 clock; 1359 1360 if (host->mmc->ios.power_mode != MMC_POWER_ON) 1361 return 0; 1362 1363 clock = sdhci_readw(host, SDHCI_CLOCK_CONTROL); 1364 1365 clock |= SDHCI_CLOCK_PLL_EN; 1366 clock &= ~SDHCI_CLOCK_INT_STABLE; 1367 sdhci_writew(host, clock, SDHCI_CLOCK_CONTROL); 1368 1369 /* Wait max 150 ms */ 1370 if (read_poll_timeout(sdhci_readw, clock, (clock & SDHCI_CLOCK_INT_STABLE), 1371 1000, 150000, false, host, SDHCI_CLOCK_CONTROL)) { 1372 pr_err("%s: PLL clock never stabilised.\n", 1373 mmc_hostname(host->mmc)); 1374 sdhci_dumpregs(host); 1375 } 1376 1377 clock |= SDHCI_CLOCK_CARD_EN; 1378 sdhci_writew(host, clock, SDHCI_CLOCK_CONTROL); 1379 1380 /* Disable LPM negotiation to avoid entering L1 state. */ 1381 gl9763e_set_low_power_negotiation(slot, false); 1382 1383 return 0; 1384 } 1385 #endif 1386 1387 #ifdef CONFIG_PM_SLEEP 1388 static int sdhci_pci_gli_resume(struct sdhci_pci_chip *chip) 1389 { 1390 struct sdhci_pci_slot *slot = chip->slots[0]; 1391 1392 pci_free_irq_vectors(slot->chip->pdev); 1393 gli_pcie_enable_msi(slot); 1394 1395 return sdhci_pci_resume_host(chip); 1396 } 1397 1398 static int gl9763e_resume(struct sdhci_pci_chip *chip) 1399 { 1400 struct sdhci_pci_slot *slot = chip->slots[0]; 1401 int ret; 1402 1403 ret = sdhci_pci_gli_resume(chip); 1404 if (ret) 1405 return ret; 1406 1407 ret = cqhci_resume(slot->host->mmc); 1408 if (ret) 1409 return ret; 1410 1411 /* 1412 * Disable LPM negotiation to bring device back in sync 1413 * with its runtime_pm state. 1414 */ 1415 gl9763e_set_low_power_negotiation(slot, false); 1416 1417 return 0; 1418 } 1419 1420 static int gl9763e_suspend(struct sdhci_pci_chip *chip) 1421 { 1422 struct sdhci_pci_slot *slot = chip->slots[0]; 1423 int ret; 1424 1425 /* 1426 * Certain SoCs can suspend only with the bus in low- 1427 * power state, notably x86 SoCs when using S0ix. 1428 * Re-enable LPM negotiation to allow entering L1 state 1429 * and entering system suspend. 1430 */ 1431 gl9763e_set_low_power_negotiation(slot, true); 1432 1433 ret = cqhci_suspend(slot->host->mmc); 1434 if (ret) 1435 goto err_suspend; 1436 1437 ret = sdhci_suspend_host(slot->host); 1438 if (ret) 1439 goto err_suspend_host; 1440 1441 return 0; 1442 1443 err_suspend_host: 1444 cqhci_resume(slot->host->mmc); 1445 err_suspend: 1446 gl9763e_set_low_power_negotiation(slot, false); 1447 return ret; 1448 } 1449 #endif 1450 1451 static int gli_probe_slot_gl9763e(struct sdhci_pci_slot *slot) 1452 { 1453 struct pci_dev *pdev = slot->chip->pdev; 1454 struct sdhci_host *host = slot->host; 1455 u32 value; 1456 1457 host->mmc->caps |= MMC_CAP_8_BIT_DATA | 1458 MMC_CAP_1_8V_DDR | 1459 MMC_CAP_NONREMOVABLE; 1460 host->mmc->caps2 |= MMC_CAP2_HS200_1_8V_SDR | 1461 MMC_CAP2_HS400_1_8V | 1462 MMC_CAP2_HS400_ES | 1463 MMC_CAP2_NO_SDIO | 1464 MMC_CAP2_NO_SD; 1465 1466 pci_read_config_dword(pdev, PCIE_GLI_9763E_MB, &value); 1467 if (!(value & GLI_9763E_MB_CMDQ_OFF)) 1468 if (value & GLI_9763E_MB_ERP_ON) 1469 host->mmc->caps2 |= MMC_CAP2_CQE | MMC_CAP2_CQE_DCMD; 1470 1471 gli_pcie_enable_msi(slot); 1472 host->mmc_host_ops.hs400_enhanced_strobe = 1473 gl9763e_hs400_enhanced_strobe; 1474 gli_set_gl9763e(slot); 1475 sdhci_enable_v4_mode(host); 1476 1477 return 0; 1478 } 1479 1480 #define REG_OFFSET_IN_BITS(reg) ((reg) << 3 & 0x18) 1481 1482 static u16 sdhci_gli_readw(struct sdhci_host *host, int reg) 1483 { 1484 u32 val = readl(host->ioaddr + (reg & ~3)); 1485 u16 word; 1486 1487 word = (val >> REG_OFFSET_IN_BITS(reg)) & 0xffff; 1488 return word; 1489 } 1490 1491 static u8 sdhci_gli_readb(struct sdhci_host *host, int reg) 1492 { 1493 u32 val = readl(host->ioaddr + (reg & ~3)); 1494 u8 byte = (val >> REG_OFFSET_IN_BITS(reg)) & 0xff; 1495 1496 return byte; 1497 } 1498 1499 static const struct sdhci_ops sdhci_gl9755_ops = { 1500 .read_w = sdhci_gli_readw, 1501 .read_b = sdhci_gli_readb, 1502 .set_clock = sdhci_gl9755_set_clock, 1503 .enable_dma = sdhci_pci_enable_dma, 1504 .set_bus_width = sdhci_set_bus_width, 1505 .reset = sdhci_reset, 1506 .set_uhs_signaling = sdhci_set_uhs_signaling, 1507 .voltage_switch = sdhci_gli_voltage_switch, 1508 }; 1509 1510 const struct sdhci_pci_fixes sdhci_gl9755 = { 1511 .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 1512 .quirks2 = SDHCI_QUIRK2_BROKEN_DDR50, 1513 .probe_slot = gli_probe_slot_gl9755, 1514 .ops = &sdhci_gl9755_ops, 1515 #ifdef CONFIG_PM_SLEEP 1516 .resume = sdhci_pci_gli_resume, 1517 #endif 1518 }; 1519 1520 static const struct sdhci_ops sdhci_gl9750_ops = { 1521 .read_w = sdhci_gli_readw, 1522 .read_b = sdhci_gli_readb, 1523 .read_l = sdhci_gl9750_readl, 1524 .set_clock = sdhci_gl9750_set_clock, 1525 .enable_dma = sdhci_pci_enable_dma, 1526 .set_bus_width = sdhci_set_bus_width, 1527 .reset = sdhci_gl9750_reset, 1528 .set_uhs_signaling = sdhci_set_uhs_signaling, 1529 .voltage_switch = sdhci_gli_voltage_switch, 1530 .platform_execute_tuning = gl9750_execute_tuning, 1531 }; 1532 1533 const struct sdhci_pci_fixes sdhci_gl9750 = { 1534 .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 1535 .quirks2 = SDHCI_QUIRK2_BROKEN_DDR50, 1536 .probe_slot = gli_probe_slot_gl9750, 1537 .ops = &sdhci_gl9750_ops, 1538 #ifdef CONFIG_PM_SLEEP 1539 .resume = sdhci_pci_gli_resume, 1540 #endif 1541 }; 1542 1543 static const struct sdhci_ops sdhci_gl9763e_ops = { 1544 .set_clock = sdhci_set_clock, 1545 .enable_dma = sdhci_pci_enable_dma, 1546 .set_bus_width = sdhci_set_bus_width, 1547 .reset = sdhci_and_cqhci_reset, 1548 .set_uhs_signaling = sdhci_set_gl9763e_signaling, 1549 .voltage_switch = sdhci_gli_voltage_switch, 1550 .irq = sdhci_gl9763e_cqhci_irq, 1551 }; 1552 1553 const struct sdhci_pci_fixes sdhci_gl9763e = { 1554 .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 1555 .probe_slot = gli_probe_slot_gl9763e, 1556 .ops = &sdhci_gl9763e_ops, 1557 #ifdef CONFIG_PM_SLEEP 1558 .resume = gl9763e_resume, 1559 .suspend = gl9763e_suspend, 1560 #endif 1561 #ifdef CONFIG_PM 1562 .runtime_suspend = gl9763e_runtime_suspend, 1563 .runtime_resume = gl9763e_runtime_resume, 1564 .allow_runtime_pm = true, 1565 #endif 1566 .add_host = gl9763e_add_host, 1567 }; 1568 1569 static const struct sdhci_ops sdhci_gl9767_ops = { 1570 .set_clock = sdhci_gl9767_set_clock, 1571 .enable_dma = sdhci_pci_enable_dma, 1572 .set_bus_width = sdhci_set_bus_width, 1573 .reset = sdhci_gl9767_reset, 1574 .set_uhs_signaling = sdhci_set_uhs_signaling, 1575 .voltage_switch = sdhci_gl9767_voltage_switch, 1576 }; 1577 1578 const struct sdhci_pci_fixes sdhci_gl9767 = { 1579 .quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC, 1580 .quirks2 = SDHCI_QUIRK2_BROKEN_DDR50, 1581 .probe_slot = gli_probe_slot_gl9767, 1582 .ops = &sdhci_gl9767_ops, 1583 #ifdef CONFIG_PM_SLEEP 1584 .resume = sdhci_pci_gli_resume, 1585 #endif 1586 }; 1587