core.h 8.12 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * Core private header for the pin control subsystem
 *
 * Copyright (C) 2011 ST-Ericsson SA
 * Written on behalf of Linaro for ST-Ericsson
 *
 * Author: Linus Walleij <linus.walleij@linaro.org>
 *
 * License terms: GNU General Public License (GPL) version 2
 */

12
#include <linux/kref.h>
13 14
#include <linux/mutex.h>
#include <linux/radix-tree.h>
15
#include <linux/pinctrl/pinconf.h>
16
#include <linux/pinctrl/machine.h>
17 18 19

struct pinctrl_gpio_range;

20 21 22 23 24 25 26
/**
 * struct pinctrl_dev - pin control class device
 * @node: node to include this pin controller in the global pin controller list
 * @desc: the pin controller descriptor supplied when initializing this pin
 *	controller
 * @pin_desc_tree: each pin descriptor for this pin controller is stored in
 *	this radix tree
27 28
 * @pin_group_tree: optionally each pin group can be stored in this radix tree
 * @num_groups: optionally number of groups can be kept here
29 30
 * @pin_function_tree: optionally each function can be stored in this radix tree
 * @num_functions: optionally number of functions can be kept here
31 32 33 34 35 36
 * @gpio_ranges: a list of GPIO ranges that is handled by this pin controller,
 *	ranges are added to this list at runtime
 * @dev: the device entry for this pin controller
 * @owner: module providing the pin controller, used for refcounting
 * @driver_data: driver data for drivers registering to the pin controller
 *	subsystem
37
 * @p: result of pinctrl_get() for this device
38 39
 * @hog_default: default state for pins hogged by this device
 * @hog_sleep: sleep state for pins hogged by this device
40
 * @mutex: mutex taken on each pin controller specific action
41
 * @device_root: debugfs root for this device
42 43 44 45 46
 */
struct pinctrl_dev {
	struct list_head node;
	struct pinctrl_desc *desc;
	struct radix_tree_root pin_desc_tree;
47
#ifdef CONFIG_GENERIC_PINCTRL_GROUPS
48 49
	struct radix_tree_root pin_group_tree;
	unsigned int num_groups;
50 51 52 53
#endif
#ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
	struct radix_tree_root pin_function_tree;
	unsigned int num_functions;
54
#endif
55
	struct list_head gpio_ranges;
56
	struct device *dev;
57 58
	struct module *owner;
	void *driver_data;
59
	struct pinctrl *p;
60 61
	struct pinctrl_state *hog_default;
	struct pinctrl_state *hog_sleep;
62
	struct mutex mutex;
63 64 65
#ifdef CONFIG_DEBUG_FS
	struct dentry *device_root;
#endif
66 67 68 69 70 71
};

/**
 * struct pinctrl - per-device pin control state holder
 * @node: global list node
 * @dev: the device using this pin control handle
72 73
 * @states: a list of states for this device
 * @state: the current state
74 75
 * @dt_maps: the mapping table chunks dynamically parsed from device tree for
 *	this device, if any
76
 * @users: reference count
77 78 79 80
 */
struct pinctrl {
	struct list_head node;
	struct device *dev;
81 82
	struct list_head states;
	struct pinctrl_state *state;
83
	struct list_head dt_maps;
84
	struct kref users;
85 86 87 88
};

/**
 * struct pinctrl_state - a pinctrl state for a device
89
 * @node: list node for struct pinctrl's @states field
90 91 92 93 94 95
 * @name: the name of this state
 * @settings: a list of settings for this state
 */
struct pinctrl_state {
	struct list_head node;
	const char *name;
96 97 98
	struct list_head settings;
};

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
/**
 * 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;
};

123
/**
124
 * struct pinctrl_setting - an individual mux or config setting
125
 * @node: list node for struct pinctrl_settings's @settings field
126
 * @type: the type of setting
127 128
 * @pctldev: pin control device handling to be programmed. Not used for
 *   PIN_MAP_TYPE_DUMMY_STATE.
129
 * @dev_name: the name of the device using this state
130
 * @data: Data specific to the setting type
131 132 133
 */
struct pinctrl_setting {
	struct list_head node;
134
	enum pinctrl_map_type type;
135
	struct pinctrl_dev *pctldev;
136
	const char *dev_name;
137 138 139 140
	union {
		struct pinctrl_setting_mux mux;
		struct pinctrl_setting_configs configs;
	} data;
141 142 143 144 145 146 147
};

