drivers/pinctrl/pinctrl-uclass.c

   1 /*
   2  * Copyright (C) 2015  Masahiro Yamada <yamada.masahiro@socionext.com>
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <libfdt.h>
   9 #include <linux/err.h>
  10 #include <linux/list.h>
  11 #include <dm/device.h>
  12 #include <dm/lists.h>
  13 #include <dm/pinctrl.h>
  14 #include <dm/uclass.h>
  15
  16 DECLARE_GLOBAL_DATA_PTR;
  17
  18 #if CONFIG_IS_ENABLED(PINCTRL_FULL)
  19 /**
  20  * pinctrl_config_one() - apply pinctrl settings for a single node
  21  *
  22  * @config: pin configuration node
  23  * @return: 0 on success, or negative error code on failure
  24  */
  25 static int pinctrl_config_one(struct udevice *config)
  26 {
  27         struct udevice *pctldev;
  28         const struct pinctrl_ops *ops;
  29
  30         pctldev = config;
  31         for (;;) {
  32                 pctldev = dev_get_parent(pctldev);
  33                 if (!pctldev) {
  34                         dev_err(config, "could not find pctldev\n");
  35                         return -EINVAL;
  36                 }
  37                 if (pctldev->uclass->uc_drv->id == UCLASS_PINCTRL)
  38                         break;
  39         }
  40
  41         ops = pinctrl_get_ops(pctldev);
  42         return ops->set_state(pctldev, config);
  43 }
  44
  45 /**
  46  * pinctrl_select_state_full() - full implementation of pinctrl_select_state
  47  *
  48  * @dev: peripheral device
  49  * @statename: state name, like "default"
  50  * @return: 0 on success, or negative error code on failure
  51  */
  52 static int pinctrl_select_state_full(struct udevice *dev, const char *statename)
  53 {
  54         const void *fdt = gd->fdt_blob;
  55         int node = dev->of_offset;
  56         char propname[32]; /* long enough */
  57         const fdt32_t *list;
  58         uint32_t phandle;
  59         int config_node;
  60         struct udevice *config;
  61         int state, size, i, ret;
  62
  63         state = fdt_find_string(fdt, node, "pinctrl-names", statename);
  64         if (state < 0) {
  65                 char *end;
  66                 /*
  67                  * If statename is not found in "pinctrl-names",
  68                  * assume statename is just the integer state ID.
  69                  */
  70                 state = simple_strtoul(statename, &end, 10);
  71                 if (*end)
  72                         return -EINVAL;
  73         }
  74
  75         snprintf(propname, sizeof(propname), "pinctrl-%d", state);
  76         list = fdt_getprop(fdt, node, propname, &size);
  77         if (!list)
  78                 return -EINVAL;
  79
  80         size /= sizeof(*list);
  81         for (i = 0; i < size; i++) {
  82                 phandle = fdt32_to_cpu(*list++);
  83
  84                 config_node = fdt_node_offset_by_phandle(fdt, phandle);
  85                 if (config_node < 0) {
  86                         dev_err(dev, "prop %s index %d invalid phandle\n",
  87                                 propname, i);
  88                         return -EINVAL;
  89                 }
  90                 ret = uclass_get_device_by_of_offset(UCLASS_PINCONFIG,
  91                                                      config_node, &config);
  92                 if (ret)
  93                         return ret;
  94
  95                 ret = pinctrl_config_one(config);
  96                 if (ret)
  97                         return ret;
  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         const void *fdt = gd->fdt_blob;
 113         int offset = dev->of_offset;
 114         bool pre_reloc_only = !(gd->flags & GD_FLG_RELOC);
 115         const char *name;
 116         int ret;
 117
 118         for (offset = fdt_first_subnode(fdt, offset);
 119              offset > 0;
 120              offset = fdt_next_subnode(fdt, offset)) {
 121                 if (pre_reloc_only &&
 122                     !fdt_getprop(fdt, offset, "u-boot,dm-pre-reloc", NULL))
 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                 fdt_get_property(fdt, offset, "compatible", &ret);
 129                 if (ret >= 0)
 130                         continue;
 131
 132                 if (ret != -FDT_ERR_NOTFOUND)
 133                         return ret;
 134
 135                 name = fdt_get_name(fdt, offset, NULL);
 136                 if (!name)
 137                         return -EINVAL;
 138                 ret = device_bind_driver_to_node(dev, "pinconfig", name,
 139                                                  offset, NULL);
 140                 if (ret)
 141                         return ret;
 142         }
 143
 144         return 0;
 145 }
 146
 147 UCLASS_DRIVER(pinconfig) = {
 148         .id = UCLASS_PINCONFIG,
 149         .post_bind = pinconfig_post_bind,
 150         .name = "pinconfig",
 151 };
 152
 153 U_BOOT_DRIVER(pinconfig_generic) = {
 154         .name = "pinconfig",
 155         .id = UCLASS_PINCONFIG,
 156 };
 157
 158 #else
 159 static int pinctrl_select_state_full(struct udevice *dev, const char *statename)
 160 {
 161         return -ENODEV;
 162 }
 163
 164 static int pinconfig_post_bind(struct udevice *dev)
 165 {
 166         return 0;
 167 }
 168 #endif
 169
 170 /**
 171  * pinctrl_select_state_simple() - simple implementation of pinctrl_select_state
 172  *
 173  * @dev: peripheral device
 174  * @return: 0 on success, or negative error code on failure
 175  */
 176 static int pinctrl_select_state_simple(struct udevice *dev)
 177 {
 178         struct udevice *pctldev;
 179         struct pinctrl_ops *ops;
 180         int ret;
 181
 182         /*
 183          * For simplicity, assume the first device of PINCTRL uclass
 184          * is the correct one.  This is most likely OK as there is
 185          * usually only one pinctrl device on the system.
 186          */
 187         ret = uclass_get_device(UCLASS_PINCTRL, 0, &pctldev);
 188         if (ret)
 189                 return ret;
 190
 191         ops = pinctrl_get_ops(pctldev);
 192         if (!ops->set_state_simple) {
 193                 dev_dbg(dev, "set_state_simple op missing\n");
 194                 return -ENOSYS;
 195         }
 196
 197         return ops->set_state_simple(pctldev, dev);
 198 }
 199
 200 int pinctrl_select_state(struct udevice *dev, const char *statename)
 201 {
 202         /*
 203          * Try full-implemented pinctrl first.
 204          * If it fails or is not implemented, try simple one.
 205          */
 206         if (pinctrl_select_state_full(dev, statename))
 207                 return pinctrl_select_state_simple(dev);
 208
 209         return 0;
 210 }
 211
 212 int pinctrl_request(struct udevice *dev, int func, int flags)
 213 {
 214         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 215
 216         if (!ops->request)
 217                 return -ENOSYS;
 218
 219         return ops->request(dev, func, flags);
 220 }
 221
 222 int pinctrl_request_noflags(struct udevice *dev, int func)
 223 {
 224         return pinctrl_request(dev, func, 0);
 225 }
 226
 227 int pinctrl_get_periph_id(struct udevice *dev, struct udevice *periph)
 228 {
 229         struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 230
 231         if (!ops->get_periph_id)
 232                 return -ENOSYS;
 233
 234         return ops->get_periph_id(dev, periph);
 235 }
 236
 237 /**
 238  * pinconfig_post-bind() - post binding for PINCTRL uclass
 239  * Recursively bind child nodes as pinconfig devices in case of full pinctrl.
 240  *
 241  * @dev: pinctrl device
 242  * @return: 0 on success, or negative error code on failure
 243  */
 244 static int pinctrl_post_bind(struct udevice *dev)
 245 {
 246         const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 247
 248         if (!ops) {
 249                 dev_dbg(dev, "ops is not set.  Do not bind.\n");
 250                 return -EINVAL;
 251         }
 252
 253         /*
 254          * If set_state callback is set, we assume this pinctrl driver is the
 255          * full implementation.  In this case, its child nodes should be bound
 256          * so that peripheral devices can easily search in parent devices
 257          * during later DT-parsing.
 258          */
 259         if (ops->set_state)
 260                 return pinconfig_post_bind(dev);
 261
 262         return 0;
 263 }
 264
 265 UCLASS_DRIVER(pinctrl) = {
 266         .id = UCLASS_PINCTRL,
 267         .post_bind = pinctrl_post_bind,
 268         .name = "pinctrl",
 269 };