dm: Add GPIO support and tests
authorSimon Glass <sjg@chromium.org>
Wed, 26 Feb 2014 22:59:24 +0000 (15:59 -0700)
committerTom Rini <trini@ti.com>
Tue, 4 Mar 2014 17:15:30 +0000 (12:15 -0500)
Add driver model support for GPIOs. Since existing GPIO drivers do not use
driver model, this feature must be enabled by CONFIG_DM_GPIO. After all
GPO drivers are converted over we can perhaps remove this config.

Tests are provided for the sandbox implementation, and are a sufficient
sanity check for basic operation.

The GPIO uclass understands the concept of named banks of GPIOs, with each
GPIO device providing a single bank. Within each bank the GPIOs are numbered
using an offset from 0 to n-1. For example a bank named 'b' with 20
offsets will provide GPIOs named b0 to b19.

Anonymous GPIO banks are also supported, and are just numbered without any
prefix.

Each time a GPIO driver is added to the uclass, the GPIOs are renumbered
accordinging, so there is always a global GPIO numbering order.

Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Marek Vasut <marex@denx.de>
Signed-off-by: Pavel Herrmann <morpheus.ibis@gmail.com>
Signed-off-by: Viktor Křivák <viktor.krivak@gmail.com>
Signed-off-by: Tomas Hlavacek <tmshlvck@gmail.com>
drivers/gpio/Makefile
drivers/gpio/gpio-uclass.c [new file with mode: 0644]
include/asm-generic/gpio.h
test/dm/gpio.c [new file with mode: 0644]

index ed2c0c7..4e001e1 100644 (file)
@@ -5,6 +5,8 @@
 # SPDX-License-Identifier:     GPL-2.0+
 #
 
 # SPDX-License-Identifier:     GPL-2.0+
 #
 
+obj-$(CONFIG_DM_GPIO)          += gpio-uclass.o
+
 obj-$(CONFIG_AT91_GPIO)        += at91_gpio.o
 obj-$(CONFIG_INTEL_ICH6_GPIO)  += intel_ich6_gpio.o
 obj-$(CONFIG_KIRKWOOD_GPIO)    += kw_gpio.o
 obj-$(CONFIG_AT91_GPIO)        += at91_gpio.o
 obj-$(CONFIG_INTEL_ICH6_GPIO)  += intel_ich6_gpio.o
 obj-$(CONFIG_KIRKWOOD_GPIO)    += kw_gpio.o
