@@ -239,6 +239,11 @@ void board_init_r(gd_t *id, ulong dest_addr)
.name = "demo_drv",
.platform_data = NULL
};
+ static const struct driver_info gs_info = {
+ .name = "gpio_sandbox",
+ .platform_data = NULL
+ };
+
struct instance *root = get_root_instance();
struct instance *demo1, *demo2, *demo3;
demo1 = driver_bind(root, &info);
@@ -248,6 +253,7 @@ void board_init_r(gd_t *id, ulong dest_addr)
demo2 = driver_bind(demo1, &info);
demo3 = driver_bind(demo2, &info);
driver_bind(demo2, &info);
+ driver_bind(root, &gs_info);
demo_hello(demo2);
@@ -25,6 +25,8 @@ include $(TOPDIR)/config.mk
LIB := $(obj)libgpio.o
+COBJS-$(CONFIG_DM) += core.o
+
COBJS-$(CONFIG_AT91_GPIO) += at91_gpio.o
COBJS-$(CONFIG_KIRKWOOD_GPIO) += kw_gpio.o
COBJS-$(CONFIG_MARVELL_GPIO) += mvgpio.o
new file mode 100644
@@ -0,0 +1,365 @@
+#include <common.h>
+#include <malloc.h>
+#include <asm/gpio.h>
+#include <dm/manager.h>
+#include <linux/list.h>
+
+/*
+ * The idea here is to have GPIOs numbered like this from user point of view:
+ *
+ * 32 24 23 16 15 0
+ * [ GPIO block ID ] [ GPIO chip ID ] [ GPIO ID within the GPIO chip ]
+ *
+ */
+
+#define GPIO_TO_BLOCK_ID(x) (((x) >> 24) & 0xff)
+#define GPIO_TO_CHIP_ID(x) (((x) >> 16) & 0xff)
+#define GPIO_TO_CHIP_OFFSET(x) ((x) & 0xffff)
+
+struct gpio_core_entry {
+ struct list_head list;
+ struct instance *instance;
+ struct dm_gpio_ops *ops;
+ int id;
+};
+
+/**
+ * gpio_to_entry() - Convert GPIO number to entry in the list
+ * 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 struct gpio_core_entry *gpio_to_entry(unsigned gpio)
+{
+ uint8_t block = GPIO_TO_BLOCK_ID(gpio);
+ uint8_t chip = GPIO_TO_CHIP_ID(gpio);
+ uint8_t offset = GPIO_TO_CHIP_OFFSET(gpio);
+ struct core_instance *core = get_core_instance(CORE_GPIO);
+ struct gpio_core_entry *tmp, *ret = NULL;
+
+ list_for_each_entry(tmp, &core->succ, list) {
+ if (tmp->id != block)
+ continue;
+ if (tmp->ops->base != chip)
+ continue;
+ if (tmp->ops->ngpio < offset)
+ return NULL;
+ else {
+ ret = tmp;
+ break;
+ }
+ }
+
+ if (ret)
+ driver_activate(ret->instance);
+
+ return ret;
+}
+
+/**
+ * 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)
+{
+ struct gpio_core_entry *e = gpio_to_entry(gpio);
+ if (!e)
+ return -EINVAL;
+
+ return e->ops->gpio_request(gpio, 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)
+{
+ struct gpio_core_entry *e = gpio_to_entry(gpio);
+ if (!e)
+ return -EINVAL;
+
+ return e->ops->gpio_free(gpio);
+}
+
+/**
+ * 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)
+{
+ struct gpio_core_entry *e = gpio_to_entry(gpio);
+ if (!e)
+ return -EINVAL;
+
+ return e->ops->gpio_direction_input(gpio);
+}
+
+/**
+ * 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)
+{
+ struct gpio_core_entry *e = gpio_to_entry(gpio);
+ if (!e)
+ return -EINVAL;
+
+ return e->ops->gpio_direction_output(gpio, 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)
+{
+ struct gpio_core_entry *e = gpio_to_entry(gpio);
+ if (!e)
+ return -EINVAL;
+
+ return e->ops->gpio_get_value(gpio);
+}
+
+/**
+ * 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)
+{
+ struct gpio_core_entry *e = gpio_to_entry(gpio);
+ if (!e)
+ return -EINVAL;
+
+ return e->ops->gpio_set_value(gpio, value);
+}
+
+/**
+ * gpio_core_init() - Initialize the GPIO core
+ * core: Instance of the GPIO core
+ *
+ * This function does the initial configuration of the GPIO core's
+ * internal structures. Returns 0 always.
+ */
+static int gpio_core_init(struct core_instance *core)
+{
+ INIT_LIST_HEAD(&core->succ);
+ core->private_data = NULL;
+
+ return 0;
+}
+
+/**
+ * gpio_core_reloc() - Relocate the GPIO core
+ * new: New instance of the GPIO core
+ * old: Old instance of the GPIO core
+ *
+ * This function relocates the GPIO core.
+ * FIXME: Implement this.
+ */
+static int gpio_core_reloc(struct core_instance *new, struct core_instance *old)
+{
+ return 0; /* FIXME */
+}
+
+/**
+ * gpio_core_destroy() - Stop the GPIO core
+ * core: Instance of the GPIO core
+ *
+ * This function stops the GPIO core operation and disconnects all drivers from
+ * it. Returns 0 always.
+ */
+static int gpio_core_destroy(struct core_instance *core)
+{
+ struct gpio_core_entry *tmp, *n;
+
+ list_for_each_entry_safe(tmp, n, &core->succ, list) {
+ list_del(&tmp->list);
+ free(tmp);
+ }
+
+ return 0;
+}
+
+/**
+ * gpio_core_get_count() - Return number of drivers connected to GPIO core
+ * core: Instance of the GPIO core
+ *
+ * This function counts the number of driver instances associated with the
+ * GPIO core and returns this number.
+ */
+static int gpio_core_get_count(struct core_instance *core)
+{
+ struct gpio_core_entry *tmp;
+ int i = 0;
+
+ list_for_each_entry(tmp, &core->succ, list)
+ i++;
+
+ return i;
+}
+
+/**
+ * gpio_core_get_count() - Return n-th driver connected to GPIO core
+ * core: Instance of the GPIO core
+ * idx: Index of the driver
+ *
+ * This function returns the idx-th driver instance associated with the GPIO
+ * core. Returns the instance on success, NULL on error.
+ */
+static struct instance *gpio_core_get_child(struct core_instance *core, int idx)
+{
+ struct gpio_core_entry *tmp;
+ int i = 0;
+
+ list_for_each_entry(tmp, &core->succ, list) {
+ if (i == idx)
+ return tmp->instance;
+ i++;
+ }
+
+ return NULL;
+}
+
+/**
+ * gpio_core_bind() - Bind instance of a driver to a GPIO core
+ * core: Instance of the GPIO core
+ * dev: Instance of the driver
+ * ops: Operations supplied by this driver, struct dm_gpio_ops *
+ * data: Auxiliary data, must be NULL for GPIO core
+ *
+ * This function binds a driver with a GPIO core. The driver is inserted into
+ * the list of driver instances the GPIO core tracks, so the GPIO core is aware
+ * of the driver. The driver instance is not yet activated.
+ *
+ * Returns 0 on success, negative value on error.
+ */
+static int gpio_core_bind(struct core_instance *core, struct instance *dev,
+ void *ops, void *data)
+{
+ struct gpio_core_entry *new, *tmp, *last = NULL;
+
+ if (data || !ops)
+ return -EINVAL;
+
+ new = malloc(sizeof(*new));
+ if (!new)
+ return -ENOMEM;
+
+ new->instance = dev;
+ new->ops = ops;
+
+ list_for_each_entry(tmp, &core->succ, list) {
+ if (tmp->instance == dev)
+ last = tmp;
+ }
+
+ if (!last) {
+ if (list_empty(&core->succ)) {
+ new->id = 0;
+ } else {
+ tmp = list_entry(core->succ.prev,
+ struct gpio_core_entry, list);
+ new->id = tmp->id + 1;
+ }
+ } else {
+ tmp = list_entry(&last->list, struct gpio_core_entry, list);
+ new->id = tmp->id;
+ }
+
+ list_add_tail(&new->list, &core->succ);
+
+ return 0;
+}
+
+/**
+ * gpio_core_unbind() - Unbind instance of a driver from a GPIO core
+ * core: Instance of the GPIO core
+ * dev: Instance of the driver
+ *
+ * This function unbinds a driver from a GPIO core. The driver is removed from
+ * the list of driver instances the GPIO core tracks, so the GPIO core is no
+ * longer aware of the driver. The driver instance is not deactivated.
+ *
+ * Returns 0 always.
+ */
+static int gpio_core_unbind(struct core_instance *core, struct instance *dev)
+{
+ struct gpio_core_entry *tmp, *n;
+
+ list_for_each_entry_safe(tmp, n, &core->succ, list) {
+ if (tmp->instance == dev) {
+ list_del(&tmp->list);
+ free(tmp);
+ }
+ }
+
+ return 0;
+}
+
+/**
+ * gpio_core_replace() - Find and replace instance of a driver in the list
+ * core: Instance of the GPIO core
+ * new: New instance of the driver, post relocation one
+ * old: Old instance of the driver, pre relocation one
+ *
+ * This function replaces pointers to pre-relocation driver instances in the
+ * core's list of drivers with pointers to post-relocation driver instances.
+ * Returns 0 on success, negative value on error.
+ */
+static int gpio_core_replace(struct core_instance *core, struct instance *new,
+ struct instance *old)
+{
+ struct gpio_core_entry *tmp;
+
+ if (!core || !new || !old)
+ return -EINVAL;
+
+ list_for_each_entry(tmp, &core->succ, list) {
+ if (tmp->instance != old)
+ continue;
+ tmp->instance = new;
+ }
+
+ return 0;
+}
+
+U_BOOT_CORE(CORE_GPIO,
+ gpio_core_init,
+ gpio_core_reloc,
+ gpio_core_destroy,
+ gpio_core_get_count,
+ gpio_core_get_child,
+ gpio_core_bind,
+ gpio_core_unbind,
+ gpio_core_replace);
@@ -21,6 +21,7 @@
#include <common.h>
#include <asm/gpio.h>
+#include <dm/manager.h>
/* Flags for each GPIO */
#define GPIOF_OUTPUT (1 << 0) /* Currently set as an output */
@@ -111,7 +112,7 @@ int sandbox_gpio_set_direction(unsigned gp, int output)
*/
/* set GPIO port 'gp' as an input */
-int gpio_direction_input(unsigned gp)
+static int sb_gpio_direction_input(unsigned gp)
{
debug("%s: gp:%u\n", __func__, gp);
@@ -122,7 +123,7 @@ int gpio_direction_input(unsigned gp)
}
/* set GPIO port 'gp' as an output, with polarity 'value' */
-int gpio_direction_output(unsigned gp, int value)
+static int sb_gpio_direction_output(unsigned gp, int value)
{
debug("%s: gp:%u, value = %d\n", __func__, gp, value);
@@ -134,7 +135,7 @@ int gpio_direction_output(unsigned gp, int value)
}
/* read GPIO IN value of port 'gp' */
-int gpio_get_value(unsigned gp)
+static int sb_gpio_get_value(unsigned gp)
{
debug("%s: gp:%u\n", __func__, gp);
@@ -145,7 +146,7 @@ int gpio_get_value(unsigned gp)
}
/* write GPIO OUT value to port 'gp' */
-int gpio_set_value(unsigned gp, int value)
+static int sb_gpio_set_value(unsigned gp, int value)
{
debug("%s: gp:%u, value = %d\n", __func__, gp, value);
@@ -160,7 +161,7 @@ int gpio_set_value(unsigned gp, int value)
return sandbox_gpio_set_value(gp, value);
}
-int gpio_request(unsigned gp, const char *label)
+static int sb_gpio_request(unsigned gp, const char *label)
{
debug("%s: gp:%u, label:%s\n", __func__, gp, label);
@@ -178,7 +179,7 @@ int gpio_request(unsigned gp, const char *label)
return set_gpio_flag(gp, GPIOF_RESERVED, 1);
}
-int gpio_free(unsigned gp)
+static int sb_gpio_free(unsigned gp)
{
debug("%s: gp:%u\n", __func__, gp);
@@ -207,3 +208,48 @@ void gpio_info(void)
label ? label : "");
}
}
+
+#ifdef CONFIG_DM
+static struct dm_gpio_ops gpio_sandbox_ops = {
+ .base = 0,
+ .ngpio = CONFIG_SANDBOX_GPIO_COUNT,
+ .gpio_request = sb_gpio_request,
+ .gpio_free = sb_gpio_free,
+ .gpio_direction_input = sb_gpio_direction_input,
+ .gpio_direction_output = sb_gpio_direction_output,
+ .gpio_get_value = sb_gpio_get_value,
+ .gpio_set_value = sb_gpio_set_value,
+};
+
+static int gpio_sandbox_bind(struct instance *dev)
+{
+ return core_bind(CORE_GPIO, dev, &gpio_sandbox_ops, NULL);
+}
+
+static int gpio_sandbox_probe(struct instance *dev)
+{
+ return 0;
+}
+
+static int gpio_sandbox_reloc(struct instance *new, struct instance *old)
+{
+ return 0;
+}
+
+static int gpio_sandbox_remove(struct instance *dev)
+{
+ return 0;
+}
+
+static int gpio_sandbox_unbind(struct instance *dev)
+{
+ return core_unbind(CORE_GPIO, dev);
+}
+
+U_BOOT_DRIVER(gpio_sandbox,
+ gpio_sandbox_bind,
+ gpio_sandbox_probe,
+ gpio_sandbox_reloc,
+ gpio_sandbox_remove,
+ gpio_sandbox_unbind);
+#endif
@@ -94,4 +94,23 @@ int gpio_get_value(unsigned gpio);
*/
int gpio_set_value(unsigned gpio, int value);
+/**
+ * Driver model GPIO operations, refer to functions above for description.
+ * These function 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.
+ */
+struct dm_gpio_ops {
+ int base;
+ u16 ngpio;
+ int (*gpio_request)(unsigned gpio, const char *label);
+ int (*gpio_free)(unsigned gpio);
+ int (*gpio_direction_input)(unsigned gpio);
+ int (*gpio_direction_output)(unsigned gpio, int value);
+ int (*gpio_get_value)(unsigned gpio);
+ int (*gpio_set_value)(unsigned gpio, int value);
+};
+
#endif /* _ASM_GENERIC_GPIO_H_ */
@@ -22,6 +22,8 @@
#ifndef __CONFIG_H
#define __CONFIG_H
+#define CONFIG_DM
+
#define CONFIG_NR_DRAM_BANKS 1
#define CONFIG_DRAM_SIZE (128 << 20)
@@ -28,6 +28,7 @@
enum core_id {
CORE_INVALID = 0,
+ CORE_GPIO,
};
#endif
Signed-off-by: Marek Vasut <marex@denx.de> --- arch/sandbox/lib/board.c | 6 + drivers/gpio/Makefile | 2 + drivers/gpio/core.c | 365 +++++++++++++++++++++++++++++++++++++++++++ drivers/gpio/sandbox.c | 58 ++++++- include/asm-generic/gpio.h | 19 +++ include/configs/sandbox.h | 2 + include/dm/core_numbering.h | 1 + 7 files changed, 447 insertions(+), 6 deletions(-) create mode 100644 drivers/gpio/core.c