1 /* 2 * EIM driver for Freescale's i.MX chips 3 * 4 * Copyright (C) 2013 Freescale Semiconductor, Inc. 5 * 6 * This file is licensed under the terms of the GNU General Public 7 * License version 2. This program is licensed "as is" without any 8 * warranty of any kind, whether express or implied. 9 */ 10 #include <linux/module.h> 11 #include <linux/clk.h> 12 #include <linux/io.h> 13 #include <linux/of_device.h> 14 #include <linux/mfd/syscon.h> 15 #include <linux/mfd/syscon/imx6q-iomuxc-gpr.h> 16 #include <linux/regmap.h> 17 18 struct imx_weim_devtype { 19 unsigned int cs_count; 20 unsigned int cs_regs_count; 21 unsigned int cs_stride; 22 unsigned int wcr_offset; 23 unsigned int wcr_bcm; 24 unsigned int wcr_cont_bclk; 25 }; 26 27 static const struct imx_weim_devtype imx1_weim_devtype = { 28 .cs_count = 6, 29 .cs_regs_count = 2, 30 .cs_stride = 0x08, 31 }; 32 33 static const struct imx_weim_devtype imx27_weim_devtype = { 34 .cs_count = 6, 35 .cs_regs_count = 3, 36 .cs_stride = 0x10, 37 }; 38 39 static const struct imx_weim_devtype imx50_weim_devtype = { 40 .cs_count = 4, 41 .cs_regs_count = 6, 42 .cs_stride = 0x18, 43 .wcr_offset = 0x90, 44 .wcr_bcm = BIT(0), 45 .wcr_cont_bclk = BIT(3), 46 }; 47 48 static const struct imx_weim_devtype imx51_weim_devtype = { 49 .cs_count = 6, 50 .cs_regs_count = 6, 51 .cs_stride = 0x18, 52 }; 53 54 #define MAX_CS_REGS_COUNT 6 55 #define MAX_CS_COUNT 6 56 #define OF_REG_SIZE 3 57 58 struct cs_timing { 59 bool is_applied; 60 u32 regs[MAX_CS_REGS_COUNT]; 61 }; 62 63 struct cs_timing_state { 64 struct cs_timing cs[MAX_CS_COUNT]; 65 }; 66 67 struct weim_priv { 68 void __iomem *base; 69 struct cs_timing_state timing_state; 70 }; 71 72 static const struct of_device_id weim_id_table[] = { 73 /* i.MX1/21 */ 74 { .compatible = "fsl,imx1-weim", .data = &imx1_weim_devtype, }, 75 /* i.MX25/27/31/35 */ 76 { .compatible = "fsl,imx27-weim", .data = &imx27_weim_devtype, }, 77 /* i.MX50/53/6Q */ 78 { .compatible = "fsl,imx50-weim", .data = &imx50_weim_devtype, }, 79 { .compatible = "fsl,imx6q-weim", .data = &imx50_weim_devtype, }, 80 /* i.MX51 */ 81 { .compatible = "fsl,imx51-weim", .data = &imx51_weim_devtype, }, 82 { } 83 }; 84 MODULE_DEVICE_TABLE(of, weim_id_table); 85 86 static int imx_weim_gpr_setup(struct platform_device *pdev) 87 { 88 struct device_node *np = pdev->dev.of_node; 89 struct property *prop; 90 const __be32 *p; 91 struct regmap *gpr; 92 u32 gprvals[4] = { 93 05, /* CS0(128M) CS1(0M) CS2(0M) CS3(0M) */ 94 033, /* CS0(64M) CS1(64M) CS2(0M) CS3(0M) */ 95 0113, /* CS0(64M) CS1(32M) CS2(32M) CS3(0M) */ 96 01111, /* CS0(32M) CS1(32M) CS2(32M) CS3(32M) */ 97 }; 98 u32 gprval = 0; 99 u32 val; 100 int cs = 0; 101 int i = 0; 102 103 gpr = syscon_regmap_lookup_by_phandle(np, "fsl,weim-cs-gpr"); 104 if (IS_ERR(gpr)) { 105 dev_dbg(&pdev->dev, "failed to find weim-cs-gpr\n"); 106 return 0; 107 } 108 109 of_property_for_each_u32(np, "ranges", prop, p, val) { 110 if (i % 4 == 0) { 111 cs = val; 112 } else if (i % 4 == 3 && val) { 113 val = (val / SZ_32M) | 1; 114 gprval |= val << cs * 3; 115 } 116 i++; 117 } 118 119 if (i == 0 || i % 4) 120 goto err; 121 122 for (i = 0; i < ARRAY_SIZE(gprvals); i++) { 123 if (gprval == gprvals[i]) { 124 /* Found it. Set up IOMUXC_GPR1[11:0] with it. */ 125 regmap_update_bits(gpr, IOMUXC_GPR1, 0xfff, gprval); 126 return 0; 127 } 128 } 129 130 err: 131 dev_err(&pdev->dev, "Invalid 'ranges' configuration\n"); 132 return -EINVAL; 133 } 134 135 /* Parse and set the timing for this device. */ 136 static int weim_timing_setup(struct device *dev, struct device_node *np, 137 const struct imx_weim_devtype *devtype) 138 { 139 u32 cs_idx, value[MAX_CS_REGS_COUNT]; 140 int i, ret; 141 int reg_idx, num_regs; 142 struct cs_timing *cst; 143 struct weim_priv *priv; 144 struct cs_timing_state *ts; 145 void __iomem *base; 146 147 if (WARN_ON(devtype->cs_regs_count > MAX_CS_REGS_COUNT)) 148 return -EINVAL; 149 if (WARN_ON(devtype->cs_count > MAX_CS_COUNT)) 150 return -EINVAL; 151 152 priv = dev_get_drvdata(dev); 153 base = priv->base; 154 ts = &priv->timing_state; 155 156 ret = of_property_read_u32_array(np, "fsl,weim-cs-timing", 157 value, devtype->cs_regs_count); 158 if (ret) 159 return ret; 160 161 /* 162 * the child node's "reg" property may contain multiple address ranges, 163 * extract the chip select for each. 164 */ 165 num_regs = of_property_count_elems_of_size(np, "reg", OF_REG_SIZE); 166 if (num_regs < 0) 167 return num_regs; 168 if (!num_regs) 169 return -EINVAL; 170 for (reg_idx = 0; reg_idx < num_regs; reg_idx++) { 171 /* get the CS index from this child node's "reg" property. */ 172 ret = of_property_read_u32_index(np, "reg", 173 reg_idx * OF_REG_SIZE, &cs_idx); 174 if (ret) 175 break; 176 177 if (cs_idx >= devtype->cs_count) 178 return -EINVAL; 179 180 /* prevent re-configuring a CS that's already been configured */ 181 cst = &ts->cs[cs_idx]; 182 if (cst->is_applied && memcmp(value, cst->regs, 183 devtype->cs_regs_count * sizeof(u32))) { 184 dev_err(dev, "fsl,weim-cs-timing conflict on %pOF", np); 185 return -EINVAL; 186 } 187 188 /* set the timing for WEIM */ 189 for (i = 0; i < devtype->cs_regs_count; i++) 190 writel(value[i], 191 base + cs_idx * devtype->cs_stride + i * 4); 192 if (!cst->is_applied) { 193 cst->is_applied = true; 194 memcpy(cst->regs, value, 195 devtype->cs_regs_count * sizeof(u32)); 196 } 197 } 198 199 return 0; 200 } 201 202 static int weim_parse_dt(struct platform_device *pdev) 203 { 204 const struct of_device_id *of_id = of_match_device(weim_id_table, 205 &pdev->dev); 206 const struct imx_weim_devtype *devtype = of_id->data; 207 int ret = 0, have_child = 0; 208 struct device_node *child; 209 struct weim_priv *priv; 210 void __iomem *base; 211 u32 reg; 212 213 if (devtype == &imx50_weim_devtype) { 214 ret = imx_weim_gpr_setup(pdev); 215 if (ret) 216 return ret; 217 } 218 219 priv = dev_get_drvdata(&pdev->dev); 220 base = priv->base; 221 222 if (of_property_read_bool(pdev->dev.of_node, "fsl,burst-clk-enable")) { 223 if (devtype->wcr_bcm) { 224 reg = readl(base + devtype->wcr_offset); 225 reg |= devtype->wcr_bcm; 226 227 if (of_property_read_bool(pdev->dev.of_node, 228 "fsl,continuous-burst-clk")) { 229 if (devtype->wcr_cont_bclk) { 230 reg |= devtype->wcr_cont_bclk; 231 } else { 232 dev_err(&pdev->dev, 233 "continuous burst clk not supported.\n"); 234 return -EINVAL; 235 } 236 } 237 238 writel(reg, base + devtype->wcr_offset); 239 } else { 240 dev_err(&pdev->dev, "burst clk mode not supported.\n"); 241 return -EINVAL; 242 } 243 } 244 245 for_each_available_child_of_node(pdev->dev.of_node, child) { 246 ret = weim_timing_setup(&pdev->dev, child, devtype); 247 if (ret) 248 dev_warn(&pdev->dev, "%pOF set timing failed.\n", 249 child); 250 else 251 have_child = 1; 252 } 253 254 if (have_child) 255 ret = of_platform_default_populate(pdev->dev.of_node, 256 NULL, &pdev->dev); 257 if (ret) 258 dev_err(&pdev->dev, "%pOF fail to create devices.\n", 259 pdev->dev.of_node); 260 return ret; 261 } 262 263 static int weim_probe(struct platform_device *pdev) 264 { 265 struct weim_priv *priv; 266 struct clk *clk; 267 void __iomem *base; 268 int ret; 269 270 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 271 if (!priv) 272 return -ENOMEM; 273 274 /* get the resource */ 275 base = devm_platform_get_and_ioremap_resource(pdev, 0, NULL); 276 if (IS_ERR(base)) 277 return PTR_ERR(base); 278 279 priv->base = base; 280 dev_set_drvdata(&pdev->dev, priv); 281 282 /* get the clock */ 283 clk = devm_clk_get(&pdev->dev, NULL); 284 if (IS_ERR(clk)) 285 return PTR_ERR(clk); 286 287 ret = clk_prepare_enable(clk); 288 if (ret) 289 return ret; 290 291 /* parse the device node */ 292 ret = weim_parse_dt(pdev); 293 if (ret) 294 clk_disable_unprepare(clk); 295 else 296 dev_info(&pdev->dev, "Driver registered.\n"); 297 298 return ret; 299 } 300 301 #if IS_ENABLED(CONFIG_OF_DYNAMIC) 302 static int of_weim_notify(struct notifier_block *nb, unsigned long action, 303 void *arg) 304 { 305 const struct imx_weim_devtype *devtype; 306 struct of_reconfig_data *rd = arg; 307 const struct of_device_id *of_id; 308 struct platform_device *pdev; 309 int ret = NOTIFY_OK; 310 311 switch (of_reconfig_get_state_change(action, rd)) { 312 case OF_RECONFIG_CHANGE_ADD: 313 of_id = of_match_node(weim_id_table, rd->dn->parent); 314 if (!of_id) 315 return NOTIFY_OK; /* not for us */ 316 317 devtype = of_id->data; 318 319 pdev = of_find_device_by_node(rd->dn->parent); 320 if (!pdev) { 321 pr_err("%s: could not find platform device for '%pOF'\n", 322 __func__, rd->dn->parent); 323 324 return notifier_from_errno(-EINVAL); 325 } 326 327 if (weim_timing_setup(&pdev->dev, rd->dn, devtype)) 328 dev_warn(&pdev->dev, 329 "Failed to setup timing for '%pOF'\n", rd->dn); 330 331 if (!of_node_check_flag(rd->dn, OF_POPULATED)) { 332 if (!of_platform_device_create(rd->dn, NULL, &pdev->dev)) { 333 dev_err(&pdev->dev, 334 "Failed to create child device '%pOF'\n", 335 rd->dn); 336 ret = notifier_from_errno(-EINVAL); 337 } 338 } 339 340 platform_device_put(pdev); 341 342 break; 343 case OF_RECONFIG_CHANGE_REMOVE: 344 if (!of_node_check_flag(rd->dn, OF_POPULATED)) 345 return NOTIFY_OK; /* device already destroyed */ 346 347 of_id = of_match_node(weim_id_table, rd->dn->parent); 348 if (!of_id) 349 return NOTIFY_OK; /* not for us */ 350 351 pdev = of_find_device_by_node(rd->dn); 352 if (!pdev) { 353 pr_err("Could not find platform device for '%pOF'\n", 354 rd->dn); 355 356 ret = notifier_from_errno(-EINVAL); 357 } else { 358 of_platform_device_destroy(&pdev->dev, NULL); 359 platform_device_put(pdev); 360 } 361 362 break; 363 default: 364 break; 365 } 366 367 return ret; 368 } 369 370 static struct notifier_block weim_of_notifier = { 371 .notifier_call = of_weim_notify, 372 }; 373 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 374 375 static struct platform_driver weim_driver = { 376 .driver = { 377 .name = "imx-weim", 378 .of_match_table = weim_id_table, 379 }, 380 .probe = weim_probe, 381 }; 382 383 static int __init weim_init(void) 384 { 385 #if IS_ENABLED(CONFIG_OF_DYNAMIC) 386 WARN_ON(of_reconfig_notifier_register(&weim_of_notifier)); 387 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 388 389 return platform_driver_register(&weim_driver); 390 } 391 module_init(weim_init); 392 393 static void __exit weim_exit(void) 394 { 395 #if IS_ENABLED(CONFIG_OF_DYNAMIC) 396 of_reconfig_notifier_unregister(&weim_of_notifier); 397 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */ 398 399 return platform_driver_unregister(&weim_driver); 400 401 } 402 module_exit(weim_exit); 403 404 MODULE_AUTHOR("Freescale Semiconductor Inc."); 405 MODULE_DESCRIPTION("i.MX EIM Controller Driver"); 406 MODULE_LICENSE("GPL"); 407