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