pinctrl: factor pin control handles over to the core

This moves the per-devices struct pinctrl handles and device map
over from the pinmux part of the subsystem to the core pinctrl part.
This makes the device handles core infrastructure with the goal of
using these handles also for pin configuration, so that device
drivers (or boards etc) will need one and only one handle to the
pin control core.

Acked-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

5 files changed, 779 insertions, 635 deletions

diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index 75c6a6bb6c0a..ec32c545f07f 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -1,7 +1,7 @@
 /*
  * Core driver for the pin control subsystem
  *
- * Copyright (C) 2011 ST-Ericsson SA
+ * Copyright (C) 2011-2012 ST-Ericsson SA
  * Written on behalf of Linaro for ST-Ericsson
  * Based on bits of regulator core, gpio core and clk core
  *
@@ -30,10 +30,30 @@
 #include "pinmux.h"
 #include "pinconf.h"
 
+/**
+ * struct pinctrl_hog - a list item to stash control hogs
+ * @node: pin control hog list node
+ * @map: map entry responsible for this hogging
+ * @pmx: the pin control hogged by this item
+ */
+struct pinctrl_hog {
+        struct list_head node;
+        struct pinctrl_map const *map;
+        struct pinctrl *p;
+};
+
 /* Global list of pin control devices */
 static DEFINE_MUTEX(pinctrldev_list_mutex);
 static LIST_HEAD(pinctrldev_list);
 
+/* List of pin controller handles */
+static DEFINE_MUTEX(pinctrl_list_mutex);
+static LIST_HEAD(pinctrl_list);
+
+/* Global pinctrl maps */
+static struct pinctrl_map *pinctrl_maps;
+static unsigned pinctrl_maps_num;
+
 const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
 {
         /* We're not allowed to register devices without name */
@@ -337,6 +357,476 @@ int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
         return -EINVAL;
 }
 
+/**
+ * pinctrl_request_gpio() - request a single pin to be used in as GPIO
+ * @gpio: the GPIO pin number from the GPIO subsystem number space
+ *
+ * This function should *ONLY* be used from gpiolib-based GPIO drivers,
+ * as part of their gpio_request() semantics, platforms and individual drivers
+ * shall *NOT* request GPIO pins to be muxed in.
+ */
+int pinctrl_request_gpio(unsigned gpio)
+{
+        struct pinctrl_dev *pctldev;
+        struct pinctrl_gpio_range *range;
+        int ret;
+        int pin;
+
+        ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
+        if (ret)
+                return -EINVAL;
+
+        /* Convert to the pin controllers number space */
+        pin = gpio - range->base + range->pin_base;
+
+        return pinmux_request_gpio(pctldev, range, pin, gpio);
+}
+EXPORT_SYMBOL_GPL(pinctrl_request_gpio);
+
+/**
+ * pinctrl_free_gpio() - free control on a single pin, currently used as GPIO
+ * @gpio: the GPIO pin number from the GPIO subsystem number space
+ *
+ * This function should *ONLY* be used from gpiolib-based GPIO drivers,
+ * as part of their gpio_free() semantics, platforms and individual drivers
+ * shall *NOT* request GPIO pins to be muxed out.
+ */
+void pinctrl_free_gpio(unsigned gpio)
+{
+        struct pinctrl_dev *pctldev;
+        struct pinctrl_gpio_range *range;
+        int ret;
+        int pin;
+
+        ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
+        if (ret)
+                return;
+
+        /* Convert to the pin controllers number space */
+        pin = gpio - range->base + range->pin_base;
+
+        return pinmux_free_gpio(pctldev, pin, range);
+}
+EXPORT_SYMBOL_GPL(pinctrl_free_gpio);
+
+static int pinctrl_gpio_direction(unsigned gpio, bool input)
+{
+        struct pinctrl_dev *pctldev;
+        struct pinctrl_gpio_range *range;
+        int ret;
+        int pin;
+
+        ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
+        if (ret)
+                return ret;
+
+        /* Convert to the pin controllers number space */
+        pin = gpio - range->base + range->pin_base;
+
+        return pinmux_gpio_direction(pctldev, range, pin, input);
+}
+
+/**
+ * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode
+ * @gpio: the GPIO pin number from the GPIO subsystem number space
+ *
+ * This function should *ONLY* be used from gpiolib-based GPIO drivers,
+ * as part of their gpio_direction_input() semantics, platforms and individual
+ * drivers shall *NOT* touch pin control GPIO calls.
+ */
+int pinctrl_gpio_direction_input(unsigned gpio)
+{
+        return pinctrl_gpio_direction(gpio, true);
+}
+EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input);
+
+/**
+ * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode
+ * @gpio: the GPIO pin number from the GPIO subsystem number space
+ *
+ * This function should *ONLY* be used from gpiolib-based GPIO drivers,
+ * as part of their gpio_direction_output() semantics, platforms and individual
+ * drivers shall *NOT* touch pin control GPIO calls.
+ */
+int pinctrl_gpio_direction_output(unsigned gpio)
+{
+        return pinctrl_gpio_direction(gpio, false);
+}
+EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output);
+
+/**
+ * pinctrl_get() - retrieves the pin controller handle for a certain device
+ * @dev: the device to get the pin controller handle for
+ * @name: an optional specific control mapping name or NULL, the name is only
+ *      needed if you want to have more than one mapping per device, or if you
+ *      need an anonymous pin control (not tied to any specific device)
+ */
+struct pinctrl *pinctrl_get(struct device *dev, const char *name)
+{
+        struct pinctrl_map const *map = NULL;
+        struct pinctrl_dev *pctldev = NULL;
+        const char *devname = NULL;
+        struct pinctrl *p;
+        bool found_map;
+        unsigned num_maps = 0;
+        int ret = -ENODEV;
+        int i;
+
+        /* We must have dev or ID or both */
+        if (!dev && !name)
+                return ERR_PTR(-EINVAL);
+
+        if (dev)
+                devname = dev_name(dev);
+
+        pr_debug("get pin control handle %s for device %s\n", name,
+                 devname ? devname : "(none)");
+
+        /*
+         * create the state cookie holder struct pinctrl for each
+         * mapping, this is what consumers will get when requesting
+         * a pin control handle with pinctrl_get()
+         */
+        p = kzalloc(sizeof(struct pinctrl), GFP_KERNEL);
+        if (p == NULL)
+                return ERR_PTR(-ENOMEM);
+        mutex_init(&p->mutex);
+        pinmux_init_pinctrl_handle(p);
+
+        /* Iterate over the pin control maps to locate the right ones */
+        for (i = 0; i < pinctrl_maps_num; i++) {
+                map = &pinctrl_maps[i];
+                found_map = false;
+
+                /*
+                 * First, try to find the