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