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