drivers/pinctrl/pinctrl-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015  Masahiro Yamada <yamada.masahiro@socionext.com>
   4  */
   5
   6 #define LOG_CATEGORY UCLASS_PINCTRL
   7
   8 #include <common.h>
   9 #include <malloc.h>
  10 #include <asm/global_data.h>
  11 #include <dm/device_compat.h>
  12 #include <linux/libfdt.h>
  13 #include <linux/err.h>
  14 #include <linux/list.h>
  15 #include <dm.h>
  16 #include <dm/lists.h>
  17 #include <dm/pinctrl.h>
  18 #include <dm/util.h>
  19 #include <dm/of_access.h>
  20
  21 DECLARE_GLOBAL_DATA_PTR;
  22
  23 /**
  24  * pinctrl_config_one() - apply pinctrl settings for a single node
  25  *
  26  * @config: pin configuration node
  27  * @return: 0 on success, or negative error code on failure
  28  */
  29 static int pinctrl_config_one(struct udevice *config)
  30 {
  31         struct udevice *pctldev;
  32         const struct pinctrl_ops *ops;
  33
  34         pctldev = config;
  35         for (;;) {
  36                 pctldev = dev_get_parent(pctldev);
  37                 if (!pctldev) {
  38                         dev_err(config, "could not find pctldev\n");
  39                         return -EINVAL;
  40                 }
  41                 if (pctldev->uclass->uc_drv->id == UCLASS_PINCTRL)
  42                         break;
  43         }
  44
  45         ops = pinctrl_get_ops(pctldev);
  46         return ops->set_state(pctldev, config);
  47 }
  48
  49 /**
  50  * pinctrl_select_state_full() - full implementation of pinctrl_select_state
  51  *
  52  * @dev: peripheral device
  53  * @statename: state name, like "default"
  54  * @return: 0 on success, or negative error code on failure
  55  */
  56 static int pinctrl_select_state_full(struct udevice *dev, const char *statename)
  57 {
  58         char propname[32]; /* long enough */
  59         const fdt32_t *list;
  60         uint32_t phandle;
  61         struct udevice *config;
  62         int state, size, i, ret;
  63
  64         state = dev_read_stringlist_search(dev, "pinctrl-names", statename);
  65         if (state < 0) {
  66                 char *end;
  67                 /*
  68                  * If statename is not found in "pinctrl-names",
  69                  * assume statename is just the integer state ID.
  70                  */
  71                 state = dectoul(statename, &end);
  72                 if (*end)
  73                         return -ENOSYS;
  74         }
  75
  76         snprintf(propname, sizeof(propname), "pinctrl-%d", state);
  77         list = dev_read_prop(dev, propname, &size);
  78         if (!list)
  79                 return -ENOSYS;
  80
  81         size /= sizeof(*list);
  82         for (i = 0; i < size; i++) {
  83                 phandle = fdt32_to_cpu(*list++);
  84                 ret = uclass_get_device_by_phandle_id(UCLASS_PINCONFIG, phandle,
  85                                                       &config);
  86                 if (ret) {
  87                         dev_warn(dev, "%s: uclass_get_device_by_phandle_id: err=%d\n",
  88                                 __func__, ret);
  89                         continue;
  90                 }
  91
  92                 ret = pinctrl_config_one(config);
  93                 if (ret) {
  94                         dev_warn(dev, "%s: pinctrl_config_one: err=%d\n",
  95                                 __func__, ret);
  96                         continue;
  97                 }
  98         }
  99
 100         return 0;
 101 }
 102
 103 /**
 104  * pinconfig_post_bind() - post binding for PINCONFIG uclass
 105  * Recursively bind its children as pinconfig devices.
 106  *
 107  * @dev: pinconfig device
 108  * @return: 0 on success, or negative error code on failure
 109  */
 110 static int pinconfig_post_bind(struct udevice *dev)
 111 {
 112         bool pre_reloc_only = !(gd->flags & GD_FLG_RELOC);
 113         const char *name;
 114         ofnode node;
 115         int ret;
 116
 117         if (!dev_has_ofnode(dev))
 118                 return 0;
 119
 120         dev_for_each_subnode(node, dev) {
 121                 if (pre_reloc_only &&
 122                     !ofnode_pre_reloc(node))
 123                         continue;
 124                 /*
 125                  * If this node has "compatible" property, this is not
 126                  * a pin configuration node, but a normal device. skip.
 127                  */
 128                 ofnode_get_property(node, "compatible", &ret);
 129                 if (ret >= 0)
 130                         continue;
 131                 /* If this node has "gpio-controller" property, skip */
 132                 if (ofnode_read_bool(node, "gpio-controller"))
 133                         continue;
 134
 135                 if (ret != -FDT_ERR_NOTFOUND)
 136                         return ret;
 137
 138                 name = ofnode_get_name(node);
 139                 if (!name)
 140                         return -EINVAL;
 141                 ret = device_bind_driver_to_node(dev, "pinconfig", name,
 142                                                  node, NULL);
 143                 if (ret)
 144                         return ret;
 145         }
 146
 147         return 0;
 148 }
 149
 150 #if CONFIG_IS_ENABLED(PINCTRL_FULL)
 151 UCLASS_DRIVER(pinconfig) = {
 152         .id = UCLASS_PINCONFIG,
 153 #if CONFIG_IS_ENABLED(PINCONF_RECURSIVE)
 154         .post_bind = pinconfig_post_bind,
 155 #endif
 156         .name = "pinconfig",
 157 };
 158
 159 U_BOOT_DRIVER(pinconfig_generic) = {
 160         .name = "pinconfig",
 161         .id = UCLASS_PINCONFIG,
 162 };
 163 #endif
 164
 165 static int
 166 pinctrl_gpio_get_pinctrl_and_offset(struct udevice *dev, unsigned offset,
 167                                     struct udevice **pctldev,
 168                                     unsigned int *pin_selector)
 169 {
 170         struct ofnode_phandle_args args;
 171         unsigned gpio_offset, pfc_base, pfc_pins;
 172         int ret;
 173
 174         ret = dev_read_phandle_with_args(dev, "gpio-ranges", NULL, 3,
 175                                          0, &args);
 176         if (ret) {
 177                 dev_dbg(dev, "%s: dev_read_phandle_with_args: err=%d\n",
 178                         __func__, ret);
 179                 return ret;
 180         }
 181
 182         ret = uclass_get_device_by_ofnode(UCLASS_PINCTRL,
 183                                           args.node, pctldev);
 184         if (ret) {
 185                 dev_dbg(dev,
 186                         "%s: uclass_get_device_by_of_offset failed: err=%d\n",
 187                         __func__, ret);
 188                 return ret;
 189         }
 190
 191         gpio_offset = args.args[0];
 192         pfc_base = args.args[1];
 193         pfc_pins = args.args[2];
 194
 195         if (offset < gpio_offset || offset > gpio_offset + pfc_pins) {
 196                 dev_dbg(dev,
 197                         "%s: GPIO can not be mapped to pincontrol pin\n",
 198                         __func__);
 199                 return -EINVAL;
 200         }
 201
 202         offset -= gpio_offset;
 203         offset += pfc_base;
 204         *pin_selector = offset;
 205
 206         return 0;
 207 }
 208
 209 /**
 210  * pinctrl_gpio_request() - request a single pin to be used as GPIO
 211  *
 212  * @dev: GPIO peripheral device
 213  * @offset: the GPIO pin offset from the GPIO controller
 214  * @label: the GPIO pin label
 215  * @return: 0 on success, or negative error code on failure
 216  */
 217 int pinctrl_gpio_request(struct udevice *dev, unsigned offset, const char *label)
 218 {
 219         const struct pinctrl_ops *ops;
 220         struct udevice *pctldev;
 221         unsigned int pin_selector;
 222         int ret;
 223
 224         ret = pinctrl_gpio_get_pinctrl_and_offset(dev, offset,
 225                                                   &pctldev, &pin_selector);
 226         if (ret)
 227                 return ret;
 228
 229         ops = pinctrl_get_ops(pctldev);
 230         assert(ops);
 231         if (!ops->gpio_request_enable)
 232                 return -ENOSYS;
 233
 234         return ops->gpio_request_enable(pctldev, pin_selector);
 235 }
 236
 237 /**
 238  * pinctrl_gpio_free() - free a single pin used as GPIO
 239  *
 240  * @dev: GPIO peripheral device
 241  * @offset: the GPIO pin offset from the GPIO controller
 242  * @return: 0 on success, or negative error code on failure
 243  */
 244 int pinctrl_gpio_free(struct udevice *dev, unsigned offset)
 245 {
 246         const struct pinctrl_ops *ops;
 247         struct udevice *pctldev;
 248         unsigned int pin_selector;
 249         int ret;
 250
 251         ret = pinctrl_gpio_get_pinctrl_and_offset(dev, offset,
 252                                                   &pctldev, &pin_selector);
 253         if (ret)
 254                 return ret;
 255
 256         ops = pinctrl_get_ops(pctldev);
 257         assert(ops);
 258         if (!ops->gpio_disable_free)
 259                 return -ENOSYS;
 260
 261         return ops->gpio_disable_free(pctldev, pin_selector);
 262 }
 263
 264 /**
 265  * pinctrl_select_state_simple() - simple implementation of pinctrl_select_state
 266  *
 267  * @dev: peripheral device
 268  * @return: 0 on success, or negative error code on failure
 269  */
 270 static int pinctrl_select_state_simple(struct udevice *dev)
 271 {
 272         struct udevice *pctldev;
 273         struct pinctrl_ops *ops;
 274         int ret;
 275
 276         /*
 277          * For most system, there is only one pincontroller device. But in
 278          * case of multiple pincontroller devices, probe the one with sequence
 279          * number 0 (defined by alias) to avoid race condition.
 280          */
 281         ret = uclass_get_device_by_seq(UCLASS_PINCTRL, 0, &pctldev);
 282         if (ret)
 283                 /* if not found, get the first one */
 284                 ret = uclass_get_device(UCLASS_PINCTRL, 0, &pctldev);
 285         if (ret)
 286                 return ret;
 287
 288         ops = pinctrl_get_ops(pctldev);
 289         if (!ops->set_state_simple) {
 290                 dev_dbg(dev, "set_state_simple op missing\n");
 291                 return -ENOSYS;
 292         }
 293
 294         return ops->set_state_simple(pctldev, dev);
 295 }
 296
 297 int pinctrl_select_state(struct udevice *dev, const char *statename)
 298 {
 299         /*
 300          * Some device which is logical like mmc.blk, do not have
 301          * a valid ofnode.
 302          */
 303         if (!dev_has_ofnode(dev))
 304                 return 0;
 305         /*
 306          * Try full-implemented pinctrl first.
 307          * If it fails or is not implemented, try simple one.
 308          */
 309         if (CONFIG_IS_ENABLED(PINCTRL_FULL))
 310                 return pinctrl_select_state_full(dev, statename);
 311
 312         return pinctrl_select_state_simple(dev);
 313 }
 314
 315 int pinctrl_request(struct udevice *dev, int func, int flags)
 316 {
 317         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 318
 319         if (!ops->request)
 320                 return -ENOSYS;
 321
 322         return ops->request(dev, func, flags);
 323 }
 324
 325 int pinctrl_request_noflags(struct udevice *dev, int func)
 326 {
 327         return pinctrl_request(dev, func, 0);
 328 }
 329
 330 int pinctrl_get_periph_id(struct udevice *dev, struct udevice *periph)
 331 {
 332         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 333
 334         if (!ops->get_periph_id)
 335                 return -ENOSYS;
 336
 337         return ops->get_periph_id(dev, periph);
 338 }
 339
 340 int pinctrl_get_gpio_mux(struct udevice *dev, int banknum, int index)
 341 {
 342         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 343
 344         if (!ops->get_gpio_mux)
 345                 return -ENOSYS;
 346
 347         return ops->get_gpio_mux(dev, banknum, index);
 348 }
 349
 350 int pinctrl_get_pins_count(struct udevice *dev)
 351 {
 352         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 353
 354         if (!ops->get_pins_count)
 355                 return -ENOSYS;
 356
 357         return ops->get_pins_count(dev);
 358 }
 359
 360 int pinctrl_get_pin_name(struct udevice *dev, int selector, char *buf,
 361                          int size)
 362 {
 363         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 364
 365         if (!ops->get_pin_name)
 366                 return -ENOSYS;
 367
 368         snprintf(buf, size, ops->get_pin_name(dev, selector));
 369
 370         return 0;
 371 }
 372
 373 int pinctrl_get_pin_muxing(struct udevice *dev, int selector, char *buf,
 374                            int size)
 375 {
 376         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 377
 378         if (!ops->get_pin_muxing)
 379                 return -ENOSYS;
 380
 381         return ops->get_pin_muxing(dev, selector, buf, size);
 382 }
 383
 384 /**
 385  * pinctrl_post_bind() - post binding for PINCTRL uclass
 386  * Recursively bind child nodes as pinconfig devices in case of full pinctrl.
 387  *
 388  * @dev: pinctrl device
 389  * @return: 0 on success, or negative error code on failure
 390  */
 391 static int __maybe_unused pinctrl_post_bind(struct udevice *dev)
 392 {
 393         const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 394
 395         if (!ops) {
 396                 dev_dbg(dev, "ops is not set.  Do not bind.\n");
 397                 return -EINVAL;
 398         }
 399
 400         /*
 401          * If the pinctrl driver has the full implementation, its child nodes
 402          * should be bound so that peripheral devices can easily search in
 403          * parent devices during later DT-parsing.
 404          */
 405         if (CONFIG_IS_ENABLED(PINCTRL_FULL))
 406                 return pinconfig_post_bind(dev);
 407
 408         return 0;
 409 }
 410
 411 UCLASS_DRIVER(pinctrl) = {
 412         .id = UCLASS_PINCTRL,
 413 #if CONFIG_IS_ENABLED(OF_REAL)
 414         .post_bind = pinctrl_post_bind,
 415 #endif
 416         .flags = DM_UC_FLAG_SEQ_ALIAS,
 417         .name = "pinctrl",
 418 };