1/*
  2 * Core private header for the pin control subsystem
  3 *
  4 * Copyright (C) 2011 ST-Ericsson SA
  5 * Written on behalf of Linaro for ST-Ericsson
  6 *
  7 * Author: Linus Walleij <linus.walleij@linaro.org>
  8 *
  9 * License terms: GNU General Public License (GPL) version 2
 10 */
 11
 12#include <linux/kref.h>
 13#include <linux/mutex.h>
 14#include <linux/radix-tree.h>
 15#include <linux/pinctrl/pinconf.h>
 16#include <linux/pinctrl/machine.h>
 17
 18struct pinctrl_gpio_range;
 19
 20/**
 21 * struct pinctrl_dev - pin control class device
 22 * @node: node to include this pin controller in the global pin controller list
 23 * @desc: the pin controller descriptor supplied when initializing this pin
 24 *	controller
 25 * @pin_desc_tree: each pin descriptor for this pin controller is stored in
 26 *	this radix tree
 27 * @gpio_ranges: a list of GPIO ranges that is handled by this pin controller,
 28 *	ranges are added to this list at runtime
 29 * @dev: the device entry for this pin controller
 30 * @owner: module providing the pin controller, used for refcounting
 31 * @driver_data: driver data for drivers registering to the pin controller
 32 *	subsystem
 33 * @p: result of pinctrl_get() for this device
 34 * @hog_default: default state for pins hogged by this device
 35 * @hog_sleep: sleep state for pins hogged by this device
 36 * @mutex: mutex taken on each pin controller specific action
 37 * @device_root: debugfs root for this device
 38 */
 39struct pinctrl_dev {
 40	struct list_head node;
 41	struct pinctrl_desc *desc;
 42	struct radix_tree_root pin_desc_tree;
 43	struct list_head gpio_ranges;
 44	struct device *dev;
 45	struct module *owner;
 46	void *driver_data;
 47	struct pinctrl *p;
 48	struct pinctrl_state *hog_default;
 49	struct pinctrl_state *hog_sleep;
 50	struct mutex mutex;
 51#ifdef CONFIG_DEBUG_FS
 52	struct dentry *device_root;
 53#endif
 54};
 55
 56/**
 57 * struct pinctrl - per-device pin control state holder
 58 * @node: global list node
 59 * @dev: the device using this pin control handle
 60 * @states: a list of states for this device
 61 * @state: the current state
 62 * @dt_maps: the mapping table chunks dynamically parsed from device tree for
 63 *	this device, if any
 64 * @users: reference count
 65 */
 66struct pinctrl {
 67	struct list_head node;
 68	struct device *dev;
 69	struct list_head states;
 70	struct pinctrl_state *state;
 71	struct list_head dt_maps;
 72	struct kref users;
 73};
 74
 75/**
 76 * struct pinctrl_state - a pinctrl state for a device
 77 * @node: list node for struct pinctrl's @states field
 78 * @name: the name of this state
 79 * @settings: a list of settings for this state
 80 */
 81struct pinctrl_state {
 82	struct list_head node;
 83	const char *name;
 84	struct list_head settings;
 85};
 86
 87/**
 88 * struct pinctrl_setting_mux - setting data for MAP_TYPE_MUX_GROUP
 89 * @group: the group selector to program
 90 * @func: the function selector to program
 91 */
 92struct pinctrl_setting_mux {
 93	unsigned group;
 94	unsigned func;
 95};
 96
 97/**
 98 * struct pinctrl_setting_configs - setting data for MAP_TYPE_CONFIGS_*
 99 * @group_or_pin: the group selector or pin ID to program
100 * @configs: a pointer to an array of config parameters/values to program into
101 *	hardware. Each individual pin controller defines the format and meaning
102 *	of config parameters.
103 * @num_configs: the number of entries in array @configs
104 */
105struct pinctrl_setting_configs {
106	unsigned group_or_pin;
107	unsigned long *configs;
108	unsigned num_configs;
109};
110
111/**
112 * struct pinctrl_setting - an individual mux or config setting
113 * @node: list node for struct pinctrl_settings's @settings field
114 * @type: the type of setting
115 * @pctldev: pin control device handling to be programmed. Not used for
116 *   PIN_MAP_TYPE_DUMMY_STATE.
117 * @dev_name: the name of the device using this state
118 * @data: Data specific to the setting type
119 */
120struct pinctrl_setting {
121	struct list_head node;
122	enum pinctrl_map_type type;
123	struct pinctrl_dev *pctldev;
124	const char *dev_name;
125	union {
126		struct pinctrl_setting_mux mux;
127		struct pinctrl_setting_configs configs;
128	} data;
129};
130
131/**
132 * struct pin_desc - pin descriptor for each physical pin in the arch
133 * @pctldev: corresponding pin control device
134 * @name: a name for the pin, e.g. the name of the pin/pad/finger on a
135 *	datasheet or such
136 * @dynamic_name: if the name of this pin was dynamically allocated
137 * @drv_data: driver-defined per-pin data. pinctrl core does not touch this
138 * @mux_usecount: If zero, the pin is not claimed, and @owner should be NULL.
139 *	If non-zero, this pin is claimed by @owner. This field is an integer
140 *	rather than a boolean, since pinctrl_get() might process multiple
141 *	mapping table entries that refer to, and hence claim, the same group
142 *	or pin, and each of these will increment the @usecount.
143 * @mux_owner: The name of device that called pinctrl_get().
144 * @mux_setting: The most recent selected mux setting for this pin, if any.
145 * @gpio_owner: If pinctrl_request_gpio() was called for this pin, this is
146 *	the name of the GPIO that "owns" this pin.
147 */
148struct pin_desc {
149	struct pinctrl_dev *pctldev;
150	const char *name;
151	bool dynamic_name;
152	void *drv_data;
153	/* These fields only added when supporting pinmux drivers */
154#ifdef CONFIG_PINMUX
155	unsigned mux_usecount;
156	const char *mux_owner;
157	const struct pinctrl_setting_mux *mux_setting;
158	const char *gpio_owner;
159#endif
160};
161
162/**
163 * struct pinctrl_maps - a list item containing part of the mapping table
164 * @node: mapping table list node
165 * @maps: array of mapping table entries
166 * @num_maps: the number of entries in @maps
167 */
168struct pinctrl_maps {
169	struct list_head node;
170	struct pinctrl_map const *maps;
171	unsigned num_maps;
172};
173
174struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *dev_name);
175struct pinctrl_dev *get_pinctrl_dev_from_of_node(struct device_node *np);
176int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name);
177const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin);
178int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
179			       const char *pin_group);
180
181static inline struct pin_desc *pin_desc_get(struct pinctrl_dev *pctldev,
182					    unsigned int pin)
183{
184	return radix_tree_lookup(&pctldev->pin_desc_tree, pin);
185}
186
187extern struct pinctrl_gpio_range *
188pinctrl_find_gpio_range_from_pin_nolock(struct pinctrl_dev *pctldev,
189					unsigned int pin);
190
191int pinctrl_register_map(struct pinctrl_map const *maps, unsigned num_maps,
192			 bool dup);
193void pinctrl_unregister_map(struct pinctrl_map const *map);
194
195extern int pinctrl_force_sleep(struct pinctrl_dev *pctldev);
196extern int pinctrl_force_default(struct pinctrl_dev *pctldev);
197
198extern struct mutex pinctrl_maps_mutex;
199extern struct list_head pinctrl_maps;
200
201#define for_each_maps(_maps_node_, _i_, _map_) \
202	list_for_each_entry(_maps_node_, &pinctrl_maps, node) \
203		for (_i_ = 0, _map_ = &_maps_node_->maps[_i_]; \
204			_i_ < _maps_node_->num_maps; \
205			_i_++, _map_ = &_maps_node_->maps[_i_])