1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * System Control and Power Interface (SCMI) Protocol based pinctrl driver
4 *
5 * Copyright (C) 2024 EPAM
6 * Copyright 2024 NXP
7 */
8
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/errno.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/scmi_protocol.h>
15 #include <linux/slab.h>
16 #include <linux/types.h>
17
18 #include <linux/pinctrl/machine.h>
19 #include <linux/pinctrl/pinconf.h>
20 #include <linux/pinctrl/pinconf-generic.h>
21 #include <linux/pinctrl/pinctrl.h>
22 #include <linux/pinctrl/pinmux.h>
23
24 #include "pinctrl-utils.h"
25 #include "core.h"
26 #include "pinconf.h"
27
28 #define DRV_NAME "scmi-pinctrl"
29
30 /* Define num configs, if not large than 4 use stack, else use kcalloc() */
31 #define SCMI_NUM_CONFIGS 4
32
33 static const struct scmi_pinctrl_proto_ops *pinctrl_ops;
34
35 struct scmi_pinctrl {
36 struct device *dev;
37 struct scmi_protocol_handle *ph;
38 struct pinctrl_dev *pctldev;
39 struct pinctrl_desc pctl_desc;
40 struct pinfunction *functions;
41 unsigned int nr_functions;
42 };
43
pinctrl_scmi_get_groups_count(struct pinctrl_dev * pctldev)44 static int pinctrl_scmi_get_groups_count(struct pinctrl_dev *pctldev)
45 {
46 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
47
48 return pinctrl_ops->count_get(pmx->ph, GROUP_TYPE);
49 }
50
pinctrl_scmi_get_group_name(struct pinctrl_dev * pctldev,unsigned int selector)51 static const char *pinctrl_scmi_get_group_name(struct pinctrl_dev *pctldev,
52 unsigned int selector)
53 {
54 int ret;
55 const char *name;
56 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
57
58 ret = pinctrl_ops->name_get(pmx->ph, selector, GROUP_TYPE, &name);
59 if (ret) {
60 dev_err(pmx->dev, "get name failed with err %d", ret);
61 return NULL;
62 }
63
64 return name;
65 }
66
pinctrl_scmi_get_group_pins(struct pinctrl_dev * pctldev,unsigned int selector,const unsigned int ** pins,unsigned int * num_pins)67 static int pinctrl_scmi_get_group_pins(struct pinctrl_dev *pctldev,
68 unsigned int selector,
69 const unsigned int **pins,
70 unsigned int *num_pins)
71 {
72 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
73
74 return pinctrl_ops->group_pins_get(pmx->ph, selector, pins, num_pins);
75 }
76
77 static const struct pinctrl_ops pinctrl_scmi_pinctrl_ops = {
78 .get_groups_count = pinctrl_scmi_get_groups_count,
79 .get_group_name = pinctrl_scmi_get_group_name,
80 .get_group_pins = pinctrl_scmi_get_group_pins,
81 #ifdef CONFIG_OF
82 .dt_node_to_map = pinconf_generic_dt_node_to_map_all,
83 .dt_free_map = pinconf_generic_dt_free_map,
84 #endif
85 };
86
pinctrl_scmi_get_functions_count(struct pinctrl_dev * pctldev)87 static int pinctrl_scmi_get_functions_count(struct pinctrl_dev *pctldev)
88 {
89 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
90
91 return pinctrl_ops->count_get(pmx->ph, FUNCTION_TYPE);
92 }
93
pinctrl_scmi_get_function_name(struct pinctrl_dev * pctldev,unsigned int selector)94 static const char *pinctrl_scmi_get_function_name(struct pinctrl_dev *pctldev,
95 unsigned int selector)
96 {
97 int ret;
98 const char *name;
99 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
100
101 ret = pinctrl_ops->name_get(pmx->ph, selector, FUNCTION_TYPE, &name);
102 if (ret) {
103 dev_err(pmx->dev, "get name failed with err %d", ret);
104 return NULL;
105 }
106
107 return name;
108 }
109
pinctrl_scmi_get_function_groups(struct pinctrl_dev * pctldev,unsigned int selector,const char * const ** p_groups,unsigned int * const p_num_groups)110 static int pinctrl_scmi_get_function_groups(struct pinctrl_dev *pctldev,
111 unsigned int selector,
112 const char * const **p_groups,
113 unsigned int * const p_num_groups)
114 {
115 struct pinfunction *func;
116 const unsigned int *group_ids;
117 unsigned int num_groups;
118 const char **groups;
119 int ret, i;
120 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
121
122 if (!p_groups || !p_num_groups)
123 return -EINVAL;
124
125 if (selector >= pmx->nr_functions)
126 return -EINVAL;
127
128 func = &pmx->functions[selector];
129 if (func->ngroups)
130 goto done;
131
132 ret = pinctrl_ops->function_groups_get(pmx->ph, selector, &num_groups,
133 &group_ids);
134 if (ret) {
135 dev_err(pmx->dev, "Unable to get function groups, err %d", ret);
136 return ret;
137 }
138 if (!num_groups)
139 return -EINVAL;
140
141 groups = kcalloc(num_groups, sizeof(*groups), GFP_KERNEL);
142 if (!groups)
143 return -ENOMEM;
144
145 for (i = 0; i < num_groups; i++) {
146 groups[i] = pinctrl_scmi_get_group_name(pctldev, group_ids[i]);
147 if (!groups[i]) {
148 ret = -EINVAL;
149 goto err_free;
150 }
151 }
152
153 func->ngroups = num_groups;
154 func->groups = groups;
155 done:
156 *p_groups = func->groups;
157 *p_num_groups = func->ngroups;
158
159 return 0;
160
161 err_free:
162 kfree(groups);
163
164 return ret;
165 }
166
pinctrl_scmi_func_set_mux(struct pinctrl_dev * pctldev,unsigned int selector,unsigned int group)167 static int pinctrl_scmi_func_set_mux(struct pinctrl_dev *pctldev,
168 unsigned int selector, unsigned int group)
169 {
170 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
171
172 return pinctrl_ops->mux_set(pmx->ph, selector, group);
173 }
174
pinctrl_scmi_request(struct pinctrl_dev * pctldev,unsigned int offset)175 static int pinctrl_scmi_request(struct pinctrl_dev *pctldev,
176 unsigned int offset)
177 {
178 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
179
180 return pinctrl_ops->pin_request(pmx->ph, offset);
181 }
182
pinctrl_scmi_free(struct pinctrl_dev * pctldev,unsigned int offset)183 static int pinctrl_scmi_free(struct pinctrl_dev *pctldev, unsigned int offset)
184 {
185 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
186
187 return pinctrl_ops->pin_free(pmx->ph, offset);
188 }
189
190 static const struct pinmux_ops pinctrl_scmi_pinmux_ops = {
191 .request = pinctrl_scmi_request,
192 .free = pinctrl_scmi_free,
193 .get_functions_count = pinctrl_scmi_get_functions_count,
194 .get_function_name = pinctrl_scmi_get_function_name,
195 .get_function_groups = pinctrl_scmi_get_function_groups,
196 .set_mux = pinctrl_scmi_func_set_mux,
197 };
198
pinctrl_scmi_map_pinconf_type(enum pin_config_param param,enum scmi_pinctrl_conf_type * type)199 static int pinctrl_scmi_map_pinconf_type(enum pin_config_param param,
200 enum scmi_pinctrl_conf_type *type)
201 {
202 u32 arg = param;
203
204 switch (arg) {
205 case PIN_CONFIG_BIAS_BUS_HOLD:
206 *type = SCMI_PIN_BIAS_BUS_HOLD;
207 break;
208 case PIN_CONFIG_BIAS_DISABLE:
209 *type = SCMI_PIN_BIAS_DISABLE;
210 break;
211 case PIN_CONFIG_BIAS_HIGH_IMPEDANCE:
212 *type = SCMI_PIN_BIAS_HIGH_IMPEDANCE;
213 break;
214 case PIN_CONFIG_BIAS_PULL_DOWN:
215 *type = SCMI_PIN_BIAS_PULL_DOWN;
216 break;
217 case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT:
218 *type = SCMI_PIN_BIAS_PULL_DEFAULT;
219 break;
220 case PIN_CONFIG_BIAS_PULL_UP:
221 *type = SCMI_PIN_BIAS_PULL_UP;
222 break;
223 case PIN_CONFIG_DRIVE_OPEN_DRAIN:
224 *type = SCMI_PIN_DRIVE_OPEN_DRAIN;
225 break;
226 case PIN_CONFIG_DRIVE_OPEN_SOURCE:
227 *type = SCMI_PIN_DRIVE_OPEN_SOURCE;
228 break;
229 case PIN_CONFIG_DRIVE_PUSH_PULL:
230 *type = SCMI_PIN_DRIVE_PUSH_PULL;
231 break;
232 case PIN_CONFIG_DRIVE_STRENGTH:
233 *type = SCMI_PIN_DRIVE_STRENGTH;
234 break;
235 case PIN_CONFIG_DRIVE_STRENGTH_UA:
236 *type = SCMI_PIN_DRIVE_STRENGTH;
237 break;
238 case PIN_CONFIG_INPUT_DEBOUNCE:
239 *type = SCMI_PIN_INPUT_DEBOUNCE;
240 break;
241 case PIN_CONFIG_INPUT_ENABLE:
242 *type = SCMI_PIN_INPUT_MODE;
243 break;
244 case PIN_CONFIG_INPUT_SCHMITT:
245 *type = SCMI_PIN_INPUT_SCHMITT;
246 break;
247 case PIN_CONFIG_INPUT_SCHMITT_ENABLE:
248 *type = SCMI_PIN_INPUT_MODE;
249 break;
250 case PIN_CONFIG_MODE_LOW_POWER:
251 *type = SCMI_PIN_LOW_POWER_MODE;
252 break;
253 case PIN_CONFIG_OUTPUT_ENABLE:
254 *type = SCMI_PIN_OUTPUT_MODE;
255 break;
256 case PIN_CONFIG_POWER_SOURCE:
257 *type = SCMI_PIN_POWER_SOURCE;
258 break;
259 case PIN_CONFIG_SLEW_RATE:
260 *type = SCMI_PIN_SLEW_RATE;
261 break;
262 case SCMI_PIN_OEM_START ... SCMI_PIN_OEM_END:
263 *type = arg;
264 break;
265 default:
266 return -EINVAL;
267 }
268
269 return 0;
270 }
271
pinctrl_scmi_map_pinconf_type_get(enum pin_config_param param,enum scmi_pinctrl_conf_type * type)272 static int pinctrl_scmi_map_pinconf_type_get(enum pin_config_param param,
273 enum scmi_pinctrl_conf_type *type)
274 {
275 if (param == PIN_CONFIG_LEVEL) {
276 *type = SCMI_PIN_INPUT_VALUE;
277 return 0;
278 }
279
280 return pinctrl_scmi_map_pinconf_type(param, type);
281 }
282
pinctrl_scmi_map_pinconf_type_set(enum pin_config_param param,enum scmi_pinctrl_conf_type * type)283 static int pinctrl_scmi_map_pinconf_type_set(enum pin_config_param param,
284 enum scmi_pinctrl_conf_type *type)
285 {
286 if (param == PIN_CONFIG_LEVEL) {
287 *type = SCMI_PIN_OUTPUT_VALUE;
288 return 0;
289 }
290
291 return pinctrl_scmi_map_pinconf_type(param, type);
292 }
293
pinctrl_scmi_pinconf_get(struct pinctrl_dev * pctldev,unsigned int pin,unsigned long * config)294 static int pinctrl_scmi_pinconf_get(struct pinctrl_dev *pctldev,
295 unsigned int pin, unsigned long *config)
296 {
297 int ret;
298 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
299 enum pin_config_param config_type;
300 enum scmi_pinctrl_conf_type type;
301 u32 config_value;
302
303 if (!config)
304 return -EINVAL;
305
306 config_type = pinconf_to_config_param(*config);
307
308 ret = pinctrl_scmi_map_pinconf_type_get(config_type, &type);
309 if (ret)
310 return ret;
311
312 ret = pinctrl_ops->settings_get_one(pmx->ph, pin, PIN_TYPE, type,
313 &config_value);
314 /* Convert SCMI error code to PINCTRL expected error code */
315 if (ret == -EOPNOTSUPP)
316 return -ENOTSUPP;
317 if (ret)
318 return ret;
319
320 *config = pinconf_to_config_packed(config_type, config_value);
321
322 return 0;
323 }
324
325 static int
pinctrl_scmi_alloc_configs(struct pinctrl_dev * pctldev,u32 num_configs,u32 ** p_config_value,enum scmi_pinctrl_conf_type ** p_config_type)326 pinctrl_scmi_alloc_configs(struct pinctrl_dev *pctldev, u32 num_configs,
327 u32 **p_config_value,
328 enum scmi_pinctrl_conf_type **p_config_type)
329 {
330 if (num_configs <= SCMI_NUM_CONFIGS)
331 return 0;
332
333 *p_config_value = kcalloc(num_configs, sizeof(**p_config_value), GFP_KERNEL);
334 if (!*p_config_value)
335 return -ENOMEM;
336
337 *p_config_type = kzalloc_objs(**p_config_type, num_configs);
338 if (!*p_config_type) {
339 kfree(*p_config_value);
340 return -ENOMEM;
341 }
342
343 return 0;
344 }
345
346 static void
pinctrl_scmi_free_configs(struct pinctrl_dev * pctldev,u32 num_configs,u32 ** p_config_value,enum scmi_pinctrl_conf_type ** p_config_type)347 pinctrl_scmi_free_configs(struct pinctrl_dev *pctldev, u32 num_configs,
348 u32 **p_config_value,
349 enum scmi_pinctrl_conf_type **p_config_type)
350 {
351 if (num_configs <= SCMI_NUM_CONFIGS)
352 return;
353
354 kfree(*p_config_value);
355 kfree(*p_config_type);
356 }
357
pinctrl_scmi_pinconf_set(struct pinctrl_dev * pctldev,unsigned int pin,unsigned long * configs,unsigned int num_configs)358 static int pinctrl_scmi_pinconf_set(struct pinctrl_dev *pctldev,
359 unsigned int pin,
360 unsigned long *configs,
361 unsigned int num_configs)
362 {
363 int i, cnt, ret;
364 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
365 enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS];
366 u32 config_value[SCMI_NUM_CONFIGS];
367 enum scmi_pinctrl_conf_type *p_config_type = config_type;
368 u32 *p_config_value = config_value;
369 enum pin_config_param param;
370
371 if (!configs || !num_configs)
372 return -EINVAL;
373
374 ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, &p_config_type,
375 &p_config_value);
376 if (ret)
377 return ret;
378
379 cnt = 0;
380 for (i = 0; i < num_configs; i++) {
381 param = pinconf_to_config_param(configs[i]);
382 if (param == PIN_CONFIG_PERSIST_STATE)
383 continue;
384 ret = pinctrl_scmi_map_pinconf_type_set(param, &p_config_type[cnt]);
385 if (ret) {
386 dev_err(pmx->dev, "Error map pinconf_type %d\n", ret);
387 goto free_config;
388 }
389 p_config_value[cnt] = pinconf_to_config_argument(configs[i]);
390 cnt++;
391 }
392
393 ret = pinctrl_ops->settings_conf(pmx->ph, pin, PIN_TYPE, cnt,
394 p_config_type, p_config_value);
395 if (ret)
396 dev_err(pmx->dev, "Error parsing config %d\n", ret);
397
398 free_config:
399 pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type,
400 &p_config_value);
401 return ret;
402 }
403
pinctrl_scmi_pinconf_group_set(struct pinctrl_dev * pctldev,unsigned int group,unsigned long * configs,unsigned int num_configs)404 static int pinctrl_scmi_pinconf_group_set(struct pinctrl_dev *pctldev,
405 unsigned int group,
406 unsigned long *configs,
407 unsigned int num_configs)
408 {
409 int i, ret;
410 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
411 enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS];
412 u32 config_value[SCMI_NUM_CONFIGS];
413 enum scmi_pinctrl_conf_type *p_config_type = config_type;
414 u32 *p_config_value = config_value;
415 enum pin_config_param param;
416
417 if (!configs || !num_configs)
418 return -EINVAL;
419
420 ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, &p_config_type,
421 &p_config_value);
422 if (ret)
423 return ret;
424
425 for (i = 0; i < num_configs; i++) {
426 param = pinconf_to_config_param(configs[i]);
427 ret = pinctrl_scmi_map_pinconf_type_set(param, &p_config_type[i]);
428 if (ret) {
429 dev_err(pmx->dev, "Error map pinconf_type %d\n", ret);
430 goto free_config;
431 }
432
433 p_config_value[i] = pinconf_to_config_argument(configs[i]);
434 }
435
436 ret = pinctrl_ops->settings_conf(pmx->ph, group, GROUP_TYPE,
437 num_configs, p_config_type,
438 p_config_value);
439 if (ret)
440 dev_err(pmx->dev, "Error parsing config %d", ret);
441
442 free_config:
443 pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type,
444 &p_config_value);
445 return ret;
446 };
447
pinctrl_scmi_pinconf_group_get(struct pinctrl_dev * pctldev,unsigned int group,unsigned long * config)448 static int pinctrl_scmi_pinconf_group_get(struct pinctrl_dev *pctldev,
449 unsigned int group,
450 unsigned long *config)
451 {
452 int ret;
453 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
454 enum pin_config_param config_type;
455 enum scmi_pinctrl_conf_type type;
456 u32 config_value;
457
458 if (!config)
459 return -EINVAL;
460
461 config_type = pinconf_to_config_param(*config);
462 ret = pinctrl_scmi_map_pinconf_type_get(config_type, &type);
463 if (ret) {
464 dev_err(pmx->dev, "Error map pinconf_type %d\n", ret);
465 return ret;
466 }
467
468 ret = pinctrl_ops->settings_get_one(pmx->ph, group, GROUP_TYPE, type,
469 &config_value);
470 /* Convert SCMI error code to PINCTRL expected error code */
471 if (ret == -EOPNOTSUPP)
472 return -ENOTSUPP;
473 if (ret)
474 return ret;
475
476 *config = pinconf_to_config_packed(config_type, config_value);
477
478 return 0;
479 }
480
481 static const struct pinconf_ops pinctrl_scmi_pinconf_ops = {
482 .is_generic = true,
483 .pin_config_get = pinctrl_scmi_pinconf_get,
484 .pin_config_set = pinctrl_scmi_pinconf_set,
485 .pin_config_group_set = pinctrl_scmi_pinconf_group_set,
486 .pin_config_group_get = pinctrl_scmi_pinconf_group_get,
487 .pin_config_config_dbg_show = pinconf_generic_dump_config,
488 };
489
pinctrl_scmi_get_pins(struct scmi_pinctrl * pmx,struct pinctrl_desc * desc)490 static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx,
491 struct pinctrl_desc *desc)
492 {
493 struct pinctrl_pin_desc *pins;
494 unsigned int npins;
495 int ret, i;
496
497 npins = pinctrl_ops->count_get(pmx->ph, PIN_TYPE);
498 /*
499 * npins will never be zero, the scmi pinctrl driver has bailed out
500 * if npins is zero.
501 */
502 pins = devm_kmalloc_array(pmx->dev, npins, sizeof(*pins), GFP_KERNEL);
503 if (!pins)
504 return -ENOMEM;
505
506 for (i = 0; i < npins; i++) {
507 pins[i].number = i;
508 /*
509 * The memory for name is handled by the scmi firmware driver,
510 * no need free here
511 */
512 ret = pinctrl_ops->name_get(pmx->ph, i, PIN_TYPE, &pins[i].name);
513 if (ret)
514 return dev_err_probe(pmx->dev, ret,
515 "Can't get name for pin %d", i);
516 }
517
518 desc->npins = npins;
519 desc->pins = pins;
520 dev_dbg(pmx->dev, "got pins %u", npins);
521
522 return 0;
523 }
524
525 static const char * const scmi_pinctrl_blocklist[] = {
526 "fsl,imx94",
527 "fsl,imx95",
528 "fsl,imx952",
529 NULL
530 };
531
scmi_pinctrl_probe(struct scmi_device * sdev)532 static int scmi_pinctrl_probe(struct scmi_device *sdev)
533 {
534 int ret;
535 struct device *dev = &sdev->dev;
536 struct scmi_pinctrl *pmx;
537 const struct scmi_handle *handle;
538 struct scmi_protocol_handle *ph;
539
540 if (!sdev->handle)
541 return -EINVAL;
542
543 if (of_machine_compatible_match(scmi_pinctrl_blocklist))
544 return -ENODEV;
545
546 handle = sdev->handle;
547
548 pinctrl_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_PINCTRL, &ph);
549 if (IS_ERR(pinctrl_ops))
550 return PTR_ERR(pinctrl_ops);
551
552 pmx = devm_kzalloc(dev, sizeof(*pmx), GFP_KERNEL);
553 if (!pmx)
554 return -ENOMEM;
555
556 pmx->ph = ph;
557
558 pmx->dev = dev;
559 pmx->pctl_desc.name = DRV_NAME;
560 pmx->pctl_desc.owner = THIS_MODULE;
561 pmx->pctl_desc.pctlops = &pinctrl_scmi_pinctrl_ops;
562 pmx->pctl_desc.pmxops = &pinctrl_scmi_pinmux_ops;
563 pmx->pctl_desc.confops = &pinctrl_scmi_pinconf_ops;
564
565 ret = pinctrl_scmi_get_pins(pmx, &pmx->pctl_desc);
566 if (ret)
567 return ret;
568
569 ret = devm_pinctrl_register_and_init(dev, &pmx->pctl_desc, pmx,
570 &pmx->pctldev);
571 if (ret)
572 return dev_err_probe(dev, ret, "Failed to register pinctrl\n");
573
574 pmx->nr_functions = pinctrl_scmi_get_functions_count(pmx->pctldev);
575 pmx->functions = devm_kcalloc(dev, pmx->nr_functions,
576 sizeof(*pmx->functions), GFP_KERNEL);
577 if (!pmx->functions)
578 return -ENOMEM;
579
580 return pinctrl_enable(pmx->pctldev);
581 }
582
583 static const struct scmi_device_id scmi_id_table[] = {
584 { SCMI_PROTOCOL_PINCTRL, "pinctrl" },
585 { }
586 };
587 MODULE_DEVICE_TABLE(scmi, scmi_id_table);
588
589 static struct scmi_driver scmi_pinctrl_driver = {
590 .name = DRV_NAME,
591 .probe = scmi_pinctrl_probe,
592 .id_table = scmi_id_table,
593 };
594 module_scmi_driver(scmi_pinctrl_driver);
595
596 MODULE_AUTHOR("Oleksii Moisieiev <oleksii_moisieiev@epam.com>");
597 MODULE_AUTHOR("Peng Fan <peng.fan@nxp.com>");
598 MODULE_DESCRIPTION("ARM SCMI pin controller driver");
599 MODULE_LICENSE("GPL");
600