pinctrl.h

  1/* SPDX-License-Identifier: GPL-2.0-only */
  2/*
  3 * Interface the pinctrl subsystem
  4 *
  5 * Copyright (C) 2011 ST-Ericsson SA
  6 * Written on behalf of Linaro for ST-Ericsson
  7 * This interface is used in the core to keep track of pins.
  8 *
  9 * Author: Linus Walleij <linus.walleij@linaro.org>
 10 */
 11#ifndef __LINUX_PINCTRL_PINCTRL_H
 12#define __LINUX_PINCTRL_PINCTRL_H
 13
 14#include <linux/bits.h>
 15#include <linux/types.h>
 16
 17struct device;
 18struct device_node;
 19struct gpio_chip;
 20struct module;
 21struct seq_file;
 22
 23struct pin_config_item;
 24struct pinconf_generic_params;
 25struct pinconf_ops;
 26struct pinctrl_dev;
 27struct pinctrl_map;
 28struct pinmux_ops;
 29
 30/**
 31 * struct pingroup - provides information on pingroup
 32 * @name: a name for pingroup
 33 * @pins: an array of pins in the pingroup
 34 * @npins: number of pins in the pingroup
 35 */
 36struct pingroup {
 37	const char *name;
 38	const unsigned int *pins;
 39	size_t npins;
 40};
 41
 42/* Convenience macro to define a single named or anonymous pingroup */
 43#define PINCTRL_PINGROUP(_name, _pins, _npins)	\
 44(struct pingroup) {				\
 45	.name = _name,				\
 46	.pins = _pins,				\
 47	.npins = _npins,			\
 48}
 49
 50/**
 51 * struct pinctrl_pin_desc - boards/machines provide information on their
 52 * pins, pads or other muxable units in this struct
 53 * @number: unique pin number from the global pin number space
 54 * @name: a name for this pin
 55 * @drv_data: driver-defined per-pin data. pinctrl core does not touch this
 56 */
 57struct pinctrl_pin_desc {
 58	unsigned int number;
 59	const char *name;
 60	void *drv_data;
 61};
 62
 63/* Convenience macro to define a single named or anonymous pin descriptor */
 64#define PINCTRL_PIN(a, b) { .number = a, .name = b }
 65#define PINCTRL_PIN_ANON(a) { .number = a }
 66
 67/**
 68 * struct pinctrl_gpio_range - each pin controller can provide subranges of
 69 * the GPIO number space to be handled by the controller
 70 * @node: list node for internal use
 71 * @name: a name for the chip in this range
 72 * @id: an ID number for the chip in this range
 73 * @base: base offset of the GPIO range
 74 * @pin_base: base pin number of the GPIO range if pins == NULL
 75 * @npins: number of pins in the GPIO range, including the base number
 76 * @pins: enumeration of pins in GPIO range or NULL
 77 * @gc: an optional pointer to a gpio_chip
 78 */
 79struct pinctrl_gpio_range {
 80	struct list_head node;
 81	const char *name;
 82	unsigned int id;
 83	unsigned int base;
 84	unsigned int pin_base;
 85	unsigned int npins;
 86	unsigned int const *pins;
 87	struct gpio_chip *gc;
 88};
 89
 90/**
 91 * struct pinctrl_ops - global pin control operations, to be implemented by
 92 * pin controller drivers.
 93 * @get_groups_count: Returns the count of total number of groups registered.
 94 * @get_group_name: return the group name of the pin group
 95 * @get_group_pins: return an array of pins corresponding to a certain
 96 *	group selector @pins, and the size of the array in @num_pins
 97 * @pin_dbg_show: optional debugfs display hook that will provide per-device
 98 *	info for a certain pin in debugfs
 99 * @dt_node_to_map: parse a device tree "pin configuration node", and create
100 *	mapping table entries for it. These are returned through the @map and
101 *	@num_maps output parameters. This function is optional, and may be
102 *	omitted for pinctrl drivers that do not support device tree.
103 * @dt_free_map: free mapping table entries created via @dt_node_to_map. The
104 *	top-level @map pointer must be freed, along with any dynamically
105 *	allocated members of the mapping table entries themselves. This
106 *	function is optional, and may be omitted for pinctrl drivers that do
107 *	not support device tree.
108 */
109struct pinctrl_ops {
110	int (*get_groups_count) (struct pinctrl_dev *pctldev);
111	const char *(*get_group_name) (struct pinctrl_dev *pctldev,
112				       unsigned int selector);
113	int (*get_group_pins) (struct pinctrl_dev *pctldev,
114			       unsigned int selector,
115			       const unsigned int **pins,
116			       unsigned int *num_pins);
117	void (*pin_dbg_show) (struct pinctrl_dev *pctldev, struct seq_file *s,
118			      unsigned int offset);
119	int (*dt_node_to_map) (struct pinctrl_dev *pctldev,
120			       struct device_node *np_config,
121			       struct pinctrl_map **map, unsigned int *num_maps);
122	void (*dt_free_map) (struct pinctrl_dev *pctldev,
123			     struct pinctrl_map *map, unsigned int num_maps);
124};
125
126/**
127 * struct pinctrl_desc - pin controller descriptor, register this to pin
128 * control subsystem
129 * @name: name for the pin controller
130 * @pins: an array of pin descriptors describing all the pins handled by
131 *	this pin controller
132 * @npins: number of descriptors in the array, usually just ARRAY_SIZE()
133 *	of the pins field above
134 * @pctlops: pin control operation vtable, to support global concepts like
135 *	grouping of pins, this is optional.
136 * @pmxops: pinmux operations vtable, if you support pinmuxing in your driver
137 * @confops: pin config operations vtable, if you support pin configuration in
138 *	your driver
139 * @owner: module providing the pin controller, used for refcounting
140 * @num_custom_params: Number of driver-specific custom parameters to be parsed
141 *	from the hardware description
142 * @custom_params: List of driver_specific custom parameters to be parsed from
143 *	the hardware description
144 * @custom_conf_items: Information how to print @params in debugfs, must be
145 *	the same size as the @custom_params, i.e. @num_custom_params
146 * @link_consumers: If true create a device link between pinctrl and its
147 *	consumers (i.e. the devices requesting pin control states). This is
148 *	sometimes necessary to ascertain the right suspend/resume order for
149 *	example.
150 */
151struct pinctrl_desc {
152	const char *name;
153	const struct pinctrl_pin_desc *pins;
154	unsigned int npins;
155	const struct pinctrl_ops *pctlops;
156	const struct pinmux_ops *pmxops;
157	const struct pinconf_ops *confops;
158	struct module *owner;
159#ifdef CONFIG_GENERIC_PINCONF
160	unsigned int num_custom_params;
161	const struct pinconf_generic_params *custom_params;
162	const struct pin_config_item *custom_conf_items;
163#endif
164	bool link_consumers;
165};
166
167/* External interface to pin controller */
168
169extern int pinctrl_register_and_init(const struct pinctrl_desc *pctldesc,
170				     struct device *dev, void *driver_data,
171				     struct pinctrl_dev **pctldev);
172extern int pinctrl_enable(struct pinctrl_dev *pctldev);
173
174/* Please use pinctrl_register_and_init() and pinctrl_enable() instead */
175extern struct pinctrl_dev *pinctrl_register(const struct pinctrl_desc *pctldesc,
176				struct device *dev, void *driver_data);
177
178extern void pinctrl_unregister(struct pinctrl_dev *pctldev);
179
180extern int devm_pinctrl_register_and_init(struct device *dev,
181				const struct pinctrl_desc *pctldesc,
182				void *driver_data,
183				struct pinctrl_dev **pctldev);
184
185/* Please use devm_pinctrl_register_and_init() instead */
186extern struct pinctrl_dev *devm_pinctrl_register(struct device *dev,
187				const struct pinctrl_desc *pctldesc,
188				void *driver_data);
189
190extern void devm_pinctrl_unregister(struct device *dev,
191				struct pinctrl_dev *pctldev);
192
193extern void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
194				struct pinctrl_gpio_range *range);
195extern void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
196				struct pinctrl_gpio_range *ranges,
197				unsigned int nranges);
198extern void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
199				struct pinctrl_gpio_range *range);
200
201extern struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
202		struct pinctrl_gpio_range *range);
203extern struct pinctrl_gpio_range *
204pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
205				 unsigned int pin);
206extern int pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
207				  const char *pin_group, const unsigned int **pins,
208				  unsigned int *num_pins);
209
210#define PINFUNCTION_FLAG_GPIO	BIT(0)
211
212/**
213 * struct pinfunction - Description about a function
214 * @name: Name of the function
215 * @groups: An array of groups for this function
216 * @ngroups: Number of groups in @groups
217 * @flags: Additional pin function flags
218 */
219struct pinfunction {
220	const char *name;
221	const char * const *groups;
222	size_t ngroups;
223	unsigned long flags;
224};
225
226/* Convenience macro to define a single named pinfunction */
227#define PINCTRL_PINFUNCTION(_name, _groups, _ngroups)	\
228(struct pinfunction) {					\
229		.name = (_name),			\
230		.groups = (_groups),			\
231		.ngroups = (_ngroups),			\
232	}
233
234/* Same as PINCTRL_PINFUNCTION() but for the GPIO category of functions */
235#define PINCTRL_GPIO_PINFUNCTION(_name, _groups, _ngroups)	\
236(struct pinfunction) {						\
237		.name = (_name),				\
238		.groups = (_groups),				\
239		.ngroups = (_ngroups),				\
240		.flags = PINFUNCTION_FLAG_GPIO,			\
241	}
242
243#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_PINCTRL)
244extern struct pinctrl_dev *of_pinctrl_get(struct device_node *np);
245#else
246static inline
247struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
248{
249	return NULL;
250}
251#endif /* CONFIG_OF */
252
253extern const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev);
254extern const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev);
255extern void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev);
256
257#endif /* __LINUX_PINCTRL_PINCTRL_H */