1/* 2 * twl4030_gpio.c -- access to GPIOs on TWL4030/TPS659x0 chips 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> 35 36#include <linux/i2c/twl.h> 37 38 39/* 40 * The GPIO "subchip" supports 18 GPIOs which can be configured as 41 * inputs or outputs, with pullups or pulldowns on each pin. Each 42 * GPIO can trigger interrupts on either or both edges. 43 * 44 * GPIO interrupts can be fed to either of two IRQ lines; this is 45 * intended to support multiple hosts. 46 * 47 * There are also two LED pins used sometimes as output-only GPIOs. 48 */ 49 50 51static struct gpio_chip twl_gpiochip; 52static int twl4030_gpio_irq_base; 53 54/* genirq interfaces are not available to modules */ 55#ifdef MODULE 56#define is_module() true 57#else 58#define is_module() false 59#endif 60 61/* GPIO_CTRL Fields */ 62#define MASK_GPIO_CTRL_GPIO0CD1 BIT(0) 63#define MASK_GPIO_CTRL_GPIO1CD2 BIT(1) 64#define MASK_GPIO_CTRL_GPIO_ON BIT(2) 65 66/* Mask for GPIO registers when aggregated into a 32-bit integer */ 67#define GPIO_32_MASK 0x0003ffff 68 69/* Data structures */ 70static DEFINE_MUTEX(gpio_lock); 71 72/* store usage of each GPIO. - each bit represents one GPIO */ 73static unsigned int gpio_usage_count; 74 75/*----------------------------------------------------------------------*/ 76 77/* 78 * To configure TWL4030 GPIO module registers 79 */ 80static inline int gpio_twl4030_write(u8 address, u8 data) 81{ 82 return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address); 83} 84 85/*----------------------------------------------------------------------*/ 86 87/* 88 * LED register offsets (use TWL4030_MODULE_{LED,PWMA,PWMB})) 89 * PWMs A and B are dedicated to LEDs A and B, respectively. 90 */ 91 92#define TWL4030_LED_LEDEN 0x0 93 94/* LEDEN bits */ 95#define LEDEN_LEDAON BIT(0) 96#define LEDEN_LEDBON BIT(1) 97#define LEDEN_LEDAEXT BIT(2) 98#define LEDEN_LEDBEXT BIT(3) 99#define LEDEN_LEDAPWM BIT(4) 100#define LEDEN_LEDBPWM BIT(5) 101#define LEDEN_PWM_LENGTHA BIT(6) 102#define LEDEN_PWM_LENGTHB BIT(7) 103 104#define TWL4030_PWMx_PWMxON 0x0 105#define TWL4030_PWMx_PWMxOFF 0x1 106 107#define PWMxON_LENGTH BIT(7) 108 109/*----------------------------------------------------------------------*/ 110 111/* 112 * To read a TWL4030 GPIO module register 113 */ 114static inline int gpio_twl4030_read(u8 address) 115{ 116 u8 data; 117 int ret = 0; 118 119 ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address); 120 return (ret < 0) ? ret : data; 121} 122 123/*----------------------------------------------------------------------*/ 124 125static u8 cached_leden; /* protected by gpio_lock */ 126 127/* The LED lines are open drain outputs ... a FET pulls to GND, so an 128 * external pullup is needed. We could also expose the integrated PWM 129 * as a LED brightness control; we initialize it as "always on". 130 */ 131static void twl4030_led_set_value(int led, int value) 132{ 133 u8 mask = LEDEN_LEDAON | LEDEN_LEDAPWM; 134 int status; 135 136 if (led) 137 mask <<= 1; 138 139 mutex_lock(&gpio_lock); 140 if (value) 141 cached_leden &= ~mask; 142 else 143 cached_leden |= mask; 144 status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden, 145 TWL4030_LED_LEDEN); 146 mutex_unlock(&gpio_lock); 147} 148 149static int twl4030_set_gpio_direction(int gpio, int is_input) 150{ 151 u8 d_bnk = gpio >> 3; 152 u8 d_msk = BIT(gpio & 0x7); 153 u8 reg = 0; 154 u8 base = REG_GPIODATADIR1 + d_bnk; 155 int ret = 0; 156 157 mutex_lock(&gpio_lock); 158 ret = gpio_twl4030_read(base); 159 if (ret >= 0) { 160 if (is_input) 161 reg = ret & ~d_msk; 162 else 163 reg = ret | d_msk; 164 165 ret = gpio_twl4030_write(base, reg); 166 } 167 mutex_unlock(&gpio_lock); 168 return ret; 169} 170 171static int twl4030_set_gpio_dataout(int gpio, int enable) 172{ 173 u8 d_bnk = gpio >> 3; 174 u8 d_msk = BIT(gpio & 0x7); 175 u8 base = 0; 176 177 if (enable) 178 base = REG_SETGPIODATAOUT1 + d_bnk; 179 else 180 base = REG_CLEARGPIODATAOUT1 + d_bnk; 181 182 return gpio_twl4030_write(base, d_msk); 183} 184 185static int twl4030_get_gpio_datain(int gpio) 186{ 187 u8 d_bnk = gpio >> 3; 188 u8 d_off = gpio & 0x7; 189 u8 base = 0; 190 int ret = 0; 191 192 if (unlikely((gpio >= TWL4030_GPIO_MAX) 193 || !(gpio_usage_count & BIT(gpio)))) 194 return -EPERM; 195 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 204/*----------------------------------------------------------------------*/ 205 206static int twl_request(struct gpio_chip *chip, unsigned offset) 207{ 208 int status = 0; 209 210 mutex_lock(&gpio_lock); 211 212 /* Support the two LED outputs as output-only GPIOs. */ 213 if (offset >= TWL4030_GPIO_MAX) { 214 u8 ledclr_mask = LEDEN_LEDAON | LEDEN_LEDAEXT 215 | LEDEN_LEDAPWM | LEDEN_PWM_LENGTHA; 216 u8 module = TWL4030_MODULE_PWMA; 217 218 offset -= TWL4030_GPIO_MAX; 219 if (offset) { 220 ledclr_mask <<= 1; 221 module = TWL4030_MODULE_PWMB; 222 } 223 224 /* initialize PWM to always-drive */ 225 status = twl_i2c_write_u8(module, 0x7f, 226 TWL4030_PWMx_PWMxOFF); 227 if (status < 0) 228 goto done; 229 status = twl_i2c_write_u8(module, 0x7f, 230 TWL4030_PWMx_PWMxON); 231 if (status < 0) 232 goto done; 233 234 /* init LED to not-driven (high) */ 235 module = TWL4030_MODULE_LED; 236 status = twl_i2c_read_u8(module, &cached_leden, 237 TWL4030_LED_LEDEN); 238 if (status < 0) 239 goto done; 240 cached_leden &= ~ledclr_mask; 241 status = twl_i2c_write_u8(module, cached_leden, 242 TWL4030_LED_LEDEN); 243 if (status < 0) 244 goto done; 245 246 status = 0; 247 goto done; 248 } 249 250 /* on first use, turn GPIO module "on" */ 251 if (!gpio_usage_count) { 252 struct twl4030_gpio_platform_data *pdata; 253 u8 value = MASK_GPIO_CTRL_GPIO_ON; 254 255 /* optionally have the first two GPIOs switch vMMC1 256 * and vMMC2 power supplies based on card presence. 257 */ 258 pdata = chip->dev->platform_data; 259 value |= pdata->mmc_cd & 0x03; 260 261 status = gpio_twl4030_write(REG_GPIO_CTRL, value); 262 } 263 264 if (!status) 265 gpio_usage_count |= (0x1 << offset); 266 267done: 268 mutex_unlock(&gpio_lock); 269 return status; 270} 271 272static void twl_free(struct gpio_chip *chip, unsigned offset) 273{ 274 if (offset >= TWL4030_GPIO_MAX) { 275 twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1); 276 return; 277 } 278 279 mutex_lock(&gpio_lock); 280 281 gpio_usage_count &= ~BIT(offset); 282 283 /* on last use, switch off GPIO module */ 284 if (!gpio_usage_count) 285 gpio_twl4030_write(REG_GPIO_CTRL, 0x0); 286 287 mutex_unlock(&gpio_lock); 288} 289 290static int twl_direction_in(struct gpio_chip *chip, unsigned offset) 291{ 292 return (offset < TWL4030_GPIO_MAX) 293 ? twl4030_set_gpio_direction(offset, 1) 294 : -EINVAL; 295} 296 297static int twl_get(struct gpio_chip *chip, unsigned offset) 298{ 299 int status = 0; 300 301 if (offset < TWL4030_GPIO_MAX) 302 status = twl4030_get_gpio_datain(offset); 303 else if (offset == TWL4030_GPIO_MAX) 304 status = cached_leden & LEDEN_LEDAON; 305 else 306 status = cached_leden & LEDEN_LEDBON; 307 return (status < 0) ? 0 : status; 308} 309 310static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value) 311{ 312 if (offset < TWL4030_GPIO_MAX) { 313 twl4030_set_gpio_dataout(offset, value); 314 return twl4030_set_gpio_direction(offset, 0); 315 } else { 316 twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value); 317 return 0; 318 } 319} 320 321static void twl_set(struct gpio_chip *chip, unsigned offset, int value) 322{ 323 if (offset < TWL4030_GPIO_MAX) 324 twl4030_set_gpio_dataout(offset, value); 325 else 326 twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value); 327} 328 329static int twl_to_irq(struct gpio_chip *chip, unsigned offset) 330{ 331 return (twl4030_gpio_irq_base && (offset < TWL4030_GPIO_MAX)) 332 ? (twl4030_gpio_irq_base + offset) 333 : -EINVAL; 334} 335 336static struct gpio_chip twl_gpiochip = { 337 .label = "twl4030", 338 .owner = THIS_MODULE, 339 .request = twl_request, 340 .free = twl_free, 341 .direction_input = twl_direction_in, 342 .get = twl_get, 343 .direction_output = twl_direction_out, 344 .set = twl_set, 345 .to_irq = twl_to_irq, 346 .can_sleep = 1, 347}; 348 349/*----------------------------------------------------------------------*/ 350 351static int __devinit gpio_twl4030_pulls(u32 ups, u32 downs) 352{ 353 u8 message[6]; 354 unsigned i, gpio_bit; 355 356 /* For most pins, a pulldown was enabled by default. 357 * We should have data that's specific to this board. 358 */ 359 for (gpio_bit = 1, i = 1; i < 6; i++) { 360 u8 bit_mask; 361 unsigned j; 362 363 for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) { 364 if (ups & gpio_bit) 365 bit_mask |= 1 << (j + 1); 366 else if (downs & gpio_bit) 367 bit_mask |= 1 << (j + 0); 368 } 369 message[i] = bit_mask; 370 } 371 372 return twl_i2c_write(TWL4030_MODULE_GPIO, message, 373 REG_GPIOPUPDCTR1, 5); 374} 375 376static int __devinit gpio_twl4030_debounce(u32 debounce, u8 mmc_cd) 377{ 378 u8 message[4]; 379 380 /* 30 msec of debouncing is always used for MMC card detect, 381 * and is optional for everything else. 382 */ 383 message[1] = (debounce & 0xff) | (mmc_cd & 0x03); 384 debounce >>= 8; 385 message[2] = (debounce & 0xff); 386 debounce >>= 8; 387 message[3] = (debounce & 0x03); 388 389 return twl_i2c_write(TWL4030_MODULE_GPIO, message, 390 REG_GPIO_DEBEN1, 3); 391} 392 393static int gpio_twl4030_remove(struct platform_device *pdev); 394 395static int __devinit gpio_twl4030_probe(struct platform_device *pdev) 396{ 397 struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data; 398 int ret; 399 400 /* maybe setup IRQs */ 401 if (pdata->irq_base) { 402 if (is_module()) { 403 dev_err(&pdev->dev, 404 "can't dispatch IRQs from modules\n"); 405 goto no_irqs; 406 } 407 ret = twl4030_sih_setup(TWL4030_MODULE_GPIO); 408 if (ret < 0) 409 return ret; 410 WARN_ON(ret != pdata->irq_base); 411 twl4030_gpio_irq_base = ret; 412 } 413 414no_irqs: 415 /* 416 * NOTE: boards may waste power if they don't set pullups 417 * and pulldowns correctly ... default for non-ULPI pins is 418 * pulldown, and some other pins may have external pullups 419 * or pulldowns. Careful! 420 */ 421 ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns); 422 if (ret) 423 dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n", 424 pdata->pullups, pdata->pulldowns, 425 ret); 426 427 ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd); 428 if (ret) 429 dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n", 430 pdata->debounce, pdata->mmc_cd, 431 ret); 432 433 twl_gpiochip.base = pdata->gpio_base; 434 twl_gpiochip.ngpio = TWL4030_GPIO_MAX; 435 twl_gpiochip.dev = &pdev->dev; 436 437 /* NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE, 438 * is (still) clear if use_leds is set. 439 */ 440 if (pdata->use_leds) 441 twl_gpiochip.ngpio += 2; 442 443 ret = gpiochip_add(&twl_gpiochip); 444 if (ret < 0) { 445 dev_err(&pdev->dev, 446 "could not register gpiochip, %d\n", 447 ret); 448 twl_gpiochip.ngpio = 0; 449 gpio_twl4030_remove(pdev); 450 } else if (pdata->setup) { 451 int status; 452 453 status = pdata->setup(&pdev->dev, 454 pdata->gpio_base, TWL4030_GPIO_MAX); 455 if (status) 456 dev_dbg(&pdev->dev, "setup --> %d\n", status); 457 } 458 459 return ret; 460} 461 462/* Cannot use __devexit as gpio_twl4030_probe() calls us */ 463static int gpio_twl4030_remove(struct platform_device *pdev) 464{ 465 struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data; 466 int status; 467 468 if (pdata->teardown) { 469 status = pdata->teardown(&pdev->dev, 470 pdata->gpio_base, TWL4030_GPIO_MAX); 471 if (status) { 472 dev_dbg(&pdev->dev, "teardown --> %d\n", status); 473 return status; 474 } 475 } 476 477 status = gpiochip_remove(&twl_gpiochip); 478 if (status < 0) 479 return status; 480 481 if (is_module()) 482 return 0; 483 484 /* REVISIT no support yet for deregistering all the IRQs */ 485 WARN_ON(1); 486 return -EIO; 487} 488 489/* Note: this hardware lives inside an I2C-based multi-function device. */ 490MODULE_ALIAS("platform:twl4030_gpio"); 491 492static struct platform_driver gpio_twl4030_driver = { 493 .driver.name = "twl4030_gpio", 494 .driver.owner = THIS_MODULE, 495 .probe = gpio_twl4030_probe, 496 .remove = gpio_twl4030_remove, 497}; 498 499static int __init gpio_twl4030_init(void) 500{ 501 return platform_driver_register(&gpio_twl4030_driver); 502} 503subsys_initcall(gpio_twl4030_init); 504 505static void __exit gpio_twl4030_exit(void) 506{ 507 platform_driver_unregister(&gpio_twl4030_driver); 508} 509module_exit(gpio_twl4030_exit); 510 511MODULE_AUTHOR("Texas Instruments, Inc."); 512MODULE_DESCRIPTION("GPIO interface for TWL4030"); 513MODULE_LICENSE("GPL"); 514