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 const struct sdhci_ops aspeed_sdhci_ops = { 115 .set_clock = aspeed_sdhci_set_clock, 116 .get_max_clock = aspeed_sdhci_get_max_clock, 117 .set_bus_width = aspeed_sdhci_set_bus_width, 118 .get_timeout_clock = sdhci_pltfm_clk_get_max_clock, 119 .reset = sdhci_reset, 120 .set_uhs_signaling = sdhci_set_uhs_signaling, 121 }; 122 123 static const struct sdhci_pltfm_data aspeed_sdhci_pdata = { 124 .ops = &aspeed_sdhci_ops, 125 .quirks = SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN, 126 }; 127 128 static inline int aspeed_sdhci_calculate_slot(struct aspeed_sdhci *dev, 129 struct resource *res) 130 { 131 resource_size_t delta; 132 133 if (!res || resource_type(res) != IORESOURCE_MEM) 134 return -EINVAL; 135 136 if (res->start < dev->parent->res->start) 137 return -EINVAL; 138 139 delta = res->start - dev->parent->res->start; 140 if (delta & (0x100 - 1)) 141 return -EINVAL; 142 143 return (delta / 0x100) - 1; 144 } 145 146 static int aspeed_sdhci_probe(struct platform_device *pdev) 147 { 148 struct sdhci_pltfm_host *pltfm_host; 149 struct aspeed_sdhci *dev; 150 struct sdhci_host *host; 151 struct resource *res; 152 int slot; 153 int ret; 154 155 host = sdhci_pltfm_init(pdev, &aspeed_sdhci_pdata, sizeof(*dev)); 156 if (IS_ERR(host)) 157 return PTR_ERR(host); 158 159 pltfm_host = sdhci_priv(host); 160 dev = sdhci_pltfm_priv(pltfm_host); 161 dev->parent = dev_get_drvdata(pdev->dev.parent); 162 163 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 164 slot = aspeed_sdhci_calculate_slot(dev, res); 165 166 if (slot < 0) 167 return slot; 168 else if (slot >= 2) 169 return -EINVAL; 170 171 dev_info(&pdev->dev, "Configuring for slot %d\n", slot); 172 dev->width_mask = !slot ? ASPEED_SDC_S0MMC8 : ASPEED_SDC_S1MMC8; 173 174 sdhci_get_of_property(pdev); 175 176 pltfm_host->clk = devm_clk_get(&pdev->dev, NULL); 177 if (IS_ERR(pltfm_host->clk)) 178 return PTR_ERR(pltfm_host->clk); 179 180 ret = clk_prepare_enable(pltfm_host->clk); 181 if (ret) { 182 dev_err(&pdev->dev, "Unable to enable SDIO clock\n"); 183 goto err_pltfm_free; 184 } 185 186 ret = mmc_of_parse(host->mmc); 187 if (ret) 188 goto err_sdhci_add; 189 190 ret = sdhci_add_host(host); 191 if (ret) 192 goto err_sdhci_add; 193 194 return 0; 195 196 err_sdhci_add: 197 clk_disable_unprepare(pltfm_host->clk); 198 err_pltfm_free: 199 sdhci_pltfm_free(pdev); 200 return ret; 201 } 202 203 static int aspeed_sdhci_remove(struct platform_device *pdev) 204 { 205 struct sdhci_pltfm_host *pltfm_host; 206 struct sdhci_host *host; 207 int dead = 0; 208 209 host = platform_get_drvdata(pdev); 210 pltfm_host = sdhci_priv(host); 211 212 sdhci_remove_host(host, dead); 213 214 clk_disable_unprepare(pltfm_host->clk); 215 216 sdhci_pltfm_free(pdev); 217 218 return 0; 219 } 220 221 static const struct of_device_id aspeed_sdhci_of_match[] = { 222 { .compatible = "aspeed,ast2400-sdhci", }, 223 { .compatible = "aspeed,ast2500-sdhci", }, 224 { .compatible = "aspeed,ast2600-sdhci", }, 225 { } 226 }; 227 228 static struct platform_driver aspeed_sdhci_driver = { 229 .driver = { 230 .name = "sdhci-aspeed", 231 .of_match_table = aspeed_sdhci_of_match, 232 }, 233 .probe = aspeed_sdhci_probe, 234 .remove = aspeed_sdhci_remove, 235 }; 236 237 static int aspeed_sdc_probe(struct platform_device *pdev) 238 239 { 240 struct device_node *parent, *child; 241 struct aspeed_sdc *sdc; 242 int ret; 243 244 sdc = devm_kzalloc(&pdev->dev, sizeof(*sdc), GFP_KERNEL); 245 if (!sdc) 246 return -ENOMEM; 247 248 spin_lock_init(&sdc->lock); 249 250 sdc->clk = devm_clk_get(&pdev->dev, NULL); 251 if (IS_ERR(sdc->clk)) 252 return PTR_ERR(sdc->clk); 253 254 ret = clk_prepare_enable(sdc->clk); 255 if (ret) { 256 dev_err(&pdev->dev, "Unable to enable SDCLK\n"); 257 return ret; 258 } 259 260 sdc->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 261 sdc->regs = devm_ioremap_resource(&pdev->dev, sdc->res); 262 if (IS_ERR(sdc->regs)) { 263 ret = PTR_ERR(sdc->regs); 264 goto err_clk; 265 } 266 267 dev_set_drvdata(&pdev->dev, sdc); 268 269 parent = pdev->dev.of_node; 270 for_each_available_child_of_node(parent, child) { 271 struct platform_device *cpdev; 272 273 cpdev = of_platform_device_create(child, NULL, &pdev->dev); 274 if (!cpdev) { 275 of_node_put(child); 276 ret = -ENODEV; 277 goto err_clk; 278 } 279 } 280 281 return 0; 282 283 err_clk: 284 clk_disable_unprepare(sdc->clk); 285 return ret; 286 } 287 288 static int aspeed_sdc_remove(struct platform_device *pdev) 289 { 290 struct aspeed_sdc *sdc = dev_get_drvdata(&pdev->dev); 291 292 clk_disable_unprepare(sdc->clk); 293 294 return 0; 295 } 296 297 static const struct of_device_id aspeed_sdc_of_match[] = { 298 { .compatible = "aspeed,ast2400-sd-controller", }, 299 { .compatible = "aspeed,ast2500-sd-controller", }, 300 { .compatible = "aspeed,ast2600-sd-controller", }, 301 { } 302 }; 303 304 MODULE_DEVICE_TABLE(of, aspeed_sdc_of_match); 305 306 static struct platform_driver aspeed_sdc_driver = { 307 .driver = { 308 .name = "sd-controller-aspeed", 309 .pm = &sdhci_pltfm_pmops, 310 .of_match_table = aspeed_sdc_of_match, 311 }, 312 .probe = aspeed_sdc_probe, 313 .remove = aspeed_sdc_remove, 314 }; 315 316 static int __init aspeed_sdc_init(void) 317 { 318 int rc; 319 320 rc = platform_driver_register(&aspeed_sdhci_driver); 321 if (rc < 0) 322 return rc; 323 324 rc = platform_driver_register(&aspeed_sdc_driver); 325 if (rc < 0) 326 platform_driver_unregister(&aspeed_sdhci_driver); 327 328 return rc; 329 } 330 module_init(aspeed_sdc_init); 331 332 static void __exit aspeed_sdc_exit(void) 333 { 334 platform_driver_unregister(&aspeed_sdc_driver); 335 platform_driver_unregister(&aspeed_sdhci_driver); 336 } 337 module_exit(aspeed_sdc_exit); 338 339 MODULE_DESCRIPTION("Driver for the ASPEED SD/SDIO/SDHCI Controllers"); 340 MODULE_AUTHOR("Ryan Chen <ryan_chen@aspeedtech.com>"); 341 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>"); 342 MODULE_LICENSE("GPL"); 343