drivers/gpio/gpio-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013 Google, Inc
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <dm/device_compat.h>
   9 #include <dm/device-internal.h>
  10 #include <dm/lists.h>
  11 #include <dm/uclass-internal.h>
  12 #include <dt-bindings/gpio/gpio.h>
  13 #include <errno.h>
  14 #include <fdtdec.h>
  15 #include <malloc.h>
  16 #include <asm/gpio.h>
  17 #include <linux/bug.h>
  18 #include <linux/ctype.h>
  19
  20 DECLARE_GLOBAL_DATA_PTR;
  21
  22 /**
  23  * gpio_desc_init() - Initialize the GPIO descriptor
  24  *
  25  * @desc:       GPIO descriptor to initialize
  26  * @dev:        GPIO device
  27  * @offset:     Offset of device GPIO
  28  */
  29 static void gpio_desc_init(struct gpio_desc *desc,
  30                            struct udevice *dev,
  31                            uint offset)
  32 {
  33         desc->dev = dev;
  34         desc->offset = offset;
  35         desc->flags = 0;
  36 }
  37
  38 /**
  39  * gpio_to_device() - Convert global GPIO number to device, number
  40  *
  41  * Convert the GPIO number to an entry in the list of GPIOs
  42  * or GPIO blocks registered with the GPIO controller. Returns
  43  * entry on success, NULL on error.
  44  *
  45  * @gpio:       The numeric representation of the GPIO
  46  * @desc:       Returns description (desc->flags will always be 0)
  47  * @return 0 if found, -ENOENT if not found
  48  */
  49 static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc)
  50 {
  51         struct gpio_dev_priv *uc_priv;
  52         struct udevice *dev;
  53         int ret;
  54
  55         for (ret = uclass_first_device(UCLASS_GPIO, &dev);
  56              dev;
  57              ret = uclass_next_device(&dev)) {
  58                 uc_priv = dev_get_uclass_priv(dev);
  59                 if (gpio >= uc_priv->gpio_base &&
  60                     gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
  61                         gpio_desc_init(desc, dev, gpio - uc_priv->gpio_base);
  62                         return 0;
  63                 }
  64         }
  65
  66         /* No such GPIO */
  67         return ret ? ret : -ENOENT;
  68 }
  69
  70 int dm_gpio_lookup_name(const char *name, struct gpio_desc *desc)
  71 {
  72         struct gpio_dev_priv *uc_priv = NULL;
  73         struct udevice *dev;
  74         ulong offset;
  75         int numeric;
  76         int ret;
  77
  78         numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1;
  79         for (ret = uclass_first_device(UCLASS_GPIO, &dev);
  80              dev;
  81              ret = uclass_next_device(&dev)) {
  82                 int len;
  83
  84                 uc_priv = dev_get_uclass_priv(dev);
  85                 if (numeric != -1) {
  86                         offset = numeric - uc_priv->gpio_base;
  87                         /* Allow GPIOs to be numbered from 0 */
  88                         if (offset < uc_priv->gpio_count)
  89                                 break;
  90                 }
  91
  92                 len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0;
  93
  94                 if (!strncasecmp(name, uc_priv->bank_name, len)) {
  95                         if (!strict_strtoul(name + len, 10, &offset))
  96                                 break;
  97                 }
  98         }
  99
 100         if (!dev)
 101                 return ret ? ret : -EINVAL;
 102
 103         gpio_desc_init(desc, dev, offset);
 104
 105         return 0;
 106 }
 107
 108 int gpio_lookup_name(const char *name, struct udevice **devp,
 109                      unsigned int *offsetp, unsigned int *gpiop)
 110 {
 111         struct gpio_desc desc;
 112         int ret;
 113
 114         if (devp)
 115                 *devp = NULL;
 116         ret = dm_gpio_lookup_name(name, &desc);
 117         if (ret)
 118                 return ret;
 119
 120         if (devp)
 121                 *devp = desc.dev;
 122         if (offsetp)
 123                 *offsetp = desc.offset;
 124         if (gpiop) {
 125                 struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(desc.dev);
 126
 127                 *gpiop = uc_priv->gpio_base + desc.offset;
 128         }
 129
 130         return 0;
 131 }
 132
 133 int gpio_xlate_offs_flags(struct udevice *dev, struct gpio_desc *desc,
 134                           struct ofnode_phandle_args *args)
 135 {
 136         if (args->args_count < 1)
 137                 return -EINVAL;
 138
 139         desc->offset = args->args[0];
 140
 141         if (args->args_count < 2)
 142                 return 0;
 143
 144         desc->flags = 0;
 145         if (args->args[1] & GPIO_ACTIVE_LOW)
 146                 desc->flags |= GPIOD_ACTIVE_LOW;
 147
 148         /*
 149          * need to test 2 bits for gpio output binding:
 150          * OPEN_DRAIN (0x6) = SINGLE_ENDED (0x2) | LINE_OPEN_DRAIN (0x4)
 151          * OPEN_SOURCE (0x2) = SINGLE_ENDED (0x2) | LINE_OPEN_SOURCE (0x0)
 152          */
 153         if (args->args[1] & GPIO_SINGLE_ENDED) {
 154                 if (args->args[1] & GPIO_LINE_OPEN_DRAIN)
 155                         desc->flags |= GPIOD_OPEN_DRAIN;
 156                 else
 157                         desc->flags |= GPIOD_OPEN_SOURCE;
 158         }
 159
 160         if (args->args[1] & GPIO_PULL_UP)
 161                 desc->flags |= GPIOD_PULL_UP;
 162
 163         if (args->args[1] & GPIO_PULL_DOWN)
 164                 desc->flags |= GPIOD_PULL_DOWN;
 165
 166         return 0;
 167 }
 168
 169 static int gpio_find_and_xlate(struct gpio_desc *desc,
 170                                struct ofnode_phandle_args *args)
 171 {
 172         struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
 173
 174         if (ops->xlate)
 175                 return ops->xlate(desc->dev, desc, args);
 176         else
 177                 return gpio_xlate_offs_flags(desc->dev, desc, args);
 178 }
 179
 180 #if defined(CONFIG_GPIO_HOG)
 181
 182 struct gpio_hog_priv {
 183         struct gpio_desc gpiod;
 184 };
 185
 186 struct gpio_hog_data {
 187         int gpiod_flags;
 188         int value;
 189         u32 val[2];
 190 };
 191
 192 static int gpio_hog_ofdata_to_platdata(struct udevice *dev)
 193 {
 194         struct gpio_hog_data *plat = dev_get_platdata(dev);
 195         const char *nodename;
 196         int ret;
 197
 198         plat->value = 0;
 199         if (dev_read_bool(dev, "input")) {
 200                 plat->gpiod_flags = GPIOD_IS_IN;
 201         } else if (dev_read_bool(dev, "output-high")) {
 202                 plat->value = 1;
 203                 plat->gpiod_flags = GPIOD_IS_OUT;
 204         } else if (dev_read_bool(dev, "output-low")) {
 205                 plat->gpiod_flags = GPIOD_IS_OUT;
 206         } else {
 207                 printf("%s: missing gpio-hog state.\n", __func__);
 208                 return -EINVAL;
 209         }
 210         ret = dev_read_u32_array(dev, "gpios", plat->val, 2);
 211         if (ret) {
 212                 printf("%s: wrong gpios property, 2 values needed %d\n",
 213                        __func__, ret);
 214                 return ret;
 215         }
 216         nodename = dev_read_string(dev, "line-name");
 217         if (nodename)
 218                 device_set_name(dev, nodename);
 219
 220         return 0;
 221 }
 222
 223 static int gpio_hog_probe(struct udevice *dev)
 224 {
 225         struct gpio_hog_data *plat = dev_get_platdata(dev);
 226         struct gpio_hog_priv *priv = dev_get_priv(dev);
 227         int ret;
 228
 229         ret = gpio_dev_request_index(dev->parent, dev->name, "gpio-hog",
 230                                      plat->val[0], plat->gpiod_flags,
 231                                      plat->val[1], &priv->gpiod);
 232         if (ret < 0) {
 233                 debug("%s: node %s could not get gpio.\n", __func__,
 234                       dev->name);
 235                 return ret;
 236         }
 237
 238         if (plat->gpiod_flags == GPIOD_IS_OUT) {
 239                 ret = dm_gpio_set_value(&priv->gpiod, plat->value);
 240                 if (ret < 0) {
 241                         debug("%s: node %s could not set gpio.\n", __func__,
 242                               dev->name);
 243                         return ret;
 244                 }
 245         }
 246
 247         return 0;
 248 }
 249
 250 int gpio_hog_probe_all(void)
 251 {
 252         struct udevice *dev;
 253         int ret;
 254         int retval = 0;
 255
 256         for (uclass_first_device(UCLASS_NOP, &dev);
 257              dev;
 258              uclass_find_next_device(&dev)) {
 259                 if (dev->driver == DM_GET_DRIVER(gpio_hog)) {
 260                         ret = device_probe(dev);
 261                         if (ret) {
 262                                 printf("Failed to probe device %s err: %d\n",
 263                                        dev->name, ret);
 264                                 retval = ret;
 265                         }
 266                 }
 267         }
 268
 269         return retval;
 270 }
 271
 272 int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc)
 273 {
 274         struct udevice *dev;
 275
 276         *desc = NULL;
 277         gpio_hog_probe_all();
 278         if (!uclass_get_device_by_name(UCLASS_NOP, name, &dev)) {
 279                 struct gpio_hog_priv *priv = dev_get_priv(dev);
 280
 281                 *desc = &priv->gpiod;
 282                 return 0;
 283         }
 284
 285         return -ENODEV;
 286 }
 287
 288 U_BOOT_DRIVER(gpio_hog) = {
 289         .name   = "gpio_hog",
 290         .id     = UCLASS_NOP,
 291         .ofdata_to_platdata = gpio_hog_ofdata_to_platdata,
 292         .probe = gpio_hog_probe,
 293         .priv_auto_alloc_size = sizeof(struct gpio_hog_priv),
 294         .platdata_auto_alloc_size = sizeof(struct gpio_hog_data),
 295 };
 296 #else
 297 int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc)
 298 {
 299         return 0;
 300 }
 301 #endif
 302
 303 int dm_gpio_request(struct gpio_desc *desc, const char *label)
 304 {
 305         struct udevice *dev = desc->dev;
 306         struct gpio_dev_priv *uc_priv;
 307         char *str;
 308         int ret;
 309
 310         uc_priv = dev_get_uclass_priv(dev);
 311         if (uc_priv->name[desc->offset])
 312                 return -EBUSY;
 313         str = strdup(label);
 314         if (!str)
 315                 return -ENOMEM;
 316         if (gpio_get_ops(dev)->request) {
 317                 ret = gpio_get_ops(dev)->request(dev, desc->offset, label);
 318                 if (ret) {
 319                         free(str);
 320                         return ret;
 321                 }
 322         }
 323         uc_priv->name[desc->offset] = str;
 324
 325         return 0;
 326 }
 327
 328 static int dm_gpio_requestf(struct gpio_desc *desc, const char *fmt, ...)
 329 {
 330 #if !defined(CONFIG_SPL_BUILD) || !CONFIG_IS_ENABLED(USE_TINY_PRINTF)
 331         va_list args;
 332         char buf[40];
 333
 334         va_start(args, fmt);
 335         vscnprintf(buf, sizeof(buf), fmt, args);
 336         va_end(args);
 337         return dm_gpio_request(desc, buf);
 338 #else
 339         return dm_gpio_request(desc, fmt);
 340 #endif
 341 }
 342
 343 /**
 344  * gpio_request() - [COMPAT] Request GPIO
 345  * gpio:        GPIO number
 346  * label:       Name for the requested GPIO
 347  *
 348  * The label is copied and allocated so the caller does not need to keep
 349  * the pointer around.
 350  *
 351  * This function implements the API that's compatible with current
 352  * GPIO API used in U-Boot. The request is forwarded to particular
 353  * GPIO driver. Returns 0 on success, negative value on error.
 354  */
 355 int gpio_request(unsigned gpio, const char *label)
 356 {
 357         struct gpio_desc desc;
 358         int ret;
 359
 360         ret = gpio_to_device(gpio, &desc);
 361         if (ret)
 362                 return ret;
 363
 364         return dm_gpio_request(&desc, label);
 365 }
 366
 367 /**
 368  * gpio_requestf() - [COMPAT] Request GPIO
 369  * @gpio:       GPIO number
 370  * @fmt:        Format string for the requested GPIO
 371  * @...:        Arguments for the printf() format string
 372  *
 373  * This function implements the API that's compatible with current
 374  * GPIO API used in U-Boot. The request is forwarded to particular
 375  * GPIO driver. Returns 0 on success, negative value on error.
 376  */
 377 int gpio_requestf(unsigned gpio, const char *fmt, ...)
 378 {
 379 #if !defined(CONFIG_SPL_BUILD) || !CONFIG_IS_ENABLED(USE_TINY_PRINTF)
 380         va_list args;
 381         char buf[40];
 382
 383         va_start(args, fmt);
 384         vscnprintf(buf, sizeof(buf), fmt, args);
 385         va_end(args);
 386         return gpio_request(gpio, buf);
 387 #else
 388         return gpio_request(gpio, fmt);
 389 #endif
 390 }
 391
 392 int _dm_gpio_free(struct udevice *dev, uint offset)
 393 {
 394         struct gpio_dev_priv *uc_priv;
 395         int ret;
 396
 397         uc_priv = dev_get_uclass_priv(dev);
 398         if (!uc_priv->name[offset])
 399                 return -ENXIO;
 400         if (gpio_get_ops(dev)->rfree) {
 401                 ret = gpio_get_ops(dev)->rfree(dev, offset);
 402                 if (ret)
 403                         return ret;
 404         }
 405
 406         free(uc_priv->name[offset]);
 407         uc_priv->name[offset] = NULL;
 408
 409         return 0;
 410 }
 411
 412 /**
 413  * gpio_free() - [COMPAT] Relinquish GPIO
 414  * gpio:        GPIO number
 415  *
 416  * This function implements the API that's compatible with current
 417  * GPIO API used in U-Boot. The request is forwarded to particular
 418  * GPIO driver. Returns 0 on success, negative value on error.
 419  */
 420 int gpio_free(unsigned gpio)
 421 {
 422         struct gpio_desc desc;
 423         int ret;
 424
 425         ret = gpio_to_device(gpio, &desc);
 426         if (ret)
 427                 return ret;
 428
 429         return _dm_gpio_free(desc.dev, desc.offset);
 430 }
 431
 432 static int check_reserved(const struct gpio_desc *desc, const char *func)
 433 {
 434         struct gpio_dev_priv *uc_priv;
 435
 436         if (!dm_gpio_is_valid(desc))
 437                 return -ENOENT;
 438
 439         uc_priv = dev_get_uclass_priv(desc->dev);
 440         if (!uc_priv->name[desc->offset]) {
 441                 printf("%s: %s: error: gpio %s%d not reserved\n",
 442                        desc->dev->name, func,
 443                        uc_priv->bank_name ? uc_priv->bank_name : "",
 444                        desc->offset);
 445                 return -EBUSY;
 446         }
 447
 448         return 0;
 449 }
 450
 451 /**
 452  * gpio_direction_input() - [COMPAT] Set GPIO direction to input
 453  * gpio:        GPIO number
 454  *
 455  * This function implements the API that's compatible with current
 456  * GPIO API used in U-Boot. The request is forwarded to particular
 457  * GPIO driver. Returns 0 on success, negative value on error.
 458  */
 459 int gpio_direction_input(unsigned gpio)
 460 {
 461         struct gpio_desc desc;
 462         int ret;
 463
 464         ret = gpio_to_device(gpio, &desc);
 465         if (ret)
 466                 return ret;
 467         ret = check_reserved(&desc, "dir_input");
 468         if (ret)
 469                 return ret;
 470
 471         return gpio_get_ops(desc.dev)->direction_input(desc.dev, desc.offset);
 472 }
 473
 474 /**
 475  * gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value
 476  * gpio:        GPIO number
 477  * value:       Logical value to be set on the GPIO pin
 478  *
 479  * This function implements the API that's compatible with current
 480  * GPIO API used in U-Boot. The request is forwarded to particular
 481  * GPIO driver. Returns 0 on success, negative value on error.
 482  */
 483 int gpio_direction_output(unsigned gpio, int value)
 484 {
 485         struct gpio_desc desc;
 486         int ret;
 487
 488         ret = gpio_to_device(gpio, &desc);
 489         if (ret)
 490                 return ret;
 491         ret = check_reserved(&desc, "dir_output");
 492         if (ret)
 493                 return ret;
 494
 495         return gpio_get_ops(desc.dev)->direction_output(desc.dev,
 496                                                         desc.offset, value);
 497 }
 498
 499 static int _gpio_get_value(const struct gpio_desc *desc)
 500 {
 501         int value;
 502
 503         value = gpio_get_ops(desc->dev)->get_value(desc->dev, desc->offset);
 504
 505         return desc->flags & GPIOD_ACTIVE_LOW ? !value : value;
 506 }
 507
 508 int dm_gpio_get_value(const struct gpio_desc *desc)
 509 {
 510         int ret;
 511
 512         ret = check_reserved(desc, "get_value");
 513         if (ret)
 514                 return ret;
 515
 516         return _gpio_get_value(desc);
 517 }
 518
 519 int dm_gpio_set_value(const struct gpio_desc *desc, int value)
 520 {
 521         int ret;
 522
 523         ret = check_reserved(desc, "set_value");
 524         if (ret)
 525                 return ret;
 526
 527         if (desc->flags & GPIOD_ACTIVE_LOW)
 528                 value = !value;
 529         gpio_get_ops(desc->dev)->set_value(desc->dev, desc->offset, value);
 530         return 0;
 531 }
 532
 533 /* check dir flags invalid configuration */
 534 static int check_dir_flags(ulong flags)
 535 {
 536         if ((flags & GPIOD_IS_OUT) && (flags & GPIOD_IS_IN)) {
 537                 log_debug("%s: flags 0x%lx has GPIOD_IS_OUT and GPIOD_IS_IN\n",
 538                           __func__, flags);
 539                 return -EINVAL;
 540         }
 541
 542         if ((flags & GPIOD_PULL_UP) && (flags & GPIOD_PULL_DOWN)) {
 543                 log_debug("%s: flags 0x%lx has GPIOD_PULL_UP and GPIOD_PULL_DOWN\n",
 544                           __func__, flags);
 545                 return -EINVAL;
 546         }
 547
 548         if ((flags & GPIOD_OPEN_DRAIN) && (flags & GPIOD_OPEN_SOURCE)) {
 549                 log_debug("%s: flags 0x%lx has GPIOD_OPEN_DRAIN and GPIOD_OPEN_SOURCE\n",
 550                           __func__, flags);
 551                 return -EINVAL;
 552         }
 553
 554         return 0;
 555 }
 556
 557 static int _dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags)
 558 {
 559         struct udevice *dev = desc->dev;
 560         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 561         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 562         int ret = 0;
 563
 564         ret = check_dir_flags(flags);
 565         if (ret) {
 566                 dev_dbg(dev,
 567                         "%s error: set_dir_flags for gpio %s%d has invalid dir flags 0x%lx\n",
 568                         desc->dev->name,
 569                         uc_priv->bank_name ? uc_priv->bank_name : "",
 570                         desc->offset, flags);
 571
 572                 return ret;
 573         }
 574
 575         /* GPIOD_ are directly managed by driver in set_dir_flags*/
 576         if (ops->set_dir_flags) {
 577                 ret = ops->set_dir_flags(dev, desc->offset, flags);
 578         } else {
 579                 if (flags & GPIOD_IS_OUT) {
 580                         ret = ops->direction_output(dev, desc->offset,
 581                                                     GPIOD_FLAGS_OUTPUT(flags));
 582                 } else if (flags & GPIOD_IS_IN) {
 583                         ret = ops->direction_input(dev, desc->offset);
 584                 }
 585         }
 586
 587         return ret;
 588 }
 589
 590 int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags)
 591 {
 592         int ret;
 593
 594         ret = check_reserved(desc, "set_dir_flags");
 595         if (ret)
 596                 return ret;
 597
 598         /* combine the requested flags (for IN/OUT) and the descriptor flags */
 599         flags |= desc->flags;
 600         ret = _dm_gpio_set_dir_flags(desc, flags);
 601
 602         /* update the descriptor flags */
 603         if (ret)
 604                 desc->flags = flags;
 605
 606         return ret;
 607 }
 608
 609 int dm_gpio_set_dir(struct gpio_desc *desc)
 610 {
 611         int ret;
 612
 613         ret = check_reserved(desc, "set_dir");
 614         if (ret)
 615                 return ret;
 616
 617         return _dm_gpio_set_dir_flags(desc, desc->flags);
 618 }
 619
 620 int dm_gpio_get_dir_flags(struct gpio_desc *desc, ulong *flags)
 621 {
 622         struct udevice *dev = desc->dev;
 623         int ret, value;
 624         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 625         ulong dir_flags;
 626
 627         ret = check_reserved(desc, "get_dir_flags");
 628         if (ret)
 629                 return ret;
 630
 631         /* GPIOD_ are directly provided by driver except GPIOD_ACTIVE_LOW */
 632         if (ops->get_dir_flags) {
 633                 ret = ops->get_dir_flags(dev, desc->offset, &dir_flags);
 634                 if (ret)
 635                         return ret;
 636
 637                 /* GPIOD_ACTIVE_LOW is saved in desc->flags */
 638                 value = dir_flags & GPIOD_IS_OUT_ACTIVE ? 1 : 0;
 639                 if (desc->flags & GPIOD_ACTIVE_LOW)
 640                         value = !value;
 641                 dir_flags &= ~(GPIOD_ACTIVE_LOW | GPIOD_IS_OUT_ACTIVE);
 642                 dir_flags |= (desc->flags & GPIOD_ACTIVE_LOW);
 643                 if (value)
 644                         dir_flags |= GPIOD_IS_OUT_ACTIVE;
 645         } else {
 646                 dir_flags = desc->flags;
 647                 /* only GPIOD_IS_OUT_ACTIVE is provided by uclass */
 648                 dir_flags &= ~GPIOD_IS_OUT_ACTIVE;
 649                 if ((desc->flags & GPIOD_IS_OUT) && _gpio_get_value(desc))
 650                         dir_flags |= GPIOD_IS_OUT_ACTIVE;
 651         }
 652         *flags = dir_flags;
 653
 654         return 0;
 655 }
 656
 657 /**
 658  * gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value
 659  * gpio:        GPIO number
 660  *
 661  * This function implements the API that's compatible with current
 662  * GPIO API used in U-Boot. The request is forwarded to particular
 663  * GPIO driver. Returns the value of the GPIO pin, or negative value
 664  * on error.
 665  */
 666 int gpio_get_value(unsigned gpio)
 667 {
 668         int ret;
 669
 670         struct gpio_desc desc;
 671
 672         ret = gpio_to_device(gpio, &desc);
 673         if (ret)
 674                 return ret;
 675         return dm_gpio_get_value(&desc);
 676 }
 677
 678 /**
 679  * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin
 680  * gpio:        GPIO number
 681  * value:       Logical value to be set on the GPIO pin.
 682  *
 683  * This function implements the API that's compatible with current
 684  * GPIO API used in U-Boot. The request is forwarded to particular
 685  * GPIO driver. Returns 0 on success, negative value on error.
 686  */
 687 int gpio_set_value(unsigned gpio, int value)
 688 {
 689         struct gpio_desc desc;
 690         int ret;
 691
 692         ret = gpio_to_device(gpio, &desc);
 693         if (ret)
 694                 return ret;
 695         return dm_gpio_set_value(&desc, value);
 696 }
 697
 698 const char *gpio_get_bank_info(struct udevice *dev, int *bit_count)
 699 {
 700         struct gpio_dev_priv *priv;
 701
 702         /* Must be called on an active device */
 703         priv = dev_get_uclass_priv(dev);
 704         assert(priv);
 705
 706         *bit_count = priv->gpio_count;
 707         return priv->bank_name;
 708 }
 709
 710 static const char * const gpio_function[GPIOF_COUNT] = {
 711         "input",
 712         "output",
 713         "unused",
 714         "unknown",
 715         "func",
 716 };
 717
 718 static int get_function(struct udevice *dev, int offset, bool skip_unused,
 719                         const char **namep)
 720 {
 721         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 722         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 723
 724         BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 725         if (!device_active(dev))
 726                 return -ENODEV;
 727         if (offset < 0 || offset >= uc_priv->gpio_count)
 728                 return -EINVAL;
 729         if (namep)
 730                 *namep = uc_priv->name[offset];
 731         if (skip_unused && !uc_priv->name[offset])
 732                 return GPIOF_UNUSED;
 733         if (ops->get_function) {
 734                 int ret;
 735
 736                 ret = ops->get_function(dev, offset);
 737                 if (ret < 0)
 738                         return ret;
 739                 if (ret >= ARRAY_SIZE(gpio_function))
 740                         return -ENODATA;
 741                 return ret;
 742         }
 743
 744         return GPIOF_UNKNOWN;
 745 }
 746
 747 int gpio_get_function(struct udevice *dev, int offset, const char **namep)
 748 {
 749         return get_function(dev, offset, true, namep);
 750 }
 751
 752 int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep)
 753 {
 754         return get_function(dev, offset, false, namep);
 755 }
 756
 757 int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
 758 {
 759         struct dm_gpio_ops *ops = gpio_get_ops(dev);
 760         struct gpio_dev_priv *priv;
 761         char *str = buf;
 762         int func;
 763         int ret;
 764         int len;
 765
 766         BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 767
 768         *buf = 0;
 769         priv = dev_get_uclass_priv(dev);
 770         ret = gpio_get_raw_function(dev, offset, NULL);
 771         if (ret < 0)
 772                 return ret;
 773         func = ret;
 774         len = snprintf(str, buffsize, "%s%d: %s",
 775                        priv->bank_name ? priv->bank_name : "",
 776                        offset, gpio_function[func]);
 777         if (func == GPIOF_INPUT || func == GPIOF_OUTPUT ||
 778             func == GPIOF_UNUSED) {
 779                 const char *label;
 780                 bool used;
 781
 782                 ret = ops->get_value(dev, offset);
 783                 if (ret < 0)
 784                         return ret;
 785                 used = gpio_get_function(dev, offset, &label) != GPIOF_UNUSED;
 786                 snprintf(str + len, buffsize - len, ": %d [%c]%s%s",
 787                          ret,
 788                          used ? 'x' : ' ',
 789                          used ? " " : "",
 790                          label ? label : "");
 791         }
 792
 793         return 0;
 794 }
 795
 796 int gpio_claim_vector(const int *gpio_num_array, const char *fmt)
 797 {
 798         int i, ret;
 799         int gpio;
 800
 801         for (i = 0; i < 32; i++) {
 802                 gpio = gpio_num_array[i];
 803                 if (gpio == -1)
 804                         break;
 805                 ret = gpio_requestf(gpio, fmt, i);
 806                 if (ret)
 807                         goto err;
 808                 ret = gpio_direction_input(gpio);
 809                 if (ret) {
 810                         gpio_free(gpio);
 811                         goto err;
 812                 }
 813         }
 814
 815         return 0;
 816 err:
 817         for (i--; i >= 0; i--)
 818                 gpio_free(gpio_num_array[i]);
 819
 820         return ret;
 821 }
 822
 823 /*
 824  * get a number comprised of multiple GPIO values. gpio_num_array points to
 825  * the array of gpio pin numbers to scan, terminated by -1.
 826  */
 827 int gpio_get_values_as_int(const int *gpio_list)
 828 {
 829         int gpio;
 830         unsigned bitmask = 1;
 831         unsigned vector = 0;
 832         int ret;
 833
 834         while (bitmask &&
 835                ((gpio = *gpio_list++) != -1)) {
 836                 ret = gpio_get_value(gpio);
 837                 if (ret < 0)
 838                         return ret;
 839                 else if (ret)
 840                         vector |= bitmask;
 841                 bitmask <<= 1;
 842         }
 843
 844         return vector;
 845 }
 846
 847 int dm_gpio_get_values_as_int(const struct gpio_desc *desc_list, int count)
 848 {
 849         unsigned bitmask = 1;
 850         unsigned vector = 0;
 851         int ret, i;
 852
 853         for (i = 0; i < count; i++) {
 854                 ret = dm_gpio_get_value(&desc_list[i]);
 855                 if (ret < 0)
 856                         return ret;
 857                 else if (ret)
 858                         vector |= bitmask;
 859                 bitmask <<= 1;
 860         }
 861
 862         return vector;
 863 }
 864
 865 /**
 866  * gpio_request_tail: common work for requesting a gpio.
 867  *
 868  * ret:         return value from previous work in function which calls
 869  *              this function.
 870  *              This seems bogus (why calling this function instead not
 871  *              calling it and end caller function instead?).
 872  *              Because on error in caller function we want to set some
 873  *              default values in gpio desc and have a common error
 874  *              debug message, which provides this function.
 875  * nodename:    Name of node for which gpio gets requested
 876  *              used for gpio label name.
 877  * args:        pointer to output arguments structure
 878  * list_name:   Name of GPIO list
 879  *              used for gpio label name.
 880  * index:       gpio index in gpio list
 881  *              used for gpio label name.
 882  * desc:        pointer to gpio descriptor, filled from this
 883  *              function.
 884  * flags:       gpio flags to use.
 885  * add_index:   should index added to gpio label name
 886  * gpio_dev:    pointer to gpio device from which the gpio
 887  *              will be requested. If NULL try to get the
 888  *              gpio device with uclass_get_device_by_ofnode()
 889  *
 890  * return:      In error case this function sets default values in
 891  *              gpio descriptor, also emmits a debug message.
 892  *              On success it returns 0 else the error code from
 893  *              function calls, or the error code passed through
 894  *              ret to this function.
 895  *
 896  */
 897 static int gpio_request_tail(int ret, const char *nodename,
 898                              struct ofnode_phandle_args *args,
 899                              const char *list_name, int index,
 900                              struct gpio_desc *desc, int flags,
 901                              bool add_index, struct udevice *gpio_dev)
 902 {
 903         gpio_desc_init(desc, gpio_dev, 0);
 904         if (ret)
 905                 goto err;
 906
 907         if (!desc->dev) {
 908                 ret = uclass_get_device_by_ofnode(UCLASS_GPIO, args->node,
 909                                                   &desc->dev);
 910                 if (ret) {
 911                         debug("%s: uclass_get_device_by_ofnode failed\n",
 912                               __func__);
 913                         goto err;
 914                 }
 915         }
 916         ret = gpio_find_and_xlate(desc, args);
 917         if (ret) {
 918                 debug("%s: gpio_find_and_xlate failed\n", __func__);
 919                 goto err;
 920         }
 921         ret = dm_gpio_requestf(desc, add_index ? "%s.%s%d" : "%s.%s",
 922                                nodename, list_name, index);
 923         if (ret) {
 924                 debug("%s: dm_gpio_requestf failed\n", __func__);
 925                 goto err;
 926         }
 927         ret = dm_gpio_set_dir_flags(desc, flags);
 928         if (ret) {
 929                 debug("%s: dm_gpio_set_dir failed\n", __func__);
 930                 goto err;
 931         }
 932
 933         return 0;
 934 err:
 935         debug("%s: Node '%s', property '%s', failed to request GPIO index %d: %d\n",
 936               __func__, nodename, list_name, index, ret);
 937         return ret;
 938 }
 939
 940 static int _gpio_request_by_name_nodev(ofnode node, const char *list_name,
 941                                        int index, struct gpio_desc *desc,
 942                                        int flags, bool add_index)
 943 {
 944         struct ofnode_phandle_args args;
 945         int ret;
 946
 947         ret = ofnode_parse_phandle_with_args(node, list_name, "#gpio-cells", 0,
 948                                              index, &args);
 949
 950         return gpio_request_tail(ret, ofnode_get_name(node), &args, list_name,
 951                                  index, desc, flags, add_index, NULL);
 952 }
 953
 954 int gpio_request_by_name_nodev(ofnode node, const char *list_name, int index,
 955                                struct gpio_desc *desc, int flags)
 956 {
 957         return _gpio_request_by_name_nodev(node, list_name, index, desc, flags,
 958                                            index > 0);
 959 }
 960
 961 int gpio_request_by_name(struct udevice *dev, const char *list_name, int index,
 962                          struct gpio_desc *desc, int flags)
 963 {
 964         struct ofnode_phandle_args args;
 965         ofnode node;
 966         int ret;
 967
 968         ret = dev_read_phandle_with_args(dev, list_name, "#gpio-cells", 0,
 969                                          index, &args);
 970         node = dev_ofnode(dev);
 971         return gpio_request_tail(ret, ofnode_get_name(node), &args, list_name,
 972                                  index, desc, flags, index > 0, NULL);
 973 }
 974
 975 int gpio_request_list_by_name_nodev(ofnode node, const char *list_name,
 976                                     struct gpio_desc *desc, int max_count,
 977                                     int flags)
 978 {
 979         int count;
 980         int ret;
 981
 982         for (count = 0; count < max_count; count++) {
 983                 ret = _gpio_request_by_name_nodev(node, list_name, count,
 984                                                   &desc[count], flags, true);
 985                 if (ret == -ENOENT)
 986                         break;
 987                 else if (ret)
 988                         goto err;
 989         }
 990
 991         /* We ran out of GPIOs in the list */
 992         return count;
 993
 994 err:
 995         gpio_free_list_nodev(desc, count - 1);
 996
 997         return ret;
 998 }
 999
