This source file includes following definitions.
- zx_dt_node_to_map
- zx_set_mux
- zx_pin_config_get
- zx_pin_config_set
- zx_pinctrl_build_state
- zx_pinctrl_init
1
2
3
4
5
6
7 #include <linux/io.h>
8 #include <linux/of.h>
9 #include <linux/of_address.h>
10 #include <linux/of_device.h>
11 #include <linux/pinctrl/pinctrl.h>
12 #include <linux/pinctrl/pinconf-generic.h>
13 #include <linux/pinctrl/pinmux.h>
14 #include <linux/platform_device.h>
15 #include <linux/slab.h>
16
17 #include "../core.h"
18 #include "../pinctrl-utils.h"
19 #include "../pinmux.h"
20 #include "pinctrl-zx.h"
21
22 #define ZX_PULL_DOWN BIT(0)
23 #define ZX_PULL_UP BIT(1)
24 #define ZX_INPUT_ENABLE BIT(3)
25 #define ZX_DS_SHIFT 4
26 #define ZX_DS_MASK (0x7 << ZX_DS_SHIFT)
27 #define ZX_DS_VALUE(x) (((x) << ZX_DS_SHIFT) & ZX_DS_MASK)
28 #define ZX_SLEW BIT(8)
29
30 struct zx_pinctrl {
31 struct pinctrl_dev *pctldev;
32 struct device *dev;
33 void __iomem *base;
34 void __iomem *aux_base;
35 spinlock_t lock;
36 struct zx_pinctrl_soc_info *info;
37 };
38
39 static int zx_dt_node_to_map(struct pinctrl_dev *pctldev,
40 struct device_node *np_config,
41 struct pinctrl_map **map, u32 *num_maps)
42 {
43 return pinconf_generic_dt_node_to_map(pctldev, np_config, map,
44 num_maps, PIN_MAP_TYPE_INVALID);
45 }
46
47 static const struct pinctrl_ops zx_pinctrl_ops = {
48 .dt_node_to_map = zx_dt_node_to_map,
49 .dt_free_map = pinctrl_utils_free_map,
50 .get_groups_count = pinctrl_generic_get_group_count,
51 .get_group_name = pinctrl_generic_get_group_name,
52 .get_group_pins = pinctrl_generic_get_group_pins,
53 };
54
55 #define NONAON_MVAL 2
56
57 static int zx_set_mux(struct pinctrl_dev *pctldev, unsigned int func_selector,
58 unsigned int group_selector)
59 {
60 struct zx_pinctrl *zpctl = pinctrl_dev_get_drvdata(pctldev);
61 struct zx_pinctrl_soc_info *info = zpctl->info;
62 const struct pinctrl_pin_desc *pindesc = info->pins + group_selector;
63 struct zx_pin_data *data = pindesc->drv_data;
64 struct zx_mux_desc *mux;
65 u32 mask, offset, bitpos;
66 struct function_desc *func;
67 unsigned long flags;
68 u32 val, mval;
69
70
71 if (!data)
72 return -EINVAL;
73
74 mux = data->muxes;
75 mask = (1 << data->width) - 1;
76 offset = data->offset;
77 bitpos = data->bitpos;
78
79 func = pinmux_generic_get_function(pctldev, func_selector);
80 if (!func)
81 return -EINVAL;
82
83 while (mux->name) {
84 if (strcmp(mux->name, func->name) == 0)
85 break;
86 mux++;
87 }
88
89
90 mval = mux->muxval;
91
92 spin_lock_irqsave(&zpctl->lock, flags);
93
94 if (data->aon_pin) {
95
96
97
98
99
100 u16 aoffset = pindesc->number / 16 * 4;
101 u16 abitpos = (pindesc->number % 16) * 2;
102
103 if (mval & AON_MUX_FLAG) {
104
105
106
107
108 val = readl(zpctl->aux_base + aoffset);
109 val &= ~(0x3 << abitpos);
110 val |= (mval & 0x3) << abitpos;
111 writel(val, zpctl->aux_base + aoffset);
112 } else {
113
114
115
116
117 val = readl(zpctl->base + offset);
118 val &= ~(mask << bitpos);
119 val |= (mval & mask) << bitpos;
120 writel(val, zpctl->base + offset);
121
122
123
124
125
126 val = readl(zpctl->aux_base + aoffset);
127 val &= ~(0x3 << abitpos);
128 val |= NONAON_MVAL << abitpos;
129 writel(val, zpctl->aux_base + aoffset);
130 }
131
132 } else {
133
134
135
136
137 val = readl(zpctl->base + offset);
138 val &= ~(mask << bitpos);
139 val |= (mval & mask) << bitpos;
140 writel(val, zpctl->base + offset);
141 }
142
143 spin_unlock_irqrestore(&zpctl->lock, flags);
144
145 return 0;
146 }
147
148 static const struct pinmux_ops zx_pinmux_ops = {
149 .get_functions_count = pinmux_generic_get_function_count,
150 .get_function_name = pinmux_generic_get_function_name,
151 .get_function_groups = pinmux_generic_get_function_groups,
152 .set_mux = zx_set_mux,
153 };
154
155 static int zx_pin_config_get(struct pinctrl_dev *pctldev, unsigned int pin,
156 unsigned long *config)
157 {
158 struct zx_pinctrl *zpctl = pinctrl_dev_get_drvdata(pctldev);
159 struct zx_pinctrl_soc_info *info = zpctl->info;
160 const struct pinctrl_pin_desc *pindesc = info->pins + pin;
161 struct zx_pin_data *data = pindesc->drv_data;
162 enum pin_config_param param = pinconf_to_config_param(*config);
163 u32 val;
164
165
166 if (!data)
167 return -EINVAL;
168
169 val = readl(zpctl->aux_base + data->coffset);
170 val = val >> data->cbitpos;
171
172 switch (param) {
173 case PIN_CONFIG_BIAS_PULL_DOWN:
174 val &= ZX_PULL_DOWN;
175 val = !!val;
176 if (val == 0)
177 return -EINVAL;
178 break;
179 case PIN_CONFIG_BIAS_PULL_UP:
180 val &= ZX_PULL_UP;
181 val = !!val;
182 if (val == 0)
183 return -EINVAL;
184 break;
185 case PIN_CONFIG_INPUT_ENABLE:
186 val &= ZX_INPUT_ENABLE;
187 val = !!val;
188 if (val == 0)
189 return -EINVAL;
190 break;
191 case PIN_CONFIG_DRIVE_STRENGTH:
192 val &= ZX_DS_MASK;
193 val = val >> ZX_DS_SHIFT;
194 break;
195 case PIN_CONFIG_SLEW_RATE:
196 val &= ZX_SLEW;
197 val = !!val;
198 break;
199 default:
200 return -ENOTSUPP;
201 }
202
203 *config = pinconf_to_config_packed(param, val);
204
205 return 0;
206 }
207
208 static int zx_pin_config_set(struct pinctrl_dev *pctldev, unsigned int pin,
209 unsigned long *configs, unsigned int num_configs)
210 {
211 struct zx_pinctrl *zpctl = pinctrl_dev_get_drvdata(pctldev);
212 struct zx_pinctrl_soc_info *info = zpctl->info;
213 const struct pinctrl_pin_desc *pindesc = info->pins + pin;
214 struct zx_pin_data *data = pindesc->drv_data;
215 enum pin_config_param param;
216 u32 val, arg;
217 int i;
218
219
220 if (!data)
221 return -EINVAL;
222
223 val = readl(zpctl->aux_base + data->coffset);
224
225 for (i = 0; i < num_configs; i++) {
226 param = pinconf_to_config_param(configs[i]);
227 arg = pinconf_to_config_argument(configs[i]);
228
229 switch (param) {
230 case PIN_CONFIG_BIAS_PULL_DOWN:
231 val |= ZX_PULL_DOWN << data->cbitpos;
232 break;
233 case PIN_CONFIG_BIAS_PULL_UP:
234 val |= ZX_PULL_UP << data->cbitpos;
235 break;
236 case PIN_CONFIG_INPUT_ENABLE:
237 val |= ZX_INPUT_ENABLE << data->cbitpos;
238 break;
239 case PIN_CONFIG_DRIVE_STRENGTH:
240 val &= ~(ZX_DS_MASK << data->cbitpos);
241 val |= ZX_DS_VALUE(arg) << data->cbitpos;
242 break;
243 case PIN_CONFIG_SLEW_RATE:
244 if (arg)
245 val |= ZX_SLEW << data->cbitpos;
246 else
247 val &= ~ZX_SLEW << data->cbitpos;
248 break;
249 default:
250 return -ENOTSUPP;
251 }
252 }
253
254 writel(val, zpctl->aux_base + data->coffset);
255 return 0;
256 }
257
258 static const struct pinconf_ops zx_pinconf_ops = {
259 .pin_config_set = zx_pin_config_set,
260 .pin_config_get = zx_pin_config_get,
261 .is_generic = true,
262 };
263
264 static int zx_pinctrl_build_state(struct platform_device *pdev)
265 {
266 struct zx_pinctrl *zpctl = platform_get_drvdata(pdev);
267 struct zx_pinctrl_soc_info *info = zpctl->info;
268 struct pinctrl_dev *pctldev = zpctl->pctldev;
269 struct function_desc *functions;
270 int nfunctions;
271 struct group_desc *groups;
272 int ngroups;
273 int i;
274
275
276 ngroups = info->npins;
277 groups = devm_kcalloc(&pdev->dev, ngroups, sizeof(*groups),
278 GFP_KERNEL);
279 if (!groups)
280 return -ENOMEM;
281
282 for (i = 0; i < ngroups; i++) {
283 const struct pinctrl_pin_desc *pindesc = info->pins + i;
284 struct group_desc *group = groups + i;
285
286 group->name = pindesc->name;
287 group->pins = (int *) &pindesc->number;
288 group->num_pins = 1;
289 radix_tree_insert(&pctldev->pin_group_tree, i, group);
290 }
291
292 pctldev->num_groups = ngroups;
293
294
295 functions = kcalloc(info->npins, sizeof(*functions), GFP_KERNEL);
296 if (!functions)
297 return -ENOMEM;
298
299 nfunctions = 0;
300 for (i = 0; i < info->npins; i++) {
301 const struct pinctrl_pin_desc *pindesc = info->pins + i;
302 struct zx_pin_data *data = pindesc->drv_data;
303 struct zx_mux_desc *mux;
304
305
306 if (!data)
307 continue;
308
309
310 mux = data->muxes;
311 while (mux->name) {
312 struct function_desc *func = functions;
313
314
315 while (func->name) {
316 if (strcmp(mux->name, func->name) == 0) {
317
318 func->num_group_names++;
319 break;
320 }
321 func++;
322 }
323
324 if (!func->name) {
325
326 func->name = mux->name;
327 func->num_group_names = 1;
328 radix_tree_insert(&pctldev->pin_function_tree,
329 nfunctions++, func);
330 }
331
332 mux++;
333 }
334 }
335
336 pctldev->num_functions = nfunctions;
337 functions = krealloc(functions, nfunctions * sizeof(*functions),
338 GFP_KERNEL);
339
340
341 for (i = 0; i < info->npins; i++) {
342 const struct pinctrl_pin_desc *pindesc = info->pins + i;
343 struct zx_pin_data *data = pindesc->drv_data;
344 struct zx_mux_desc *mux;
345
346 if (!data)
347 continue;
348
349 mux = data->muxes;
350 while (mux->name) {
351 struct function_desc *func;
352 const char **group;
353 int j;
354
355
356 for (j = 0; j < nfunctions; j++)
357 if (strcmp(functions[j].name, mux->name) == 0)
358 break;
359
360 func = functions + j;
361 if (!func->group_names) {
362 func->group_names = devm_kcalloc(&pdev->dev,
363 func->num_group_names,
364 sizeof(*func->group_names),
365 GFP_KERNEL);
366 if (!func->group_names) {
367 kfree(functions);
368 return -ENOMEM;
369 }
370 }
371
372 group = func->group_names;
373 while (*group)
374 group++;
375 *group = pindesc->name;
376
377 mux++;
378 }
379 }
380
381 return 0;
382 }
383
384 int zx_pinctrl_init(struct platform_device *pdev,
385 struct zx_pinctrl_soc_info *info)
386 {
387 struct pinctrl_desc *pctldesc;
388 struct zx_pinctrl *zpctl;
389 struct device_node *np;
390 struct resource *res;
391 int ret;
392
393 zpctl = devm_kzalloc(&pdev->dev, sizeof(*zpctl), GFP_KERNEL);
394 if (!zpctl)
395 return -ENOMEM;
396
397 spin_lock_init(&zpctl->lock);
398
399 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
400 zpctl->base = devm_ioremap_resource(&pdev->dev, res);
401 if (IS_ERR(zpctl->base))
402 return PTR_ERR(zpctl->base);
403
404 np = of_parse_phandle(pdev->dev.of_node, "zte,auxiliary-controller", 0);
405 if (!np) {
406 dev_err(&pdev->dev, "failed to find auxiliary controller\n");
407 return -ENODEV;
408 }
409
410 zpctl->aux_base = of_iomap(np, 0);
411 of_node_put(np);
412 if (!zpctl->aux_base)
413 return -ENOMEM;
414
415 zpctl->dev = &pdev->dev;
416 zpctl->info = info;
417
418 pctldesc = devm_kzalloc(&pdev->dev, sizeof(*pctldesc), GFP_KERNEL);
419 if (!pctldesc)
420 return -ENOMEM;
421
422 pctldesc->name = dev_name(&pdev->dev);
423 pctldesc->owner = THIS_MODULE;
424 pctldesc->pins = info->pins;
425 pctldesc->npins = info->npins;
426 pctldesc->pctlops = &zx_pinctrl_ops;
427 pctldesc->pmxops = &zx_pinmux_ops;
428 pctldesc->confops = &zx_pinconf_ops;
429
430 zpctl->pctldev = devm_pinctrl_register(&pdev->dev, pctldesc, zpctl);
431 if (IS_ERR(zpctl->pctldev)) {
432 ret = PTR_ERR(zpctl->pctldev);
433 dev_err(&pdev->dev, "failed to register pinctrl: %d\n", ret);
434 return ret;
435 }
436
437 platform_set_drvdata(pdev, zpctl);
438
439 ret = zx_pinctrl_build_state(pdev);
440 if (ret) {
441 dev_err(&pdev->dev, "failed to build state: %d\n", ret);
442 return ret;
443 }
444
445 dev_info(&pdev->dev, "initialized pinctrl driver\n");
446 return 0;
447 }