diff --git a/drivers/gpio/gpio-uclass.c b/drivers/gpio/gpio-uclass.c
new file mode 100644 (file)
index 0000000..56bfd11
--- /dev/null
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2013 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <dm.h>
+#include <errno.h>
+#include <asm/gpio.h>
+
+/**
+ * gpio_to_device() - Convert global GPIO number to device, number
+ * gpio:       The numeric representation of the GPIO
+ *
+ * Convert the GPIO number to an entry in the list of GPIOs
+ * or GPIO blocks registered with the GPIO controller. Returns
+ * entry on success, NULL on error.
+ */
+static int gpio_to_device(unsigned int gpio, struct device **devp,
+                         unsigned int *offset)
+{
+       struct gpio_dev_priv *uc_priv;
+       struct device *dev;
+       int ret;
+
+       for (ret = uclass_first_device(UCLASS_GPIO, &dev);
+            dev;
+            ret = uclass_next_device(&dev)) {
+               uc_priv = dev->uclass_priv;
+               if (gpio >= uc_priv->gpio_base &&
+                   gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
+                       *devp = dev;
+                       *offset = gpio - uc_priv->gpio_base;
+                       return 0;
+               }
+       }
+
+       /* No such GPIO */
+       return ret ? ret : -EINVAL;
+}
+
+int gpio_lookup_name(const char *name, struct device **devp,
+                    unsigned int *offsetp, unsigned int *gpiop)
+{
+       struct gpio_dev_priv *uc_priv;
+       struct device *dev;
+       int ret;
+
+       if (devp)
+               *devp = NULL;
+       for (ret = uclass_first_device(UCLASS_GPIO, &dev);
+            dev;
+            ret = uclass_next_device(&dev)) {
+               ulong offset;
+               int len;
+
+               uc_priv = dev->uclass_priv;
+               len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0;
+
+               if (!strncmp(name, uc_priv->bank_name, len)) {
+                       if (strict_strtoul(name + len, 10, &offset))
+                               continue;
+                       if (devp)
+                               *devp = dev;
+                       if (offsetp)
+                               *offsetp = offset;
+                       if (gpiop)
+                               *gpiop = uc_priv->gpio_base + offset;
+                       return 0;
+               }
+       }
+
+       return ret ? ret : -EINVAL;
+}
+
+/**
+ * gpio_request() - [COMPAT] Request GPIO
+ * gpio:       GPIO number
+ * label:      Name for the requested GPIO
+ *
+ * This function implements the API that's compatible with current
+ * GPIO API used in U-Boot. The request is forwarded to particular
+ * GPIO driver. Returns 0 on success, negative value on error.
+ */
+int gpio_request(unsigned gpio, const char *label)
+{
+       unsigned int offset;
+       struct device *dev;
+       int ret;
+
+       ret = gpio_to_device(gpio, &dev, &offset);
+       if (ret)
+               return ret;
+
+       if (!gpio_get_ops(dev)->request)
+               return 0;
+
+       return gpio_get_ops(dev)->request(dev, offset, label);
+}
+
+/**
+ * gpio_free() - [COMPAT] Relinquish GPIO
+ * gpio:       GPIO number
+ *
+ * This function implements the API that's compatible with current
+ * GPIO API used in U-Boot. The request is forwarded to particular
+ * GPIO driver. Returns 0 on success, negative value on error.
+ */
+int gpio_free(unsigned gpio)
+{
+       unsigned int offset;
+       struct device *dev;
+       int ret;
+
+       ret = gpio_to_device(gpio, &dev, &offset);
+       if (ret)
+               return ret;
+
+       if (!gpio_get_ops(dev)->free)
+               return 0;
+       return gpio_get_ops(dev)->free(dev, offset);
+}
+
+/**
+ * gpio_direction_input() - [COMPAT] Set GPIO direction to input
+ * gpio:       GPIO number
+ *
+ * This function implements the API that's compatible with current
+ * GPIO API used in U-Boot. The request is forwarded to particular
+ * GPIO driver. Returns 0 on success, negative value on error.
+ */
+int gpio_direction_input(unsigned gpio)
+{
+       unsigned int offset;
+       struct device *dev;
+       int ret;
+
+       ret = gpio_to_device(gpio, &dev, &offset);
+       if (ret)
+               return ret;
+
+       return gpio_get_ops(dev)->direction_input(dev, offset);
+}
+
+/**
+ * gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value
+ * gpio:       GPIO number
+ * value:      Logical value to be set on the GPIO pin
+ *
+ * This function implements the API that's compatible with current
+ * GPIO API used in U-Boot. The request is forwarded to particular
+ * GPIO driver. Returns 0 on success, negative value on error.
+ */
+int gpio_direction_output(unsigned gpio, int value)
+{
+       unsigned int offset;
+       struct device *dev;
+       int ret;
+
+       ret = gpio_to_device(gpio, &dev, &offset);
+       if (ret)
+               return ret;
+
+       return gpio_get_ops(dev)->direction_output(dev, offset, value);
+}
+
+/**
+ * gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value
+ * gpio:       GPIO number
+ *
+ * This function implements the API that's compatible with current
+ * GPIO API used in U-Boot. The request is forwarded to particular
+ * GPIO driver. Returns the value of the GPIO pin, or negative value
+ * on error.
+ */
+int gpio_get_value(unsigned gpio)
+{
+       unsigned int offset;
+       struct device *dev;
+       int ret;
+
+       ret = gpio_to_device(gpio, &dev, &offset);
+       if (ret)
+               return ret;
+
+       return gpio_get_ops(dev)->get_value(dev, offset);
+}
+
+/**
+ * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin
+ * gpio:       GPIO number
+ * value:      Logical value to be set on the GPIO pin.
+ *
+ * This function implements the API that's compatible with current
+ * GPIO API used in U-Boot. The request is forwarded to particular
+ * GPIO driver. Returns 0 on success, negative value on error.
+ */
+int gpio_set_value(unsigned gpio, int value)
+{
+       unsigned int offset;
+       struct device *dev;
+       int ret;
+
+       ret = gpio_to_device(gpio, &dev, &offset);
+       if (ret)
+               return ret;
+
+       return gpio_get_ops(dev)->set_value(dev, offset, value);
+}
+
+const char *gpio_get_bank_info(struct device *dev, int *bit_count)
+{
+       struct gpio_dev_priv *priv;
+
+       /* Must be called on an active device */
+       priv = dev->uclass_priv;
+       assert(priv);
+
+       *bit_count = priv->gpio_count;
+       return priv->bank_name;
+}
+
+/* We need to renumber the GPIOs when any driver is probed/removed */
+static int gpio_renumber(void)
+{
+       struct gpio_dev_priv *uc_priv;
+       struct device *dev;
+       struct uclass *uc;
+       unsigned base;
+       int ret;
+
+       ret = uclass_get(UCLASS_GPIO, &uc);
+       if (ret)
+               return ret;
+
+       /* Ensure that we have a base for each bank */
+       base = 0;
+       uclass_foreach_dev(dev, uc) {
+               if (device_active(dev)) {
+                       uc_priv = dev->uclass_priv;
+                       uc_priv->gpio_base = base;
+                       base += uc_priv->gpio_count;
+               }
+       }
+
+       return 0;
+}
+
+static int gpio_post_probe(struct device *dev)
+{
+       return gpio_renumber();
+}
+
+static int gpio_pre_remove(struct device *dev)
+{
+       return gpio_renumber();
+}
+
+UCLASS_DRIVER(gpio) = {
+       .id             = UCLASS_GPIO,
+       .name           = "gpio",
+       .post_probe     = gpio_post_probe,
+       .pre_remove     = gpio_pre_remove,
+       .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
+};
index f541039..e325df4 100644 (file)
@@ -78,4 +78,108 @@ int gpio_get_value(unsigned gpio);
  * @return 0 if ok, -1 on error
  */
 int gpio_set_value(unsigned gpio, int value);
  * @return 0 if ok, -1 on error
  */
 int gpio_set_value(unsigned gpio, int value);
