1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * System Control Driver
5 * Copyright (C) 2012 Freescale Semiconductor, Inc.
6 * Copyright (C) 2012 Linaro Ltd.
8 * Author: Dong Aisheng <dong.aisheng@linaro.org>
11 #include <linux/clk.h>
12 #include <linux/err.h>
13 #include <linux/hwspinlock.h>
15 #include <linux/init.h>
16 #include <linux/list.h>
18 #include <linux/of_address.h>
19 #include <linux/of_platform.h>
20 #include <linux/platform_data/syscon.h>
21 #include <linux/platform_device.h>
22 #include <linux/regmap.h>
23 #include <linux/mfd/syscon.h>
24 #include <linux/slab.h>
26 static struct platform_driver syscon_driver
;
28 static DEFINE_SPINLOCK(syscon_list_slock
);
29 static LIST_HEAD(syscon_list
);
32 struct device_node
*np
;
33 struct regmap
*regmap
;
34 struct list_head list
;
37 static const struct regmap_config syscon_regmap_config
= {
43 static struct syscon
*of_syscon_register(struct device_node
*np
)
46 struct syscon
*syscon
;
47 struct regmap
*regmap
;
51 struct regmap_config syscon_config
= syscon_regmap_config
;
54 if (!of_device_is_compatible(np
, "syscon"))
55 return ERR_PTR(-EINVAL
);
57 syscon
= kzalloc(sizeof(*syscon
), GFP_KERNEL
);
59 return ERR_PTR(-ENOMEM
);
61 if (of_address_to_resource(np
, 0, &res
)) {
66 base
= ioremap(res
.start
, resource_size(&res
));
72 /* Parse the device's DT node for an endianness specification */
73 if (of_property_read_bool(np
, "big-endian"))
74 syscon_config
.val_format_endian
= REGMAP_ENDIAN_BIG
;
75 else if (of_property_read_bool(np
, "little-endian"))
76 syscon_config
.val_format_endian
= REGMAP_ENDIAN_LITTLE
;
77 else if (of_property_read_bool(np
, "native-endian"))
78 syscon_config
.val_format_endian
= REGMAP_ENDIAN_NATIVE
;
81 * search for reg-io-width property in DT. If it is not provided,
82 * default to 4 bytes. regmap_init_mmio will return an error if values
83 * are invalid so there is no need to check them here.
85 ret
= of_property_read_u32(np
, "reg-io-width", ®_io_width
);
89 ret
= of_hwspin_lock_get_id(np
, 0);
90 if (ret
> 0 || (IS_ENABLED(CONFIG_HWSPINLOCK
) && ret
== 0)) {
91 syscon_config
.use_hwlock
= true;
92 syscon_config
.hwlock_id
= ret
;
93 syscon_config
.hwlock_mode
= HWLOCK_IRQSTATE
;
97 /* Ignore missing hwlock, it's optional. */
100 pr_err("Failed to retrieve valid hwlock: %d\n", ret
);
107 syscon_config
.name
= of_node_full_name(np
);
108 syscon_config
.reg_stride
= reg_io_width
;
109 syscon_config
.val_bits
= reg_io_width
* 8;
110 syscon_config
.max_register
= resource_size(&res
) - reg_io_width
;
111 syscon_config
.name
= of_node_full_name(np
);
113 regmap
= regmap_init_mmio(NULL
, base
, &syscon_config
);
114 if (IS_ERR(regmap
)) {
115 pr_err("regmap init failed\n");
116 ret
= PTR_ERR(regmap
);
120 clk
= of_clk_get(np
, 0);
123 /* clock is optional */
127 ret
= regmap_mmio_attach_clk(regmap
, clk
);
132 syscon
->regmap
= regmap
;
135 spin_lock(&syscon_list_slock
);
136 list_add_tail(&syscon
->list
, &syscon_list
);
137 spin_unlock(&syscon_list_slock
);
153 struct regmap
*syscon_node_to_regmap(struct device_node
*np
)
155 struct syscon
*entry
, *syscon
= NULL
;
157 spin_lock(&syscon_list_slock
);
159 list_for_each_entry(entry
, &syscon_list
, list
)
160 if (entry
->np
== np
) {
165 spin_unlock(&syscon_list_slock
);
168 syscon
= of_syscon_register(np
);
171 return ERR_CAST(syscon
);
173 return syscon
->regmap
;
175 EXPORT_SYMBOL_GPL(syscon_node_to_regmap
);
177 struct regmap
*syscon_regmap_lookup_by_compatible(const char *s
)
179 struct device_node
*syscon_np
;
180 struct regmap
*regmap
;
182 syscon_np
= of_find_compatible_node(NULL
, NULL
, s
);
184 return ERR_PTR(-ENODEV
);
186 regmap
= syscon_node_to_regmap(syscon_np
);
187 of_node_put(syscon_np
);
191 EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_compatible
);
193 struct regmap
*syscon_regmap_lookup_by_phandle(struct device_node
*np
,
194 const char *property
)
196 struct device_node
*syscon_np
;
197 struct regmap
*regmap
;
200 syscon_np
= of_parse_phandle(np
, property
, 0);
205 return ERR_PTR(-ENODEV
);
207 regmap
= syscon_node_to_regmap(syscon_np
);
208 of_node_put(syscon_np
);
212 EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_phandle
);
214 static int syscon_probe(struct platform_device
*pdev
)
216 struct device
*dev
= &pdev
->dev
;
217 struct syscon_platform_data
*pdata
= dev_get_platdata(dev
);
218 struct syscon
*syscon
;
219 struct regmap_config syscon_config
= syscon_regmap_config
;
220 struct resource
*res
;
223 syscon
= devm_kzalloc(dev
, sizeof(*syscon
), GFP_KERNEL
);
227 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
231 base
= devm_ioremap(dev
, res
->start
, resource_size(res
));
235 syscon_config
.max_register
= res
->end
- res
->start
- 3;
237 syscon_config
.name
= pdata
->label
;
238 syscon
->regmap
= devm_regmap_init_mmio(dev
, base
, &syscon_config
);
239 if (IS_ERR(syscon
->regmap
)) {
240 dev_err(dev
, "regmap init failed\n");
241 return PTR_ERR(syscon
->regmap
);
244 platform_set_drvdata(pdev
, syscon
);
246 dev_dbg(dev
, "regmap %pR registered\n", res
);
251 static const struct platform_device_id syscon_ids
[] = {
256 static struct platform_driver syscon_driver
= {
260 .probe
= syscon_probe
,
261 .id_table
= syscon_ids
,
264 static int __init
syscon_init(void)
266 return platform_driver_register(&syscon_driver
);
268 postcore_initcall(syscon_init
);