1000 int gpio_request_list_by_name(struct udevice *dev, const char *list_name,
1001                               struct gpio_desc *desc, int max_count,
1002                               int flags)
1003 {
1004         /*
1005          * This isn't ideal since we don't use dev->name in the debug()
1006          * calls in gpio_request_by_name(), but we can do this until
1007          * gpio_request_list_by_name_nodev() can be dropped.
1008          */
1009         return gpio_request_list_by_name_nodev(dev_ofnode(dev), list_name, desc,
1010                                                max_count, flags);
1011 }
1012
1013 int gpio_get_list_count(struct udevice *dev, const char *list_name)
1014 {
1015         int ret;
1016
1017         ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev_of_offset(dev),
1018                                              list_name, "#gpio-cells", 0, -1,
1019                                              NULL);
1020         if (ret) {
1021                 debug("%s: Node '%s', property '%s', GPIO count failed: %d\n",
1022                       __func__, dev->name, list_name, ret);
1023         }
1024
1025         return ret;
1026 }
1027
1028 int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc)
1029 {
1030         /* For now, we don't do any checking of dev */
1031         return _dm_gpio_free(desc->dev, desc->offset);
1032 }
1033
1034 int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count)
1035 {
1036         int i;
1037
1038         /* For now, we don't do any checking of dev */
1039         for (i = 0; i < count; i++)
1040                 dm_gpio_free(dev, &desc[i]);
1041
1042         return 0;
1043 }
1044
1045 int gpio_free_list_nodev(struct gpio_desc *desc, int count)
1046 {
1047         return gpio_free_list(NULL, desc, count);
1048 }
1049
1050 /* We need to renumber the GPIOs when any driver is probed/removed */
1051 static int gpio_renumber(struct udevice *removed_dev)
1052 {
1053         struct gpio_dev_priv *uc_priv;
1054         struct udevice *dev;
1055         struct uclass *uc;
1056         unsigned base;
1057         int ret;
1058
1059         ret = uclass_get(UCLASS_GPIO, &uc);
1060         if (ret)
1061                 return ret;
1062
1063         /* Ensure that we have a base for each bank */
1064         base = 0;
1065         uclass_foreach_dev(dev, uc) {
1066                 if (device_active(dev) && dev != removed_dev) {
1067                         uc_priv = dev_get_uclass_priv(dev);
1068                         uc_priv->gpio_base = base;
1069                         base += uc_priv->gpio_count;
1070                 }
1071         }
1072
1073         return 0;
1074 }
1075
1076 int gpio_get_number(const struct gpio_desc *desc)
1077 {
1078         struct udevice *dev = desc->dev;
1079         struct gpio_dev_priv *uc_priv;
1080
1081         if (!dev)
1082                 return -1;
1083         uc_priv = dev->uclass_priv;
1084
1085         return uc_priv->gpio_base + desc->offset;
1086 }
1087
1088 static int gpio_post_probe(struct udevice *dev)
1089 {
1090         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
1091
1092         uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *));
1093         if (!uc_priv->name)
1094                 return -ENOMEM;
1095
1096         return gpio_renumber(NULL);
1097 }
1098
1099 static int gpio_pre_remove(struct udevice *dev)
1100 {
1101         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
1102         int i;
1103
1104         for (i = 0; i < uc_priv->gpio_count; i++) {
1105                 if (uc_priv->name[i])
1106                         free(uc_priv->name[i]);
1107         }
1108         free(uc_priv->name);
1109
1110         return gpio_renumber(dev);
1111 }
1112
1113 int gpio_dev_request_index(struct udevice *dev, const char *nodename,
1114                            char *list_name, int index, int flags,
1115                            int dtflags, struct gpio_desc *desc)
1116 {
1117         struct ofnode_phandle_args args;
1118
1119         args.node =  ofnode_null();
1120         args.args_count = 2;
1121         args.args[0] = index;
1122         args.args[1] = dtflags;
1123
1124         return gpio_request_tail(0, nodename, &args, list_name, index, desc,
1125                                  flags, 0, dev);
1126 }
1127
1128 static int gpio_post_bind(struct udevice *dev)
1129 {
1130         struct udevice *child;
1131         ofnode node;
1132
1133 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
1134         struct dm_gpio_ops *ops = (struct dm_gpio_ops *)device_get_ops(dev);
1135         static int reloc_done;
1136
1137         if (!reloc_done) {
1138                 if (ops->request)
1139                         ops->request += gd->reloc_off;
1140                 if (ops->rfree)
1141                         ops->rfree += gd->reloc_off;
1142                 if (ops->direction_input)
1143                         ops->direction_input += gd->reloc_off;
1144                 if (ops->direction_output)
1145                         ops->direction_output += gd->reloc_off;
1146                 if (ops->get_value)
1147                         ops->get_value += gd->reloc_off;
1148                 if (ops->set_value)
1149                         ops->set_value += gd->reloc_off;
1150                 if (ops->get_function)
1151                         ops->get_function += gd->reloc_off;
1152                 if (ops->xlate)
1153                         ops->xlate += gd->reloc_off;
1154                 if (ops->set_dir_flags)
1155                         ops->set_dir_flags += gd->reloc_off;
1156                 if (ops->get_dir_flags)
1157                         ops->get_dir_flags += gd->reloc_off;
1158
1159                 reloc_done++;
1160         }
1161 #endif
1162
1163         if (IS_ENABLED(CONFIG_GPIO_HOG)) {
1164                 dev_for_each_subnode(node, dev) {
1165                         if (ofnode_read_bool(node, "gpio-hog")) {
1166                                 const char *name = ofnode_get_name(node);
1167                                 int ret;
1168
1169                                 ret = device_bind_driver_to_node(dev,
1170                                                                  "gpio_hog",
1171                                                                  name, node,
1172                                                                  &child);
1173                                 if (ret)
1174                                         return ret;
1175                         }
1176                 }
1177         }
1178         return 0;
1179 }
1180
1181 UCLASS_DRIVER(gpio) = {
1182         .id             = UCLASS_GPIO,
1183         .name           = "gpio",
1184         .flags          = DM_UC_FLAG_SEQ_ALIAS,
1185         .post_probe     = gpio_post_probe,
1186         .post_bind      = gpio_post_bind,
1187         .pre_remove     = gpio_pre_remove,
1188         .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
1189 };