+
+/* State of a GPIO, as reported by get_state() */
+enum {
+       GPIOF_INPUT = 0,
+       GPIOF_OUTPUT,
+       GPIOF_UNKNOWN,
+};
+
+struct device;
+
+/**
+ * struct struct dm_gpio_ops - Driver model GPIO operations
+ *
+ * Refer to functions above for description. These function largely copy
+ * the old API.
+ *
+ * This is trying to be close to Linux GPIO API. Once the U-Boot uses the
+ * new DM GPIO API, this should be really easy to flip over to the Linux
+ * GPIO API-alike interface.
+ *
+ * Akso it would be useful to standardise additional functions like
+ * pullup, slew rate and drive strength.
+ *
+ * gpio_request)( and gpio_free() are optional - if NULL then they will
+ * not be called.
+ *
+ * Note that @offset is the offset from the base GPIO of the device. So
+ * offset 0 is the device's first GPIO and offset o-1 is the last GPIO,
+ * where o is the number of GPIO lines controlled by the device. A device
+ * is typically used to control a single bank of GPIOs. Within complex
+ * SoCs there may be many banks and therefore many devices all referring
+ * to the different IO addresses within the SoC.
+ *
+ * The uclass combines all GPIO devices togther to provide a consistent
+ * numbering from 0 to n-1, where n is the number of GPIOs in total across
+ * all devices. Be careful not to confuse offset with gpio in the parameters.
+ */
+struct dm_gpio_ops {
+       int (*request)(struct device *dev, unsigned offset, const char *label);
+       int (*free)(struct device *dev, unsigned offset);
+       int (*direction_input)(struct device *dev, unsigned offset);
+       int (*direction_output)(struct device *dev, unsigned offset,
+                               int value);
+       int (*get_value)(struct device *dev, unsigned offset);
+       int (*set_value)(struct device *dev, unsigned offset, int value);
+       int (*get_function)(struct device *dev, unsigned offset);
+       int (*get_state)(struct device *dev, unsigned offset, char *state,
+                        int maxlen);
+};
+
+/**
+ * struct gpio_dev_priv - information about a device used by the uclass
+ *
+ * The uclass combines all active GPIO devices into a unified numbering
+ * scheme. To do this it maintains some private information aobut each
+ * device.
+ *
+ * To implement driver model support in your GPIO driver, add a probe
+ * handler, and set @gpio_count and @bank_name correctly in that handler.
+ * This tells the uclass the name of the GPIO bank and the number of GPIOs
+ * it contains.
+ *
+ * @bank_name: Name of the GPIO device (e.g 'a' means GPIOs will be called
+ * 'A0', 'A1', etc.
+ * @gpio_count: Number of GPIOs in this device
+ * @gpio_base: Base GPIO number for this device. For the first active device
+ * this will be 0; the numbering for others will follow sequentially so that
+ * @gpio_base for device 1 will equal the number of GPIOs in device 0.
+ */
+struct gpio_dev_priv {
+       const char *bank_name;
+       unsigned gpio_count;
+       unsigned gpio_base;
+};
+
+/* Access the GPIO operations for a device */
+#define gpio_get_ops(dev)      ((struct dm_gpio_ops *)(dev)->driver->ops)
+
+/**
+ * gpio_get_bank_info - Return information about a GPIO bank/device
+ *
+ * This looks up a device and returns both its GPIO base name and the number
+ * of GPIOs it controls.
+ *
+ * @dev: Device to look up
+ * @offset_count: Returns number of GPIOs within this bank
+ * @return bank name of this device
+ */
+const char *gpio_get_bank_info(struct device *dev, int *offset_count);
+
+/**
+ * gpio_lookup_name - Look up a GPIO name and return its details
+ *
+ * This is used to convert a named GPIO into a device, offset and GPIO
+ * number.
+ *
+ * @name: GPIO name to look up
+ * @devp: Returns pointer to device which contains this GPIO
+ * @offsetp: Returns the offset number within this device
+ * @gpiop: Returns the absolute GPIO number, numbered from 0
+ */
+int gpio_lookup_name(const char *name, struct device **devp,
+                    unsigned int *offsetp, unsigned int *gpiop);
+
 #endif /* _ASM_GENERIC_GPIO_H_ */
 #endif /* _ASM_GENERIC_GPIO_H_ */
