1 files changed, 128 insertions, 62 deletions
diff --git a/include/linux/pinctrl/machine.h b/include/linux/pinctrl/machine.h
index d0aecb7f6fb9..fee4349364f7 100644
--- a/include/linux/pinctrl/machine.h
+++ b/include/linux/pinctrl/machine.h
@@ -9,87 +9,153 @@
 *
 * License terms: GNU General Public License (GPL) version 2
 */
-#ifndef __LINUX_PINMUX_MACHINE_H
+#ifndef __LINUX_PINCTRL_MACHINE_H
-#define __LINUX_PINMUX_MACHINE_H
+#define __LINUX_PINCTRL_MACHINE_H
+#include "pinctrl-state.h"
+enum pinctrl_map_type {
+        PIN_MAP_TYPE_INVALID,
+        PIN_MAP_TYPE_DUMMY_STATE,
+        PIN_MAP_TYPE_MUX_GROUP,
+        PIN_MAP_TYPE_CONFIGS_PIN,
+        PIN_MAP_TYPE_CONFIGS_GROUP,
+};
+/**
+ * struct pinctrl_map_mux - mapping table content for MAP_TYPE_MUX_GROUP
+ * @group: the name of the group whose mux function is to be configured. This
+ *      field may be left NULL, and the first applicable group for the function
+ *      will be used.
+ * @function: the mux function to select for the group
+ */
+struct pinctrl_map_mux {
+        const char *group;
+        const char *function;
+};
 /**
- * struct pinmux_map - boards/machines shall provide this map for devices
+ * struct pinctrl_map_configs - mapping table content for MAP_TYPE_CONFIGS_*
+ * @group_or_pin: the name of the pin or group whose configuration parameters
+ *      are to be configured.
+ * @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_map_configs {
+        const char *group_or_pin;
+        unsigned long *configs;
+        unsigned num_configs;
+};
+/**
+ * struct pinctrl_map - boards/machines shall provide this map for devices
+ * @dev_name: the name of the device using this specific mapping, the name
+ *      must be the same as in your struct device*. If this name is set to the
+ *      same name as the pin controllers own dev_name(), the map entry will be
+ *      hogged by the driver itself upon registration
 * @name: the name of this specific map entry for the particular machine.
- *      This is the second parameter passed to pinmux_get() when you want
+ *      This is the parameter passed to pinmux_lookup_state()
- *      to have several mappings to the same device
+ * @type: the type of mapping table entry
- * @ctrl_dev: the pin control device to be used by this mapping, may be NULL
- *      if you provide .ctrl_dev_name instead (this is more common)
 * @ctrl_dev_name: the name of the device controlling this specific mapping,
- *      the name must be the same as in your struct device*, may be NULL if
+ *      the name must be the same as in your struct device*. This field is not
- *      you provide .ctrl_dev instead
+ *      used for PIN_MAP_TYPE_DUMMY_STATE
- * @function: a function in the driver to use for this mapping, the driver
+ * @data: Data specific to the mapping type
- *      will lookup the function referenced by this ID on the specified
- *      pin control device
- * @group: sometimes a function can map to different pin groups, so this
- *      selects a certain specific pin group to activate for the function, if
- *      left as NULL, the first applicable group will be used
- * @dev: the device using this specific mapping, may be NULL if you provide
- *      .dev_name instead (this is more common)
- * @dev_name: the name of the device using this specific mapping, the name
- *      must be the same as in your struct device*, may be NULL if you
- *      provide .dev instead
- * @hog_on_boot: if this is set to true, the pin control subsystem will itself
- *      hog the mappings as the pinmux device drivers are attached, so this is
- *      typically used with system maps (mux mappings without an assigned
- *      device) that you want to get hogged and enabled by default as soon as
- *      a pinmux device supporting it is registered. These maps will not be
- *      disabled and put until the system shuts down.
 */
