4 files changed, 143 insertions, 28 deletions

diff --git a/include/linux/pinctrl/machine.h b/include/linux/pinctrl/machine.h
index 88863531d862..d0aecb7f6fb9 100644
--- a/include/linux/pinctrl/machine.h
+++ b/include/linux/pinctrl/machine.h
@@ -48,7 +48,7 @@ struct pinmux_map {
         const char *group;
         struct device *dev;
         const char *dev_name;
-        const bool hog_on_boot;
+        bool hog_on_boot;
 };
 
 /*
@@ -66,30 +66,22 @@ struct pinmux_map {
         { .name = a, .ctrl_dev_name = b, .function = c }
 
 /*
- * Convenience macro to map a function onto the primary device pinctrl device
- * this is especially helpful on systems that have only one pin controller
- * or need to set up a lot of mappings on the primary controller.
- */
-#define PINMUX_MAP_PRIMARY(a, b, c) \
-        { .name = a, .ctrl_dev_name = "pinctrl.0", .function = b, \
-          .dev_name = c }
-
-/*
- * Convenience macro to map a system function onto the primary pinctrl device.
- * System functions are not assigned to a particular device.
+ * Convenience macro to map a system function onto a certain pinctrl device,
+ * to be hogged by the pinmux core until the system shuts down.
  */
-#define PINMUX_MAP_PRIMARY_SYS(a, b) \
-        { .name = a, .ctrl_dev_name = "pinctrl.0", .function = b }
+#define PINMUX_MAP_SYS_HOG(a, b, c) \
+        { .name = a, .ctrl_dev_name = b, .function = c, \
+          .hog_on_boot = true }
 
 /*
- * Convenience macro to map a system function onto the primary pinctrl device,
- * to be hogged by the pinmux core until the system shuts down.
+ * Convenience macro to map a system function onto a certain pinctrl device
+ * using a specified group, to be hogged by the pinmux core until the system
+ * shuts down.
  */