diff --git a/test/dm/gpio.c b/test/dm/gpio.c
new file mode 100644 (file)
index 0000000..bf632bc
--- /dev/null
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2013 Google, Inc
+ *
+ * SPDX-License-Identifier:    GPL-2.0+
+ */
+
+#include <common.h>
+#include <fdtdec.h>
+#include <dm.h>
+#include <dm/ut.h>
+#include <dm/test.h>
+#include <dm/util.h>
+#include <asm/gpio.h>
+
+/* Test that sandbox GPIOs work correctly */
+static int dm_test_gpio(struct dm_test_state *dms)
+{
+       unsigned int offset, gpio;
+       struct dm_gpio_ops *ops;
+       struct device *dev;
+       const char *name;
+       int offset_count;
+       char buf[80];
+
+       /*
+        * We expect to get 3 banks. One is anonymous (just numbered) and
+        * comes from platdata. The other two are named a (20 gpios)
+        * and b (10 gpios) and come from the device tree. See
+        * test/dm/test.dts.
+        */
+       ut_assertok(gpio_lookup_name("b4", &dev, &offset, &gpio));
+       ut_asserteq_str(dev->name, "extra-gpios");
+       ut_asserteq(4, offset);
+       ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 20 + 4, gpio);
+
+       name = gpio_get_bank_info(dev, &offset_count);
+       ut_asserteq_str("b", name);
+       ut_asserteq(10, offset_count);
+
+       /* Get the operations for this device */
+       ops = gpio_get_ops(dev);
+       ut_assert(ops->get_state);
+
+       /* Cannot get a value until it is reserved */
+       ut_asserteq(-1, ops->get_value(dev, offset));
+
+       /*
+        * Now some tests that use the 'sandbox' back door. All GPIOs
+        * should default to input, include b4 that we are using here.
+        */
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4:  in: 0 [ ]", buf);
+
+       /* Change it to an output */
+       sandbox_gpio_set_direction(dev, offset, 1);
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4: out: 0 [ ]", buf);
+
+       sandbox_gpio_set_value(dev, offset, 1);
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4: out: 1 [ ]", buf);
+
+       ut_assertok(ops->request(dev, offset, "testing"));
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4: out: 1 [x] testing", buf);
+
+       /* Change the value a bit */
+       ut_asserteq(1, ops->get_value(dev, offset));
+       ut_assertok(ops->set_value(dev, offset, 0));
+       ut_asserteq(0, ops->get_value(dev, offset));
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4: out: 0 [x] testing", buf);
+       ut_assertok(ops->set_value(dev, offset, 1));
+       ut_asserteq(1, ops->get_value(dev, offset));
+
+       /* Make it an input */
+       ut_assertok(ops->direction_input(dev, offset));
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4:  in: 1 [x] testing", buf);
+       sandbox_gpio_set_value(dev, offset, 0);
+       ut_asserteq(0, sandbox_gpio_get_value(dev, offset));
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4:  in: 0 [x] testing", buf);
+
+       ut_assertok(ops->free(dev, offset));
+       ut_assertok(ops->get_state(dev, offset, buf, sizeof(buf)));
+       ut_asserteq_str("b4:  in: 0 [ ]", buf);
+
+       /* Check the 'a' bank also */
+       ut_assertok(gpio_lookup_name("a15", &dev, &offset, &gpio));
+       ut_asserteq_str(dev->name, "base-gpios");
+       ut_asserteq(15, offset);
+       ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT + 15, gpio);
+
+       name = gpio_get_bank_info(dev, &offset_count);
+       ut_asserteq_str("a", name);
+       ut_asserteq(20, offset_count);
+
+       /* And the anonymous bank */
+       ut_assertok(gpio_lookup_name("14", &dev, &offset, &gpio));
+       ut_asserteq_str(dev->name, "gpio_sandbox");
+       ut_asserteq(14, offset);
+       ut_asserteq(14, gpio);
+
+       name = gpio_get_bank_info(dev, &offset_count);
+       ut_asserteq_ptr(NULL, name);
+       ut_asserteq(CONFIG_SANDBOX_GPIO_COUNT, offset_count);
+
+       return 0;
+}
+DM_TEST(dm_test_gpio, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);