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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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