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 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 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 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 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 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 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 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 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 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 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_OUTPUT_ENABLE: 255 *type = SCMI_PIN_OUTPUT_MODE; 256 break; 257 case PIN_CONFIG_POWER_SOURCE: 258 *type = SCMI_PIN_POWER_SOURCE; 259 break; 260 case PIN_CONFIG_SLEW_RATE: 261 *type = SCMI_PIN_SLEW_RATE; 262 break; 263 case SCMI_PIN_OEM_START ... SCMI_PIN_OEM_END: 264 *type = arg; 265 break; 266 default: 267 return -EINVAL; 268 } 269 270 return 0; 271 } 272 273 static int pinctrl_scmi_map_pinconf_type_get(enum pin_config_param param, 274 enum scmi_pinctrl_conf_type *type) 275 { 276 if (param == PIN_CONFIG_LEVEL) { 277 *type = SCMI_PIN_INPUT_VALUE; 278 return 0; 279 } 280 281 return pinctrl_scmi_map_pinconf_type(param, type); 282 } 283 284 static int pinctrl_scmi_map_pinconf_type_set(enum pin_config_param param, 285 enum scmi_pinctrl_conf_type *type) 286 { 287 if (param == PIN_CONFIG_LEVEL) { 288 *type = SCMI_PIN_OUTPUT_VALUE; 289 return 0; 290 } 291 292 return pinctrl_scmi_map_pinconf_type(param, type); 293 } 294 295 static int pinctrl_scmi_pinconf_get(struct pinctrl_dev *pctldev, 296 unsigned int pin, unsigned long *config) 297 { 298 int ret; 299 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 300 enum pin_config_param config_type; 301 enum scmi_pinctrl_conf_type type; 302 u32 config_value; 303 304 if (!config) 305 return -EINVAL; 306 307 config_type = pinconf_to_config_param(*config); 308 309 ret = pinctrl_scmi_map_pinconf_type_get(config_type, &type); 310 if (ret) 311 return ret; 312 313 ret = pinctrl_ops->settings_get_one(pmx->ph, pin, PIN_TYPE, type, 314 &config_value); 315 /* Convert SCMI error code to PINCTRL expected error code */ 316 if (ret == -EOPNOTSUPP) 317 return -ENOTSUPP; 318 if (ret) 319 return ret; 320 321 *config = pinconf_to_config_packed(config_type, config_value); 322 323 return 0; 324 } 325 326 static int 327 pinctrl_scmi_alloc_configs(struct pinctrl_dev *pctldev, u32 num_configs, 328 u32 **p_config_value, 329 enum scmi_pinctrl_conf_type **p_config_type) 330 { 331 if (num_configs <= SCMI_NUM_CONFIGS) 332 return 0; 333 334 *p_config_value = kcalloc(num_configs, sizeof(**p_config_value), GFP_KERNEL); 335 if (!*p_config_value) 336 return -ENOMEM; 337 338 *p_config_type = kzalloc_objs(**p_config_type, num_configs); 339 if (!*p_config_type) { 340 kfree(*p_config_value); 341 return -ENOMEM; 342 } 343 344 return 0; 345 } 346 347 static void 348 pinctrl_scmi_free_configs(struct pinctrl_dev *pctldev, u32 num_configs, 349 u32 **p_config_value, 350 enum scmi_pinctrl_conf_type **p_config_type) 351 { 352 if (num_configs <= SCMI_NUM_CONFIGS) 353 return; 354 355 kfree(*p_config_value); 356 kfree(*p_config_type); 357 } 358 359 static int pinctrl_scmi_pinconf_set(struct pinctrl_dev *pctldev, 360 unsigned int pin, 361 unsigned long *configs, 362 unsigned int num_configs) 363 { 364 int i, cnt, ret; 365 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 366 enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS]; 367 u32 config_value[SCMI_NUM_CONFIGS]; 368 enum scmi_pinctrl_conf_type *p_config_type = config_type; 369 u32 *p_config_value = config_value; 370 enum pin_config_param param; 371 372 if (!configs || !num_configs) 373 return -EINVAL; 374 375 ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, &p_config_type, 376 &p_config_value); 377 if (ret) 378 return ret; 379 380 cnt = 0; 381 for (i = 0; i < num_configs; i++) { 382 param = pinconf_to_config_param(configs[i]); 383 if (param == PIN_CONFIG_PERSIST_STATE) 384 continue; 385 ret = pinctrl_scmi_map_pinconf_type_set(param, &p_config_type[cnt]); 386 if (ret) { 387 dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); 388 goto free_config; 389 } 390 p_config_value[cnt] = pinconf_to_config_argument(configs[i]); 391 cnt++; 392 } 393 394 ret = pinctrl_ops->settings_conf(pmx->ph, pin, PIN_TYPE, cnt, 395 p_config_type, p_config_value); 396 if (ret) 397 dev_err(pmx->dev, "Error parsing config %d\n", ret); 398 399 free_config: 400 pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type, 401 &p_config_value); 402 return ret; 403 } 404 405 static int pinctrl_scmi_pinconf_group_set(struct pinctrl_dev *pctldev, 406 unsigned int group, 407 unsigned long *configs, 408 unsigned int num_configs) 409 { 410 int i, ret; 411 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 412 enum scmi_pinctrl_conf_type config_type[SCMI_NUM_CONFIGS]; 413 u32 config_value[SCMI_NUM_CONFIGS]; 414 enum scmi_pinctrl_conf_type *p_config_type = config_type; 415 u32 *p_config_value = config_value; 416 enum pin_config_param param; 417 418 if (!configs || !num_configs) 419 return -EINVAL; 420 421 ret = pinctrl_scmi_alloc_configs(pctldev, num_configs, &p_config_type, 422 &p_config_value); 423 if (ret) 424 return ret; 425 426 for (i = 0; i < num_configs; i++) { 427 param = pinconf_to_config_param(configs[i]); 428 ret = pinctrl_scmi_map_pinconf_type_set(param, &p_config_type[i]); 429 if (ret) { 430 dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); 431 goto free_config; 432 } 433 434 p_config_value[i] = pinconf_to_config_argument(configs[i]); 435 } 436 437 ret = pinctrl_ops->settings_conf(pmx->ph, group, GROUP_TYPE, 438 num_configs, p_config_type, 439 p_config_value); 440 if (ret) 441 dev_err(pmx->dev, "Error parsing config %d", ret); 442 443 free_config: 444 pinctrl_scmi_free_configs(pctldev, num_configs, &p_config_type, 445 &p_config_value); 446 return ret; 447 }; 448 449 static int pinctrl_scmi_pinconf_group_get(struct pinctrl_dev *pctldev, 450 unsigned int group, 451 unsigned long *config) 452 { 453 int ret; 454 struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); 455 enum pin_config_param config_type; 456 enum scmi_pinctrl_conf_type type; 457 u32 config_value; 458 459 if (!config) 460 return -EINVAL; 461 462 config_type = pinconf_to_config_param(*config); 463 ret = pinctrl_scmi_map_pinconf_type_get(config_type, &type); 464 if (ret) { 465 dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); 466 return ret; 467 } 468 469 ret = pinctrl_ops->settings_get_one(pmx->ph, group, GROUP_TYPE, type, 470 &config_value); 471 /* Convert SCMI error code to PINCTRL expected error code */ 472 if (ret == -EOPNOTSUPP) 473 return -ENOTSUPP; 474 if (ret) 475 return ret; 476 477 *config = pinconf_to_config_packed(config_type, config_value); 478 479 return 0; 480 } 481 482 static const struct pinconf_ops pinctrl_scmi_pinconf_ops = { 483 .is_generic = true, 484 .pin_config_get = pinctrl_scmi_pinconf_get, 485 .pin_config_set = pinctrl_scmi_pinconf_set, 486 .pin_config_group_set = pinctrl_scmi_pinconf_group_set, 487 .pin_config_group_get = pinctrl_scmi_pinconf_group_get, 488 .pin_config_config_dbg_show = pinconf_generic_dump_config, 489 }; 490 491 static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx, 492 struct pinctrl_desc *desc) 493 { 494 struct pinctrl_pin_desc *pins; 495 unsigned int npins; 496 int ret, i; 497 498 npins = pinctrl_ops->count_get(pmx->ph, PIN_TYPE); 499 /* 500 * npins will never be zero, the scmi pinctrl driver has bailed out 501 * if npins is zero. 502 */ 503 pins = devm_kmalloc_array(pmx->dev, npins, sizeof(*pins), GFP_KERNEL); 504 if (!pins) 505 return -ENOMEM; 506 507 for (i = 0; i < npins; i++) { 508 pins[i].number = i; 509 /* 510 * The memory for name is handled by the scmi firmware driver, 511 * no need free here 512 */ 513 ret = pinctrl_ops->name_get(pmx->ph, i, PIN_TYPE, &pins[i].name); 514 if (ret) 515 return dev_err_probe(pmx->dev, ret, 516 "Can't get name for pin %d", i); 517 } 518 519 desc->npins = npins; 520 desc->pins = pins; 521 dev_dbg(pmx->dev, "got pins %u", npins); 522 523 return 0; 524 } 525 526 static const char * const scmi_pinctrl_blocklist[] = { 527 "fsl,imx94", 528 "fsl,imx95", 529 "fsl,imx952", 530 NULL 531 }; 532 533 static int scmi_pinctrl_probe(struct scmi_device *sdev) 534 { 535 int ret; 536 struct device *dev = &sdev->dev; 537 struct scmi_pinctrl *pmx; 538 const struct scmi_handle *handle; 539 struct scmi_protocol_handle *ph; 540 541 if (!sdev->handle) 542 return -EINVAL; 543 544 if (of_machine_compatible_match(scmi_pinctrl_blocklist)) 545 return -ENODEV; 546 547 handle = sdev->handle; 548 549 pinctrl_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_PINCTRL, &ph); 550 if (IS_ERR(pinctrl_ops)) 551 return PTR_ERR(pinctrl_ops); 552 553 pmx = devm_kzalloc(dev, sizeof(*pmx), GFP_KERNEL); 554 if (!pmx) 555 return -ENOMEM; 556 557 pmx->ph = ph; 558 559 pmx->dev = dev; 560 pmx->pctl_desc.name = DRV_NAME; 561 pmx->pctl_desc.owner = THIS_MODULE; 562 pmx->pctl_desc.pctlops = &pinctrl_scmi_pinctrl_ops; 563 pmx->pctl_desc.pmxops = &pinctrl_scmi_pinmux_ops; 564 pmx->pctl_desc.confops = &pinctrl_scmi_pinconf_ops; 565 566 ret = pinctrl_scmi_get_pins(pmx, &pmx->pctl_desc); 567 if (ret) 568 return ret; 569 570 ret = devm_pinctrl_register_and_init(dev, &pmx->pctl_desc, pmx, 571 &pmx->pctldev); 572 if (ret) 573 return dev_err_probe(dev, ret, "Failed to register pinctrl\n"); 574 575 pmx->nr_functions = pinctrl_scmi_get_functions_count(pmx->pctldev); 576 pmx->functions = devm_kcalloc(dev, pmx->nr_functions, 577 sizeof(*pmx->functions), GFP_KERNEL); 578 if (!pmx->functions) 579 return -ENOMEM; 580 581 return pinctrl_enable(pmx->pctldev); 582 } 583 584 static const struct scmi_device_id scmi_id_table[] = { 585 { SCMI_PROTOCOL_PINCTRL, "pinctrl" }, 586 { } 587 }; 588 MODULE_DEVICE_TABLE(scmi, scmi_id_table); 589 590 static struct scmi_driver scmi_pinctrl_driver = { 591 .name = DRV_NAME, 592 .probe = scmi_pinctrl_probe, 593 .id_table = scmi_id_table, 594 }; 595 module_scmi_driver(scmi_pinctrl_driver); 596 597 MODULE_AUTHOR("Oleksii Moisieiev <oleksii_moisieiev@epam.com>"); 598 MODULE_AUTHOR("Peng Fan <peng.fan@nxp.com>"); 599 MODULE_DESCRIPTION("ARM SCMI pin controller driver"); 600 MODULE_LICENSE("GPL"); 601