-#define PINMUX_MAP_PRIMARY_SYS_HOG(a, b) \
-        { .name = a, .ctrl_dev_name = "pinctrl.0", .function = b, \
+#define PINMUX_MAP_SYS_HOG_GROUP(a, b, c, d)            \
+        { .name = a, .ctrl_dev_name = b, .function = c, .group = d, \
           .hog_on_boot = true }
 
-
 #ifdef CONFIG_PINMUX
 
 extern int pinmux_register_mappings(struct pinmux_map const *map,
diff --git a/include/linux/pinctrl/pinconf.h b/include/linux/pinctrl/pinconf.h
new file mode 100644
index 000000000000..477922cf043a
--- /dev/null
+++ b/include/linux/pinctrl/pinconf.h
@@ -0,0 +1,97 @@
+/*
+ * Interface the pinconfig portions of the pinctrl subsystem
+ *
+ * Copyright (C) 2011 ST-Ericsson SA
+ * Written on behalf of Linaro for ST-Ericsson
+ * This interface is used in the core to keep track of pins.
+ *
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ */
+#ifndef __LINUX_PINCTRL_PINCONF_H
+#define __LINUX_PINCTRL_PINCONF_H
+
+#ifdef CONFIG_PINCONF
+
+struct pinctrl_dev;
+struct seq_file;
+
+/**
+ * struct pinconf_ops - pin config operations, to be implemented by
+ * pin configuration capable drivers.
+ * @pin_config_get: get the config of a certain pin, if the requested config
+ *      is not available on this controller this should return -ENOTSUPP
+ *      and if it is available but disabled it should return -EINVAL
+ * @pin_config_get: get the config of a certain pin
+ * @pin_config_set: configure an individual pin
+ * @pin_config_group_get: get configurations for an entire pin group
+ * @pin_config_group_set: configure all pins in a group
+ * @pin_config_dbg_show: optional debugfs display hook that will provide
+ *      per-device info for a certain pin in debugfs
+ * @pin_config_group_dbg_show: optional debugfs display hook that will provide
+ *      per-device info for a certain group in debugfs
+ */
+struct pinconf_ops {
+        int (*pin_config_get) (struct pinctrl_dev *pctldev,
+                               unsigned pin,
+                               unsigned long *config);
+        int (*pin_config_set) (struct pinctrl_dev *pctldev,
+                               unsigned pin,
+                               unsigned long config);
+        int (*pin_config_group_get) (struct pinctrl_dev *pctldev,
+                                     unsigned selector,
+                                     unsigned long *config);
+        int (*pin_config_group_set) (struct pinctrl_dev *pctldev,
+                                     unsigned selector,
+                                     unsigned long config);
+        void (*pin_config_dbg_show) (struct pinctrl_dev *pctldev,
+                                     struct seq_file *s,
+                                     unsigned offset);
+        void (*pin_config_group_dbg_show) (struct pinctrl_dev *pctldev,
+                                           struct seq_file *s,
+                                           unsigned selector);
+};
+
+extern int pin_config_get(const char *dev_name, const char *name,
+                          unsigned long *config);
+extern int pin_config_set(const char *dev_name, const char *name,
+                          unsigned long config);
+extern int pin_config_group_get(const char *dev_name,
+                                const char *pin_group,
+                                unsigned long *config);
+extern int pin_config_group_set(const char *dev_name,
+                                const char *pin_group,
+                                unsigned long config);
+
+#else
+
+static inline int pin_config_get(const char *dev_name, const char *name,
+                                 unsigned long *config)
+{
+        return 0;
+}
+
+static inline int pin_config_set(const char *dev_name, const char *name,
+                                 unsigned long config)
+{
+        return 0;
+}
+
+static inline int pin_config_group_get(const char *dev_name,
+                                       const char *pin_group,
+                                       unsigned long *config)
+{
+        return 0;
+}
+
+static inline int pin_config_group_set(const char *dev_name,
+                                       const char *pin_group,
+                                       unsigned long config)
+{
+        return 0;
+}
+
+#endif
+
+#endif /* __LINUX_PINCTRL_PINCONF_H */
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 04c011038f32..8bd22ee7aa09 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -21,6 +21,7 @@
 
 struct pinctrl_dev;
 struct pinmux_ops;
+struct pinconf_ops;
 struct gpio_chip;
 
 /**
@@ -45,6 +46,7 @@ struct pinctrl_pin_desc {
  * @name: a name for the chip in this range
  * @id: an ID number for the chip in this range
  * @base: base offset of the GPIO range
+ * @pin_base: base pin number of the GPIO range
  * @npins: number of pins in the GPIO range, including the base number
  * @gc: an optional pointer to a gpio_chip
  */
@@ -53,6 +55,7 @@ struct pinctrl_gpio_range {
         const char *name;
         unsigned int id;
         unsigned int base;
+        unsigned int pin_base;
         unsigned int npins;
         struct gpio_chip *gc;
 };
@@ -89,22 +92,20 @@ struct pinctrl_ops {
  *      this pin controller
  * @npins: number of descriptors in the array, usually just ARRAY_SIZE()
  *      of the pins field above
- * @maxpin: since pin spaces may be sparse, there can he "holes" in the
- *      pin range, this attribute gives the maximum pin number in the
- *      total range. This should not be lower than npins for example,
- *      but may be equal to npins if you have no holes in the pin range.
  * @pctlops: pin control operation vtable, to support global concepts like
  *      grouping of pins, this is optional.
- * @pmxops: pinmux operation vtable, if you support pinmuxing in your driver
+ * @pmxops: pinmux operations vtable, if you support pinmuxing in your driver
+ * @confops: pin config operations vtable, if you support pin configuration in
+ *      your driver
  * @owner: module providing the pin controller, used for refcounting
  */
 struct pinctrl_desc {
         const char *name;
         struct pinctrl_pin_desc const *pins;
         unsigned int npins;
-        unsigned int maxpin;
         struct pinctrl_ops *pctlops;
         struct pinmux_ops *pmxops;
+        struct pinconf_ops *confops;
         struct module *owner;
 };
 
@@ -123,7 +124,7 @@ extern void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev);
 
 struct pinctrl_dev;
 
-/* Sufficiently stupid default function when pinctrl is not in use */
+/* Sufficiently stupid default functions when pinctrl is not in use */
 static inline bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
 {
         return pin >= 0;
diff --git a/include/linux/pinctrl/pinmux.h b/include/linux/pinctrl/pinmux.h
index 3c430e797efc..937b3e2fa36f 100644
--- a/include/linux/pinctrl/pinmux.h
+++ b/include/linux/pinctrl/pinmux.h
@@ -52,9 +52,15 @@ struct pinctrl_dev;
  * @disable: disable a certain muxing selector with a certain pin group
  * @gpio_request_enable: requests and enables GPIO on a certain pin.
  *      Implement this only if you can mux every pin individually as GPIO. The
- *      affected GPIO range is passed along with an offset into that
+ *      affected GPIO range is passed along with an offset(pin number) into that
  *      specific GPIO range - function selectors and pin groups are orthogonal
- *      to this, the core will however make sure the pins do not collide
+ *      to this, the core will however make sure the pins do not collide.
+ * @gpio_disable_free: free up GPIO muxing on a certain pin, the reverse of
+ *      @gpio_request_enable
+ * @gpio_set_direction: Since controllers may need different configurations
+ *      depending on whether the GPIO is configured as input or output,
+ *      a direction selector function may be implemented as a backing
+ *      to the GPIO controllers that need pin muxing.
  */
 struct pinmux_ops {
         int (*request) (struct pinctrl_dev *pctldev, unsigned offset);
@@ -73,11 +79,20 @@ struct pinmux_ops {
         int (*gpio_request_enable) (struct pinctrl_dev *pctldev,
                                     struct pinctrl_gpio_range *range,
                                     unsigned offset);
+        void (*gpio_disable_free) (struct pinctrl_dev *pctldev,
+                                   struct pinctrl_gpio_range *range,
+                                   unsigned offset);
+        int (*gpio_set_direction) (struct pinctrl_dev *pctldev,
+                                   struct pinctrl_gpio_range *range,
+                                   unsigned offset,
+                                   bool input);
 };
 
 /* External interface to pinmux */
 extern int pinmux_request_gpio(unsigned gpio);
 extern void pinmux_free_gpio(unsigned gpio);
+extern int pinmux_gpio_direction_input(unsigned gpio);
+extern int pinmux_gpio_direction_output(unsigned gpio);
 extern struct pinmux * __must_check pinmux_get(struct device *dev, const char *name);
 extern void pinmux_put(struct pinmux *pmx);
 extern int pinmux_enable(struct pinmux *pmx);
@@ -94,6 +109,16 @@ static inline void pinmux_free_gpio(unsigned gpio)
 {
 }
 
+static inline int pinmux_gpio_direction_input(unsigned gpio)
+{
+        return 0;
+}
+
+static inline int pinmux_gpio_direction_output(unsigned gpio)
+{
+        return 0;
+}
+
 static inline struct pinmux * __must_check pinmux_get(struct device *dev, const char *name)
 {
         return NULL;