1 #ifndef __LINUX_GPIO_DRIVER_H 2 #define __LINUX_GPIO_DRIVER_H 3 4 #include <linux/types.h> 5 6 struct device; 7 struct gpio_desc; 8 struct seq_file; 9 10 /** 11 * struct gpio_chip - abstract a GPIO controller 12 * @label: for diagnostics 13 * @dev: optional device providing the GPIOs 14 * @owner: helps prevent removal of modules exporting active GPIOs 15 * @list: links gpio_chips together for traversal 16 * @request: optional hook for chip-specific activation, such as 17 * enabling module power and clock; may sleep 18 * @free: optional hook for chip-specific deactivation, such as 19 * disabling module power and clock; may sleep 20 * @get_direction: returns direction for signal "offset", 0=out, 1=in, 21 * (same as GPIOF_DIR_XXX), or negative error 22 * @direction_input: configures signal "offset" as input, or returns error 23 * @direction_output: configures signal "offset" as output, or returns error 24 * @get: returns value for signal "offset"; for output signals this 25 * returns either the value actually sensed, or zero 26 * @set: assigns output value for signal "offset" 27 * @set_debounce: optional hook for setting debounce time for specified gpio in 28 * interrupt triggered gpio chips 29 * @to_irq: optional hook supporting non-static gpio_to_irq() mappings; 30 * implementation may not sleep 31 * @dbg_show: optional routine to show contents in debugfs; default code 32 * will be used when this is omitted, but custom code can show extra 33 * state (such as pullup/pulldown configuration). 34 * @base: identifies the first GPIO number handled by this chip; or, if 35 * negative during registration, requests dynamic ID allocation. 36 * @ngpio: the number of GPIOs handled by this controller; the last GPIO 37 * handled is (base + ngpio - 1). 38 * @desc: array of ngpio descriptors. Private. 39 * @can_sleep: flag must be set iff get()/set() methods sleep, as they 40 * must while accessing GPIO expander chips over I2C or SPI 41 * @names: if set, must be an array of strings to use as alternative 42 * names for the GPIOs in this chip. Any entry in the array 43 * may be NULL if there is no alias for the GPIO, however the 44 * array must be @ngpio entries long. A name can include a single printk 45 * format specifier for an unsigned int. It is substituted by the actual 46 * number of the gpio. 47 * 48 * A gpio_chip can help platforms abstract various sources of GPIOs so 49 * they can all be accessed through a common programing interface. 50 * Example sources would be SOC controllers, FPGAs, multifunction 51 * chips, dedicated GPIO expanders, and so on. 52 * 53 * Each chip controls a number of signals, identified in method calls 54 * by "offset" values in the range 0..(@ngpio - 1). When those signals 55 * are referenced through calls like gpio_get_value(gpio), the offset 56 * is calculated by subtracting @base from the gpio number. 57 */ 58 struct gpio_chip { 59 const char *label; 60 struct device *dev; 61 struct module *owner; 62 struct list_head list; 63 64 int (*request)(struct gpio_chip *chip, 65 unsigned offset); 66 void (*free)(struct gpio_chip *chip, 67 unsigned offset); 68 int (*get_direction)(struct gpio_chip *chip, 69 unsigned offset); 70 int (*direction_input)(struct gpio_chip *chip, 71 unsigned offset); 72 int (*direction_output)(struct gpio_chip *chip, 73 unsigned offset, int value); 74 int (*get)(struct gpio_chip *chip, 75 unsigned offset); 76 void (*set)(struct gpio_chip *chip, 77 unsigned offset, int value); 78 int (*set_debounce)(struct gpio_chip *chip, 79 unsigned offset, 80 unsigned debounce); 81 82 int (*to_irq)(struct gpio_chip *chip, 83 unsigned offset); 84 85 void (*dbg_show)(struct seq_file *s, 86 struct gpio_chip *chip); 87 int base; 88 u16 ngpio; 89 struct gpio_desc *desc; 90 const char *const *names; 91 unsigned can_sleep:1; 92 unsigned exported:1; 93 94 #if defined(CONFIG_OF_GPIO) 95 /* 96 * If CONFIG_OF is enabled, then all GPIO controllers described in the 97 * device tree automatically may have an OF translation 98 */ 99 struct device_node *of_node; 100 int of_gpio_n_cells; 101 int (*of_xlate)(struct gpio_chip *gc, 102 const struct of_phandle_args *gpiospec, u32 *flags); 103 #endif 104 #ifdef CONFIG_PINCTRL 105 /* 106 * If CONFIG_PINCTRL is enabled, then gpio controllers can optionally 107 * describe the actual pin range which they serve in an SoC. This 108 * information would be used by pinctrl subsystem to configure 109 * corresponding pins for gpio usage. 110 */ 111 struct list_head pin_ranges; 112 #endif 113 }; 114 115 extern const char *gpiochip_is_requested(struct gpio_chip *chip, 116 unsigned offset); 117 118 /* add/remove chips */ 119 extern int gpiochip_add(struct gpio_chip *chip); 120 extern int __must_check gpiochip_remove(struct gpio_chip *chip); 121 extern struct gpio_chip *gpiochip_find(void *data, 122 int (*match)(struct gpio_chip *chip, void *data)); 123 124 /* lock/unlock as IRQ */ 125 int gpiod_lock_as_irq(struct gpio_desc *desc); 126 void gpiod_unlock_as_irq(struct gpio_desc *desc); 127 128 enum gpio_lookup_flags { 129 GPIO_ACTIVE_HIGH = (0 << 0), 130 GPIO_ACTIVE_LOW = (1 << 0), 131 GPIO_OPEN_DRAIN = (1 << 1), 132 GPIO_OPEN_SOURCE = (1 << 2), 133 }; 134 135 /** 136 * Lookup table for associating GPIOs to specific devices and functions using 137 * platform data. 138 */ 139 struct gpiod_lookup { 140 struct list_head list; 141 /* 142 * name of the chip the GPIO belongs to 143 */ 144 const char *chip_label; 145 /* 146 * hardware number (i.e. relative to the chip) of the GPIO 147 */ 148 u16 chip_hwnum; 149 /* 150 * name of device that can claim this GPIO 151 */ 152 const char *dev_id; 153 /* 154 * name of the GPIO from the device's point of view 155 */ 156 const char *con_id; 157 /* 158 * index of the GPIO in case several GPIOs share the same name 159 */ 160 unsigned int idx; 161 /* 162 * mask of GPIO_* values 163 */ 164 enum gpio_lookup_flags flags; 165 }; 166 167 /* 168 * Simple definition of a single GPIO under a con_id 169 */ 170 #define GPIO_LOOKUP(_chip_label, _chip_hwnum, _dev_id, _con_id, _flags) \ 171 GPIO_LOOKUP_IDX(_chip_label, _chip_hwnum, _dev_id, _con_id, 0, _flags) 172 173 /* 174 * Use this macro if you need to have several GPIOs under the same con_id. 175 * Each GPIO needs to use a different index and can be accessed using 176 * gpiod_get_index() 177 */ 178 #define GPIO_LOOKUP_IDX(_chip_label, _chip_hwnum, _dev_id, _con_id, _idx, \ 179 _flags) \ 180 { \ 181 .chip_label = _chip_label, \ 182 .chip_hwnum = _chip_hwnum, \ 183 .dev_id = _dev_id, \ 184 .con_id = _con_id, \ 185 .idx = _idx, \ 186 .flags = _flags, \ 187 } 188 189 void gpiod_add_table(struct gpiod_lookup *table, size_t size); 190 191 #endif 192