pinctrl: enhance mapping table to support pin config operations

The pinctrl mapping table can now contain entries to:
* Set the mux function of a pin group
* Apply a set of pin config options to a pin or a group

This allows pinctrl_select_state() to apply pin configs settings as well
as mux settings.

v3: Fix find_pinctrl() to iterate over the correct list.
   s/_MUX_CONFIGS_/_CONFIGS_/ in mapping table macros.
   Fix documentation to use correct mapping table macro.
v2: Added numerous extra PIN_MAP_*() special-case macros.
   Fixed kerneldoc typo. Delete pinctrl_get_pin_id() and
   replace it with pin_get_from_name(). Various minor fixes.
   Updates due to rebase.

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

6 files changed, 426 insertions, 60 deletions

diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index c6f3ca32189e..ec3b8cc188af 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -502,6 +502,9 @@ static int add_setting(struct pinctrl *p, struct pinctrl_map const *map)
         if (IS_ERR(state))
                 return PTR_ERR(state);
 
+        if (map->type == PIN_MAP_TYPE_DUMMY_STATE)
+                return 0;
+
         setting = kzalloc(sizeof(*setting), GFP_KERNEL);
         if (setting == NULL) {
                 dev_err(p->dev,
@@ -509,6 +512,8 @@ static int add_setting(struct pinctrl *p, struct pinctrl_map const *map)
                 return -ENOMEM;
         }
 
+        setting->type = map->type;
+
         setting->pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name);
         if (setting->pctldev == NULL) {
                 dev_err(p->dev, "unknown pinctrl device %s in map entry",
@@ -518,7 +523,18 @@ static int add_setting(struct pinctrl *p, struct pinctrl_map const *map)
                 return -ENODEV;
         }
 
-        ret = pinmux_map_to_setting(map, setting);
+        switch (map->type) {
+        case PIN_MAP_TYPE_MUX_GROUP:
+                ret = pinmux_map_to_setting(map, setting);
+                break;
+        case PIN_MAP_TYPE_CONFIGS_PIN:
+        case PIN_MAP_TYPE_CONFIGS_GROUP:
+                ret = pinconf_map_to_setting(map, setting);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
         if (ret < 0) {
                 kfree(setting);
                 return ret;
@@ -533,7 +549,7 @@ static struct pinctrl *find_pinctrl(struct device *dev)
 {
         struct pinctrl *p;
 
-        list_for_each_entry(p, &pinctrldev_list, node)
+        list_for_each_entry(p, &pinctrl_list, node)
                 if (p->dev == dev)
                         return p;
 
@@ -626,9 +642,19 @@ static void pinctrl_put_locked(struct pinctrl *p, bool inlist)
 
         list_for_each_entry_safe(state, n1, &p->states, node) {
                 list_for_each_entry_safe(setting, n2, &state->settings, node) {
-                        if (state == p->state)
-                                pinmux_disable_setting(setting);
-                        pinmux_free_setting(setting);
+                        switch (setting->type) {
+                        case PIN_MAP_TYPE_MUX_GROUP:
+                                if (state == p->state)
+                                        pinmux_disable_setting(setting);
+                                pinmux_free_setting(setting);
+                                break;
+                        case PIN_MAP_TYPE_CONFIGS_PIN:
+                        case PIN_MAP_TYPE_CONFIGS_GROUP:
+                                pinconf_free_setting(setting);
+                                break;
+                        default:
+                                break;
+                        }
                         list_del(&setting->node);
                         kfree(setting);
                 }
@@ -703,9 +729,13 @@ static int pinctrl_select_state_locked(struct pinctrl *p,
                  */
                 list_for_each_entry(setting, &p->state->settings, node) {
                         bool found = false;
+                        if (setting->type != PIN_MAP_TYPE_MUX_GROUP)
+                                continue;
                         list_for_each_entry(setting2, &state->settings, node) {
-                                if (setting2->group_selector ==
-                                                setting->group_selector) {
+                                if (setting2->type != PIN_MAP_TYPE_MUX_GROUP)
+                                        continue;
+                                if (setting2->data.mux.group ==
+                                                setting->data.mux.group) {
                                         found = true;
                                         break;
                                 }
@@ -719,7 +749,18 @@ static int pinctrl_select_state_locked(struct pinctrl *p,
 
         /* Apply all the settings for the new state */
         list_for_each_entry(setting, &state->settings, node) {
-                ret = pinmux_enable_setting(setting);
+                switch (setting->type) {
+                case PIN_MAP_TYPE_MUX_GROUP:
+                        ret = pinmux_enable_setting(setting);
+                        break;
+                case PIN_MAP_TYPE_CONFIGS_PIN:
+                case PIN_MAP_TYPE_CONFIGS_GROUP:
+                        ret = pinconf_apply_setting(setting);
+                        break;
+                default:
+                        ret = -EINVAL;
+                        break;
+                }
                 if (ret < 0) {
                         /* FIXME: Difficult to return to prev state */
                         return ret;
@@ -756,33 +797,48 @@ EXPORT_SYMBOL_GPL(pinctrl_select_state);
 int pinctrl_register_mappings(struct pinctrl_map const *maps,
                               unsigned num_maps)
 {
-        int i;
+        int i, ret;
         struct pinctrl_maps *maps_node;
 
         pr_debug("add %d pinmux maps\n", num_maps);
 
         /* First sanity check the new mapping */
         for (i = 0; i < num_maps; i++) {
+                if (!maps[i].dev_name) {
+                        pr_err("failed to register map %s (%d): no device given\n",
+                               maps[i].name, i);
+                        return -EINVAL;
+                }
+
                 if (!maps[i].name) {
                         pr_err("failed to register map %d: no map name given\n",
                                i);
                         return -EINVAL;
                 }
 
-                if (!maps[i].ctrl_dev_name) {
+                if (maps[i].type != PIN_MAP_TYPE_DUMMY_STATE &&
+                                !maps[i].ctrl_dev_name) {
                         pr_err("failed to register map %s (%d): no pin control device given\n",
                                maps[i].name, i);
                         return -EINVAL;
                 }
 
-                if (!maps[i].function) {
-                        pr_err("failed to register map %s (%d): no function ID given\n",
-                               maps[i].name, i);
-                        return -EINVAL;
-                }
-
-                if (!maps[i].dev_name) {
-                        pr_err("failed to register map %s (%d): no device given\n",
+                switch (maps[i].type) {
+                case PIN_MAP_TYPE_DUMMY_STATE:
+                        break;
+                case PIN_MAP_TYPE_MUX_GROUP:
+                        ret = pinmux_validate_map(&maps[i], i);
+                        if (ret < 0)
+                                return 0;
+                        break;
+                case PIN_MAP_TYPE_CONFIGS_PIN:
+                case PIN_MAP_TYPE_CONFIGS_GROUP:
+                        ret = pinconf_validate_map(&maps[i], i);
+                        if (ret < 0)
+                                return 0;
+                        break;
+                default:
+                        pr_err("failed to register map %s (%d): invalid type given\n",
                                maps[i].name, i);
                         return -EINVAL;
                 }
@@ -934,6 +990,22 @@ static int pinctrl_devices_show(struct seq_file *s, void *what)
         return 0;
 }
 
+static inline const char *map_type(enum pinctrl_map_type type)
+{
+        static const char * const names[] = {
+                "INVALID",
+                "DUMMY_STATE",
+                "MUX_GROUP",
+                "CONFIGS_PIN",
+                "CONFIGS_GROUP",
+        };
+
+        if (type >= ARRAY_SIZE(names))
+                return "UNKNOWN";
+
+        return names[type];
+}
+
 static int pinctrl_maps_show(struct seq_file *s, void *what)
 {
         struct pinctrl_maps *maps_node;
@@ -945,12 +1017,27 @@ static int pinctrl_maps_show(struct seq_file *s, void *what)
         mutex_lock(&pinctrl_mutex);
 
         for_each_maps(maps_node, i, map) {
-                seq_printf(s, "%s:\n", map->name);
-                seq_printf(s, "  device: %s\n", map->dev_name);
-                seq_printf(s, "  controlling device %s\n", map->ctrl_dev_name);
-                seq_printf(s, "  function: %s\n", map->function);
-                seq_printf(s, "  group: %s\n", map->group ? map->group :
-                           "(default)");
+                seq_printf(s, "device %s\nstate %s\ntype %s (%d)\n",
+                           map->dev_name, map->name, map_type(map->type),
+                           map->type);
+
+                if (map->type != PIN_MAP_TYPE_DUMMY_STATE)
+                        seq_printf(s, "controlling device %s\n",
+                                   map->ctrl_dev_name);
+
+                switch (map->type) {
+                case PIN_MAP_TYPE_MUX_GROUP:
+                        pinmux_show_map(s, map);
+                        break;
+                case PIN_MAP_TYPE_CONFIGS_PIN:
+                case PIN_MAP_TYPE_CONFIGS_GROUP:
+                        pinconf_show_map(s, map);
+                        break;
+                default:
+                        break;
+                }
+
+                seq_printf(s, "\n");
         }
 
         mutex_unlock(&pinctrl_mutex);
@@ -977,8 +1064,23 @@ static int pinctrl_show(struct seq_file *s, void *what)
                         seq_printf(s, "  state: %s\n", state->name);
 
                         list_for_each_entry(setting, &state->settings, node) {
-                                seq_printf(s, "    ");
-                                pinmux_dbg_show(s, setting);
+                                struct pinctrl_dev *pctldev = setting->pctldev;
+
+                                seq_printf(s, "    type: %s controller %s ",
+                                           map_type(setting->type),
+                                           pinctrl_dev_get_name(pctldev));
+
+                                switch (setting->type) {
+                                case PIN_MAP_TYPE_MUX_GROUP:
+                                        pinmux_show_setting(s, setting);
+                                        break;
+                                case PIN_MAP_TYPE_CONFIGS_PIN:
+                                case PIN_MAP_TYPE_CONFIGS_GROUP:
+                                        pinconf_show_setting(s, setting);
+                                        break;
+                                default:
+                                        break;
+                                }
                         }
                 }
         }
diff --git a/drivers/pinctrl/core.h b/drivers/pinctrl/core.h
index 5691d312e15a..1cae3723bbed 100644
--- a/drivers/pinctrl/core.h
+++ b/drivers/pinctrl/core.h
@@ -72,17 +72,44 @@ struct pinctrl_state {
 };
 
 /**
+ * struct pinctrl_setting_mux - setting data for MAP_TYPE_MUX_GROUP
+ * @group: the group selector to program
+ * @func: the function selector to program
+ */
+struct pinctrl_setting_mux {
+        unsigned group;
+        unsigned func;
+};
+
+/**
+ * struct pinctrl_setting_configs - setting data for MAP_TYPE_CONFIGS_*
+ * @group_or_pin: the group selector or pin ID to program
+ * @configs: a pointer to an array of config parameters/values to program into
+ *      hardware. Each individual pin controller defines the format and meaning
+ *      of config parameters.
+ * @num_configs: the number of entries in array @configs
+ */
+struct pinctrl_setting_configs {
+        unsigned group_or_pin;
+        unsigned long *configs;
+        unsigned num_configs;
+};
+
+/**
  * struct pinctrl_setting - an individual mux setting
  * @node: list node for struct pinctrl_settings's @settings field
+ * @type: the type of setting
  * @pctldev: pin control device handling to be programmed
- * @group_selector: the group selector to program
- * @func_selector: the function selector to program
+ * @data: Data specific to the setting type
  */
 struct pinctrl_setting {
         struct list_head node;
+        enum pinctrl_map_type type;
         struct pinctrl_dev *pctldev;
-        unsigned group_selector;
-        unsigned func_selector;
+        union {
+                struct pinctrl_setting_mux mux;
+                struct pinctrl_setting_configs configs;
+        } data;
 };
 
 /**
diff --git a/drivers/pinctrl/pinconf.c b/drivers/pinctrl/pinconf.c
index e0a453790a40..84869f28b101 100644
--- a/drivers/pinctrl/pinconf.c
+++ b/drivers/pinctrl/pinconf.c
@@ -36,6 +36,24 @@ int pinconf_check_ops(struct pinctrl_dev *pctldev)
         return 0;
 }
 
+int pinconf_validate_map(struct pinctrl_map const *map, int i)
+{
+        if (!map->data.configs.group_or_pin) {
+                pr_err("failed to register map %s (%d): no group/pin given\n",
+                       map->name, i);
+                return -EINVAL;
+        }
+
+        if (map->data.configs.num_configs &&
+                        !map->data.configs.configs) {
+                pr_err("failed to register map %s (%d): no configs ptr given\n",
+                       map->name, i);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
                            unsigned long *config)
 {
@@ -260,8 +278,155 @@ unlock:
 }
 EXPORT_SYMBOL(pin_config_group_set);
 
+int pinconf_map_to_setting(struct pinctrl_map const *map,
+                          struct pinctrl_setting *setting)
+{
+        struct pinctrl_dev *pctldev = setting->pctldev;
+
+        switch (setting->type) {
+        case PIN_MAP_TYPE_CONFIGS_PIN:
+                setting->data.configs.group_or_pin =
+                        pin_get_from_name(pctldev,
+                                          map->data.configs.group_or_pin);
+                if (setting->data.configs.group_or_pin < 0)
+                        return setting->data.configs.group_or_pin;
+                break;
+        case PIN_MAP_TYPE_CONFIGS_GROUP:
+                setting->data.configs.group_or_pin =
+                        pinctrl_get_group_selector(pctldev,
+                                        map->data.configs.group_or_pin);
+                if (setting->data.configs.group_or_pin < 0)
+                        return setting->data.configs.group_or_pin;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        setting->data.configs.num_configs = map->data.configs.num_configs;
+        setting->data.configs.configs = map->data.configs.configs;
+
+        return 0;
+}
+
+void pinconf_free_setting(struct pinctrl_setting const *setting)
+{
+}
+
+int pinconf_apply_setting(struct pinctrl_setting const *setting)
+{
+        struct pinctrl_dev *pctldev = setting->pctldev;
+        const struct pinconf_ops *ops = pctldev->desc->confops;
+        int i, ret;
+
+        if (!ops) {
+                dev_err(pctldev->dev, "missing confops\n");
+                return -EINVAL;
+        }
+
+        switch (setting->type) {
+        case PIN_MAP_TYPE_CONFIGS_PIN:
+                if (!ops->pin_config_set) {
+                        dev_err(pctldev->dev, "missing pin_config_set op\n");
+                        return -EINVAL;
+                }
+                for (i = 0; i < setting->data.configs.num_configs; i++) {
+                        ret = ops->pin_config_set(pctldev,
+                                        setting->data.configs.group_or_pin,
+                                        setting->data.configs.configs[i]);
+                        if (ret < 0) {
+                                dev_err(pctldev->dev,
+                                        "pin_config_set op failed for pin %d config %08lx\n",
+                                        setting->data.configs.group_or_pin,
+                                        setting->data.configs.configs[i]);
+                                return ret;
+                        }
+                }
+                break;
+        case PIN_MAP_TYPE_CONFIGS_GROUP:
+                if (!ops->pin_config_group_set) {
+                        dev_err(pctldev->dev,
+                                "missing pin_config_group_set op\n");
+                        return -EINVAL;
+                }
+                for (i = 0; i < setting->data.configs.num_configs; i++) {
+                        ret = ops->pin_config_group_set(pctldev,
+                                        setting->data.configs.group_or_pin,
+                                        setting->data.configs.configs[i]);
+                        if (ret < 0) {
+                                dev_err(pctldev->dev,
+                                        "pin_config_group_set op failed for group %d config %08lx\n",
+                                        setting->data.configs.group_or_pin,
+                                        setting->data.configs.configs[i]);
+                                return ret;
+                        }
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 #ifdef CONFIG_DEBUG_FS
 
+void pinconf_show_map(struct seq_file *s, struct pinctrl_map const *map)
+{
+        int i;
+
+        switch (map->type) {
+        case PIN_MAP_TYPE_CONFIGS_PIN:
+                seq_printf(s, "pin ");
+                break;
+        case PIN_MAP_TYPE_CONFIGS_GROUP:
+                seq_printf(s, "group ");
+                break;
+        default:
+                break;
+        }
+
+        seq_printf(s, "%s\n", map->data.configs.group_or_pin);
+
+        for (i = 0; i < map->data.configs.num_configs; i++)
+                seq_printf(s, "config %08lx\n", map->data.configs.configs[i]);
+}
+
+void pinconf_show_setting(struct seq_file *s,
+                          struct pinctrl_setting const *setting)
+{
+        struct pinctrl_dev *pctldev = setting->pctldev;
+        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
+        struct pin_desc *desc;
+        int i;
+
+        switch (setting->type) {
+        case PIN_MAP_TYPE_CONFIGS_PIN:
+                desc = pin_desc_get(setting->pctldev,
+                                    setting->data.configs.group_or_pin);
+                seq_printf(s, "pin %s (%d)",
+                           desc->name ? desc->name : "unnamed",
+                           setting->data.configs.group_or_pin);
+                break;
+        case PIN_MAP_TYPE_CONFIGS_GROUP:
+                seq_printf(s, "group %s (%d)",
+                           pctlops->get_group_name(pctldev,
+                                        setting->data.configs.group_or_pin),
+                           setting->data.configs.group_or_pin);
+                break;
+        default:
+                break;
+        }
+
+        /*
+         * FIXME: We should really get the pin controler to dump the config
+         * values, so they can be decoded to something meaningful.
+         */
+        for (i = 0; i < setting->data.configs.num_configs; i++)
+                seq_printf(s, " %08lx", setting->data.configs.configs[i]);
+
+        seq_printf(s, "\n");
+}
+
 static void pinconf_dump_pin(struct pinctrl_dev *pctldev,
                              struct seq_file *s, int pin)
 {
diff --git a/drivers/pinctrl/pinconf.h b/drivers/pinctrl/pinconf.h
index 1d6ea9de75fc..0ded227661a5 100644
--- a/drivers/pinctrl/pinconf.h
+++ b/drivers/pinctrl/pinconf.h
@@ -15,6 +15,16 @@
 
 int pinconf_check_ops(struct pinctrl_dev *pctldev);
 
+int pinconf_validate_map(struct pinctrl_map const *map, int i);
+
+int pinconf_map_to_setting(struct pinctrl_map const *map,
+                          struct pinctrl_setting *setting);
+void pinconf_free_setting(struct pinctrl_setting const *setting);
+int pinconf_apply_setting(struct pinctrl_setting const *setting);
+
+void pinconf_show_map(struct seq_file *s, struct pinctrl_map const *map);
+void pinconf_show_setting(struct seq_file *s,
+                          struct pinctrl_setting const *setting);
 void pinconf_init_device_debugfs(struct dentry *devroot,
                                  struct pinctrl_dev *pctldev);
 
@@ -25,6 +35,36 @@ static inline int pinconf_check_ops(struct pinctrl_dev *pctldev)
         return 0;
 }
 
+static inline int pinconf_validate_map(struct pinctrl_map const *map, int i)
+{
+        return 0;
+}
+
+static inline int pinconf_map_to_setting(struct pinctrl_map const *map,
+                          struct pinctrl_setting *setting)
+{
+        return 0;
+}
+
+static inline void pinconf_free_setting(struct pinctrl_setting const *setting)
+{
+}
+
+static inline int pinconf_apply_setting(struct pinctrl_setting const *setting)
+{
+        return 0;
+}
+
+static inline void pinconf_show_map(struct seq_file *s,
+                                    struct pinctrl_map const *map)
+{
+}
+
+static inline void pinconf_show_setting(struct seq_file *s,
+                          struct pinctrl_setting const *setting)
+{
+}
+
 static inline void pinconf_init_device_debugfs(struct dentry *devroot,
                                                struct pinctrl_dev *pctldev)
 {
diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c
index 56ca42e6a6ec..4852ebe5712e 100644
--- a/drivers/pinctrl/pinmux.c
+++ b/drivers/pinctrl/pinmux.c
@@ -58,6 +58,17 @@ int pinmux_check_ops(struct pinctrl_dev *pctldev)
         return 0;
 }
 
+int pinmux_validate_map(struct pinctrl_map const *map, int i)
+{
+        if (!map->data.mux.function) {
+                pr_err("failed to register map %s (%d): no function given\n",
+                       map->name, i);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 /**
  * pin_request() - request a single pin to be muxed in, typically for GPIO
  * @pin: the pin number in the global pin space
@@ -284,21 +295,21 @@ int pinmux_map_to_setting(struct pinctrl_map const *map,
         const unsigned *pins;
         unsigned num_pins;
 
-        setting->func_selector =
-                pinmux_func_name_to_selector(pctldev, map->function);
-        if (setting->func_selector < 0)
-                return setting->func_selector;
+        setting->data.mux.func =
+                pinmux_func_name_to_selector(pctldev, map->data.mux.function);
+        if (setting->data.mux.func < 0)
+                return setting->data.mux.func;
 
-        ret = pmxops->get_function_groups(pctldev, setting->func_selector,
+        ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
                                           &groups, &num_groups);
         if (ret < 0)
                 return ret;
         if (!num_groups)
                 return -EINVAL;
 
-        if (map->group) {
+        if (map->data.mux.group) {
                 bool found = false;
-                group = map->group;
+                group = map->data.mux.group;
                 for (i = 0; i < num_groups; i++) {
                         if (!strcmp(group, groups[i])) {
                                 found = true;
@@ -311,17 +322,16 @@ int pinmux_map_to_setting(struct pinctrl_map const *map,
                 group = groups[0];
         }
 
-        setting->group_selector =
-                pinctrl_get_group_selector(pctldev, group);
-        if (setting->group_selector < 0)
-                return setting->group_selector;
+        setting->data.mux.group = pinctrl_get_group_selector(pctldev, group);
+        if (setting->data.mux.group < 0)
+                return setting->data.mux.group;
 
-        ret = pctlops->get_group_pins(pctldev, setting->group_selector,
-                                      &pins, &num_pins);
+        ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins,
+                                      &num_pins);
         if (ret) {
                 dev_err(pctldev->dev,
                         "could not get pins for device %s group selector %d\n",
-                        pinctrl_dev_get_name(pctldev), setting->group_selector);
+                        pinctrl_dev_get_name(pctldev), setting->data.mux.group);
                         return -ENODEV;
         }
 
@@ -352,12 +362,12 @@ void pinmux_free_setting(struct pinctrl_setting const *setting)
         int ret;
         int i;
 
-        ret = pctlops->get_group_pins(pctldev, setting->group_selector,
+        ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
                                       &pins, &num_pins);
         if (ret) {
                 dev_err(pctldev->dev,
                         "could not get pins for device %s group selector %d\n",
-                        pinctrl_dev_get_name(pctldev), setting->group_selector);
+                        pinctrl_dev_get_name(pctldev), setting->data.mux.group);
                 return;
         }
 
@@ -370,8 +380,8 @@ int pinmux_enable_setting(struct pinctrl_setting const *setting)
         struct pinctrl_dev *pctldev = setting->pctldev;
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 
-        return ops->enable(pctldev, setting->func_selector,
-                           setting->group_selector);
+        return ops->enable(pctldev, setting->data.mux.func,
+                           setting->data.mux.group);
 }
 
 void pinmux_disable_setting(struct pinctrl_setting const *setting)
@@ -379,7 +389,7 @@ void pinmux_disable_setting(struct pinctrl_setting const *setting)
         struct pinctrl_dev *pctldev = setting->pctldev;
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 
-        ops->disable(pctldev, setting->func_selector, setting->group_selector);
+        ops->disable(pctldev, setting->data.mux.func, setting->data.mux.group);
 }
 
 #ifdef CONFIG_DEBUG_FS
@@ -456,18 +466,25 @@ static int pinmux_pins_show(struct seq_file *s, void *what)
         return 0;
 }
 
-void pinmux_dbg_show(struct seq_file *s, struct pinctrl_setting const *setting)
+void pinmux_show_map(struct seq_file *s, struct pinctrl_map const *map)
+{
+        seq_printf(s, "group %s\nfunction %s\n",
+                map->data.mux.group ? map->data.mux.group : "(default)",
+                map->data.mux.function);
+}
+
+void pinmux_show_setting(struct seq_file *s,
+                         struct pinctrl_setting const *setting)
 {
         struct pinctrl_dev *pctldev = setting->pctldev;
         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 
-        seq_printf(s, "controller: %s group: %s (%u) function: %s (%u)\n",
-                   pinctrl_dev_get_name(pctldev),
-                   pctlops->get_group_name(pctldev, setting->group_selector),
-                   setting->group_selector,
-                   pmxops->get_function_name(pctldev, setting->func_selector),
-                   setting->func_selector);
+        seq_printf(s, "group: %s (%u) function: %s (%u)\n",
+                   pctlops->get_group_name(pctldev, setting->data.mux.group),
+                   setting->data.mux.group,
+                   pmxops->get_function_name(pctldev, setting->data.mux.func),
+                   setting->data.mux.func);
 }
 
 static int pinmux_functions_open(struct inode *inode, struct file *file)
diff --git a/drivers/pinctrl/pinmux.h b/drivers/pinctrl/pinmux.h
index 1500ae88f87c..6fc47003e95d 100644
--- a/drivers/pinctrl/pinmux.h
+++ b/drivers/pinctrl/pinmux.h
@@ -14,6 +14,8 @@
 
 int pinmux_check_ops(struct pinctrl_dev *pctldev);
 
+int pinmux_validate_map(struct pinctrl_map const *map, int i);
+
 int pinmux_request_gpio(struct pinctrl_dev *pctldev,
                         struct pinctrl_gpio_range *range,
                         unsigned pin, unsigned gpio);
@@ -29,7 +31,9 @@ void pinmux_free_setting(struct pinctrl_setting const *setting);
 int pinmux_enable_setting(struct pinctrl_setting const *setting);
 void pinmux_disable_setting(struct pinctrl_setting const *setting);
 
-void pinmux_dbg_show(struct seq_file *s, struct pinctrl_setting const *setting);
+void pinmux_show_map(struct seq_file *s, struct pinctrl_map const *map);
+void pinmux_show_setting(struct seq_file *s,
+                         struct pinctrl_setting const *setting);
 void pinmux_init_device_debugfs(struct dentry *devroot,
                                 struct pinctrl_dev *pctldev);
 
@@ -40,6 +44,11 @@ static inline int pinmux_check_ops(struct pinctrl_dev *pctldev)
         return 0;
 }
 
+static inline int pinmux_validate_map(struct pinctrl_map const *map, int i)
+{
+        return 0;
+}
+
 static inline int pinmux_request_gpio(struct pinctrl_dev *pctldev,
                         struct pinctrl_gpio_range *range,
                         unsigned pin, unsigned gpio)
@@ -80,12 +89,18 @@ static inline void pinmux_disable_setting(
 {
 }
 
-static inline void pinmux_init_device_debugfs(struct dentry *devroot,
-                                              struct pinctrl_dev *pctldev)
+static inline void pinmux_show_map(struct seq_file *s,
+                                   struct pinctrl_map const *map)
+{
+}
+
+static inline void pinmux_show_setting(struct seq_file *s,
+                                       struct pinctrl_setting const *setting)
 {
 }
 
-static inline void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p)
+static inline void pinmux_init_device_debugfs(struct dentry *devroot,
+                                              struct pinctrl_dev *pctldev)
 {
 }