David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 1 | /* |
Grant Likely | c103de2 | 2011-06-04 18:38:28 -0600 | [diff] [blame] | 2 | * Access to GPIOs on TWL4030/TPS659x0 chips |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2006-2007 Texas Instruments, Inc. |
| 5 | * Copyright (C) 2006 MontaVista Software, Inc. |
| 6 | * |
| 7 | * Code re-arranged and cleaned up by: |
| 8 | * Syed Mohammed Khasim <x0khasim@ti.com> |
| 9 | * |
| 10 | * Initial Code: |
| 11 | * Andy Lowe / Nishanth Menon |
| 12 | * |
| 13 | * This program is free software; you can redistribute it and/or modify |
| 14 | * it under the terms of the GNU General Public License as published by |
| 15 | * the Free Software Foundation; either version 2 of the License, or |
| 16 | * (at your option) any later version. |
| 17 | * |
| 18 | * This program is distributed in the hope that it will be useful, |
| 19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 21 | * GNU General Public License for more details. |
| 22 | * |
| 23 | * You should have received a copy of the GNU General Public License |
| 24 | * along with this program; if not, write to the Free Software |
| 25 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 26 | */ |
| 27 | |
| 28 | #include <linux/module.h> |
| 29 | #include <linux/init.h> |
| 30 | #include <linux/interrupt.h> |
| 31 | #include <linux/kthread.h> |
| 32 | #include <linux/irq.h> |
| 33 | #include <linux/gpio.h> |
| 34 | #include <linux/platform_device.h> |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 35 | #include <linux/of.h> |
| 36 | #include <linux/irqdomain.h> |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 37 | |
Santosh Shilimkar | b07682b | 2009-12-13 20:05:51 +0100 | [diff] [blame] | 38 | #include <linux/i2c/twl.h> |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 39 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 40 | /* |
| 41 | * The GPIO "subchip" supports 18 GPIOs which can be configured as |
| 42 | * inputs or outputs, with pullups or pulldowns on each pin. Each |
| 43 | * GPIO can trigger interrupts on either or both edges. |
| 44 | * |
| 45 | * GPIO interrupts can be fed to either of two IRQ lines; this is |
| 46 | * intended to support multiple hosts. |
| 47 | * |
| 48 | * There are also two LED pins used sometimes as output-only GPIOs. |
| 49 | */ |
| 50 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 51 | /* genirq interfaces are not available to modules */ |
| 52 | #ifdef MODULE |
| 53 | #define is_module() true |
| 54 | #else |
| 55 | #define is_module() false |
| 56 | #endif |
| 57 | |
| 58 | /* GPIO_CTRL Fields */ |
| 59 | #define MASK_GPIO_CTRL_GPIO0CD1 BIT(0) |
| 60 | #define MASK_GPIO_CTRL_GPIO1CD2 BIT(1) |
| 61 | #define MASK_GPIO_CTRL_GPIO_ON BIT(2) |
| 62 | |
| 63 | /* Mask for GPIO registers when aggregated into a 32-bit integer */ |
| 64 | #define GPIO_32_MASK 0x0003ffff |
| 65 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 66 | struct gpio_twl4030_priv { |
| 67 | struct gpio_chip gpio_chip; |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 68 | struct mutex mutex; |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 69 | int irq_base; |
| 70 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 71 | /* Bitfields for state caching */ |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 72 | unsigned int usage_count; |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 73 | unsigned int direction; |
| 74 | unsigned int out_state; |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 75 | }; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 76 | |
| 77 | /*----------------------------------------------------------------------*/ |
| 78 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 79 | static inline struct gpio_twl4030_priv *to_gpio_twl4030(struct gpio_chip *chip) |
| 80 | { |
| 81 | return container_of(chip, struct gpio_twl4030_priv, gpio_chip); |
| 82 | } |
| 83 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 84 | /* |
| 85 | * To configure TWL4030 GPIO module registers |
| 86 | */ |
| 87 | static inline int gpio_twl4030_write(u8 address, u8 data) |
| 88 | { |
Balaji T K | fc7b92f | 2009-12-13 21:23:33 +0100 | [diff] [blame] | 89 | return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | /*----------------------------------------------------------------------*/ |
| 93 | |
| 94 | /* |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 95 | * LED register offsets from TWL_MODULE_LED base |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 96 | * PWMs A and B are dedicated to LEDs A and B, respectively. |
| 97 | */ |
| 98 | |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 99 | #define TWL4030_LED_LEDEN_REG 0x00 |
| 100 | #define TWL4030_PWMAON_REG 0x01 |
| 101 | #define TWL4030_PWMAOFF_REG 0x02 |
| 102 | #define TWL4030_PWMBON_REG 0x03 |
| 103 | #define TWL4030_PWMBOFF_REG 0x04 |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 104 | |
| 105 | /* LEDEN bits */ |
| 106 | #define LEDEN_LEDAON BIT(0) |
| 107 | #define LEDEN_LEDBON BIT(1) |
| 108 | #define LEDEN_LEDAEXT BIT(2) |
| 109 | #define LEDEN_LEDBEXT BIT(3) |
| 110 | #define LEDEN_LEDAPWM BIT(4) |
| 111 | #define LEDEN_LEDBPWM BIT(5) |
| 112 | #define LEDEN_PWM_LENGTHA BIT(6) |
| 113 | #define LEDEN_PWM_LENGTHB BIT(7) |
| 114 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 115 | #define PWMxON_LENGTH BIT(7) |
| 116 | |
| 117 | /*----------------------------------------------------------------------*/ |
| 118 | |
| 119 | /* |
| 120 | * To read a TWL4030 GPIO module register |
| 121 | */ |
| 122 | static inline int gpio_twl4030_read(u8 address) |
| 123 | { |
| 124 | u8 data; |
| 125 | int ret = 0; |
| 126 | |
Balaji T K | fc7b92f | 2009-12-13 21:23:33 +0100 | [diff] [blame] | 127 | ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 128 | return (ret < 0) ? ret : data; |
| 129 | } |
| 130 | |
| 131 | /*----------------------------------------------------------------------*/ |
| 132 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 133 | static u8 cached_leden; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 134 | |
| 135 | /* The LED lines are open drain outputs ... a FET pulls to GND, so an |
| 136 | * external pullup is needed. We could also expose the integrated PWM |
| 137 | * as a LED brightness control; we initialize it as "always on". |
| 138 | */ |
| 139 | static void twl4030_led_set_value(int led, int value) |
| 140 | { |
| 141 | u8 mask = LEDEN_LEDAON | LEDEN_LEDAPWM; |
| 142 | int status; |
| 143 | |
| 144 | if (led) |
| 145 | mask <<= 1; |
| 146 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 147 | if (value) |
| 148 | cached_leden &= ~mask; |
| 149 | else |
| 150 | cached_leden |= mask; |
Balaji T K | fc7b92f | 2009-12-13 21:23:33 +0100 | [diff] [blame] | 151 | status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden, |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 152 | TWL4030_LED_LEDEN_REG); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | static int twl4030_set_gpio_direction(int gpio, int is_input) |
| 156 | { |
| 157 | u8 d_bnk = gpio >> 3; |
| 158 | u8 d_msk = BIT(gpio & 0x7); |
| 159 | u8 reg = 0; |
| 160 | u8 base = REG_GPIODATADIR1 + d_bnk; |
| 161 | int ret = 0; |
| 162 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 163 | ret = gpio_twl4030_read(base); |
| 164 | if (ret >= 0) { |
| 165 | if (is_input) |
| 166 | reg = ret & ~d_msk; |
| 167 | else |
| 168 | reg = ret | d_msk; |
| 169 | |
| 170 | ret = gpio_twl4030_write(base, reg); |
| 171 | } |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 172 | return ret; |
| 173 | } |
| 174 | |
| 175 | static int twl4030_set_gpio_dataout(int gpio, int enable) |
| 176 | { |
| 177 | u8 d_bnk = gpio >> 3; |
| 178 | u8 d_msk = BIT(gpio & 0x7); |
| 179 | u8 base = 0; |
| 180 | |
| 181 | if (enable) |
| 182 | base = REG_SETGPIODATAOUT1 + d_bnk; |
| 183 | else |
| 184 | base = REG_CLEARGPIODATAOUT1 + d_bnk; |
| 185 | |
| 186 | return gpio_twl4030_write(base, d_msk); |
| 187 | } |
| 188 | |
| 189 | static int twl4030_get_gpio_datain(int gpio) |
| 190 | { |
| 191 | u8 d_bnk = gpio >> 3; |
| 192 | u8 d_off = gpio & 0x7; |
| 193 | u8 base = 0; |
| 194 | int ret = 0; |
| 195 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 196 | base = REG_GPIODATAIN1 + d_bnk; |
| 197 | ret = gpio_twl4030_read(base); |
| 198 | if (ret > 0) |
| 199 | ret = (ret >> d_off) & 0x1; |
| 200 | |
| 201 | return ret; |
| 202 | } |
| 203 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 204 | /*----------------------------------------------------------------------*/ |
| 205 | |
| 206 | static int twl_request(struct gpio_chip *chip, unsigned offset) |
| 207 | { |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 208 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 209 | int status = 0; |
| 210 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 211 | mutex_lock(&priv->mutex); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 212 | |
| 213 | /* Support the two LED outputs as output-only GPIOs. */ |
| 214 | if (offset >= TWL4030_GPIO_MAX) { |
| 215 | u8 ledclr_mask = LEDEN_LEDAON | LEDEN_LEDAEXT |
| 216 | | LEDEN_LEDAPWM | LEDEN_PWM_LENGTHA; |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 217 | u8 reg = TWL4030_PWMAON_REG; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 218 | |
| 219 | offset -= TWL4030_GPIO_MAX; |
| 220 | if (offset) { |
| 221 | ledclr_mask <<= 1; |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 222 | reg = TWL4030_PWMBON_REG; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 223 | } |
| 224 | |
| 225 | /* initialize PWM to always-drive */ |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 226 | /* Configure PWM OFF register first */ |
| 227 | status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg + 1); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 228 | if (status < 0) |
| 229 | goto done; |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 230 | |
| 231 | /* Followed by PWM ON register */ |
| 232 | status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 233 | if (status < 0) |
| 234 | goto done; |
| 235 | |
| 236 | /* init LED to not-driven (high) */ |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 237 | status = twl_i2c_read_u8(TWL4030_MODULE_LED, &cached_leden, |
| 238 | TWL4030_LED_LEDEN_REG); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 239 | if (status < 0) |
| 240 | goto done; |
| 241 | cached_leden &= ~ledclr_mask; |
Peter Ujfalusi | 9859eb9 | 2012-11-13 10:35:13 +0100 | [diff] [blame] | 242 | status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden, |
| 243 | TWL4030_LED_LEDEN_REG); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 244 | if (status < 0) |
| 245 | goto done; |
| 246 | |
| 247 | status = 0; |
| 248 | goto done; |
| 249 | } |
| 250 | |
| 251 | /* on first use, turn GPIO module "on" */ |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 252 | if (!priv->usage_count) { |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 253 | struct twl4030_gpio_platform_data *pdata; |
| 254 | u8 value = MASK_GPIO_CTRL_GPIO_ON; |
| 255 | |
| 256 | /* optionally have the first two GPIOs switch vMMC1 |
| 257 | * and vMMC2 power supplies based on card presence. |
| 258 | */ |
Jingoo Han | e56aee1 | 2013-07-30 17:08:05 +0900 | [diff] [blame] | 259 | pdata = dev_get_platdata(chip->dev); |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 260 | if (pdata) |
| 261 | value |= pdata->mmc_cd & 0x03; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 262 | |
| 263 | status = gpio_twl4030_write(REG_GPIO_CTRL, value); |
| 264 | } |
| 265 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 266 | done: |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 267 | if (!status) |
| 268 | priv->usage_count |= BIT(offset); |
| 269 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 270 | mutex_unlock(&priv->mutex); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 271 | return status; |
| 272 | } |
| 273 | |
| 274 | static void twl_free(struct gpio_chip *chip, unsigned offset) |
| 275 | { |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 276 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
| 277 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 278 | mutex_lock(&priv->mutex); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 279 | if (offset >= TWL4030_GPIO_MAX) { |
| 280 | twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1); |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 281 | goto out; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 282 | } |
| 283 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 284 | priv->usage_count &= ~BIT(offset); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 285 | |
| 286 | /* on last use, switch off GPIO module */ |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 287 | if (!priv->usage_count) |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 288 | gpio_twl4030_write(REG_GPIO_CTRL, 0x0); |
| 289 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 290 | out: |
| 291 | mutex_unlock(&priv->mutex); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | static int twl_direction_in(struct gpio_chip *chip, unsigned offset) |
| 295 | { |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 296 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
| 297 | int ret; |
| 298 | |
| 299 | mutex_lock(&priv->mutex); |
| 300 | if (offset < TWL4030_GPIO_MAX) |
| 301 | ret = twl4030_set_gpio_direction(offset, 1); |
| 302 | else |
| 303 | ret = -EINVAL; |
| 304 | |
| 305 | if (!ret) |
| 306 | priv->direction &= ~BIT(offset); |
| 307 | |
| 308 | mutex_unlock(&priv->mutex); |
| 309 | |
| 310 | return ret; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | static int twl_get(struct gpio_chip *chip, unsigned offset) |
| 314 | { |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 315 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 316 | int ret; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 317 | int status = 0; |
| 318 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 319 | mutex_lock(&priv->mutex); |
| 320 | if (!(priv->usage_count & BIT(offset))) { |
| 321 | ret = -EPERM; |
| 322 | goto out; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 323 | } |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 324 | |
| 325 | if (priv->direction & BIT(offset)) |
| 326 | status = priv->out_state & BIT(offset); |
| 327 | else |
| 328 | status = twl4030_get_gpio_datain(offset); |
| 329 | |
| 330 | ret = (status <= 0) ? 0 : 1; |
| 331 | out: |
| 332 | mutex_unlock(&priv->mutex); |
| 333 | return ret; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | static void twl_set(struct gpio_chip *chip, unsigned offset, int value) |
| 337 | { |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 338 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
| 339 | |
| 340 | mutex_lock(&priv->mutex); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 341 | if (offset < TWL4030_GPIO_MAX) |
| 342 | twl4030_set_gpio_dataout(offset, value); |
| 343 | else |
| 344 | twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value); |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 345 | |
| 346 | if (value) |
| 347 | priv->out_state |= BIT(offset); |
| 348 | else |
| 349 | priv->out_state &= ~BIT(offset); |
| 350 | |
| 351 | mutex_unlock(&priv->mutex); |
| 352 | } |
| 353 | |
| 354 | static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value) |
| 355 | { |
| 356 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
| 357 | |
| 358 | mutex_lock(&priv->mutex); |
| 359 | if (offset < TWL4030_GPIO_MAX) |
| 360 | twl4030_set_gpio_dataout(offset, value); |
| 361 | |
| 362 | priv->direction |= BIT(offset); |
| 363 | mutex_unlock(&priv->mutex); |
| 364 | |
| 365 | twl_set(chip, offset, value); |
| 366 | |
| 367 | return 0; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | static int twl_to_irq(struct gpio_chip *chip, unsigned offset) |
| 371 | { |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 372 | struct gpio_twl4030_priv *priv = to_gpio_twl4030(chip); |
| 373 | |
| 374 | return (priv->irq_base && (offset < TWL4030_GPIO_MAX)) |
| 375 | ? (priv->irq_base + offset) |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 376 | : -EINVAL; |
| 377 | } |
| 378 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 379 | static struct gpio_chip template_chip = { |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 380 | .label = "twl4030", |
| 381 | .owner = THIS_MODULE, |
| 382 | .request = twl_request, |
| 383 | .free = twl_free, |
| 384 | .direction_input = twl_direction_in, |
| 385 | .get = twl_get, |
| 386 | .direction_output = twl_direction_out, |
| 387 | .set = twl_set, |
| 388 | .to_irq = twl_to_irq, |
Linus Walleij | 9fb1f39 | 2013-12-04 14:42:46 +0100 | [diff] [blame^] | 389 | .can_sleep = true, |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 390 | }; |
| 391 | |
| 392 | /*----------------------------------------------------------------------*/ |
| 393 | |
Bill Pemberton | 3836309 | 2012-11-19 13:22:34 -0500 | [diff] [blame] | 394 | static int gpio_twl4030_pulls(u32 ups, u32 downs) |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 395 | { |
Peter Ujfalusi | 14591d8 | 2012-11-13 09:28:45 +0100 | [diff] [blame] | 396 | u8 message[5]; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 397 | unsigned i, gpio_bit; |
| 398 | |
| 399 | /* For most pins, a pulldown was enabled by default. |
| 400 | * We should have data that's specific to this board. |
| 401 | */ |
Peter Ujfalusi | 14591d8 | 2012-11-13 09:28:45 +0100 | [diff] [blame] | 402 | for (gpio_bit = 1, i = 0; i < 5; i++) { |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 403 | u8 bit_mask; |
| 404 | unsigned j; |
| 405 | |
| 406 | for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) { |
| 407 | if (ups & gpio_bit) |
| 408 | bit_mask |= 1 << (j + 1); |
| 409 | else if (downs & gpio_bit) |
| 410 | bit_mask |= 1 << (j + 0); |
| 411 | } |
| 412 | message[i] = bit_mask; |
| 413 | } |
| 414 | |
Balaji T K | fc7b92f | 2009-12-13 21:23:33 +0100 | [diff] [blame] | 415 | return twl_i2c_write(TWL4030_MODULE_GPIO, message, |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 416 | REG_GPIOPUPDCTR1, 5); |
| 417 | } |
| 418 | |
Bill Pemberton | 3836309 | 2012-11-19 13:22:34 -0500 | [diff] [blame] | 419 | static int gpio_twl4030_debounce(u32 debounce, u8 mmc_cd) |
David Brownell | cabb3fc | 2009-01-06 14:42:26 -0800 | [diff] [blame] | 420 | { |
Peter Ujfalusi | 14591d8 | 2012-11-13 09:28:45 +0100 | [diff] [blame] | 421 | u8 message[3]; |
David Brownell | cabb3fc | 2009-01-06 14:42:26 -0800 | [diff] [blame] | 422 | |
| 423 | /* 30 msec of debouncing is always used for MMC card detect, |
| 424 | * and is optional for everything else. |
| 425 | */ |
Peter Ujfalusi | 14591d8 | 2012-11-13 09:28:45 +0100 | [diff] [blame] | 426 | message[0] = (debounce & 0xff) | (mmc_cd & 0x03); |
David Brownell | cabb3fc | 2009-01-06 14:42:26 -0800 | [diff] [blame] | 427 | debounce >>= 8; |
Peter Ujfalusi | 14591d8 | 2012-11-13 09:28:45 +0100 | [diff] [blame] | 428 | message[1] = (debounce & 0xff); |
David Brownell | cabb3fc | 2009-01-06 14:42:26 -0800 | [diff] [blame] | 429 | debounce >>= 8; |
Peter Ujfalusi | 14591d8 | 2012-11-13 09:28:45 +0100 | [diff] [blame] | 430 | message[2] = (debounce & 0x03); |
David Brownell | cabb3fc | 2009-01-06 14:42:26 -0800 | [diff] [blame] | 431 | |
Balaji T K | fc7b92f | 2009-12-13 21:23:33 +0100 | [diff] [blame] | 432 | return twl_i2c_write(TWL4030_MODULE_GPIO, message, |
David Brownell | cabb3fc | 2009-01-06 14:42:26 -0800 | [diff] [blame] | 433 | REG_GPIO_DEBEN1, 3); |
| 434 | } |
| 435 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 436 | static int gpio_twl4030_remove(struct platform_device *pdev); |
| 437 | |
Florian Vaussard | f74ce8f | 2012-09-05 09:46:25 +0200 | [diff] [blame] | 438 | static struct twl4030_gpio_platform_data *of_gpio_twl4030(struct device *dev) |
| 439 | { |
| 440 | struct twl4030_gpio_platform_data *omap_twl_info; |
| 441 | |
| 442 | omap_twl_info = devm_kzalloc(dev, sizeof(*omap_twl_info), GFP_KERNEL); |
| 443 | if (!omap_twl_info) |
| 444 | return NULL; |
| 445 | |
Florian Vaussard | f74ce8f | 2012-09-05 09:46:25 +0200 | [diff] [blame] | 446 | omap_twl_info->use_leds = of_property_read_bool(dev->of_node, |
| 447 | "ti,use-leds"); |
| 448 | |
| 449 | of_property_read_u32(dev->of_node, "ti,debounce", |
| 450 | &omap_twl_info->debounce); |
| 451 | of_property_read_u32(dev->of_node, "ti,mmc-cd", |
| 452 | (u32 *)&omap_twl_info->mmc_cd); |
| 453 | of_property_read_u32(dev->of_node, "ti,pullups", |
| 454 | &omap_twl_info->pullups); |
| 455 | of_property_read_u32(dev->of_node, "ti,pulldowns", |
| 456 | &omap_twl_info->pulldowns); |
| 457 | |
| 458 | return omap_twl_info; |
| 459 | } |
| 460 | |
Bill Pemberton | 3836309 | 2012-11-19 13:22:34 -0500 | [diff] [blame] | 461 | static int gpio_twl4030_probe(struct platform_device *pdev) |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 462 | { |
Jingoo Han | e56aee1 | 2013-07-30 17:08:05 +0900 | [diff] [blame] | 463 | struct twl4030_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev); |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 464 | struct device_node *node = pdev->dev.of_node; |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 465 | struct gpio_twl4030_priv *priv; |
Benoit Cousson | 2d9dd99 | 2012-02-29 22:48:32 +0100 | [diff] [blame] | 466 | int ret, irq_base; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 467 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 468 | priv = devm_kzalloc(&pdev->dev, sizeof(struct gpio_twl4030_priv), |
| 469 | GFP_KERNEL); |
| 470 | if (!priv) |
| 471 | return -ENOMEM; |
| 472 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 473 | /* maybe setup IRQs */ |
Benoit Cousson | 2d9dd99 | 2012-02-29 22:48:32 +0100 | [diff] [blame] | 474 | if (is_module()) { |
| 475 | dev_err(&pdev->dev, "can't dispatch IRQs from modules\n"); |
| 476 | goto no_irqs; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 477 | } |
| 478 | |
Benoit Cousson | 2d9dd99 | 2012-02-29 22:48:32 +0100 | [diff] [blame] | 479 | irq_base = irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX, 0); |
| 480 | if (irq_base < 0) { |
| 481 | dev_err(&pdev->dev, "Failed to alloc irq_descs\n"); |
| 482 | return irq_base; |
| 483 | } |
| 484 | |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 485 | irq_domain_add_legacy(node, TWL4030_GPIO_MAX, irq_base, 0, |
| 486 | &irq_domain_simple_ops, NULL); |
| 487 | |
Benoit Cousson | 2d9dd99 | 2012-02-29 22:48:32 +0100 | [diff] [blame] | 488 | ret = twl4030_sih_setup(&pdev->dev, TWL4030_MODULE_GPIO, irq_base); |
| 489 | if (ret < 0) |
| 490 | return ret; |
| 491 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 492 | priv->irq_base = irq_base; |
Benoit Cousson | 2d9dd99 | 2012-02-29 22:48:32 +0100 | [diff] [blame] | 493 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 494 | no_irqs: |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 495 | priv->gpio_chip = template_chip; |
| 496 | priv->gpio_chip.base = -1; |
| 497 | priv->gpio_chip.ngpio = TWL4030_GPIO_MAX; |
| 498 | priv->gpio_chip.dev = &pdev->dev; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 499 | |
Peter Ujfalusi | c111fea | 2012-12-20 10:44:11 +0100 | [diff] [blame] | 500 | mutex_init(&priv->mutex); |
| 501 | |
Florian Vaussard | f74ce8f | 2012-09-05 09:46:25 +0200 | [diff] [blame] | 502 | if (node) |
| 503 | pdata = of_gpio_twl4030(&pdev->dev); |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 504 | |
Florian Vaussard | f74ce8f | 2012-09-05 09:46:25 +0200 | [diff] [blame] | 505 | if (pdata == NULL) { |
| 506 | dev_err(&pdev->dev, "Platform data is missing\n"); |
| 507 | return -ENXIO; |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 508 | } |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 509 | |
Florian Vaussard | f74ce8f | 2012-09-05 09:46:25 +0200 | [diff] [blame] | 510 | /* |
| 511 | * NOTE: boards may waste power if they don't set pullups |
| 512 | * and pulldowns correctly ... default for non-ULPI pins is |
| 513 | * pulldown, and some other pins may have external pullups |
| 514 | * or pulldowns. Careful! |
| 515 | */ |
| 516 | ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns); |
| 517 | if (ret) |
| 518 | dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n", |
| 519 | pdata->pullups, pdata->pulldowns, ret); |
| 520 | |
| 521 | ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd); |
| 522 | if (ret) |
| 523 | dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n", |
| 524 | pdata->debounce, pdata->mmc_cd, ret); |
| 525 | |
| 526 | /* |
| 527 | * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE, |
| 528 | * is (still) clear if use_leds is set. |
| 529 | */ |
| 530 | if (pdata->use_leds) |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 531 | priv->gpio_chip.ngpio += 2; |
Florian Vaussard | f74ce8f | 2012-09-05 09:46:25 +0200 | [diff] [blame] | 532 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 533 | ret = gpiochip_add(&priv->gpio_chip); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 534 | if (ret < 0) { |
Benoit Cousson | 2d9dd99 | 2012-02-29 22:48:32 +0100 | [diff] [blame] | 535 | dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret); |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 536 | priv->gpio_chip.ngpio = 0; |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 537 | gpio_twl4030_remove(pdev); |
Tony Lindgren | a940d9a | 2012-09-04 17:43:30 -0700 | [diff] [blame] | 538 | goto out; |
| 539 | } |
| 540 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 541 | platform_set_drvdata(pdev, priv); |
Tony Lindgren | a940d9a | 2012-09-04 17:43:30 -0700 | [diff] [blame] | 542 | |
| 543 | if (pdata && pdata->setup) { |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 544 | int status; |
| 545 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 546 | status = pdata->setup(&pdev->dev, priv->gpio_chip.base, |
| 547 | TWL4030_GPIO_MAX); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 548 | if (status) |
| 549 | dev_dbg(&pdev->dev, "setup --> %d\n", status); |
| 550 | } |
| 551 | |
Tony Lindgren | a940d9a | 2012-09-04 17:43:30 -0700 | [diff] [blame] | 552 | out: |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 553 | return ret; |
| 554 | } |
| 555 | |
Bill Pemberton | 206210c | 2012-11-19 13:25:50 -0500 | [diff] [blame] | 556 | /* Cannot use as gpio_twl4030_probe() calls us */ |
Mike Frysinger | 46c529c | 2009-10-26 16:50:06 -0700 | [diff] [blame] | 557 | static int gpio_twl4030_remove(struct platform_device *pdev) |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 558 | { |
Jingoo Han | e56aee1 | 2013-07-30 17:08:05 +0900 | [diff] [blame] | 559 | struct twl4030_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev); |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 560 | struct gpio_twl4030_priv *priv = platform_get_drvdata(pdev); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 561 | int status; |
| 562 | |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 563 | if (pdata && pdata->teardown) { |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 564 | status = pdata->teardown(&pdev->dev, priv->gpio_chip.base, |
| 565 | TWL4030_GPIO_MAX); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 566 | if (status) { |
| 567 | dev_dbg(&pdev->dev, "teardown --> %d\n", status); |
| 568 | return status; |
| 569 | } |
| 570 | } |
| 571 | |
Peter Ujfalusi | 72c7901 | 2012-12-06 10:52:05 +0000 | [diff] [blame] | 572 | status = gpiochip_remove(&priv->gpio_chip); |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 573 | if (status < 0) |
| 574 | return status; |
| 575 | |
| 576 | if (is_module()) |
| 577 | return 0; |
| 578 | |
| 579 | /* REVISIT no support yet for deregistering all the IRQs */ |
| 580 | WARN_ON(1); |
| 581 | return -EIO; |
| 582 | } |
| 583 | |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 584 | static const struct of_device_id twl_gpio_match[] = { |
| 585 | { .compatible = "ti,twl4030-gpio", }, |
| 586 | { }, |
| 587 | }; |
| 588 | MODULE_DEVICE_TABLE(of, twl_gpio_match); |
| 589 | |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 590 | /* Note: this hardware lives inside an I2C-based multi-function device. */ |
| 591 | MODULE_ALIAS("platform:twl4030_gpio"); |
| 592 | |
| 593 | static struct platform_driver gpio_twl4030_driver = { |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 594 | .driver = { |
| 595 | .name = "twl4030_gpio", |
| 596 | .owner = THIS_MODULE, |
Sachin Kamat | e5560af | 2013-09-28 17:34:09 +0530 | [diff] [blame] | 597 | .of_match_table = twl_gpio_match, |
Benoit Cousson | b8589e2 | 2012-02-29 22:51:32 +0100 | [diff] [blame] | 598 | }, |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 599 | .probe = gpio_twl4030_probe, |
Mike Frysinger | 46c529c | 2009-10-26 16:50:06 -0700 | [diff] [blame] | 600 | .remove = gpio_twl4030_remove, |
David Brownell | e9d35947 | 2008-10-20 23:51:46 +0200 | [diff] [blame] | 601 | }; |
| 602 | |
| 603 | static int __init gpio_twl4030_init(void) |
| 604 | { |
| 605 | return platform_driver_register(&gpio_twl4030_driver); |
| 606 | } |
| 607 | subsys_initcall(gpio_twl4030_init); |
| 608 | |
| 609 | static void __exit gpio_twl4030_exit(void) |
| 610 | { |
| 611 | platform_driver_unregister(&gpio_twl4030_driver); |
| 612 | } |
| 613 | module_exit(gpio_twl4030_exit); |
| 614 | |
| 615 | MODULE_AUTHOR("Texas Instruments, Inc."); |
| 616 | MODULE_DESCRIPTION("GPIO interface for TWL4030"); |
| 617 | MODULE_LICENSE("GPL"); |