-struct pinmux_map {
+struct pinctrl_map {
+        const char *dev_name;
        const char *name;
-        struct device *ctrl_dev;
+        enum pinctrl_map_type type;
        const char *ctrl_dev_name;
-        const char *function;
+        union {
-        const char *group;
+                struct pinctrl_map_mux mux;
-        struct device *dev;
+                struct pinctrl_map_configs configs;
-        const char *dev_name;
+        } data;
-        bool hog_on_boot;
 };
-/*
+/* Convenience macros to create mapping table entries */
- * Convenience macro to set a simple map from a certain pin controller and a
- * certain function to a named device
- */
-#define PINMUX_MAP(a, b, c, d) \
-        { .name = a, .ctrl_dev_name = b, .function = c, .dev_name = d }
-/*
+#define PIN_MAP_DUMMY_STATE(dev, state) \
- * Convenience macro to map a system function onto a certain pinctrl device.
+        {                                                               \
- * System functions are not assigned to a particular device.
+                .dev_name = dev,                                        \
- */
+                .name = state,                                          \
-#define PINMUX_MAP_SYS(a, b, c) \
+                .type = PIN_MAP_TYPE_DUMMY_STATE,                       \
-        { .name = a, .ctrl_dev_name = b, .function = c }
+        }
-/*
+#define PIN_MAP_MUX_GROUP(dev, state, pinctrl, grp, func)               \
- * Convenience macro to map a system function onto a certain pinctrl device,
+        {                                                               \
- * to be hogged by the pinmux core until the system shuts down.
+                .dev_name = dev,                                        \
- */
+                .name = state,                                          \
-#define PINMUX_MAP_SYS_HOG(a, b, c) \
+                .type = PIN_MAP_TYPE_MUX_GROUP,                         \
-        { .name = a, .ctrl_dev_name = b, .function = c, \
+                .ctrl_dev_name = pinctrl,                               \
-          .hog_on_boot = true }
+                .data.mux = {                                           \
+                        .group = grp,                                   \
+                        .function = func,                               \
+                },                                                      \
+        }
-/*
+#define PIN_MAP_MUX_GROUP_DEFAULT(dev, pinctrl, grp, func)              \
- * Convenience macro to map a system function onto a certain pinctrl device
+        PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, func)
- * using a specified group, to be hogged by the pinmux core until the system
- * shuts down.
+#define PIN_MAP_MUX_GROUP_HOG(dev, state, grp, func)                    \
- */
+        PIN_MAP_MUX_GROUP(dev, state, dev, grp, func)
-#define PINMUX_MAP_SYS_HOG_GROUP(a, b, c, d)            \
-        { .name = a, .ctrl_dev_name = b, .function = c, .group = d, \
+#define PIN_MAP_MUX_GROUP_HOG_DEFAULT(dev, grp, func)                   \
-          .hog_on_boot = true }
+        PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, func)
+#define PIN_MAP_CONFIGS_PIN(dev, state, pinctrl, pin, cfgs)             \
+        {                                                               \
+                .dev_name = dev,                                        \
+                .name = state,                                          \
+                .type = PIN_MAP_TYPE_CONFIGS_PIN,                       \
+                .ctrl_dev_name = pinctrl,                               \
+                .data.configs = {                                       \
+                        .group_or_pin = pin,                            \
+                        .configs = cfgs,                                \
+                        .num_configs = ARRAY_SIZE(cfgs),                \
+                },                                                      \
+        }
+#define PIN_MAP_CONFIGS_PIN_DEFAULT(dev, pinctrl, pin, cfgs)            \
+        PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, pinctrl, pin, cfgs)
+#define PIN_MAP_CONFIGS_PIN_HOG(dev, state, pin, cfgs)                  \
+        PIN_MAP_CONFIGS_PIN(dev, state, dev, pin, cfgs)
+#define PIN_MAP_CONFIGS_PIN_HOG_DEFAULT(dev, pin, cfgs)                 \
+        PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, dev, pin, cfgs)
+#define PIN_MAP_CONFIGS_GROUP(dev, state, pinctrl, grp, cfgs)           \
+        {                                                               \
+                .dev_name = dev,                                        \
+                .name = state,                                          \
+                .type = PIN_MAP_TYPE_CONFIGS_GROUP,                     \
+                .ctrl_dev_name = pinctrl,                               \
+                .data.configs = {                                       \
+                        .group_or_pin = grp,                            \
+                        .configs = cfgs,                                \
+                        .num_configs = ARRAY_SIZE(cfgs),                \
+                },                                                      \
+        }
+#define PIN_MAP_CONFIGS_GROUP_DEFAULT(dev, pinctrl, grp, cfgs)          \
+        PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, cfgs)
+#define PIN_MAP_CONFIGS_GROUP_HOG(dev, state, grp, cfgs)                \
+        PIN_MAP_CONFIGS_GROUP(dev, state, dev, grp, cfgs)
+#define PIN_MAP_CONFIGS_GROUP_HOG_DEFAULT(dev, grp, cfgs)               \
+        PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, cfgs)
 #ifdef CONFIG_PINMUX
