1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #define pr_fmt(fmt) "generic pinconfig core: " fmt
4
5 #include <linux/array_size.h>
6 #include <linux/device.h>
7 #include <linux/module.h>
8 #include <linux/of.h>
9 #include <linux/slab.h>
10
11 #include <linux/pinctrl/pinconf-generic.h>
12 #include <linux/pinctrl/pinconf.h>
13 #include <linux/pinctrl/pinctrl.h>
14
15 #include "core.h"
16 #include "pinconf.h"
17 #include "pinctrl-utils.h"
18 #include "pinmux.h"
19
pinctrl_generic_to_map(struct pinctrl_dev * pctldev,struct device_node * parent,struct device_node * np,struct pinctrl_map ** maps,unsigned int * num_maps,unsigned int * num_reserved_maps,const char ** group_names,unsigned int ngroups,void * data,unsigned int * pins,unsigned int npins)20 int pinctrl_generic_to_map(struct pinctrl_dev *pctldev, struct device_node *parent,
21 struct device_node *np, struct pinctrl_map **maps,
22 unsigned int *num_maps, unsigned int *num_reserved_maps,
23 const char **group_names, unsigned int ngroups,
24 void *data, unsigned int *pins, unsigned int npins)
25 {
26 struct device *dev = pctldev->dev;
27 unsigned int num_configs;
28 const char *group_name;
29 unsigned long *configs;
30 int ret, reserve = 1;
31
32 group_name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn.%pOFn", parent, np);
33 if (!group_name)
34 return -ENOMEM;
35
36 group_names[ngroups] = group_name;
37
38 ret = pinctrl_utils_reserve_map(pctldev, maps, num_reserved_maps, num_maps, reserve);
39 if (ret)
40 return ret;
41
42 ret = pinctrl_utils_add_map_mux(pctldev, maps, num_reserved_maps, num_maps, group_name,
43 parent->name);
44 if (ret < 0)
45 goto err_free_map;
46
47 ret = pinctrl_generic_add_group(pctldev, group_name, pins, npins, data);
48 if (ret < 0) {
49 dev_err_probe(dev, ret, "failed to add group %s: %d\n",
50 group_name, ret);
51 goto err_free_map;
52 }
53
54 ret = pinconf_generic_parse_dt_config(np, pctldev, &configs, &num_configs);
55 if (ret) {
56 dev_err_probe(dev, ret, "failed to parse pin config of group %s\n",
57 group_name);
58 goto err_free_map;
59 }
60
61 if (num_configs == 0)
62 return 0;
63
64 ret = pinctrl_utils_reserve_map(pctldev, maps, num_reserved_maps, num_maps, reserve);
65 if (ret)
66 goto err_free_map;
67
68 ret = pinctrl_utils_add_map_configs(pctldev, maps, num_reserved_maps, num_maps, group_name,
69 configs,
70 num_configs, PIN_MAP_TYPE_CONFIGS_GROUP);
71 kfree(configs);
72 if (ret)
73 goto err_free_map;
74
75 return 0;
76
77 err_free_map:
78 pinctrl_utils_free_map(pctldev, *maps, *num_maps);
79 *maps = NULL;
80 *num_maps = 0;
81 *num_reserved_maps = 0;
82 return ret;
83 };
84 EXPORT_SYMBOL_GPL(pinctrl_generic_to_map);
85
pinctrl_generic_pins_function_dt_subnode_to_map(struct pinctrl_dev * pctldev,struct device_node * parent,struct device_node * np,struct pinctrl_map ** maps,unsigned int * num_maps,unsigned int * num_reserved_maps,const char ** group_names,unsigned int ngroups)86 static int pinctrl_generic_pins_function_dt_subnode_to_map(struct pinctrl_dev *pctldev,
87 struct device_node *parent,
88 struct device_node *np,
89 struct pinctrl_map **maps,
90 unsigned int *num_maps,
91 unsigned int *num_reserved_maps,
92 const char **group_names,
93 unsigned int ngroups)
94 {
95 struct device *dev = pctldev->dev;
96 unsigned int pin, *pins;
97 const char **functions;
98 int npins, ret;
99
100 npins = of_property_count_u32_elems(np, "pins");
101
102 if (npins < 1) {
103 dev_err(dev, "invalid pinctrl group %pOFn.%pOFn %d\n",
104 parent, np, npins);
105 return npins;
106 }
107
108 pins = devm_kcalloc(dev, npins, sizeof(*pins), GFP_KERNEL);
109 if (!pins)
110 return -ENOMEM;
111
112 functions = devm_kcalloc(dev, npins, sizeof(*functions), GFP_KERNEL);
113 if (!functions)
114 return -ENOMEM;
115
116 for (int i = 0; i < npins; i++) {
117 ret = of_property_read_u32_index(np, "pins", i, &pin);
118 if (ret)
119 return ret;
120
121 pins[i] = pin;
122
123 ret = of_property_read_string(np, "function", &functions[i]);
124 if (ret)
125 return ret;
126 }
127
128 return pinctrl_generic_to_map(pctldev, parent, np, maps, num_maps,
129 num_reserved_maps, group_names, ngroups,
130 functions, pins, npins);
131 }
132
pinctrl_generic_pinmux_dt_subnode_to_map(struct pinctrl_dev * pctldev,struct device_node * parent,struct device_node * np,struct pinctrl_map ** maps,unsigned int * num_maps,unsigned int * num_reserved_maps,const char ** group_names,unsigned int ngroups)133 static int pinctrl_generic_pinmux_dt_subnode_to_map(struct pinctrl_dev *pctldev,
134 struct device_node *parent,
135 struct device_node *np,
136 struct pinctrl_map **maps,
137 unsigned int *num_maps,
138 unsigned int *num_reserved_maps,
139 const char **group_names,
140 unsigned int ngroups)
141 {
142 struct device *dev = pctldev->dev;
143 unsigned int *pins, *muxes;
144 int npins, ret;
145
146 npins = of_property_count_u32_elems(np, "pinmux");
147
148 if (npins < 1) {
149 dev_err(dev, "invalid pinctrl group %pOFn.%pOFn %d\n",
150 parent, np, npins);
151 return npins;
152 }
153
154 pins = devm_kcalloc(dev, npins, sizeof(*pins), GFP_KERNEL);
155 if (!pins)
156 return -ENOMEM;
157
158 muxes = devm_kcalloc(dev, npins, sizeof(*muxes), GFP_KERNEL);
159 if (!muxes)
160 return -ENOMEM;
161
162 for (int i = 0; i < npins; i++) {
163 unsigned int pinmux;
164
165 ret = of_property_read_u32_index(np, "pinmux", i, &pinmux);
166 if (ret)
167 return ret;
168
169 pins[i] = pinmux >> 16;
170 muxes[i] = pinmux & GENMASK(15, 0);
171 }
172
173 return pinctrl_generic_to_map(pctldev, parent, np, maps, num_maps,
174 num_reserved_maps, group_names, ngroups,
175 muxes, pins, npins);
176 }
177
pinctrl_generic_dt_node_to_map(struct pinctrl_dev * pctldev,struct device_node * np,struct pinctrl_map ** maps,unsigned int * num_maps,int (dt_subnode_to_map)(struct pinctrl_dev *,struct device_node *,struct device_node *,struct pinctrl_map **,unsigned int *,unsigned int *,const char **,unsigned int))178 static int pinctrl_generic_dt_node_to_map(struct pinctrl_dev *pctldev,
179 struct device_node *np,
180 struct pinctrl_map **maps,
181 unsigned int *num_maps,
182 int (dt_subnode_to_map)(
183 struct pinctrl_dev *,
184 struct device_node *,
185 struct device_node *,
186 struct pinctrl_map **,
187 unsigned int *,
188 unsigned int *,
189 const char **,
190 unsigned int))
191 {
192 struct device *dev = pctldev->dev;
193 struct device_node *child_np;
194 const char **group_names;
195 unsigned int num_reserved_maps = 0;
196 int ngroups = 0;
197 int ret;
198
199 *maps = NULL;
200 *num_maps = 0;
201
202 /*
203 * Check if this is actually the pins node, or a parent containing
204 * multiple pins nodes.
205 */
206 if (!of_property_present(np, "pins"))
207 goto parent;
208
209 group_names = devm_kcalloc(dev, 1, sizeof(*group_names), GFP_KERNEL);
210 if (!group_names)
211 return -ENOMEM;
212
213 ret = dt_subnode_to_map(pctldev, np, np, maps, num_maps,
214 &num_reserved_maps, group_names, ngroups);
215 if (ret) {
216 pinctrl_utils_free_map(pctldev, *maps, *num_maps);
217 return dev_err_probe(dev, ret, "error figuring out mappings for %s\n", np->name);
218 }
219
220 ret = pinmux_generic_add_function(pctldev, np->name, group_names, 1, NULL);
221 if (ret < 0) {
222 pinctrl_utils_free_map(pctldev, *maps, *num_maps);
223 return dev_err_probe(dev, ret, "error adding function %s\n", np->name);
224 }
225
226 return 0;
227
228 parent:
229 for_each_available_child_of_node(np, child_np)
230 ngroups += 1;
231
232 group_names = devm_kcalloc(dev, ngroups, sizeof(*group_names), GFP_KERNEL);
233 if (!group_names)
234 return -ENOMEM;
235
236 ngroups = 0;
237 for_each_available_child_of_node_scoped(np, child_np) {
238 ret = dt_subnode_to_map(pctldev, np, child_np, maps, num_maps,
239 &num_reserved_maps, group_names, ngroups);
240 if (ret) {
241 pinctrl_utils_free_map(pctldev, *maps, *num_maps);
242 return dev_err_probe(dev, ret, "error figuring out mappings for %s\n",
243 np->name);
244 }
245
246 ngroups++;
247 }
248
249 ret = pinmux_generic_add_function(pctldev, np->name, group_names, ngroups, NULL);
250 if (ret < 0) {
251 pinctrl_utils_free_map(pctldev, *maps, *num_maps);
252 return dev_err_probe(dev, ret, "error adding function %s\n", np->name);
253 }
254
255 return 0;
256 }
257
258 /*
259 * For platforms that do not define groups or functions in the driver, but
260 * instead use the devicetree to describe them. This function will, unlike
261 * pinconf_generic_dt_node_to_map() etc which rely on driver defined groups
262 * and functions, create them in addition to parsing pinconf properties and
263 * adding mappings.
264 */
pinctrl_generic_pins_function_dt_node_to_map(struct pinctrl_dev * pctldev,struct device_node * np,struct pinctrl_map ** maps,unsigned int * num_maps)265 int pinctrl_generic_pins_function_dt_node_to_map(struct pinctrl_dev *pctldev,
266 struct device_node *np,
267 struct pinctrl_map **maps,
268 unsigned int *num_maps)
269 {
270 return pinctrl_generic_dt_node_to_map(pctldev, np, maps, num_maps,
271 &pinctrl_generic_pins_function_dt_subnode_to_map);
272 }
273 EXPORT_SYMBOL_GPL(pinctrl_generic_pins_function_dt_node_to_map);
274
275 /*
276 * For platforms that do not define groups or functions in the driver, but
277 * instead use the devicetree to describe them. This function will, unlike
278 * pinconf_generic_dt_node_to_map() etc which rely on driver defined groups
279 * and functions, create them in addition to parsing pinconf properties and
280 * adding mappings.
281 *
282 * It assumes that the upper 16 bits of the pinmux items contain the pin
283 * and the lower 16 the mux setting.
284 */
pinctrl_generic_pinmux_dt_node_to_map(struct pinctrl_dev * pctldev,struct device_node * np,struct pinctrl_map ** maps,unsigned int * num_maps)285 int pinctrl_generic_pinmux_dt_node_to_map(struct pinctrl_dev *pctldev,
286 struct device_node *np,
287 struct pinctrl_map **maps,
288 unsigned int *num_maps)
289 {
290 return pinctrl_generic_dt_node_to_map(pctldev, np, maps, num_maps,
291 &pinctrl_generic_pinmux_dt_subnode_to_map);
292 };
293 EXPORT_SYMBOL_GPL(pinctrl_generic_pinmux_dt_node_to_map);
294