1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com> 4 */ 5 6#include <common.h> 7#include <dm.h> 8#include <dm/device_compat.h> 9#include <linux/compat.h> 10#include <dm/pinctrl.h> 11 12/** 13 * pinctrl_pin_name_to_selector() - return the pin selector for a pin 14 * 15 * @dev: pin controller device 16 * @pin: the pin name to look up 17 * @return: pin selector, or negative error code on failure 18 */ 19static int pinctrl_pin_name_to_selector(struct udevice *dev, const char *pin) 20{ 21 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 22 unsigned npins, selector; 23 24 if (!ops->get_pins_count || !ops->get_pin_name) { 25 dev_dbg(dev, "get_pins_count or get_pin_name missing\n"); 26 return -ENOSYS; 27 } 28 29 npins = ops->get_pins_count(dev); 30 31 /* See if this pctldev has this pin */ 32 for (selector = 0; selector < npins; selector++) { 33 const char *pname = ops->get_pin_name(dev, selector); 34 35 if (!strcmp(pin, pname)) 36 return selector; 37 } 38 39 return -ENOSYS; 40} 41 42/** 43 * pinctrl_group_name_to_selector() - return the group selector for a group 44 * 45 * @dev: pin controller device 46 * @group: the pin group name to look up 47 * @return: pin group selector, or negative error code on failure 48 */ 49static int pinctrl_group_name_to_selector(struct udevice *dev, 50 const char *group) 51{ 52 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 53 unsigned ngroups, selector; 54 55 if (!ops->get_groups_count || !ops->get_group_name) { 56 dev_dbg(dev, "get_groups_count or get_group_name missing\n"); 57 return -ENOSYS; 58 } 59 60 ngroups = ops->get_groups_count(dev); 61 62 /* See if this pctldev has this group */ 63 for (selector = 0; selector < ngroups; selector++) { 64 const char *gname = ops->get_group_name(dev, selector); 65 66 if (!strcmp(group, gname)) 67 return selector; 68 } 69 70 return -ENOSYS; 71} 72 73#if CONFIG_IS_ENABLED(PINMUX) 74/** 75 * pinmux_func_name_to_selector() - return the function selector for a function 76 * 77 * @dev: pin controller device 78 * @function: the function name to look up 79 * @return: function selector, or negative error code on failure 80 */ 81static int pinmux_func_name_to_selector(struct udevice *dev, 82 const char *function) 83{ 84 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 85 unsigned nfuncs, selector = 0; 86 87 if (!ops->get_functions_count || !ops->get_function_name) { 88 dev_dbg(dev, 89 "get_functions_count or get_function_name missing\n"); 90 return -ENOSYS; 91 } 92 93 nfuncs = ops->get_functions_count(dev); 94 95 /* See if this pctldev has this function */ 96 for (selector = 0; selector < nfuncs; selector++) { 97 const char *fname = ops->get_function_name(dev, selector); 98 99 if (!strcmp(function, fname)) 100 return selector; 101 } 102 103 return -ENOSYS; 104} 105 106/** 107 * pinmux_enable_setting() - enable pin-mux setting for a certain pin/group 108 * 109 * @dev: pin controller device 110 * @is_group: target of operation (true: pin group, false: pin) 111 * @selector: pin selector or group selector, depending on @is_group 112 * @func_selector: function selector 113 * @return: 0 on success, or negative error code on failure 114 */ 115static int pinmux_enable_setting(struct udevice *dev, bool is_group, 116 unsigned selector, unsigned func_selector) 117{ 118 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 119 120 if (is_group) { 121 if (!ops->pinmux_group_set) { 122 dev_dbg(dev, "pinmux_group_set op missing\n"); 123 return -ENOSYS; 124 } 125 126 return ops->pinmux_group_set(dev, selector, func_selector); 127 } else { 128 if (!ops->pinmux_set) { 129 dev_dbg(dev, "pinmux_set op missing\n"); 130 return -ENOSYS; 131 } 132 return ops->pinmux_set(dev, selector, func_selector); 133 } 134} 135#else 136static int pinmux_func_name_to_selector(struct udevice *dev, 137 const char *function) 138{ 139 return 0; 140} 141 142static int pinmux_enable_setting(struct udevice *dev, bool is_group, 143 unsigned selector, unsigned func_selector) 144{ 145 return 0; 146} 147#endif 148 149#if CONFIG_IS_ENABLED(PINCONF) 150/** 151 * pinconf_prop_name_to_param() - return parameter ID for a property name 152 * 153 * @dev: pin controller device 154 * @property: property name in DTS, such as "bias-pull-up", "slew-rate", etc. 155 * @default_value: return default value in case no value is specified in DTS 156 * @return: return pamater ID, or negative error code on failure 157 */ 158static int pinconf_prop_name_to_param(struct udevice *dev, 159 const char *property, u32 *default_value) 160{ 161 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 162 const struct pinconf_param *p, *end; 163 164 if (!ops->pinconf_num_params || !ops->pinconf_params) { 165 dev_dbg(dev, "pinconf_num_params or pinconf_params missing\n"); 166 return -ENOSYS; 167 } 168 169 p = ops->pinconf_params; 170 end = p + ops->pinconf_num_params; 171 172 /* See if this pctldev supports this parameter */ 173 for (; p < end; p++) { 174 if (!strcmp(property, p->property)) { 175 *default_value = p->default_value; 176 return p->param; 177 } 178 } 179 180 return -ENOSYS; 181} 182 183/** 184 * pinconf_enable_setting() - apply pin configuration for a certain pin/group 185 * 186 * @dev: pin controller device 187 * @is_group: target of operation (true: pin group, false: pin) 188 * @selector: pin selector or group selector, depending on @is_group 189 * @param: configuration paramter 190 * @argument: argument taken by some configuration parameters 191 * @return: 0 on success, or negative error code on failure 192 */ 193static int pinconf_enable_setting(struct udevice *dev, bool is_group, 194 unsigned selector, unsigned param, 195 u32 argument) 196{ 197 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 198 199 if (is_group) { 200 if (!ops->pinconf_group_set) { 201 dev_dbg(dev, "pinconf_group_set op missing\n"); 202 return -ENOSYS; 203 } 204 205 return ops->pinconf_group_set(dev, selector, param, 206 argument); 207 } else { 208 if (!ops->pinconf_set) { 209 dev_dbg(dev, "pinconf_set op missing\n"); 210 return -ENOSYS; 211 } 212 return ops->pinconf_set(dev, selector, param, argument); 213 } 214} 215#else 216static int pinconf_prop_name_to_param(struct udevice *dev, 217 const char *property, u32 *default_value) 218{ 219 return -ENOSYS; 220} 221 222static int pinconf_enable_setting(struct udevice *dev, bool is_group, 223 unsigned selector, unsigned param, 224 u32 argument) 225{ 226 return 0; 227} 228#endif 229 230enum pinmux_subnode_type { 231 PST_NONE = 0, 232 PST_PIN, 233 PST_GROUP, 234 PST_PINMUX, 235}; 236 237static const char *alloc_name_with_prefix(const char *name, const char *prefix) 238{ 239 if (prefix) { 240 char *name_with_prefix = malloc(strlen(prefix) + strlen(name) + 1); 241 if (name_with_prefix) 242 sprintf(name_with_prefix, "%s%s", prefix, name); 243 return name_with_prefix; 244 } else { 245 return name; 246 } 247} 248 249static void free_name_with_prefix(const char *name_with_prefix, const char *prefix) 250{ 251 if (prefix) 252 free((char *)name_with_prefix); 253} 254 255/** 256 * pinctrl_generic_set_state_one() - set state for a certain pin/group 257 * Apply all pin multiplexing and pin configurations specified by @config 258 * for a given pin or pin group. 259 * 260 * @dev: pin controller device 261 * @config: pseudo device pointing to config node 262 * @subnode_type: target of operation (pin, group, or pin specified by a pinmux 263 * group) 264 * @selector: pin selector or group selector, depending on @subnode_type 265 * @return: 0 on success, or negative error code on failure 266 */ 267static int pinctrl_generic_set_state_one(struct udevice *dev, 268 struct udevice *config, 269 const char *prefix, 270 enum pinmux_subnode_type subnode_type, 271 unsigned selector) 272{ 273 const char *function_propname; 274 const char *propname; 275 const void *value; 276 struct ofprop property; 277 int len, func_selector, param, ret; 278 u32 arg, default_val; 279 280 assert(subnode_type != PST_NONE); 281 282 function_propname = alloc_name_with_prefix("function", prefix); 283 if (!function_propname) 284 return -ENOMEM; 285 286 dev_for_each_property(property, config) { 287 value = dev_read_prop_by_prop(&property, &propname, &len); 288 if (!value) { 289 free_name_with_prefix(function_propname, prefix); 290 return -EINVAL; 291 } 292 293 /* pinmux subnodes already have their muxing set */ 294 if (subnode_type != PST_PINMUX && 295 !strcmp(propname, function_propname)) { 296 func_selector = pinmux_func_name_to_selector(dev, 297 value); 298 if (func_selector < 0) { 299 free_name_with_prefix(function_propname, prefix); 300 return func_selector; 301 } 302 ret = pinmux_enable_setting(dev, 303 subnode_type == PST_GROUP, 304 selector, 305 func_selector); 306 } else { 307 param = pinconf_prop_name_to_param(dev, propname, 308 &default_val); 309 if (param < 0) 310 continue; /* just skip unknown properties */ 311 312 if (len >= sizeof(fdt32_t)) 313 arg = fdt32_to_cpu(*(fdt32_t *)value); 314 else 315 arg = default_val; 316 317 ret = pinconf_enable_setting(dev, 318 subnode_type == PST_GROUP, 319 selector, param, arg); 320 } 321 322 if (ret) { 323 free_name_with_prefix(function_propname, prefix); 324 return ret; 325 } 326 } 327 328 free_name_with_prefix(function_propname, prefix); 329 return 0; 330} 331 332/** 333 * pinctrl_generic_get_subnode_type() - determine whether there is a valid 334 * pins, groups, or pinmux property in the config node 335 * 336 * @dev: pin controller device 337 * @config: pseudo device pointing to config node 338 * @count: number of specifiers contained within the property 339 * @return: the type of the subnode, or PST_NONE 340 */ 341static enum pinmux_subnode_type pinctrl_generic_get_subnode_type(struct udevice *dev, 342 struct udevice *config, 343 const char *prefix, 344 int *count) 345{ 346 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 347 const char *propname; 348 349 propname = alloc_name_with_prefix("pins", prefix); 350 if (!propname) 351 return -ENOMEM; 352 *count = dev_read_string_count(config, propname); 353 free_name_with_prefix(propname, prefix); 354 if (*count >= 0) 355 return PST_PIN; 356 357 propname = alloc_name_with_prefix("groups", prefix); 358 if (!propname) 359 return -ENOMEM; 360 *count = dev_read_string_count(config, propname); 361 free_name_with_prefix(propname, prefix); 362 if (*count >= 0) 363 return PST_GROUP; 364 365 if (ops->pinmux_property_set) { 366 propname = alloc_name_with_prefix("pinmux", prefix); 367 if (!propname) 368 return -ENOMEM; 369 *count = dev_read_size(config, propname); 370 free_name_with_prefix(propname, prefix); 371 if (*count >= 0 && !(*count % sizeof(u32))) { 372 *count /= sizeof(u32); 373 return PST_PINMUX; 374 } 375 } 376 377 *count = 0; 378 return PST_NONE; 379} 380 381/** 382 * pinctrl_generic_set_state_subnode() - apply all settings in config node 383 * 384 * @dev: pin controller device 385 * @config: pseudo device pointing to config node 386 * @prefix: device tree property prefix (e.g. vendor specific) 387 * @return: 0 on success, or negative error code on failure 388 */ 389static int pinctrl_generic_set_state_subnode(struct udevice *dev, 390 struct udevice *config, 391 const char *prefix) 392{ 393 enum pinmux_subnode_type subnode_type; 394 const char *propname; 395 const char *name; 396 int count, selector, i, ret, scratch; 397 const u32 *pinmux_groups = NULL; /* prevent use-uninitialized warning */ 398 399 subnode_type = pinctrl_generic_get_subnode_type(dev, config, prefix, &count); 400 401 debug("%s(%s, %s): count=%d\n", __func__, dev->name, config->name, 402 count); 403 404 if (subnode_type == PST_PINMUX) { 405 propname = alloc_name_with_prefix("pinmux", prefix); 406 if (!propname) 407 return -ENOMEM; 408 pinmux_groups = dev_read_prop(config, propname, &scratch); 409 free_name_with_prefix(propname, prefix); 410 if (!pinmux_groups) 411 return -EINVAL; 412 } 413 414 for (i = 0; i < count; i++) { 415 switch (subnode_type) { 416 case PST_PIN: 417 propname = alloc_name_with_prefix("pins", prefix); 418 if (!propname) 419 return -ENOMEM; 420 ret = dev_read_string_index(config, propname, i, &name); 421 free_name_with_prefix(propname, prefix); 422 if (ret) 423 return ret; 424 selector = pinctrl_pin_name_to_selector(dev, name); 425 break; 426 case PST_GROUP: 427 propname = alloc_name_with_prefix("groups", prefix); 428 if (!propname) 429 return -ENOMEM; 430 ret = dev_read_string_index(config, propname, i, &name); 431 free_name_with_prefix(propname, prefix); 432 if (ret) 433 return ret; 434 selector = pinctrl_group_name_to_selector(dev, name); 435 break; 436 case PST_PINMUX: { 437 const struct pinctrl_ops *ops = pinctrl_get_ops(dev); 438 u32 pinmux_group = fdt32_to_cpu(pinmux_groups[i]); 439 440 /* Checked for in pinctrl_generic_get_subnode_type */ 441 selector = ops->pinmux_property_set(dev, pinmux_group); 442 break; 443 } 444 case PST_NONE: 445 default: 446 /* skip this node; may contain config child nodes */ 447 return 0; 448 } 449 450 if (selector < 0) 451 return selector; 452 453 ret = pinctrl_generic_set_state_one(dev, config, prefix, 454 subnode_type, selector); 455 if (ret) 456 return ret; 457 } 458 459 return 0; 460} 461 462int pinctrl_generic_set_state_prefix(struct udevice *dev, struct udevice *config, 463 const char *prefix) 464{ 465 struct udevice *child; 466 int ret; 467 468 ret = pinctrl_generic_set_state_subnode(dev, config, prefix); 469 if (ret) 470 return ret; 471 472 for (device_find_first_child(config, &child); 473 child; 474 device_find_next_child(&child)) { 475 ret = pinctrl_generic_set_state_subnode(dev, child, prefix); 476 if (ret) 477 return ret; 478 } 479 480 return 0; 481} 482 483int pinctrl_generic_set_state(struct udevice *dev, struct udevice *config) 484{ 485 return pinctrl_generic_set_state_prefix(dev, config, NULL); 486} 487