-extern int pinmux_register_mappings(struct pinmux_map const *map,
+extern int pinctrl_register_mappings(struct pinctrl_map const *map,
                                unsigned num_maps);
 #else
-static inline int pinmux_register_mappings(struct pinmux_map const *map,
+static inline int pinctrl_register_mappings(struct pinctrl_map const *map,
                                           unsigned num_maps)
 {
        return 0;

diff --git a/include/linux/pinctrl/machine.h b/include/linux/pinctrl/machine.h index d0aecb7f6fb9..fee4349364f7 100644 --- a/include/linux/pinctrl/machine.h +++ b/include/linux/pinctrl/machine.h
@@ -9,87 +9,153 @@
9	*	9	*
10	* License terms: GNU General Public License (GPL) version 2	10	* License terms: GNU General Public License (GPL) version 2
11	*/	11	*/
12	#ifndef __LINUX_PINMUX_MACHINE_H	12	#ifndef __LINUX_PINCTRL_MACHINE_H
13	#define __LINUX_PINMUX_MACHINE_H	13	#define __LINUX_PINCTRL_MACHINE_H
		14
		15	#include "pinctrl-state.h"
		16
		17	enum pinctrl_map_type {
		18	PIN_MAP_TYPE_INVALID,
		19	PIN_MAP_TYPE_DUMMY_STATE,
		20	PIN_MAP_TYPE_MUX_GROUP,
		21	PIN_MAP_TYPE_CONFIGS_PIN,
		22	PIN_MAP_TYPE_CONFIGS_GROUP,
		23	};
		24
		25	/**
		26	* struct pinctrl_map_mux - mapping table content for MAP_TYPE_MUX_GROUP
		27	* @group: the name of the group whose mux function is to be configured. This
		28	* field may be left NULL, and the first applicable group for the function
		29	* will be used.
		30	* @function: the mux function to select for the group
		31	*/
		32	struct pinctrl_map_mux {
		33	const char *group;
		34	const char *function;
		35	};
14		36
15	/**	37	/**
16	* struct pinmux_map - boards/machines shall provide this map for devices	38	* struct pinctrl_map_configs - mapping table content for MAP_TYPE_CONFIGS_*
		39	* @group_or_pin: the name of the pin or group whose configuration parameters
		40	* are to be configured.
		41	* @configs: a pointer to an array of config parameters/values to program into
		42	* hardware. Each individual pin controller defines the format and meaning
		43	* of config parameters.
		44	* @num_configs: the number of entries in array @configs
		45	*/
		46	struct pinctrl_map_configs {
		47	const char *group_or_pin;
		48	unsigned long *configs;
		49	unsigned num_configs;
		50	};
		51
		52	/**
		53	* struct pinctrl_map - boards/machines shall provide this map for devices
		54	* @dev_name: the name of the device using this specific mapping, the name
		55	* must be the same as in your struct device*. If this name is set to the
		56	* same name as the pin controllers own dev_name(), the map entry will be
		57	* hogged by the driver itself upon registration
17	* @name: the name of this specific map entry for the particular machine.	58	* @name: the name of this specific map entry for the particular machine.
18	* This is the second parameter passed to pinmux_get() when you want	59	* This is the parameter passed to pinmux_lookup_state()
19	* to have several mappings to the same device	60	* @type: the type of mapping table entry
20	* @ctrl_dev: the pin control device to be used by this mapping, may be NULL
21	* if you provide .ctrl_dev_name instead (this is more common)
22	* @ctrl_dev_name: the name of the device controlling this specific mapping,	61	* @ctrl_dev_name: the name of the device controlling this specific mapping,
23	* the name must be the same as in your struct device*, may be NULL if	62	* the name must be the same as in your struct device*. This field is not
24	* you provide .ctrl_dev instead	63	* used for PIN_MAP_TYPE_DUMMY_STATE
25	* @function: a function in the driver to use for this mapping, the driver	64	* @data: Data specific to the mapping type
26	* will lookup the function referenced by this ID on the specified
27	* pin control device
28	* @group: sometimes a function can map to different pin groups, so this
29	* selects a certain specific pin group to activate for the function, if
30	* left as NULL, the first applicable group will be used
31	* @dev: the device using this specific mapping, may be NULL if you provide
32	* .dev_name instead (this is more common)
33	* @dev_name: the name of the device using this specific mapping, the name
34	* must be the same as in your struct device*, may be NULL if you
35	* provide .dev instead
36	* @hog_on_boot: if this is set to true, the pin control subsystem will itself
37	* hog the mappings as the pinmux device drivers are attached, so this is
38	* typically used with system maps (mux mappings without an assigned
39	* device) that you want to get hogged and enabled by default as soon as
40	* a pinmux device supporting it is registered. These maps will not be
41	* disabled and put until the system shuts down.
42	*/	65	*/
43	struct pinmux_map {	66	struct pinctrl_map {
		67	const char *dev_name;
44	const char *name;	68	const char *name;
45	struct device *ctrl_dev;	69	enum pinctrl_map_type type;
46	const char *ctrl_dev_name;	70	const char *ctrl_dev_name;
47	const char *function;	71	union {
48	const char *group;	72	struct pinctrl_map_mux mux;
49	struct device *dev;	73	struct pinctrl_map_configs configs;
50	const char *dev_name;	74	} data;
51	bool hog_on_boot;
52	};	75	};
53		76
54	/*	77	/* Convenience macros to create mapping table entries */
55	* Convenience macro to set a simple map from a certain pin controller and a
56	* certain function to a named device
57	*/
58	#define PINMUX_MAP(a, b, c, d) \
59	{ .name = a, .ctrl_dev_name = b, .function = c, .dev_name = d }
60		78
61	/*	79	#define PIN_MAP_DUMMY_STATE(dev, state) \
62	* Convenience macro to map a system function onto a certain pinctrl device.	80	{ \
63	* System functions are not assigned to a particular device.	81	.dev_name = dev, \
64	*/	82	.name = state, \
65	#define PINMUX_MAP_SYS(a, b, c) \	83	.type = PIN_MAP_TYPE_DUMMY_STATE, \
66	{ .name = a, .ctrl_dev_name = b, .function = c }	84	}
67		85
68	/*	86	#define PIN_MAP_MUX_GROUP(dev, state, pinctrl, grp, func) \
69	* Convenience macro to map a system function onto a certain pinctrl device,	87	{ \
70	* to be hogged by the pinmux core until the system shuts down.	88	.dev_name = dev, \
71	*/	89	.name = state, \
72	#define PINMUX_MAP_SYS_HOG(a, b, c) \	90	.type = PIN_MAP_TYPE_MUX_GROUP, \
73	{ .name = a, .ctrl_dev_name = b, .function = c, \	91	.ctrl_dev_name = pinctrl, \
74	.hog_on_boot = true }	92	.data.mux = { \
		93	.group = grp, \
		94	.function = func, \
		95	}, \
		96	}
75		97
76	/*	98	#define PIN_MAP_MUX_GROUP_DEFAULT(dev, pinctrl, grp, func) \
77	* Convenience macro to map a system function onto a certain pinctrl device	99	PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, func)
78	* using a specified group, to be hogged by the pinmux core until the system	100
79	* shuts down.	101	#define PIN_MAP_MUX_GROUP_HOG(dev, state, grp, func) \
80	*/	102	PIN_MAP_MUX_GROUP(dev, state, dev, grp, func)
81	#define PINMUX_MAP_SYS_HOG_GROUP(a, b, c, d) \	103
82	{ .name = a, .ctrl_dev_name = b, .function = c, .group = d, \	104	#define PIN_MAP_MUX_GROUP_HOG_DEFAULT(dev, grp, func) \
83	.hog_on_boot = true }	105	PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, func)
		106
		107	#define PIN_MAP_CONFIGS_PIN(dev, state, pinctrl, pin, cfgs) \
		108	{ \
		109	.dev_name = dev, \
		110	.name = state, \
		111	.type = PIN_MAP_TYPE_CONFIGS_PIN, \
		112	.ctrl_dev_name = pinctrl, \
		113	.data.configs = { \
		114	.group_or_pin = pin, \
		115	.configs = cfgs, \
		116	.num_configs = ARRAY_SIZE(cfgs), \
		117	}, \
		118	}
		119
		120	#define PIN_MAP_CONFIGS_PIN_DEFAULT(dev, pinctrl, pin, cfgs) \
		121	PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, pinctrl, pin, cfgs)
		122
		123	#define PIN_MAP_CONFIGS_PIN_HOG(dev, state, pin, cfgs) \
		124	PIN_MAP_CONFIGS_PIN(dev, state, dev, pin, cfgs)
		125
		126	#define PIN_MAP_CONFIGS_PIN_HOG_DEFAULT(dev, pin, cfgs) \
		127	PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, dev, pin, cfgs)
		128
		129	#define PIN_MAP_CONFIGS_GROUP(dev, state, pinctrl, grp, cfgs) \
		130	{ \
		131	.dev_name = dev, \
		132	.name = state, \
		133	.type = PIN_MAP_TYPE_CONFIGS_GROUP, \
		134	.ctrl_dev_name = pinctrl, \
		135	.data.configs = { \
		136	.group_or_pin = grp, \
		137	.configs = cfgs, \
		138	.num_configs = ARRAY_SIZE(cfgs), \
		139	}, \
		140	}
		141
		142	#define PIN_MAP_CONFIGS_GROUP_DEFAULT(dev, pinctrl, grp, cfgs) \
		143	PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, cfgs)
		144
		145	#define PIN_MAP_CONFIGS_GROUP_HOG(dev, state, grp, cfgs) \
		146	PIN_MAP_CONFIGS_GROUP(dev, state, dev, grp, cfgs)
		147
		148	#define PIN_MAP_CONFIGS_GROUP_HOG_DEFAULT(dev, grp, cfgs) \
		149	PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, cfgs)
84		150
85	#ifdef CONFIG_PINMUX	151	#ifdef CONFIG_PINMUX
86		152
87	extern int pinmux_register_mappings(struct pinmux_map const *map,	153	extern int pinctrl_register_mappings(struct pinctrl_map const *map,
88	unsigned num_maps);	154	unsigned num_maps);
89		155
90	#else	156	#else
91		157
92	static inline int pinmux_register_mappings(struct pinmux_map const *map,	158	static inline int pinctrl_register_mappings(struct pinctrl_map const *map,
93	unsigned num_maps)	159	unsigned num_maps)
94	{	160	{
95	return 0;	161	return 0;