/**
 * struct pin_desc - pin descriptor for each physical pin in the arch
 * @pctldev: corresponding pin control device
 * @name: a name for the pin, e.g. the name of the pin/pad/finger on a
 *	datasheet or such
148
 * @dynamic_name: if the name of this pin was dynamically allocated
149
 * @drv_data: driver-defined per-pin data. pinctrl core does not touch this
150
 * @mux_usecount: If zero, the pin is not claimed, and @owner should be NULL.
151 152 153 154
 *	If non-zero, this pin is claimed by @owner. This field is an integer
 *	rather than a boolean, since pinctrl_get() might process multiple
 *	mapping table entries that refer to, and hence claim, the same group
 *	or pin, and each of these will increment the @usecount.
155
 * @mux_owner: The name of device that called pinctrl_get().
156
 * @mux_setting: The most recent selected mux setting for this pin, if any.
157
 * @gpio_owner: If pinctrl_gpio_request() was called for this pin, this is
158
 *	the name of the GPIO that "owns" this pin.
159 160 161
 */
struct pin_desc {
	struct pinctrl_dev *pctldev;
162
	const char *name;
163
	bool dynamic_name;
164
	void *drv_data;
165 166
	/* These fields only added when supporting pinmux drivers */
#ifdef CONFIG_PINMUX
167 168
	unsigned mux_usecount;
	const char *mux_owner;
169
	const struct pinctrl_setting_mux *mux_setting;
170
	const char *gpio_owner;
171 172 173
#endif
};

174 175 176 177 178 179 180 181
/**
 * struct pinctrl_maps - a list item containing part of the mapping table
 * @node: mapping table list node
 * @maps: array of mapping table entries
 * @num_maps: the number of entries in @maps
 */
struct pinctrl_maps {
	struct list_head node;
182
	const struct pinctrl_map *maps;
183 184 185 186 187
	unsigned num_maps;
};

#ifdef CONFIG_GENERIC_PINCTRL_GROUPS

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
/**
 * struct group_desc - generic pin group descriptor
 * @name: name of the pin group
 * @pins: array of pins that belong to the group
 * @num_pins: number of pins in the group
 * @data: pin controller driver specific data
 */
struct group_desc {
	const char *name;
	int *pins;
	int num_pins;
	void *data;
};

int pinctrl_generic_get_group_count(struct pinctrl_dev *pctldev);

const char *pinctrl_generic_get_group_name(struct pinctrl_dev *pctldev,
					   unsigned int group_selector);

int pinctrl_generic_get_group_pins(struct pinctrl_dev *pctldev,
				   unsigned int group_selector,
				   const unsigned int **pins,
				   unsigned int *npins);

struct group_desc *pinctrl_generic_get_group(struct pinctrl_dev *pctldev,
					     unsigned int group_selector);

int pinctrl_generic_add_group(struct pinctrl_dev *pctldev, const char *name,
			      int *gpins, int ngpins, void *data);

int pinctrl_generic_remove_group(struct pinctrl_dev *pctldev,
				 unsigned int group_selector);

221
#endif	/* CONFIG_GENERIC_PINCTRL_GROUPS */
222

223
struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *dev_name);
224
struct pinctrl_dev *get_pinctrl_dev_from_of_node(struct device_node *np);
225
int pin_get_from_name(struct pinctrl_dev *pctldev, const char *name);
226
const char *pin_get_name(struct pinctrl_dev *pctldev, const unsigned pin);
227 228
int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
			       const char *pin_group);
229 230 231 232 233 234

static inline struct pin_desc *pin_desc_get(struct pinctrl_dev *pctldev,
					    unsigned int pin)
{
	return radix_tree_lookup(&pctldev->pin_desc_tree, pin);
}
235

236 237 238 239
extern struct pinctrl_gpio_range *
pinctrl_find_gpio_range_from_pin_nolock(struct pinctrl_dev *pctldev,
					unsigned int pin);

240
int pinctrl_register_map(const struct pinctrl_map *maps, unsigned num_maps,
241
			 bool dup);
242
void pinctrl_unregister_map(const struct pinctrl_map *map);
243

244 245 246
extern int pinctrl_force_sleep(struct pinctrl_dev *pctldev);
extern int pinctrl_force_default(struct pinctrl_dev *pctldev);

247
extern struct mutex pinctrl_maps_mutex;
248 249 250 251 252 253 254
extern struct list_head pinctrl_maps;

#define for_each_maps(_maps_node_, _i_, _map_) \
	list_for_each_entry(_maps_node_, &pinctrl_maps, node) \
		for (_i_ = 0, _map_ = &_maps_node_->maps[_i_]; \
			_i_ < _maps_node_->num_maps; \
			_i_++, _map_ = &_maps_node_->maps[_i_])