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 <dt-bindings/gpio/gpio.h>
  10 #include <errno.h>
  11 #include <fdtdec.h>
  12 #include <malloc.h>
  13 #include <asm/gpio.h>
  14 #include <linux/bug.h>
  15 #include <linux/ctype.h>
  16
  17 DECLARE_GLOBAL_DATA_PTR;
  18
  19 /**
  20  * gpio_to_device() - Convert global GPIO number to device, number
  21  *
  22  * Convert the GPIO number to an entry in the list of GPIOs
  23  * or GPIO blocks registered with the GPIO controller. Returns
  24  * entry on success, NULL on error.
  25  *
  26  * @gpio:       The numeric representation of the GPIO
  27  * @desc:       Returns description (desc->flags will always be 0)
  28  * @return 0 if found, -ENOENT if not found
  29  */
  30 static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc)
  31 {
  32         struct gpio_dev_priv *uc_priv;
  33         struct udevice *dev;
  34         int ret;
  35
  36         for (ret = uclass_first_device(UCLASS_GPIO, &dev);
  37              dev;
  38              ret = uclass_next_device(&dev)) {
  39                 uc_priv = dev_get_uclass_priv(dev);
  40                 if (gpio >= uc_priv->gpio_base &&
  41                     gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
  42                         desc->dev = dev;
  43                         desc->offset = gpio - uc_priv->gpio_base;
  44                         desc->flags = 0;
  45                         return 0;
  46                 }
  47         }
  48
  49         /* No such GPIO */
  50         return ret ? ret : -ENOENT;
  51 }
  52
  53 int dm_gpio_lookup_name(const char *name, struct gpio_desc *desc)
  54 {
  55         struct gpio_dev_priv *uc_priv = NULL;
  56         struct udevice *dev;
  57         ulong offset;
  58         int numeric;
  59         int ret;
  60
  61         numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1;
  62         for (ret = uclass_first_device(UCLASS_GPIO, &dev);
  63              dev;
  64              ret = uclass_next_device(&dev)) {
  65                 int len;
  66
  67                 uc_priv = dev_get_uclass_priv(dev);
  68                 if (numeric != -1) {
  69                         offset = numeric - uc_priv->gpio_base;
  70                         /* Allow GPIOs to be numbered from 0 */
  71                         if (offset >= 0 && offset < uc_priv->gpio_count)
  72                                 break;
  73                 }
  74
  75                 len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0;
  76
  77                 if (!strncasecmp(name, uc_priv->bank_name, len)) {
  78                         if (!strict_strtoul(name + len, 10, &offset))
  79                                 break;
  80                 }
  81         }
  82
  83         if (!dev)
  84                 return ret ? ret : -EINVAL;
  85
  86         desc->dev = dev;
  87         desc->offset = offset;
  88
  89         return 0;
  90 }
  91
  92 int gpio_lookup_name(const char *name, struct udevice **devp,
  93                      unsigned int *offsetp, unsigned int *gpiop)
  94 {
  95         struct gpio_desc desc;
  96         int ret;
  97
  98         if (devp)
  99                 *devp = NULL;
 100         ret = dm_gpio_lookup_name(name, &desc);
 101         if (ret)
 102                 return ret;
 103
 104         if (devp)
 105                 *devp = desc.dev;
 106         if (offsetp)
 107                 *offsetp = desc.offset;
 108         if (gpiop) {
 109                 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(desc.dev);
 110
 111                 *gpiop = uc_priv->gpio_base + desc.offset;
 112         }
 113
 114         return 0;
 115 }
 116
 117 int gpio_xlate_offs_flags(struct udevice *dev,
 118                                          struct gpio_desc *desc,
 119                                          struct fdtdec_phandle_args *args)
 120 {
 121         if (args->args_count < 1)
 122                 return -EINVAL;
 123
 124         desc->offset = args->args[0];
 125
 126         if (args->args_count < 2)
 127                 return 0;
 128
 129         if (args->args[1] & GPIO_ACTIVE_LOW)
 130                 desc->flags = GPIOD_ACTIVE_LOW;
 131
 132         return 0;
 133 }
 134
 135 static int gpio_find_and_xlate(struct gpio_desc *desc,
 136                                struct fdtdec_phandle_args *args)
 137 {
 138         struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
 139
 140         if (ops->xlate)
 141                 return ops->xlate(desc->dev, desc, args);
 142         else
 143                 return gpio_xlate_offs_flags(desc->dev, desc, args);
 144 }
 145
 146 int dm_gpio_request(struct gpio_desc *desc, const char *label)
 147 {
 148         struct udevice *dev = desc->dev;
 149         struct gpio_dev_priv *uc_priv;
 150         char *str;
 151         int ret;
 152
 153         uc_priv = dev_get_uclass_priv(dev);
 154         if (uc_priv->name[desc->offset])
 155                 return -EBUSY;
 156         str = strdup(label);
 157         if (!str)
 158                 return -ENOMEM;
 159         if (gpio_get_ops(dev)->request) {
 160                 ret = gpio_get_ops(dev)->request(dev, desc->offset, label);
 161                 if (ret) {
 162                         free(str);
 163                         return ret;
 164                 }
 165         }
 166         uc_priv->name[desc->offset] = str;
 167
 168         return 0;
 169 }
 170
 171 static int dm_gpio_requestf(struct gpio_desc *desc, const char *fmt, ...)
 172 {
 173 #if !defined(CONFIG_SPL_BUILD) || !defined(CONFIG_USE_TINY_PRINTF)
 174         va_list args;
 175         char buf[40];
 176
 177         va_start(args, fmt);
 178         vscnprintf(buf, sizeof(buf), fmt, args);
 179         va_end(args);
 180         return dm_gpio_request(desc, buf);
 181 #else
 182         return dm_gpio_request(desc, fmt);
 183 #endif
 184 }
 185
 186 /**
 187  * gpio_request() - [COMPAT] Request GPIO
 188  * gpio:        GPIO number
 189  * label:       Name for the requested GPIO
 190  *
 191  * The label is copied and allocated so the caller does not need to keep
 192  * the pointer around.
 193  *
 194  * This function implements the API that's compatible with current
 195  * GPIO API used in U-Boot. The request is forwarded to particular
 196  * GPIO driver. Returns 0 on success, negative value on error.
 197  */
 198 int gpio_request(unsigned gpio, const char *label)
 199 {
 200         struct gpio_desc desc;
 201         int ret;
 202
 203         ret = gpio_to_device(gpio, &desc);
 204         if (ret)
 205                 return ret;
 206
 207         return dm_gpio_request(&desc, label);
 208 }
 209
 210 /**
 211  * gpio_requestf() - [COMPAT] Request GPIO
 212  * @gpio:       GPIO number
 213  * @fmt:        Format string for the requested GPIO
 214  * @...:        Arguments for the printf() format string
 215  *
 216  * This function implements the API that's compatible with current
 217  * GPIO API used in U-Boot. The request is forwarded to particular
 218  * GPIO driver. Returns 0 on success, negative value on error.
 219  */
 220 int gpio_requestf(unsigned gpio, const char *fmt, ...)
 221 {
 222 #if !defined(CONFIG_SPL_BUILD) || !defined(CONFIG_USE_TINY_PRINTF)
 223         va_list args;
 224         char buf[40];
 225
 226         va_start(args, fmt);
 227         vscnprintf(buf, sizeof(buf), fmt, args);
 228         va_end(args);
 229         return gpio_request(gpio, buf);
 230 #else
 231         return gpio_request(gpio, fmt);
 232 #endif
 233 }
 234
 235 int _dm_gpio_free(struct udevice *dev, uint offset)
 236 {
 237         struct gpio_dev_priv *uc_priv;
 238         int ret;
 239
 240         uc_priv = dev_get_uclass_priv(dev);
 241         if (!uc_priv->name[offset])
 242                 return -ENXIO;
 243         if (gpio_get_ops(dev)->free) {
 244                 ret = gpio_get_ops(dev)->free(dev, offset);
 245                 if (ret)
 246                         return ret;
 247         }
 248
 249         free(uc_priv->name[offset]);
 250         uc_priv->name[offset] = NULL;
 251
 252         return 0;
 253 }
 254
 255 /**
 256  * gpio_free() - [COMPAT] Relinquish GPIO
 257  * gpio:        GPIO number
 258  *
 259  * This function implements the API that's compatible with current
 260  * GPIO API used in U-Boot. The request is forwarded to particular
 261  * GPIO driver. Returns 0 on success, negative value on error.
 262  */
 263 int gpio_free(unsigned gpio)
 264 {
 265         struct gpio_desc desc;
 266         int ret;
 267
 268         ret = gpio_to_device(gpio, &desc);
 269         if (ret)
 270                 return ret;
 271
 272         return _dm_gpio_free(desc.dev, desc.offset);
 273 }
 274
 275 static int check_reserved(const struct gpio_desc *desc, const char *func)
 276 {
 277         struct gpio_dev_priv *uc_priv;
 278
 279         if (!dm_gpio_is_valid(desc))
 280                 return -ENOENT;
 281
 282         uc_priv = dev_get_uclass_priv(desc->dev);
 283         if (!uc_priv->name[desc->offset]) {
 284                 printf("%s: %s: error: gpio %s%d not reserved\n",
 285                        desc->dev->name, func,
 286                        uc_priv->bank_name ? uc_priv->bank_name : "",
 287                        desc->offset);
 288                 return -EBUSY;
 289         }
 290
 291         return 0;
 292 }
 293
 294 /**
 295  * gpio_direction_input() - [COMPAT] Set GPIO direction to input
 296  * gpio:        GPIO number
 297  *
 298  * This function implements the API that's compatible with current
 299  * GPIO API used in U-Boot. The request is forwarded to particular
 300  * GPIO driver. Returns 0 on success, negative value on error.
 301  */
 302 int gpio_direction_input(unsigned gpio)
 303 {
 304         struct gpio_desc desc;
 305         int ret;
 306
 307         ret = gpio_to_device(gpio, &desc);
 308         if (ret)
 309                 return ret;
 310         ret = check_reserved(&desc, "dir_input");
 311         if (ret)
 312                 return ret;
 313
 314         return gpio_get_ops(desc.dev)->direction_input(desc.dev, desc.offset);
 315 }
 316
 317 /**
 318  * gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value
 319  * gpio:        GPIO number
 320  * value:       Logical value to be set on the GPIO pin
 321  *
 322  * This function implements the API that's compatible with current
 323  * GPIO API used in U-Boot. The request is forwarded to particular
 324  * GPIO driver. Returns 0 on success, negative value on error.
 325  */
 326 int gpio_direction_output(unsigned gpio, int value)
 327 {
 328         struct gpio_desc desc;
 329         int ret;
 330
 331         ret = gpio_to_device(gpio, &desc);
 332         if (ret)
 333                 return ret;
 334         ret = check_reserved(&desc, "dir_output");
 335         if (ret)
 336                 return ret;
 337
 338         return gpio_get_ops(desc.dev)->direction_output(desc.dev,
 339                                                         desc.offset, value);
 340 }
 341
 342 int dm_gpio_get_value(const struct gpio_desc *desc)
 343 {
 344         int value;
 345         int ret;
 346
 347         ret = check_reserved(desc, "get_value");
 348         if (ret)
 349                 return ret;
 350
 351         value = gpio_get_ops(desc->dev)->get_value(desc->dev, desc->offset);
 352
 353         return desc->flags & GPIOD_ACTIVE_LOW ? !value : value;
 354 }
 355
 356 int dm_gpio_set_value(const struct gpio_desc *desc, int value)
 357 {
 358         int ret;
 359
 360         ret = check_reserved(desc, "set_value");
 361         if (ret)
 362                 return ret;
 363
 364         if (desc->flags & GPIOD_ACTIVE_LOW)
 365                 value = !value;
 366         gpio_get_ops(desc->dev)->set_value(desc->dev, desc->offset, value);
 367         return 0;
 368 }
 369
 370 int dm_gpio_get_open_drain(struct gpio_desc *desc)
 371 {
 372         struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
 373         int ret;
 374
 375         ret = check_reserved(desc, "get_open_drain");
 376         if (ret)
 377                 return ret;
 378
 379         if (ops->set_open_drain)
 380                 return ops->get_open_drain(desc->dev, desc->offset);
 381         else
 382                 return -ENOSYS;
 383 }
 384
 385 int dm_gpio_set_open_drain(struct gpio_desc *desc, int value)
 386 {
 387         struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
 388         int ret;
 389
 390         ret = check_reserved(desc, "set_open_drain");
 391         if (ret)
 392                 return ret;
 393
 394         if (ops->set_open_drain)
 395                 ret = ops->set_open_drain(desc->dev, desc->offset, value);
 396         else
 397                 return 0; /* feature not supported -> ignore setting */
 398
 399         return ret;
 400 }
 401
 402 int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags)
 403 {
 404         struct udevice *dev = desc->dev;
 405         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 406         int ret;
 407
 408         ret = check_reserved(desc, "set_dir");
 409         if (ret)
 410                 return ret;
 411
 412         if (flags & GPIOD_IS_OUT) {
 413                 int value = flags & GPIOD_IS_OUT_ACTIVE ? 1 : 0;
 414
 415                 if (flags & GPIOD_ACTIVE_LOW)
 416                         value = !value;
 417                 ret = ops->direction_output(dev, desc->offset, value);
 418         } else  if (flags & GPIOD_IS_IN) {
 419                 ret = ops->direction_input(dev, desc->offset);
 420         }
 421         if (ret)
 422                 return ret;
 423         /*
 424          * Update desc->flags here, so that GPIO_ACTIVE_LOW is honoured in
 425          * futures
 426          */
 427         desc->flags = flags;
 428
 429         return 0;
 430 }
 431
 432 int dm_gpio_set_dir(struct gpio_desc *desc)
 433 {
 434         return dm_gpio_set_dir_flags(desc, desc->flags);
 435 }
 436
 437 /**
 438  * gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value
 439  * gpio:        GPIO number
 440  *
 441  * This function implements the API that's compatible with current
 442  * GPIO API used in U-Boot. The request is forwarded to particular
 443  * GPIO driver. Returns the value of the GPIO pin, or negative value
 444  * on error.
 445  */
 446 int gpio_get_value(unsigned gpio)
 447 {
 448         int ret;
 449
 450         struct gpio_desc desc;
 451
 452         ret = gpio_to_device(gpio, &desc);
 453         if (ret)
 454                 return ret;
 455         return dm_gpio_get_value(&desc);
 456 }
 457
 458 /**
 459  * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin
 460  * gpio:        GPIO number
 461  * value:       Logical value to be set on the GPIO pin.
 462  *
 463  * This function implements the API that's compatible with current
 464  * GPIO API used in U-Boot. The request is forwarded to particular
 465  * GPIO driver. Returns 0 on success, negative value on error.
 466  */
 467 int gpio_set_value(unsigned gpio, int value)
 468 {
 469         struct gpio_desc desc;
 470         int ret;
 471
 472         ret = gpio_to_device(gpio, &desc);
 473         if (ret)
 474                 return ret;
 475         return dm_gpio_set_value(&desc, value);
 476 }
 477
 478 const char *gpio_get_bank_info(struct udevice *dev, int *bit_count)
 479 {
 480         struct gpio_dev_priv *priv;
 481
 482         /* Must be called on an active device */
 483         priv = dev_get_uclass_priv(dev);
 484         assert(priv);
 485
 486         *bit_count = priv->gpio_count;
 487         return priv->bank_name;
 488 }
 489
 490 static const char * const gpio_function[GPIOF_COUNT] = {
 491         "input",
 492         "output",
 493         "unused",
 494         "unknown",
 495         "func",
 496 };
 497
 498 int get_function(struct udevice *dev, int offset, bool skip_unused,
 499                  const char **namep)
 500 {
 501         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 502         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 503
 504         BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 505         if (!device_active(dev))
 506                 return -ENODEV;
 507         if (offset < 0 || offset >= uc_priv->gpio_count)
 508                 return -EINVAL;
 509         if (namep)
 510                 *namep = uc_priv->name[offset];
 511         if (skip_unused && !uc_priv->name[offset])
 512                 return GPIOF_UNUSED;
 513         if (ops->get_function) {
 514                 int ret;
 515
 516                 ret = ops->get_function(dev, offset);
 517                 if (ret < 0)
 518                         return ret;
 519                 if (ret >= ARRAY_SIZE(gpio_function))
 520                         return -ENODATA;
 521                 return ret;
 522         }
 523
 524         return GPIOF_UNKNOWN;
 525 }
 526
 527 int gpio_get_function(struct udevice *dev, int offset, const char **namep)
 528 {
 529         return get_function(dev, offset, true, namep);
 530 }
 531
 532 int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep)
 533 {
 534         return get_function(dev, offset, false, namep);
 535 }
 536
 537 int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
 538 {
 539         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 540         struct gpio_dev_priv *priv;
 541         char *str = buf;
 542         int func;
 543         int ret;
 544         int len;
 545
 546         BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 547
 548         *buf = 0;
 549         priv = dev_get_uclass_priv(dev);
 550         ret = gpio_get_raw_function(dev, offset, NULL);
 551         if (ret < 0)
 552                 return ret;
 553         func = ret;
 554         len = snprintf(str, buffsize, "%s%d: %s",
 555                        priv->bank_name ? priv->bank_name : "",
 556                        offset, gpio_function[func]);
 557         if (func == GPIOF_INPUT || func == GPIOF_OUTPUT ||
 558             func == GPIOF_UNUSED) {
 559                 const char *label;
 560                 bool used;
 561
 562                 ret = ops->get_value(dev, offset);
 563                 if (ret < 0)
 564                         return ret;
 565                 used = gpio_get_function(dev, offset, &label) != GPIOF_UNUSED;
 566                 snprintf(str + len, buffsize - len, ": %d [%c]%s%s",
 567                          ret,
 568                          used ? 'x' : ' ',
 569                          used ? " " : "",
 570                          label ? label : "");
 571         }
 572
 573         return 0;
 574 }
 575
 576 int gpio_claim_vector(const int *gpio_num_array, const char *fmt)
 577 {
 578         int i, ret;
 579         int gpio;
 580
 581         for (i = 0; i < 32; i++) {
 582                 gpio = gpio_num_array[i];
 583                 if (gpio == -1)
 584                         break;
 585                 ret = gpio_requestf(gpio, fmt, i);
 586                 if (ret)
 587                         goto err;
 588                 ret = gpio_direction_input(gpio);
 589                 if (ret) {
 590                         gpio_free(gpio);
 591                         goto err;
 592                 }
 593         }
 594
 595         return 0;
 596 err:
 597         for (i--; i >= 0; i--)
 598                 gpio_free(gpio_num_array[i]);
 599
 600         return ret;
 601 }
 602
 603 /*
 604  * get a number comprised of multiple GPIO values. gpio_num_array points to
 605  * the array of gpio pin numbers to scan, terminated by -1.
 606  */
 607 int gpio_get_values_as_int(const int *gpio_list)
 608 {
 609         int gpio;
 610         unsigned bitmask = 1;
 611         unsigned vector = 0;
 612         int ret;
 613
 614         while (bitmask &&
 615                ((gpio = *gpio_list++) != -1)) {
 616                 ret = gpio_get_value(gpio);
 617                 if (ret < 0)
 618                         return ret;
 619                 else if (ret)
 620                         vector |= bitmask;
 621                 bitmask <<= 1;
 622         }
 623
 624         return vector;
 625 }
 626
 627 int dm_gpio_get_values_as_int(const struct gpio_desc *desc_list, int count)
 628 {
 629         unsigned bitmask = 1;
 630         unsigned vector = 0;
 631         int ret, i;
 632
 633         for (i = 0; i < count; i++) {
 634                 ret = dm_gpio_get_value(&desc_list[i]);
 635                 if (ret < 0)
 636                         return ret;
 637                 else if (ret)
 638                         vector |= bitmask;
 639                 bitmask <<= 1;
 640         }
 641
 642         return vector;
 643 }
 644
 645 static int _gpio_request_by_name_nodev(const void *blob, int node,
 646                                        const char *list_name, int index,
 647                                        struct gpio_desc *desc, int flags,
 648                                        bool add_index)
 649 {
 650         struct fdtdec_phandle_args args;
 651         int ret;
 652
 653         desc->dev = NULL;
 654         desc->offset = 0;
 655         desc->flags = 0;
 656         ret = fdtdec_parse_phandle_with_args(blob, node, list_name,
 657                                              "#gpio-cells", 0, index, &args);
 658         if (ret) {
 659                 debug("%s: fdtdec_parse_phandle_with_args failed\n", __func__);
 660                 goto err;
 661         }
 662
 663         ret = uclass_get_device_by_of_offset(UCLASS_GPIO, args.node,
 664                                              &desc->dev);
 665         if (ret) {
 666                 debug("%s: uclass_get_device_by_of_offset failed\n", __func__);
 667                 goto err;
 668         }
 669         ret = gpio_find_and_xlate(desc, &args);
 670         if (ret) {
 671                 debug("%s: gpio_find_and_xlate failed\n", __func__);
 672                 goto err;
 673         }
 674         ret = dm_gpio_requestf(desc, add_index ? "%s.%s%d" : "%s.%s",
 675                                fdt_get_name(blob, node, NULL),
 676                                list_name, index);
 677         if (ret) {
 678                 debug("%s: dm_gpio_requestf failed\n", __func__);
 679                 goto err;
 680         }
 681         ret = dm_gpio_set_dir_flags(desc, flags | desc->flags);
 682         if (ret) {
 683                 debug("%s: dm_gpio_set_dir failed\n", __func__);
 684                 goto err;
 685         }
 686
 687         return 0;
 688 err:
 689         debug("%s: Node '%s', property '%s', failed to request GPIO index %d: %d\n",
 690               __func__, fdt_get_name(blob, node, NULL), list_name, index, ret);
 691         return ret;
 692 }
 693
 694 int gpio_request_by_name_nodev(const void *blob, int node,
 695                                const char *list_name, int index,
 696                                struct gpio_desc *desc, int flags)
 697 {
 698         return _gpio_request_by_name_nodev(blob, node, list_name, index, desc,
 699                                            flags, index > 0);
 700 }
 701
 702 int gpio_request_by_name(struct udevice *dev,  const char *list_name, int index,
 703                          struct gpio_desc *desc, int flags)
 704 {
 705         /*
 706          * This isn't ideal since we don't use dev->name in the debug()
 707          * calls in gpio_request_by_name(), but we can do this until
 708          * gpio_request_by_name_nodev() can be dropped.
 709          */
 710         return gpio_request_by_name_nodev(gd->fdt_blob, dev_of_offset(dev),
 711                                           list_name, index, desc, flags);
 712 }
 713
 714 int gpio_request_list_by_name_nodev(const void *blob, int node,
 715                                     const char *list_name,
 716                                     struct gpio_desc *desc, int max_count,
 717                                     int flags)
 718 {
 719         int count;
 720         int ret;
 721
 722         for (count = 0; count < max_count; count++) {
 723                 ret = _gpio_request_by_name_nodev(blob, node, list_name, count,
 724                                                   &desc[count], flags, true);
 725                 if (ret == -ENOENT)
 726                         break;
 727                 else if (ret)
 728                         goto err;
 729         }
 730
 731         /* We ran out of GPIOs in the list */
 732         return count;
 733
 734 err:
 735         gpio_free_list_nodev(desc, count - 1);
 736
 737         return ret;
 738 }
 739
 740 int gpio_request_list_by_name(struct udevice *dev, const char *list_name,
 741                               struct gpio_desc *desc, int max_count,
 742                               int flags)
 743 {
 744         /*
 745          * This isn't ideal since we don't use dev->name in the debug()
 746          * calls in gpio_request_by_name(), but we can do this until
 747          * gpio_request_list_by_name_nodev() can be dropped.
 748          */
 749         return gpio_request_list_by_name_nodev(gd->fdt_blob, dev_of_offset(dev),
 750                                                list_name, desc, max_count,
 751                                                flags);
 752 }
 753
 754 int gpio_get_list_count(struct udevice *dev, const char *list_name)
 755 {
 756         int ret;
 757
 758         ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev_of_offset(dev),
 759                                              list_name, "#gpio-cells", 0, -1,
 760                                              NULL);
 761         if (ret) {
 762                 debug("%s: Node '%s', property '%s', GPIO count failed: %d\n",
 763                       __func__, dev->name, list_name, ret);
 764         }
 765
 766         return ret;
 767 }
 768
 769 int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc)
 770 {
 771         /* For now, we don't do any checking of dev */
 772         return _dm_gpio_free(desc->dev, desc->offset);
 773 }
 774
 775 int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count)
 776 {
 777         int i;
 778
 779         /* For now, we don't do any checking of dev */
 780         for (i = 0; i < count; i++)
 781                 dm_gpio_free(dev, &desc[i]);
 782
 783         return 0;
 784 }
 785
 786 int gpio_free_list_nodev(struct gpio_desc *desc, int count)
 787 {
 788         return gpio_free_list(NULL, desc, count);
 789 }
 790
 791 /* We need to renumber the GPIOs when any driver is probed/removed */
 792 static int gpio_renumber(struct udevice *removed_dev)
 793 {
 794         struct gpio_dev_priv *uc_priv;
 795         struct udevice *dev;
 796         struct uclass *uc;
 797         unsigned base;
 798         int ret;
 799
 800         ret = uclass_get(UCLASS_GPIO, &uc);
 801         if (ret)
 802                 return ret;
 803
 804         /* Ensure that we have a base for each bank */
 805         base = 0;
 806         uclass_foreach_dev(dev, uc) {
 807                 if (device_active(dev) && dev != removed_dev) {
 808                         uc_priv = dev_get_uclass_priv(dev);
 809                         uc_priv->gpio_base = base;
 810                         base += uc_priv->gpio_count;
 811                 }
 812         }
 813
 814         return 0;
 815 }
 816
 817 int gpio_get_number(const struct gpio_desc *desc)
 818 {
 819         struct udevice *dev = desc->dev;
 820         struct gpio_dev_priv *uc_priv;
 821
 822         if (!dev)
 823                 return -1;
 824         uc_priv = dev->uclass_priv;
 825
 826         return uc_priv->gpio_base + desc->offset;
 827 }
 828
 829 static int gpio_post_probe(struct udevice *dev)
 830 {
 831         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 832
 833         uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *));
 834         if (!uc_priv->name)
 835                 return -ENOMEM;
 836
 837         return gpio_renumber(NULL);
 838 }
 839
 840 static int gpio_pre_remove(struct udevice *dev)
 841 {
 842         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 843         int i;
 844
 845         for (i = 0; i < uc_priv->gpio_count; i++) {
 846                 if (uc_priv->name[i])
 847                         free(uc_priv->name[i]);
 848         }
 849         free(uc_priv->name);
 850
 851         return gpio_renumber(dev);
 852 }
 853
 854 UCLASS_DRIVER(gpio) = {
 855         .id             = UCLASS_GPIO,
 856         .name           = "gpio",
 857         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 858         .post_probe     = gpio_post_probe,
 859         .pre_remove     = gpio_pre_remove,
 860         .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
 861 };