2 * EIM driver for Freescale's i.MX chips
4 * Copyright (C) 2013 Freescale Semiconductor, Inc.
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.
10 #include <linux/module.h>
11 #include <linux/clk.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>
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
;
24 unsigned int wcr_cont_bclk
;
27 static const struct imx_weim_devtype imx1_weim_devtype
= {
33 static const struct imx_weim_devtype imx27_weim_devtype
= {
39 static const struct imx_weim_devtype imx50_weim_devtype
= {
45 .wcr_cont_bclk
= BIT(3),
48 static const struct imx_weim_devtype imx51_weim_devtype
= {
54 #define MAX_CS_REGS_COUNT 6
55 #define MAX_CS_COUNT 6
60 u32 regs
[MAX_CS_REGS_COUNT
];
63 struct cs_timing_state
{
64 struct cs_timing cs
[MAX_CS_COUNT
];
69 struct cs_timing_state timing_state
;
72 static const struct of_device_id weim_id_table
[] = {
74 { .compatible
= "fsl,imx1-weim", .data
= &imx1_weim_devtype
, },
76 { .compatible
= "fsl,imx27-weim", .data
= &imx27_weim_devtype
, },
78 { .compatible
= "fsl,imx50-weim", .data
= &imx50_weim_devtype
, },
79 { .compatible
= "fsl,imx6q-weim", .data
= &imx50_weim_devtype
, },
81 { .compatible
= "fsl,imx51-weim", .data
= &imx51_weim_devtype
, },
84 MODULE_DEVICE_TABLE(of
, weim_id_table
);
86 static int imx_weim_gpr_setup(struct platform_device
*pdev
)
88 struct device_node
*np
= pdev
->dev
.of_node
;
89 struct property
*prop
;
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) */
103 gpr
= syscon_regmap_lookup_by_phandle(np
, "fsl,weim-cs-gpr");
105 dev_dbg(&pdev
->dev
, "failed to find weim-cs-gpr\n");
109 of_property_for_each_u32(np
, "ranges", prop
, p
, val
) {
112 } else if (i
% 4 == 3 && val
) {
113 val
= (val
/ SZ_32M
) | 1;
114 gprval
|= val
<< cs
* 3;
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
);
131 dev_err(&pdev
->dev
, "Invalid 'ranges' configuration\n");
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
)
139 u32 cs_idx
, value
[MAX_CS_REGS_COUNT
];
141 int reg_idx
, num_regs
;
142 struct cs_timing
*cst
;
143 struct weim_priv
*priv
;
144 struct cs_timing_state
*ts
;
147 if (WARN_ON(devtype
->cs_regs_count
> MAX_CS_REGS_COUNT
))
149 if (WARN_ON(devtype
->cs_count
> MAX_CS_COUNT
))
152 priv
= dev_get_drvdata(dev
);
154 ts
= &priv
->timing_state
;
156 ret
= of_property_read_u32_array(np
, "fsl,weim-cs-timing",
157 value
, devtype
->cs_regs_count
);
162 * the child node's "reg" property may contain multiple address ranges,
163 * extract the chip select for each.
165 num_regs
= of_property_count_elems_of_size(np
, "reg", OF_REG_SIZE
);
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
);
177 if (cs_idx
>= devtype
->cs_count
)
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
);
188 /* set the timing for WEIM */
189 for (i
= 0; i
< devtype
->cs_regs_count
; 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
));
202 static int weim_parse_dt(struct platform_device
*pdev
)
204 const struct of_device_id
*of_id
= of_match_device(weim_id_table
,
206 const struct imx_weim_devtype
*devtype
= of_id
->data
;
207 struct device_node
*child
;
208 int ret
, have_child
= 0;
209 struct weim_priv
*priv
;
213 if (devtype
== &imx50_weim_devtype
) {
214 ret
= imx_weim_gpr_setup(pdev
);
219 priv
= dev_get_drvdata(&pdev
->dev
);
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
;
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
;
233 "continuous burst clk not supported.\n");
238 writel(reg
, base
+ devtype
->wcr_offset
);
240 dev_err(&pdev
->dev
, "burst clk mode not supported.\n");
245 for_each_available_child_of_node(pdev
->dev
.of_node
, child
) {
246 ret
= weim_timing_setup(&pdev
->dev
, child
, devtype
);
248 dev_warn(&pdev
->dev
, "%pOF set timing failed.\n",
255 ret
= of_platform_default_populate(pdev
->dev
.of_node
,
258 dev_err(&pdev
->dev
, "%pOF fail to create devices.\n",
263 static int weim_probe(struct platform_device
*pdev
)
265 struct weim_priv
*priv
;
266 struct resource
*res
;
271 priv
= devm_kzalloc(&pdev
->dev
, sizeof(*priv
), GFP_KERNEL
);
275 /* get the resource */
276 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
277 base
= devm_ioremap_resource(&pdev
->dev
, res
);
279 return PTR_ERR(base
);
282 dev_set_drvdata(&pdev
->dev
, priv
);
285 clk
= devm_clk_get(&pdev
->dev
, NULL
);
289 ret
= clk_prepare_enable(clk
);
293 /* parse the device node */
294 ret
= weim_parse_dt(pdev
);
296 clk_disable_unprepare(clk
);
298 dev_info(&pdev
->dev
, "Driver registered.\n");
303 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
304 static int of_weim_notify(struct notifier_block
*nb
, unsigned long action
,
307 const struct imx_weim_devtype
*devtype
;
308 struct of_reconfig_data
*rd
= arg
;
309 const struct of_device_id
*of_id
;
310 struct platform_device
*pdev
;
313 switch (of_reconfig_get_state_change(action
, rd
)) {
314 case OF_RECONFIG_CHANGE_ADD
:
315 of_id
= of_match_node(weim_id_table
, rd
->dn
->parent
);
317 return NOTIFY_OK
; /* not for us */
319 devtype
= of_id
->data
;
321 pdev
= of_find_device_by_node(rd
->dn
->parent
);
323 pr_err("%s: could not find platform device for '%pOF'\n",
324 __func__
, rd
->dn
->parent
);
326 return notifier_from_errno(-EINVAL
);
329 if (weim_timing_setup(&pdev
->dev
, rd
->dn
, devtype
))
331 "Failed to setup timing for '%pOF'\n", rd
->dn
);
333 if (!of_node_check_flag(rd
->dn
, OF_POPULATED
)) {
334 if (!of_platform_device_create(rd
->dn
, NULL
, &pdev
->dev
)) {
336 "Failed to create child device '%pOF'\n",
338 ret
= notifier_from_errno(-EINVAL
);
342 platform_device_put(pdev
);
345 case OF_RECONFIG_CHANGE_REMOVE
:
346 if (!of_node_check_flag(rd
->dn
, OF_POPULATED
))
347 return NOTIFY_OK
; /* device already destroyed */
349 of_id
= of_match_node(weim_id_table
, rd
->dn
->parent
);
351 return NOTIFY_OK
; /* not for us */
353 pdev
= of_find_device_by_node(rd
->dn
);
355 pr_err("Could not find platform device for '%pOF'\n",
358 ret
= notifier_from_errno(-EINVAL
);
360 of_platform_device_destroy(&pdev
->dev
, NULL
);
361 platform_device_put(pdev
);
372 static struct notifier_block weim_of_notifier
= {
373 .notifier_call
= of_weim_notify
,
375 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
377 static struct platform_driver weim_driver
= {
380 .of_match_table
= weim_id_table
,
385 static int __init
weim_init(void)
387 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
388 WARN_ON(of_reconfig_notifier_register(&weim_of_notifier
));
389 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
391 return platform_driver_register(&weim_driver
);
393 module_init(weim_init
);
395 static void __exit
weim_exit(void)
397 #if IS_ENABLED(CONFIG_OF_DYNAMIC)
398 of_reconfig_notifier_unregister(&weim_of_notifier
);
399 #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
401 return platform_driver_unregister(&weim_driver
);
404 module_exit(weim_exit
);
406 MODULE_AUTHOR("Freescale Semiconductor Inc.");
407 MODULE_DESCRIPTION("i.MX EIM Controller Driver");
408 MODULE_LICENSE("GPL");