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