1 /* 2 * Copyright (C) 2010 Google, Inc. 3 * 4 * This software is licensed under the terms of the GNU General Public 5 * License version 2, as published by the Free Software Foundation, and 6 * may be copied, distributed, and modified under those terms. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 */ 14 15 #include <linux/err.h> 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/platform_device.h> 19 #include <linux/clk.h> 20 #include <linux/io.h> 21 #include <linux/of.h> 22 #include <linux/of_device.h> 23 #include <linux/of_gpio.h> 24 #include <linux/gpio.h> 25 #include <linux/mmc/card.h> 26 #include <linux/mmc/host.h> 27 #include <linux/mmc/slot-gpio.h> 28 29 #include <asm/gpio.h> 30 31 #include "sdhci-pltfm.h" 32 33 /* Tegra SDHOST controller vendor register definitions */ 34 #define SDHCI_TEGRA_VENDOR_MISC_CTRL 0x120 35 #define SDHCI_MISC_CTRL_ENABLE_SDR104 0x8 36 #define SDHCI_MISC_CTRL_ENABLE_SDR50 0x10 37 #define SDHCI_MISC_CTRL_ENABLE_SDHCI_SPEC_300 0x20 38 #define SDHCI_MISC_CTRL_ENABLE_DDR50 0x200 39 40 #define NVQUIRK_FORCE_SDHCI_SPEC_200 BIT(0) 41 #define NVQUIRK_ENABLE_BLOCK_GAP_DET BIT(1) 42 #define NVQUIRK_ENABLE_SDHCI_SPEC_300 BIT(2) 43 #define NVQUIRK_DISABLE_SDR50 BIT(3) 44 #define NVQUIRK_DISABLE_SDR104 BIT(4) 45 #define NVQUIRK_DISABLE_DDR50 BIT(5) 46 47 struct sdhci_tegra_soc_data { 48 const struct sdhci_pltfm_data *pdata; 49 u32 nvquirks; 50 }; 51 52 struct sdhci_tegra { 53 const struct sdhci_tegra_soc_data *soc_data; 54 int power_gpio; 55 }; 56 57 static u16 tegra_sdhci_readw(struct sdhci_host *host, int reg) 58 { 59 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 60 struct sdhci_tegra *tegra_host = pltfm_host->priv; 61 const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data; 62 63 if (unlikely((soc_data->nvquirks & NVQUIRK_FORCE_SDHCI_SPEC_200) && 64 (reg == SDHCI_HOST_VERSION))) { 65 /* Erratum: Version register is invalid in HW. */ 66 return SDHCI_SPEC_200; 67 } 68 69 return readw(host->ioaddr + reg); 70 } 71 72 static void tegra_sdhci_writel(struct sdhci_host *host, u32 val, int reg) 73 { 74 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 75 struct sdhci_tegra *tegra_host = pltfm_host->priv; 76 const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data; 77 78 /* Seems like we're getting spurious timeout and crc errors, so 79 * disable signalling of them. In case of real errors software 80 * timers should take care of eventually detecting them. 81 */ 82 if (unlikely(reg == SDHCI_SIGNAL_ENABLE)) 83 val &= ~(SDHCI_INT_TIMEOUT|SDHCI_INT_CRC); 84 85 writel(val, host->ioaddr + reg); 86 87 if (unlikely((soc_data->nvquirks & NVQUIRK_ENABLE_BLOCK_GAP_DET) && 88 (reg == SDHCI_INT_ENABLE))) { 89 /* Erratum: Must enable block gap interrupt detection */ 90 u8 gap_ctrl = readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL); 91 if (val & SDHCI_INT_CARD_INT) 92 gap_ctrl |= 0x8; 93 else 94 gap_ctrl &= ~0x8; 95 writeb(gap_ctrl, host->ioaddr + SDHCI_BLOCK_GAP_CONTROL); 96 } 97 } 98 99 static unsigned int tegra_sdhci_get_ro(struct sdhci_host *host) 100 { 101 return mmc_gpio_get_ro(host->mmc); 102 } 103 104 static void tegra_sdhci_reset(struct sdhci_host *host, u8 mask) 105 { 106 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 107 struct sdhci_tegra *tegra_host = pltfm_host->priv; 108 const struct sdhci_tegra_soc_data *soc_data = tegra_host->soc_data; 109 u32 misc_ctrl; 110 111 sdhci_reset(host, mask); 112 113 if (!(mask & SDHCI_RESET_ALL)) 114 return; 115 116 misc_ctrl = sdhci_readw(host, SDHCI_TEGRA_VENDOR_MISC_CTRL); 117 /* Erratum: Enable SDHCI spec v3.00 support */ 118 if (soc_data->nvquirks & NVQUIRK_ENABLE_SDHCI_SPEC_300) 119 misc_ctrl |= SDHCI_MISC_CTRL_ENABLE_SDHCI_SPEC_300; 120 /* Don't advertise UHS modes which aren't supported yet */ 121 if (soc_data->nvquirks & NVQUIRK_DISABLE_SDR50) 122 misc_ctrl &= ~SDHCI_MISC_CTRL_ENABLE_SDR50; 123 if (soc_data->nvquirks & NVQUIRK_DISABLE_DDR50) 124 misc_ctrl &= ~SDHCI_MISC_CTRL_ENABLE_DDR50; 125 if (soc_data->nvquirks & NVQUIRK_DISABLE_SDR104) 126 misc_ctrl &= ~SDHCI_MISC_CTRL_ENABLE_SDR104; 127 sdhci_writew(host, misc_ctrl, SDHCI_TEGRA_VENDOR_MISC_CTRL); 128 } 129 130 static void tegra_sdhci_set_bus_width(struct sdhci_host *host, int bus_width) 131 { 132 u32 ctrl; 133 134 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); 135 if ((host->mmc->caps & MMC_CAP_8_BIT_DATA) && 136 (bus_width == MMC_BUS_WIDTH_8)) { 137 ctrl &= ~SDHCI_CTRL_4BITBUS; 138 ctrl |= SDHCI_CTRL_8BITBUS; 139 } else { 140 ctrl &= ~SDHCI_CTRL_8BITBUS; 141 if (bus_width == MMC_BUS_WIDTH_4) 142 ctrl |= SDHCI_CTRL_4BITBUS; 143 else 144 ctrl &= ~SDHCI_CTRL_4BITBUS; 145 } 146 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); 147 } 148 149 static const struct sdhci_ops tegra_sdhci_ops = { 150 .get_ro = tegra_sdhci_get_ro, 151 .read_w = tegra_sdhci_readw, 152 .write_l = tegra_sdhci_writel, 153 .set_clock = sdhci_set_clock, 154 .set_bus_width = tegra_sdhci_set_bus_width, 155 .reset = tegra_sdhci_reset, 156 .set_uhs_signaling = sdhci_set_uhs_signaling, 157 }; 158 159 static const struct sdhci_pltfm_data sdhci_tegra20_pdata = { 160 .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | 161 SDHCI_QUIRK_SINGLE_POWER_WRITE | 162 SDHCI_QUIRK_NO_HISPD_BIT | 163 SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC, 164 .ops = &tegra_sdhci_ops, 165 }; 166 167 static struct sdhci_tegra_soc_data soc_data_tegra20 = { 168 .pdata = &sdhci_tegra20_pdata, 169 .nvquirks = NVQUIRK_FORCE_SDHCI_SPEC_200 | 170 NVQUIRK_ENABLE_BLOCK_GAP_DET, 171 }; 172 173 static const struct sdhci_pltfm_data sdhci_tegra30_pdata = { 174 .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | 175 SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | 176 SDHCI_QUIRK_SINGLE_POWER_WRITE | 177 SDHCI_QUIRK_NO_HISPD_BIT | 178 SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC, 179 .ops = &tegra_sdhci_ops, 180 }; 181 182 static struct sdhci_tegra_soc_data soc_data_tegra30 = { 183 .pdata = &sdhci_tegra30_pdata, 184 .nvquirks = NVQUIRK_ENABLE_SDHCI_SPEC_300 | 185 NVQUIRK_DISABLE_SDR50 | 186 NVQUIRK_DISABLE_SDR104, 187 }; 188 189 static const struct sdhci_pltfm_data sdhci_tegra114_pdata = { 190 .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | 191 SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK | 192 SDHCI_QUIRK_SINGLE_POWER_WRITE | 193 SDHCI_QUIRK_NO_HISPD_BIT | 194 SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC, 195 .ops = &tegra_sdhci_ops, 196 }; 197 198 static struct sdhci_tegra_soc_data soc_data_tegra114 = { 199 .pdata = &sdhci_tegra114_pdata, 200 .nvquirks = NVQUIRK_DISABLE_SDR50 | 201 NVQUIRK_DISABLE_DDR50 | 202 NVQUIRK_DISABLE_SDR104, 203 }; 204 205 static const struct of_device_id sdhci_tegra_dt_match[] = { 206 { .compatible = "nvidia,tegra124-sdhci", .data = &soc_data_tegra114 }, 207 { .compatible = "nvidia,tegra114-sdhci", .data = &soc_data_tegra114 }, 208 { .compatible = "nvidia,tegra30-sdhci", .data = &soc_data_tegra30 }, 209 { .compatible = "nvidia,tegra20-sdhci", .data = &soc_data_tegra20 }, 210 {} 211 }; 212 MODULE_DEVICE_TABLE(of, sdhci_tegra_dt_match); 213 214 static int sdhci_tegra_parse_dt(struct device *dev) 215 { 216 struct device_node *np = dev->of_node; 217 struct sdhci_host *host = dev_get_drvdata(dev); 218 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 219 struct sdhci_tegra *tegra_host = pltfm_host->priv; 220 221 tegra_host->power_gpio = of_get_named_gpio(np, "power-gpios", 0); 222 return mmc_of_parse(host->mmc); 223 } 224 225 static int sdhci_tegra_probe(struct platform_device *pdev) 226 { 227 const struct of_device_id *match; 228 const struct sdhci_tegra_soc_data *soc_data; 229 struct sdhci_host *host; 230 struct sdhci_pltfm_host *pltfm_host; 231 struct sdhci_tegra *tegra_host; 232 struct clk *clk; 233 int rc; 234 235 match = of_match_device(sdhci_tegra_dt_match, &pdev->dev); 236 if (!match) 237 return -EINVAL; 238 soc_data = match->data; 239 240 host = sdhci_pltfm_init(pdev, soc_data->pdata, 0); 241 if (IS_ERR(host)) 242 return PTR_ERR(host); 243 pltfm_host = sdhci_priv(host); 244 245 tegra_host = devm_kzalloc(&pdev->dev, sizeof(*tegra_host), GFP_KERNEL); 246 if (!tegra_host) { 247 dev_err(mmc_dev(host->mmc), "failed to allocate tegra_host\n"); 248 rc = -ENOMEM; 249 goto err_alloc_tegra_host; 250 } 251 tegra_host->soc_data = soc_data; 252 pltfm_host->priv = tegra_host; 253 254 rc = sdhci_tegra_parse_dt(&pdev->dev); 255 if (rc) 256 goto err_parse_dt; 257 258 if (gpio_is_valid(tegra_host->power_gpio)) { 259 rc = gpio_request(tegra_host->power_gpio, "sdhci_power"); 260 if (rc) { 261 dev_err(mmc_dev(host->mmc), 262 "failed to allocate power gpio\n"); 263 goto err_power_req; 264 } 265 gpio_direction_output(tegra_host->power_gpio, 1); 266 } 267 268 clk = clk_get(mmc_dev(host->mmc), NULL); 269 if (IS_ERR(clk)) { 270 dev_err(mmc_dev(host->mmc), "clk err\n"); 271 rc = PTR_ERR(clk); 272 goto err_clk_get; 273 } 274 clk_prepare_enable(clk); 275 pltfm_host->clk = clk; 276 277 rc = sdhci_add_host(host); 278 if (rc) 279 goto err_add_host; 280 281 return 0; 282 283 err_add_host: 284 clk_disable_unprepare(pltfm_host->clk); 285 clk_put(pltfm_host->clk); 286 err_clk_get: 287 if (gpio_is_valid(tegra_host->power_gpio)) 288 gpio_free(tegra_host->power_gpio); 289 err_power_req: 290 err_parse_dt: 291 err_alloc_tegra_host: 292 sdhci_pltfm_free(pdev); 293 return rc; 294 } 295 296 static int sdhci_tegra_remove(struct platform_device *pdev) 297 { 298 struct sdhci_host *host = platform_get_drvdata(pdev); 299 struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); 300 struct sdhci_tegra *tegra_host = pltfm_host->priv; 301 int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff); 302 303 sdhci_remove_host(host, dead); 304 305 if (gpio_is_valid(tegra_host->power_gpio)) 306 gpio_free(tegra_host->power_gpio); 307 308 clk_disable_unprepare(pltfm_host->clk); 309 clk_put(pltfm_host->clk); 310 311 sdhci_pltfm_free(pdev); 312 313 return 0; 314 } 315 316 static struct platform_driver sdhci_tegra_driver = { 317 .driver = { 318 .name = "sdhci-tegra", 319 .owner = THIS_MODULE, 320 .of_match_table = sdhci_tegra_dt_match, 321 .pm = SDHCI_PLTFM_PMOPS, 322 }, 323 .probe = sdhci_tegra_probe, 324 .remove = sdhci_tegra_remove, 325 }; 326 327 module_platform_driver(sdhci_tegra_driver); 328 329 MODULE_DESCRIPTION("SDHCI driver for Tegra"); 330 MODULE_AUTHOR("Google, Inc."); 331 MODULE_LICENSE("GPL v2"); 332