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