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