drivers/gpio/gpio-uclass.c

   1 /*
   2  * Copyright (c) 2013 Google, Inc
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <errno.h>
  10 #include <malloc.h>
  11 #include <asm/gpio.h>
  12 #include <linux/ctype.h>
  13
  14 /**
  15  * gpio_to_device() - Convert global GPIO number to device, number
  16  * gpio:        The numeric representation of the GPIO
  17  *
  18  * Convert the GPIO number to an entry in the list of GPIOs
  19  * or GPIO blocks registered with the GPIO controller. Returns
  20  * entry on success, NULL on error.
  21  */
  22 static int gpio_to_device(unsigned int gpio, struct udevice **devp,
  23                           unsigned int *offset)
  24 {
  25         struct gpio_dev_priv *uc_priv;
  26         struct udevice *dev;
  27         int ret;
  28
  29         for (ret = uclass_first_device(UCLASS_GPIO, &dev);
  30              dev;
  31              ret = uclass_next_device(&dev)) {
  32                 uc_priv = dev->uclass_priv;
  33                 if (gpio >= uc_priv->gpio_base &&
  34                     gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
  35                         *devp = dev;
  36                         *offset = gpio - uc_priv->gpio_base;
  37                         return 0;
  38                 }
  39         }
  40
  41         /* No such GPIO */
  42         return ret ? ret : -EINVAL;
  43 }
  44
  45 int gpio_lookup_name(const char *name, struct udevice **devp,
  46                      unsigned int *offsetp, unsigned int *gpiop)
  47 {
  48         struct gpio_dev_priv *uc_priv = NULL;
  49         struct udevice *dev;
  50         ulong offset;
  51         int numeric;
  52         int ret;
  53
  54         if (devp)
  55                 *devp = NULL;
  56         numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1;
  57         for (ret = uclass_first_device(UCLASS_GPIO, &dev);
  58              dev;
  59              ret = uclass_next_device(&dev)) {
  60                 int len;
  61
  62                 uc_priv = dev->uclass_priv;
  63                 if (numeric != -1) {
  64                         offset = numeric - uc_priv->gpio_base;
  65                         /* Allow GPIOs to be numbered from 0 */
  66                         if (offset >= 0 && offset < uc_priv->gpio_count)
  67                                 break;
  68                 }
  69
  70                 len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0;
  71
  72                 if (!strncasecmp(name, uc_priv->bank_name, len)) {
  73                         if (!strict_strtoul(name + len, 10, &offset))
  74                                 break;
  75                 }
  76         }
  77
  78         if (!dev)
  79                 return ret ? ret : -EINVAL;
  80
  81         if (devp)
  82                 *devp = dev;
  83         if (offsetp)
  84                 *offsetp = offset;
  85         if (gpiop)
  86                 *gpiop = uc_priv->gpio_base + offset;
  87
  88         return 0;
  89 }
  90
  91 /**
  92  * gpio_request() - [COMPAT] Request GPIO
  93  * gpio:        GPIO number
  94  * label:       Name for the requested GPIO
  95  *
  96  * The label is copied and allocated so the caller does not need to keep
  97  * the pointer around.
  98  *
  99  * This function implements the API that's compatible with current
 100  * GPIO API used in U-Boot. The request is forwarded to particular
 101  * GPIO driver. Returns 0 on success, negative value on error.
 102  */
 103 int gpio_request(unsigned gpio, const char *label)
 104 {
 105         struct gpio_dev_priv *uc_priv;
 106         unsigned int offset;
 107         struct udevice *dev;
 108         char *str;
 109         int ret;
 110
 111         ret = gpio_to_device(gpio, &dev, &offset);
 112         if (ret)
 113                 return ret;
 114
 115         uc_priv = dev->uclass_priv;
 116         if (uc_priv->name[offset])
 117                 return -EBUSY;
 118         str = strdup(label);
 119         if (!str)
 120                 return -ENOMEM;
 121         if (gpio_get_ops(dev)->request) {
 122                 ret = gpio_get_ops(dev)->request(dev, offset, label);
 123                 if (ret) {
 124                         free(str);
 125                         return ret;
 126                 }
 127         }
 128         uc_priv->name[offset] = str;
 129
 130         return 0;
 131 }
 132
 133 /**
 134  * gpio_requestf() - [COMPAT] Request GPIO
 135  * @gpio:       GPIO number
 136  * @fmt:        Format string for the requested GPIO
 137  * @...:        Arguments for the printf() format string
 138  *
 139  * This function implements the API that's compatible with current
 140  * GPIO API used in U-Boot. The request is forwarded to particular
 141  * GPIO driver. Returns 0 on success, negative value on error.
 142  */
 143 int gpio_requestf(unsigned gpio, const char *fmt, ...)
 144 {
 145         va_list args;
 146         char buf[40];
 147
 148         va_start(args, fmt);
 149         vscnprintf(buf, sizeof(buf), fmt, args);
 150         va_end(args);
 151         return gpio_request(gpio, buf);
 152 }
 153
 154 /**
 155  * gpio_free() - [COMPAT] Relinquish GPIO
 156  * gpio:        GPIO number
 157  *
 158  * This function implements the API that's compatible with current
 159  * GPIO API used in U-Boot. The request is forwarded to particular
 160  * GPIO driver. Returns 0 on success, negative value on error.
 161  */
 162 int gpio_free(unsigned gpio)
 163 {
 164         struct gpio_dev_priv *uc_priv;
 165         unsigned int offset;
 166         struct udevice *dev;
 167         int ret;
 168
 169         ret = gpio_to_device(gpio, &dev, &offset);
 170         if (ret)
 171                 return ret;
 172
 173         uc_priv = dev->uclass_priv;
 174         if (!uc_priv->name[offset])
 175                 return -ENXIO;
 176         if (gpio_get_ops(dev)->free) {
 177                 ret = gpio_get_ops(dev)->free(dev, offset);
 178                 if (ret)
 179                         return ret;
 180         }
 181
 182         free(uc_priv->name[offset]);
 183         uc_priv->name[offset] = NULL;
 184
 185         return 0;
 186 }
 187
 188 static int check_reserved(struct udevice *dev, unsigned offset,
 189                           const char *func)
 190 {
 191         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
 192
 193         if (!uc_priv->name[offset]) {
 194                 printf("%s: %s: error: gpio %s%d not reserved\n",
 195                        dev->name, func,
 196                        uc_priv->bank_name ? uc_priv->bank_name : "", offset);
 197                 return -EBUSY;
 198         }
 199
 200         return 0;
 201 }
 202
 203 /**
 204  * gpio_direction_input() - [COMPAT] Set GPIO direction to input
 205  * gpio:        GPIO number
 206  *
 207  * This function implements the API that's compatible with current
 208  * GPIO API used in U-Boot. The request is forwarded to particular
 209  * GPIO driver. Returns 0 on success, negative value on error.
 210  */
 211 int gpio_direction_input(unsigned gpio)
 212 {
 213         unsigned int offset;
 214         struct udevice *dev;
 215         int ret;
 216
 217         ret = gpio_to_device(gpio, &dev, &offset);
 218         if (ret)
 219                 return ret;
 220         ret = check_reserved(dev, offset, "dir_input");
 221
 222         return ret ? ret : gpio_get_ops(dev)->direction_input(dev, offset);
 223 }
 224
 225 /**
 226  * gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value
 227  * gpio:        GPIO number
 228  * value:       Logical value to be set on the GPIO pin
 229  *
 230  * This function implements the API that's compatible with current
 231  * GPIO API used in U-Boot. The request is forwarded to particular
 232  * GPIO driver. Returns 0 on success, negative value on error.
 233  */
 234 int gpio_direction_output(unsigned gpio, int value)
 235 {
 236         unsigned int offset;
 237         struct udevice *dev;
 238         int ret;
 239
 240         ret = gpio_to_device(gpio, &dev, &offset);
 241         if (ret)
 242                 return ret;
 243         ret = check_reserved(dev, offset, "dir_output");
 244
 245         return ret ? ret :
 246                 gpio_get_ops(dev)->direction_output(dev, offset, value);
 247 }
 248
 249 /**
 250  * gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value
 251  * gpio:        GPIO number
 252  *
 253  * This function implements the API that's compatible with current
 254  * GPIO API used in U-Boot. The request is forwarded to particular
 255  * GPIO driver. Returns the value of the GPIO pin, or negative value
 256  * on error.
 257  */
 258 int gpio_get_value(unsigned gpio)
 259 {
 260         unsigned int offset;
 261         struct udevice *dev;
 262         int ret;
 263
 264         ret = gpio_to_device(gpio, &dev, &offset);
 265         if (ret)
 266                 return ret;
 267         ret = check_reserved(dev, offset, "get_value");
 268
 269         return ret ? ret : gpio_get_ops(dev)->get_value(dev, offset);
 270 }
 271
 272 /**
 273  * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin
 274  * gpio:        GPIO number
 275  * value:       Logical value to be set on the GPIO pin.
 276  *
 277  * This function implements the API that's compatible with current
 278  * GPIO API used in U-Boot. The request is forwarded to particular
 279  * GPIO driver. Returns 0 on success, negative value on error.
 280  */
 281 int gpio_set_value(unsigned gpio, int value)
 282 {
 283         unsigned int offset;
 284         struct udevice *dev;
 285         int ret;
 286
 287         ret = gpio_to_device(gpio, &dev, &offset);
 288         if (ret)
 289                 return ret;
 290         ret = check_reserved(dev, offset, "set_value");
 291
 292         return ret ? ret : gpio_get_ops(dev)->set_value(dev, offset, value);
 293 }
 294
 295 const char *gpio_get_bank_info(struct udevice *dev, int *bit_count)
 296 {
 297         struct gpio_dev_priv *priv;
 298
 299         /* Must be called on an active device */
 300         priv = dev->uclass_priv;
 301         assert(priv);
 302
 303         *bit_count = priv->gpio_count;
 304         return priv->bank_name;
 305 }
 306
 307 static const char * const gpio_function[GPIOF_COUNT] = {
 308         "input",
 309         "output",
 310         "unused",
 311         "unknown",
 312         "func",
 313 };
 314
 315 int get_function(struct udevice *dev, int offset, bool skip_unused,
 316                  const char **namep)
 317 {
 318         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
 319         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 320
 321         BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 322         if (!device_active(dev))
 323                 return -ENODEV;
 324         if (offset < 0 || offset >= uc_priv->gpio_count)
 325                 return -EINVAL;
 326         if (namep)
 327                 *namep = uc_priv->name[offset];
 328         if (skip_unused && !uc_priv->name[offset])
 329                 return GPIOF_UNUSED;
 330         if (ops->get_function) {
 331                 int ret;
 332
 333                 ret = ops->get_function(dev, offset);
 334                 if (ret < 0)
 335                         return ret;
 336                 if (ret >= ARRAY_SIZE(gpio_function))
 337                         return -ENODATA;
 338                 return ret;
 339         }
 340
 341         return GPIOF_UNKNOWN;
 342 }
 343
 344 int gpio_get_function(struct udevice *dev, int offset, const char **namep)
 345 {
 346         return get_function(dev, offset, true, namep);
 347 }
 348
 349 int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep)
 350 {
 351         return get_function(dev, offset, false, namep);
 352 }
 353
 354 int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
 355 {
 356         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 357         struct gpio_dev_priv *priv;
 358         char *str = buf;
 359         int func;
 360         int ret;
 361         int len;
 362
 363         BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 364
 365         *buf = 0;
 366         priv = dev->uclass_priv;
 367         ret = gpio_get_raw_function(dev, offset, NULL);
 368         if (ret < 0)
 369                 return ret;
 370         func = ret;
 371         len = snprintf(str, buffsize, "%s%d: %s",
 372                        priv->bank_name ? priv->bank_name : "",
 373                        offset, gpio_function[func]);
 374         if (func == GPIOF_INPUT || func == GPIOF_OUTPUT ||
 375             func == GPIOF_UNUSED) {
 376                 const char *label;
 377                 bool used;
 378
 379                 ret = ops->get_value(dev, offset);
 380                 if (ret < 0)
 381                         return ret;
 382                 used = gpio_get_function(dev, offset, &label) != GPIOF_UNUSED;
 383                 snprintf(str + len, buffsize - len, ": %d [%c]%s%s",
 384                          ret,
 385                          used ? 'x' : ' ',
 386                          used ? " " : "",
 387                          label ? label : "");
 388         }
 389
 390         return 0;
 391 }
 392
 393 /* We need to renumber the GPIOs when any driver is probed/removed */
 394 static int gpio_renumber(struct udevice *removed_dev)
 395 {
 396         struct gpio_dev_priv *uc_priv;
 397         struct udevice *dev;
 398         struct uclass *uc;
 399         unsigned base;
 400         int ret;
 401
 402         ret = uclass_get(UCLASS_GPIO, &uc);
 403         if (ret)
 404                 return ret;
 405
 406         /* Ensure that we have a base for each bank */
 407         base = 0;
 408         uclass_foreach_dev(dev, uc) {
 409                 if (device_active(dev) && dev != removed_dev) {
 410                         uc_priv = dev->uclass_priv;
 411                         uc_priv->gpio_base = base;
 412                         base += uc_priv->gpio_count;
 413                 }
 414         }
 415
 416         return 0;
 417 }
 418
 419 static int gpio_post_probe(struct udevice *dev)
 420 {
 421         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
 422
 423         uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *));
 424         if (!uc_priv->name)
 425                 return -ENOMEM;
 426
 427         return gpio_renumber(NULL);
 428 }
 429
 430 static int gpio_pre_remove(struct udevice *dev)
 431 {
 432         struct gpio_dev_priv *uc_priv = dev->uclass_priv;
 433         int i;
 434
 435         for (i = 0; i < uc_priv->gpio_count; i++) {
 436                 if (uc_priv->name[i])
 437                         free(uc_priv->name[i]);
 438         }
 439         free(uc_priv->name);
 440
 441         return gpio_renumber(dev);
 442 }
 443
 444 UCLASS_DRIVER(gpio) = {
 445         .id             = UCLASS_GPIO,
 446         .name           = "gpio",
 447         .post_probe     = gpio_post_probe,
 448         .pre_remove     = gpio_pre_remove,
 449         .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
 450 };