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