Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright 2012 SAMSUNG Electronics |
| 4 | * Jaehoon Chung <jh80.chung@samsung.com> |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 5 | */ |
| 6 | |
| 7 | #include <common.h> |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 8 | #include <dwmmc.h> |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 9 | #include <fdtdec.h> |
Simon Glass | 3ba929a | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 10 | #include <asm/global_data.h> |
Masahiro Yamada | 75f82d0 | 2018-03-05 01:20:11 +0900 | [diff] [blame] | 11 | #include <linux/libfdt.h> |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 12 | #include <malloc.h> |
Jaehoon Chung | edd9d1dc | 2016-07-19 16:33:34 +0900 | [diff] [blame] | 13 | #include <errno.h> |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 14 | #include <asm/arch/dwmmc.h> |
| 15 | #include <asm/arch/clk.h> |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 16 | #include <asm/arch/pinmux.h> |
Przemyslaw Marczak | c3885b8 | 2015-02-20 12:29:26 +0100 | [diff] [blame] | 17 | #include <asm/arch/power.h> |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 18 | #include <asm/gpio.h> |
Simon Glass | bdd5f81 | 2023-09-14 18:21:46 -0600 | [diff] [blame^] | 19 | #include <linux/printk.h> |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 20 | |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 21 | #define DWMMC_MAX_CH_NUM 4 |
| 22 | #define DWMMC_MAX_FREQ 52000000 |
| 23 | #define DWMMC_MIN_FREQ 400000 |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 24 | #define DWMMC_MMC0_SDR_TIMING_VAL 0x03030001 |
| 25 | #define DWMMC_MMC2_SDR_TIMING_VAL 0x03020001 |
| 26 | |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 27 | #ifdef CONFIG_DM_MMC |
| 28 | #include <dm.h> |
| 29 | DECLARE_GLOBAL_DATA_PTR; |
| 30 | |
| 31 | struct exynos_mmc_plat { |
| 32 | struct mmc_config cfg; |
| 33 | struct mmc mmc; |
| 34 | }; |
| 35 | #endif |
| 36 | |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 37 | /* Exynos implmentation specific drver private data */ |
| 38 | struct dwmci_exynos_priv_data { |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 39 | #ifdef CONFIG_DM_MMC |
| 40 | struct dwmci_host host; |
| 41 | #endif |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 42 | u32 sdr_timing; |
| 43 | }; |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 44 | |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 45 | /* |
| 46 | * Function used as callback function to initialise the |
| 47 | * CLKSEL register for every mmc channel. |
| 48 | */ |
Siew Chin Lim | c51e7e1 | 2020-12-24 18:21:03 +0800 | [diff] [blame] | 49 | static int exynos_dwmci_clksel(struct dwmci_host *host) |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 50 | { |
Lukasz Majewski | 22c2afa | 2018-08-01 14:48:59 +0200 | [diff] [blame] | 51 | #ifdef CONFIG_DM_MMC |
| 52 | struct dwmci_exynos_priv_data *priv = |
| 53 | container_of(host, struct dwmci_exynos_priv_data, host); |
| 54 | #else |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 55 | struct dwmci_exynos_priv_data *priv = host->priv; |
Lukasz Majewski | 22c2afa | 2018-08-01 14:48:59 +0200 | [diff] [blame] | 56 | #endif |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 57 | dwmci_writel(host, DWMCI_CLKSEL, priv->sdr_timing); |
Siew Chin Lim | c51e7e1 | 2020-12-24 18:21:03 +0800 | [diff] [blame] | 58 | |
| 59 | return 0; |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 60 | } |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 61 | |
Simon Glass | eff7668 | 2015-08-30 16:55:15 -0600 | [diff] [blame] | 62 | unsigned int exynos_dwmci_get_clk(struct dwmci_host *host, uint freq) |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 63 | { |
Rajeshwari S Shinde | ccfa20b | 2014-02-05 10:48:15 +0530 | [diff] [blame] | 64 | unsigned long sclk; |
| 65 | int8_t clk_div; |
| 66 | |
| 67 | /* |
| 68 | * Since SDCLKIN is divided inside controller by the DIVRATIO |
| 69 | * value set in the CLKSEL register, we need to use the same output |
| 70 | * clock value to calculate the CLKDIV value. |
| 71 | * as per user manual:cclk_in = SDCLKIN / (DIVRATIO + 1) |
| 72 | */ |
| 73 | clk_div = ((dwmci_readl(host, DWMCI_CLKSEL) >> DWMCI_DIVRATIO_BIT) |
| 74 | & DWMCI_DIVRATIO_MASK) + 1; |
| 75 | sclk = get_mmc_clk(host->dev_index); |
| 76 | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 77 | /* |
| 78 | * Assume to know divider value. |
| 79 | * When clock unit is broken, need to set "host->div" |
| 80 | */ |
| 81 | return sclk / clk_div / (host->div + 1); |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 82 | } |
| 83 | |
Jaehoon Chung | 42f81a8 | 2013-11-29 20:08:57 +0900 | [diff] [blame] | 84 | static void exynos_dwmci_board_init(struct dwmci_host *host) |
| 85 | { |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 86 | struct dwmci_exynos_priv_data *priv = host->priv; |
| 87 | |
Jaehoon Chung | 42f81a8 | 2013-11-29 20:08:57 +0900 | [diff] [blame] | 88 | if (host->quirks & DWMCI_QUIRK_DISABLE_SMU) { |
| 89 | dwmci_writel(host, EMMCP_MPSBEGIN0, 0); |
| 90 | dwmci_writel(host, EMMCP_SEND0, 0); |
| 91 | dwmci_writel(host, EMMCP_CTRL0, |
| 92 | MPSCTRL_SECURE_READ_BIT | |
| 93 | MPSCTRL_SECURE_WRITE_BIT | |
| 94 | MPSCTRL_NON_SECURE_READ_BIT | |
| 95 | MPSCTRL_NON_SECURE_WRITE_BIT | MPSCTRL_VALID); |
| 96 | } |
Jaehoon Chung | 3d12e55 | 2015-02-04 15:48:39 +0900 | [diff] [blame] | 97 | |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 98 | /* Set to timing value at initial time */ |
| 99 | if (priv->sdr_timing) |
Jaehoon Chung | 3d12e55 | 2015-02-04 15:48:39 +0900 | [diff] [blame] | 100 | exynos_dwmci_clksel(host); |
Jaehoon Chung | 42f81a8 | 2013-11-29 20:08:57 +0900 | [diff] [blame] | 101 | } |
| 102 | |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 103 | static int exynos_dwmci_core_init(struct dwmci_host *host) |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 104 | { |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 105 | unsigned int div; |
| 106 | unsigned long freq, sclk; |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 107 | |
| 108 | if (host->bus_hz) |
| 109 | freq = host->bus_hz; |
| 110 | else |
| 111 | freq = DWMMC_MAX_FREQ; |
| 112 | |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 113 | /* request mmc clock vlaue of 52MHz. */ |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 114 | sclk = get_mmc_clk(host->dev_index); |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 115 | div = DIV_ROUND_UP(sclk, freq); |
| 116 | /* set the clock divisor for mmc */ |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 117 | set_mmc_clk(host->dev_index, div); |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 118 | |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 119 | host->name = "EXYNOS DWMMC"; |
Rajeshwari Shinde | 7016309 | 2013-10-29 12:53:13 +0530 | [diff] [blame] | 120 | #ifdef CONFIG_EXYNOS5420 |
| 121 | host->quirks = DWMCI_QUIRK_DISABLE_SMU; |
| 122 | #endif |
Jaehoon Chung | 42f81a8 | 2013-11-29 20:08:57 +0900 | [diff] [blame] | 123 | host->board_init = exynos_dwmci_board_init; |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 124 | |
Jaehoon Chung | ef91dd5 | 2014-05-16 13:59:57 +0900 | [diff] [blame] | 125 | host->caps = MMC_MODE_DDR_52MHz; |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 126 | host->clksel = exynos_dwmci_clksel; |
Jaehoon Chung | d94735b | 2013-10-06 18:59:31 +0900 | [diff] [blame] | 127 | host->get_mmc_clk = exynos_dwmci_get_clk; |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 128 | |
| 129 | #ifndef CONFIG_DM_MMC |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 130 | /* Add the mmc channel to be registered with mmc core */ |
| 131 | if (add_dwmci(host, DWMMC_MAX_FREQ, DWMMC_MIN_FREQ)) { |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 132 | printf("DWMMC%d registration failed\n", host->dev_index); |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 133 | return -1; |
| 134 | } |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 135 | #endif |
| 136 | |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 137 | return 0; |
| 138 | } |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 139 | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 140 | static int do_dwmci_init(struct dwmci_host *host) |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 141 | { |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 142 | int flag, err; |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 143 | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 144 | flag = host->buswidth == 8 ? PINMUX_FLAG_8BIT_MODE : PINMUX_FLAG_NONE; |
| 145 | err = exynos_pinmux_config(host->dev_id, flag); |
| 146 | if (err) { |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 147 | printf("DWMMC%d not configure\n", host->dev_index); |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 148 | return err; |
| 149 | } |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 150 | |
Jaehoon Chung | de61aaee | 2016-06-29 19:46:17 +0900 | [diff] [blame] | 151 | return exynos_dwmci_core_init(host); |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 152 | } |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 153 | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 154 | static int exynos_dwmci_get_config(const void *blob, int node, |
Lukasz Majewski | 6702cb2 | 2018-08-01 14:48:53 +0200 | [diff] [blame] | 155 | struct dwmci_host *host, |
| 156 | struct dwmci_exynos_priv_data *priv) |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 157 | { |
| 158 | int err = 0; |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 159 | u32 base, timing[3]; |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 160 | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 161 | /* Extract device id for each mmc channel */ |
| 162 | host->dev_id = pinmux_decode_periph_id(blob, node); |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 163 | |
Jaehoon Chung | db313bf | 2014-11-28 20:42:33 +0900 | [diff] [blame] | 164 | host->dev_index = fdtdec_get_int(blob, node, "index", host->dev_id); |
| 165 | if (host->dev_index == host->dev_id) |
| 166 | host->dev_index = host->dev_id - PERIPH_ID_SDMMC0; |
| 167 | |
Jaehoon Chung | e0303c7 | 2016-06-29 19:46:16 +0900 | [diff] [blame] | 168 | if (host->dev_index > 4) { |
| 169 | printf("DWMMC%d: Can't get the dev index\n", host->dev_index); |
| 170 | return -EINVAL; |
| 171 | } |
| 172 | |
Jaehoon Chung | 865ecd9 | 2016-06-29 19:46:18 +0900 | [diff] [blame] | 173 | /* Get the bus width from the device node (Default is 4bit buswidth) */ |
| 174 | host->buswidth = fdtdec_get_int(blob, node, "samsung,bus-width", 4); |
Amar | d850121 | 2013-04-27 11:42:55 +0530 | [diff] [blame] | 175 | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 176 | /* Set the base address from the device node */ |
| 177 | base = fdtdec_get_addr(blob, node, "reg"); |
| 178 | if (!base) { |
Jaehoon Chung | db313bf | 2014-11-28 20:42:33 +0900 | [diff] [blame] | 179 | printf("DWMMC%d: Can't get base address\n", host->dev_index); |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 180 | return -EINVAL; |
| 181 | } |
| 182 | host->ioaddr = (void *)base; |
| 183 | |
| 184 | /* Extract the timing info from the node */ |
| 185 | err = fdtdec_get_int_array(blob, node, "samsung,timing", timing, 3); |
| 186 | if (err) { |
Jaehoon Chung | db313bf | 2014-11-28 20:42:33 +0900 | [diff] [blame] | 187 | printf("DWMMC%d: Can't get sdr-timings for devider\n", |
| 188 | host->dev_index); |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 189 | return -EINVAL; |
| 190 | } |
| 191 | |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 192 | priv->sdr_timing = (DWMCI_SET_SAMPLE_CLK(timing[0]) | |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 193 | DWMCI_SET_DRV_CLK(timing[1]) | |
| 194 | DWMCI_SET_DIV_RATIO(timing[2])); |
Jaehoon Chung | bcb03eab | 2015-02-04 15:48:40 +0900 | [diff] [blame] | 195 | |
| 196 | /* sdr_timing didn't assigned anything, use the default value */ |
| 197 | if (!priv->sdr_timing) { |
| 198 | if (host->dev_index == 0) |
| 199 | priv->sdr_timing = DWMMC_MMC0_SDR_TIMING_VAL; |
| 200 | else if (host->dev_index == 2) |
| 201 | priv->sdr_timing = DWMMC_MMC2_SDR_TIMING_VAL; |
| 202 | } |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 203 | |
| 204 | host->fifoth_val = fdtdec_get_int(blob, node, "fifoth_val", 0); |
| 205 | host->bus_hz = fdtdec_get_int(blob, node, "bus_hz", 0); |
| 206 | host->div = fdtdec_get_int(blob, node, "div", 0); |
| 207 | |
Jaehoon Chung | 7aff967 | 2012-10-15 19:10:31 +0000 | [diff] [blame] | 208 | return 0; |
| 209 | } |
Jaehoon Chung | 6281110 | 2014-05-16 13:59:52 +0900 | [diff] [blame] | 210 | |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 211 | #ifdef CONFIG_DM_MMC |
| 212 | static int exynos_dwmmc_probe(struct udevice *dev) |
| 213 | { |
Simon Glass | fa20e93 | 2020-12-03 16:55:20 -0700 | [diff] [blame] | 214 | struct exynos_mmc_plat *plat = dev_get_plat(dev); |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 215 | struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev); |
| 216 | struct dwmci_exynos_priv_data *priv = dev_get_priv(dev); |
| 217 | struct dwmci_host *host = &priv->host; |
| 218 | int err; |
| 219 | |
Lukasz Majewski | 6702cb2 | 2018-08-01 14:48:53 +0200 | [diff] [blame] | 220 | err = exynos_dwmci_get_config(gd->fdt_blob, dev_of_offset(dev), host, |
| 221 | priv); |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 222 | if (err) |
| 223 | return err; |
| 224 | err = do_dwmci_init(host); |
| 225 | if (err) |
| 226 | return err; |
| 227 | |
Jaehoon Chung | bf819d0 | 2016-09-23 19:13:16 +0900 | [diff] [blame] | 228 | dwmci_setup_cfg(&plat->cfg, host, DWMMC_MAX_FREQ, DWMMC_MIN_FREQ); |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 229 | host->mmc = &plat->mmc; |
| 230 | host->mmc->priv = &priv->host; |
| 231 | host->priv = dev; |
| 232 | upriv->mmc = host->mmc; |
| 233 | |
| 234 | return dwmci_probe(dev); |
| 235 | } |
| 236 | |
| 237 | static int exynos_dwmmc_bind(struct udevice *dev) |
| 238 | { |
Simon Glass | fa20e93 | 2020-12-03 16:55:20 -0700 | [diff] [blame] | 239 | struct exynos_mmc_plat *plat = dev_get_plat(dev); |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 240 | |
Masahiro Yamada | cdb67f3 | 2016-09-06 22:17:32 +0900 | [diff] [blame] | 241 | return dwmci_bind(dev, &plat->mmc, &plat->cfg); |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | static const struct udevice_id exynos_dwmmc_ids[] = { |
| 245 | { .compatible = "samsung,exynos4412-dw-mshc" }, |
Lukasz Majewski | 03cf3af | 2018-08-01 14:49:00 +0200 | [diff] [blame] | 246 | { .compatible = "samsung,exynos-dwmmc" }, |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 247 | { } |
| 248 | }; |
| 249 | |
| 250 | U_BOOT_DRIVER(exynos_dwmmc_drv) = { |
| 251 | .name = "exynos_dwmmc", |
| 252 | .id = UCLASS_MMC, |
| 253 | .of_match = exynos_dwmmc_ids, |
| 254 | .bind = exynos_dwmmc_bind, |
| 255 | .ops = &dm_dwmci_ops, |
| 256 | .probe = exynos_dwmmc_probe, |
Simon Glass | 8a2b47f | 2020-12-03 16:55:17 -0700 | [diff] [blame] | 257 | .priv_auto = sizeof(struct dwmci_exynos_priv_data), |
Simon Glass | 71fa5b4 | 2020-12-03 16:55:18 -0700 | [diff] [blame] | 258 | .plat_auto = sizeof(struct exynos_mmc_plat), |
Jaehoon Chung | 98d18e9 | 2016-06-30 20:57:37 +0900 | [diff] [blame] | 259 | }; |
| 260 | #endif |