1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Copyright (C) 2019 ASPEED Technology Inc. */ 3 /* Copyright (C) 2019 IBM Corp. */ 4 5 #include <linux/clk.h> 6 #include <linux/delay.h> 7 #include <linux/device.h> 8 #include <linux/io.h> 9 #include <linux/mmc/host.h> 10 #include <linux/module.h> 11 #include <linux/of_address.h> 12 #include <linux/of.h> 13 #include <linux/of_platform.h> 14 #include <linux/platform_device.h> 15 #include <linux/spinlock.h> 16 17 #include "sdhci-pltfm.h" 18 19 #define ASPEED_SDC_INFO 0x00 20 #define ASPEED_SDC_S1MMC8 BIT(25) 21 #define ASPEED_SDC_S0MMC8 BIT(24) 22 23 struct aspeed_sdc { 24 struct clk *clk; 25 struct resource *res; 26 27 spinlock_t lock; 28 void __iomem *regs; 29 }; 30 31 struct aspeed_sdhci { 32 struct aspeed_sdc *parent; 33 u32 width_mask; 34 }; 35 36 static void aspeed_sdc_configure_8bit_mode(struct aspeed_sdc *sdc, 37 struct aspeed_sdhci *sdhci, 38 bool bus8) 39 { 40 u32 info; 41 42 /* Set/clear 8 bit mode */ 43 spin_lock(&sdc->lock); 44 info = readl(sdc->regs + ASPEED_SDC_INFO); 45 if (bus8) 46 info |= sdhci->width_mask; 47 else 48 info &= ~sdhci->width_mask; 49 writel(info, sdc->regs + ASPEED_SDC_INFO); 50 spin_unlock(&sdc->lock); 51 } 52 53 static void aspeed_sdhci_set_clock(struct sdhci_host *host, unsigned int clock) 54 { 55 struct sdhci_pltfm_host *pltfm_host; 56 unsigned long parent; 57 int div; 58 u16 clk; 59 60 pltfm_host = sdhci_priv(host); 61 parent = clk_get_rate(pltfm_host->clk); 62 63 sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL); 64 65 if (clock == 0) 66 return; 67 68 if (WARN_ON(clock > host->max_clk)) 69 clock = host->max_clk; 70 71 for (div = 1; div < 256; div *= 2) { 72 if ((parent / div) <= clock) 73 break; 74 } 75 div >>= 1; 76 77 clk = div << SDHCI_DIVIDER_SHIFT; 78 79 sdhci_enable_clk(host, clk); 80 } 81 82 static unsigned int aspeed_sdhci_get_max_clock(struct sdhci_host *host) 83 { 84 if (host->mmc->f_max) 85 return host->mmc->f_max; 86 87 return sdhci_pltfm_clk_get_max_clock(host); 88 } 89 90 static void aspeed_sdhci_set_bus_width(struct sdhci_host *host, int width) 91 { 92 struct sdhci_pltfm_host *pltfm_priv; 93 struct aspeed_sdhci *aspeed_sdhci; 94 struct aspeed_sdc *aspeed_sdc; 95 u8 ctrl; 96 97 pltfm_priv = sdhci_priv(host); 98 aspeed_sdhci = sdhci_pltfm_priv(pltfm_priv); 99 aspeed_sdc = aspeed_sdhci->parent; 100 101 /* Set/clear 8-bit mode */ 102 aspeed_sdc_configure_8bit_mode(aspeed_sdc, aspeed_sdhci, 103 width == MMC_BUS_WIDTH_8); 104 105 /* Set/clear 1 or 4 bit mode */ 106 ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL); 107 if (width == MMC_BUS_WIDTH_4) 108 ctrl |= SDHCI_CTRL_4BITBUS; 109 else 110 ctrl &= ~SDHCI_CTRL_4BITBUS; 111 sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL); 112 } 113 114 static u32 aspeed_sdhci_readl(struct sdhci_host *host, int reg) 115 { 116 u32 val = readl(host->ioaddr + reg); 117 118 if (unlikely(reg == SDHCI_PRESENT_STATE) && 119 (host->mmc->caps2 & MMC_CAP2_CD_ACTIVE_HIGH)) 120 val ^= SDHCI_CARD_PRESENT; 121 122 return val; 123 } 124 125 static const struct sdhci_ops aspeed_sdhci_ops = { 126 .read_l = aspeed_sdhci_readl, 127 .set_clock = aspeed_sdhci_set_clock, 128 .get_max_clock = aspeed_sdhci_get_max_clock, 129 .set_bus_width = aspeed_sdhci_set_bus_width, 130 .get_timeout_clock = sdhci_pltfm_clk_get_max_clock, 131 .reset = sdhci_reset, 132 .set_uhs_signaling = sdhci_set_uhs_signaling, 133 }; 134 135 static const struct sdhci_pltfm_data aspeed_sdhci_pdata = { 136 .ops = &aspeed_sdhci_ops, 137 .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN, 138 }; 139 140 static inline int aspeed_sdhci_calculate_slot(struct aspeed_sdhci *dev, 141 struct resource *res) 142 { 143 resource_size_t delta; 144 145 if (!res || resource_type(res) != IORESOURCE_MEM) 146 return -EINVAL; 147 148 if (res->start < dev->parent->res->start) 149 return -EINVAL; 150 151 delta = res->start - dev->parent->res->start; 152 if (delta & (0x100 - 1)) 153 return -EINVAL; 154 155 return (delta / 0x100) - 1; 156 } 157 158 static int aspeed_sdhci_probe(struct platform_device *pdev) 159 { 160 struct sdhci_pltfm_host *pltfm_host; 161 struct aspeed_sdhci *dev; 162 struct sdhci_host *host; 163 struct resource *res; 164 int slot; 165 int ret; 166 167 host = sdhci_pltfm_init(pdev, &aspeed_sdhci_pdata, sizeof(*dev)); 168 if (IS_ERR(host)) 169 return PTR_ERR(host); 170 171 pltfm_host = sdhci_priv(host); 172 dev = sdhci_pltfm_priv(pltfm_host); 173 dev->parent = dev_get_drvdata(pdev->dev.parent); 174 175 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 176 slot = aspeed_sdhci_calculate_slot(dev, res); 177 178 if (slot < 0) 179 return slot; 180 else if (slot >= 2) 181 return -EINVAL; 182 183 dev_info(&pdev->dev, "Configuring for slot %d\n", slot); 184 dev->width_mask = !slot ? ASPEED_SDC_S0MMC8 : ASPEED_SDC_S1MMC8; 185 186 sdhci_get_of_property(pdev); 187 188 pltfm_host->clk = devm_clk_get(&pdev->dev, NULL); 189 if (IS_ERR(pltfm_host->clk)) 190 return PTR_ERR(pltfm_host->clk); 191 192 ret = clk_prepare_enable(pltfm_host->clk); 193 if (ret) { 194 dev_err(&pdev->dev, "Unable to enable SDIO clock\n"); 195 goto err_pltfm_free; 196 } 197 198 ret = mmc_of_parse(host->mmc); 199 if (ret) 200 goto err_sdhci_add; 201 202 ret = sdhci_add_host(host); 203 if (ret) 204 goto err_sdhci_add; 205 206 return 0; 207 208 err_sdhci_add: 209 clk_disable_unprepare(pltfm_host->clk); 210 err_pltfm_free: 211 sdhci_pltfm_free(pdev); 212 return ret; 213 } 214 215 static int aspeed_sdhci_remove(struct platform_device *pdev) 216 { 217 struct sdhci_pltfm_host *pltfm_host; 218 struct sdhci_host *host; 219 int dead = 0; 220 221 host = platform_get_drvdata(pdev); 222 pltfm_host = sdhci_priv(host); 223 224 sdhci_remove_host(host, dead); 225 226 clk_disable_unprepare(pltfm_host->clk); 227 228 sdhci_pltfm_free(pdev); 229 230 return 0; 231 } 232 233 static const struct of_device_id aspeed_sdhci_of_match[] = { 234 { .compatible = "aspeed,ast2400-sdhci", }, 235 { .compatible = "aspeed,ast2500-sdhci", }, 236 { .compatible = "aspeed,ast2600-sdhci", }, 237 { } 238 }; 239 240 static struct platform_driver aspeed_sdhci_driver = { 241 .driver = { 242 .name = "sdhci-aspeed", 243 .of_match_table = aspeed_sdhci_of_match, 244 }, 245 .probe = aspeed_sdhci_probe, 246 .remove = aspeed_sdhci_remove, 247 }; 248 249 static int aspeed_sdc_probe(struct platform_device *pdev) 250 251 { 252 struct device_node *parent, *child; 253 struct aspeed_sdc *sdc; 254 int ret; 255 256 sdc = devm_kzalloc(&pdev->dev, sizeof(*sdc), GFP_KERNEL); 257 if (!sdc) 258 return -ENOMEM; 259 260 spin_lock_init(&sdc->lock); 261 262 sdc->clk = devm_clk_get(&pdev->dev, NULL); 263 if (IS_ERR(sdc->clk)) 264 return PTR_ERR(sdc->clk); 265 266 ret = clk_prepare_enable(sdc->clk); 267 if (ret) { 268 dev_err(&pdev->dev, "Unable to enable SDCLK\n"); 269 return ret; 270 } 271 272 sdc->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 273 sdc->regs = devm_ioremap_resource(&pdev->dev, sdc->res); 274 if (IS_ERR(sdc->regs)) { 275 ret = PTR_ERR(sdc->regs); 276 goto err_clk; 277 } 278 279 dev_set_drvdata(&pdev->dev, sdc); 280 281 parent = pdev->dev.of_node; 282 for_each_available_child_of_node(parent, child) { 283 struct platform_device *cpdev; 284 285 cpdev = of_platform_device_create(child, NULL, &pdev->dev); 286 if (!cpdev) { 287 of_node_put(child); 288 ret = -ENODEV; 289 goto err_clk; 290 } 291 } 292 293 return 0; 294 295 err_clk: 296 clk_disable_unprepare(sdc->clk); 297 return ret; 298 } 299 300 static int aspeed_sdc_remove(struct platform_device *pdev) 301 { 302 struct aspeed_sdc *sdc = dev_get_drvdata(&pdev->dev); 303 304 clk_disable_unprepare(sdc->clk); 305 306 return 0; 307 } 308 309 static const struct of_device_id aspeed_sdc_of_match[] = { 310 { .compatible = "aspeed,ast2400-sd-controller", }, 311 { .compatible = "aspeed,ast2500-sd-controller", }, 312 { .compatible = "aspeed,ast2600-sd-controller", }, 313 { } 314 }; 315 316 MODULE_DEVICE_TABLE(of, aspeed_sdc_of_match); 317 318 static struct platform_driver aspeed_sdc_driver = { 319 .driver = { 320 .name = "sd-controller-aspeed", 321 .pm = &sdhci_pltfm_pmops, 322 .of_match_table = aspeed_sdc_of_match, 323 }, 324 .probe = aspeed_sdc_probe, 325 .remove = aspeed_sdc_remove, 326 }; 327 328 static int __init aspeed_sdc_init(void) 329 { 330 int rc; 331 332 rc = platform_driver_register(&aspeed_sdhci_driver); 333 if (rc < 0) 334 return rc; 335 336 rc = platform_driver_register(&aspeed_sdc_driver); 337 if (rc < 0) 338 platform_driver_unregister(&aspeed_sdhci_driver); 339 340 return rc; 341 } 342 module_init(aspeed_sdc_init); 343 344 static void __exit aspeed_sdc_exit(void) 345 { 346 platform_driver_unregister(&aspeed_sdc_driver); 347 platform_driver_unregister(&aspeed_sdhci_driver); 348 } 349 module_exit(aspeed_sdc_exit); 350 351 MODULE_DESCRIPTION("Driver for the ASPEED SD/SDIO/SDHCI Controllers"); 352 MODULE_AUTHOR("Ryan Chen <ryan_chen@aspeedtech.com>"); 353 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>"); 354 MODULE_LICENSE("GPL"); 355