1 /* 2 * 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 #include <linux/of.h> 36 #include <linux/irqdomain.h> 37 38 #include <linux/i2c/twl.h> 39 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 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 66 struct gpio_twl4030_priv { 67 struct gpio_chip gpio_chip; 68 struct mutex mutex; 69 int irq_base; 70 71 /* Bitfields for state caching */ 72 unsigned int usage_count; 73 unsigned int direction; 74 unsigned int out_state; 75 }; 76 77 /*----------------------------------------------------------------------*/ 78 79 /* 80 * To configure TWL4030 GPIO module registers 81 */ 82 static inline int gpio_twl4030_write(u8 address, u8 data) 83 { 84 return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address); 85 } 86 87 /*----------------------------------------------------------------------*/ 88 89 /* 90 * LED register offsets from TWL_MODULE_LED base 91 * PWMs A and B are dedicated to LEDs A and B, respectively. 92 */ 93 94 #define TWL4030_LED_LEDEN_REG 0x00 95 #define TWL4030_PWMAON_REG 0x01 96 #define TWL4030_PWMAOFF_REG 0x02 97 #define TWL4030_PWMBON_REG 0x03 98 #define TWL4030_PWMBOFF_REG 0x04 99 100 /* LEDEN bits */ 101 #define LEDEN_LEDAON BIT(0) 102 #define LEDEN_LEDBON BIT(1) 103 #define LEDEN_LEDAEXT BIT(2) 104 #define LEDEN_LEDBEXT BIT(3) 105 #define LEDEN_LEDAPWM BIT(4) 106 #define LEDEN_LEDBPWM BIT(5) 107 #define LEDEN_PWM_LENGTHA BIT(6) 108 #define LEDEN_PWM_LENGTHB BIT(7) 109 110 #define PWMxON_LENGTH BIT(7) 111 112 /*----------------------------------------------------------------------*/ 113 114 /* 115 * To read a TWL4030 GPIO module register 116 */ 117 static inline int gpio_twl4030_read(u8 address) 118 { 119 u8 data; 120 int ret = 0; 121 122 ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address); 123 return (ret < 0) ? ret : data; 124 } 125 126 /*----------------------------------------------------------------------*/ 127 128 static u8 cached_leden; 129 130 /* The LED lines are open drain outputs ... a FET pulls to GND, so an 131 * external pullup is needed. We could also expose the integrated PWM 132 * as a LED brightness control; we initialize it as "always on". 133 */ 134 static void twl4030_led_set_value(int led, int value) 135 { 136 u8 mask = LEDEN_LEDAON | LEDEN_LEDAPWM; 137 138 if (led) 139 mask <<= 1; 140 141 if (value) 142 cached_leden &= ~mask; 143 else 144 cached_leden |= mask; 145 146 WARN_ON_ONCE(twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden, 147 TWL4030_LED_LEDEN_REG)); 148 } 149 150 static int twl4030_set_gpio_direction(int gpio, int is_input) 151 { 152 u8 d_bnk = gpio >> 3; 153 u8 d_msk = BIT(gpio & 0x7); 154 u8 reg = 0; 155 u8 base = REG_GPIODATADIR1 + d_bnk; 156 int ret = 0; 157 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 return ret; 168 } 169 170 static int twl4030_set_gpio_dataout(int gpio, int enable) 171 { 172 u8 d_bnk = gpio >> 3; 173 u8 d_msk = BIT(gpio & 0x7); 174 u8 base = 0; 175 176 if (enable) 177 base = REG_SETGPIODATAOUT1 + d_bnk; 178 else 179 base = REG_CLEARGPIODATAOUT1 + d_bnk; 180 181 return gpio_twl4030_write(base, d_msk); 182 } 183 184 static int twl4030_get_gpio_datain(int gpio) 185 { 186 u8 d_bnk = gpio >> 3; 187 u8 d_off = gpio & 0x7; 188 u8 base = 0; 189 int ret = 0; 190 191 base = REG_GPIODATAIN1 + d_bnk; 192 ret = gpio_twl4030_read(base); 193 if (ret > 0) 194 ret = (ret >> d_off) & 0x1; 195 196 return ret; 197 } 198 199 /*----------------------------------------------------------------------*/ 200 201 static int twl_request(struct gpio_chip *chip, unsigned offset) 202 { 203 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 204 int status = 0; 205 206 mutex_lock(&priv->mutex); 207 208 /* Support the two LED outputs as output-only GPIOs. */ 209 if (offset >= TWL4030_GPIO_MAX) { 210 u8 ledclr_mask = LEDEN_LEDAON | LEDEN_LEDAEXT 211 | LEDEN_LEDAPWM | LEDEN_PWM_LENGTHA; 212 u8 reg = TWL4030_PWMAON_REG; 213 214 offset -= TWL4030_GPIO_MAX; 215 if (offset) { 216 ledclr_mask <<= 1; 217 reg = TWL4030_PWMBON_REG; 218 } 219 220 /* initialize PWM to always-drive */ 221 /* Configure PWM OFF register first */ 222 status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg + 1); 223 if (status < 0) 224 goto done; 225 226 /* Followed by PWM ON register */ 227 status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg); 228 if (status < 0) 229 goto done; 230 231 /* init LED to not-driven (high) */ 232 status = twl_i2c_read_u8(TWL4030_MODULE_LED, &cached_leden, 233 TWL4030_LED_LEDEN_REG); 234 if (status < 0) 235 goto done; 236 cached_leden &= ~ledclr_mask; 237 status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden, 238 TWL4030_LED_LEDEN_REG); 239 if (status < 0) 240 goto done; 241 242 status = 0; 243 goto done; 244 } 245 246 /* on first use, turn GPIO module "on" */ 247 if (!priv->usage_count) { 248 struct twl4030_gpio_platform_data *pdata; 249 u8 value = MASK_GPIO_CTRL_GPIO_ON; 250 251 /* optionally have the first two GPIOs switch vMMC1 252 * and vMMC2 power supplies based on card presence. 253 */ 254 pdata = dev_get_platdata(chip->parent); 255 if (pdata) 256 value |= pdata->mmc_cd & 0x03; 257 258 status = gpio_twl4030_write(REG_GPIO_CTRL, value); 259 } 260 261 done: 262 if (!status) 263 priv->usage_count |= BIT(offset); 264 265 mutex_unlock(&priv->mutex); 266 return status; 267 } 268 269 static void twl_free(struct gpio_chip *chip, unsigned offset) 270 { 271 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 272 273 mutex_lock(&priv->mutex); 274 if (offset >= TWL4030_GPIO_MAX) { 275 twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1); 276 goto out; 277 } 278 279 priv->usage_count &= ~BIT(offset); 280 281 /* on last use, switch off GPIO module */ 282 if (!priv->usage_count) 283 gpio_twl4030_write(REG_GPIO_CTRL, 0x0); 284 285 out: 286 mutex_unlock(&priv->mutex); 287 } 288 289 static int twl_direction_in(struct gpio_chip *chip, unsigned offset) 290 { 291 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 292 int ret; 293 294 mutex_lock(&priv->mutex); 295 if (offset < TWL4030_GPIO_MAX) 296 ret = twl4030_set_gpio_direction(offset, 1); 297 else 298 ret = -EINVAL; /* LED outputs can't be set as input */ 299 300 if (!ret) 301 priv->direction &= ~BIT(offset); 302 303 mutex_unlock(&priv->mutex); 304 305 return ret; 306 } 307 308 static int twl_get(struct gpio_chip *chip, unsigned offset) 309 { 310 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 311 int ret; 312 int status = 0; 313 314 mutex_lock(&priv->mutex); 315 if (!(priv->usage_count & BIT(offset))) { 316 ret = -EPERM; 317 goto out; 318 } 319 320 if (priv->direction & BIT(offset)) 321 status = priv->out_state & BIT(offset); 322 else 323 status = twl4030_get_gpio_datain(offset); 324 325 ret = (status < 0) ? status : !!status; 326 out: 327 mutex_unlock(&priv->mutex); 328 return ret; 329 } 330 331 static void twl_set(struct gpio_chip *chip, unsigned offset, int value) 332 { 333 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 334 335 mutex_lock(&priv->mutex); 336 if (offset < TWL4030_GPIO_MAX) 337 twl4030_set_gpio_dataout(offset, value); 338 else 339 twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value); 340 341 if (value) 342 priv->out_state |= BIT(offset); 343 else 344 priv->out_state &= ~BIT(offset); 345 346 mutex_unlock(&priv->mutex); 347 } 348 349 static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value) 350 { 351 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 352 int ret = 0; 353 354 mutex_lock(&priv->mutex); 355 if (offset < TWL4030_GPIO_MAX) { 356 ret = twl4030_set_gpio_direction(offset, 0); 357 if (ret) { 358 mutex_unlock(&priv->mutex); 359 return ret; 360 } 361 } 362 363 /* 364 * LED gpios i.e. offset >= TWL4030_GPIO_MAX are always output 365 */ 366 367 priv->direction |= BIT(offset); 368 mutex_unlock(&priv->mutex); 369 370 twl_set(chip, offset, value); 371 372 return ret; 373 } 374 375 static int twl_to_irq(struct gpio_chip *chip, unsigned offset) 376 { 377 struct gpio_twl4030_priv *priv = gpiochip_get_data(chip); 378 379 return (priv->irq_base && (offset < TWL4030_GPIO_MAX)) 380 ? (priv->irq_base + offset) 381 : -EINVAL; 382 } 383 384 static const struct gpio_chip template_chip = { 385 .label = "twl4030", 386 .owner = THIS_MODULE, 387 .request = twl_request, 388 .free = twl_free, 389 .direction_input = twl_direction_in, 390 .get = twl_get, 391 .direction_output = twl_direction_out, 392 .set = twl_set, 393 .to_irq = twl_to_irq, 394 .can_sleep = true, 395 }; 396 397 /*----------------------------------------------------------------------*/ 398 399 static int gpio_twl4030_pulls(u32 ups, u32 downs) 400 { 401 u8 message[5]; 402 unsigned i, gpio_bit; 403 404 /* For most pins, a pulldown was enabled by default. 405 * We should have data that's specific to this board. 406 */ 407 for (gpio_bit = 1, i = 0; i < 5; i++) { 408 u8 bit_mask; 409 unsigned j; 410 411 for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) { 412 if (ups & gpio_bit) 413 bit_mask |= 1 << (j + 1); 414 else if (downs & gpio_bit) 415 bit_mask |= 1 << (j + 0); 416 } 417 message[i] = bit_mask; 418 } 419 420 return twl_i2c_write(TWL4030_MODULE_GPIO, message, 421 REG_GPIOPUPDCTR1, 5); 422 } 423 424 static int gpio_twl4030_debounce(u32 debounce, u8 mmc_cd) 425 { 426 u8 message[3]; 427 428 /* 30 msec of debouncing is always used for MMC card detect, 429 * and is optional for everything else. 430 */ 431 message[0] = (debounce & 0xff) | (mmc_cd & 0x03); 432 debounce >>= 8; 433 message[1] = (debounce & 0xff); 434 debounce >>= 8; 435 message[2] = (debounce & 0x03); 436 437 return twl_i2c_write(TWL4030_MODULE_GPIO, message, 438 REG_GPIO_DEBEN1, 3); 439 } 440 441 static int gpio_twl4030_remove(struct platform_device *pdev); 442 443 static struct twl4030_gpio_platform_data *of_gpio_twl4030(struct device *dev, 444 struct twl4030_gpio_platform_data *pdata) 445 { 446 struct twl4030_gpio_platform_data *omap_twl_info; 447 448 omap_twl_info = devm_kzalloc(dev, sizeof(*omap_twl_info), GFP_KERNEL); 449 if (!omap_twl_info) 450 return NULL; 451 452 if (pdata) 453 *omap_twl_info = *pdata; 454 455 omap_twl_info->use_leds = of_property_read_bool(dev->of_node, 456 "ti,use-leds"); 457 458 of_property_read_u32(dev->of_node, "ti,debounce", 459 &omap_twl_info->debounce); 460 of_property_read_u32(dev->of_node, "ti,mmc-cd", 461 (u32 *)&omap_twl_info->mmc_cd); 462 of_property_read_u32(dev->of_node, "ti,pullups", 463 &omap_twl_info->pullups); 464 of_property_read_u32(dev->of_node, "ti,pulldowns", 465 &omap_twl_info->pulldowns); 466 467 return omap_twl_info; 468 } 469 470 static int gpio_twl4030_probe(struct platform_device *pdev) 471 { 472 struct twl4030_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev); 473 struct device_node *node = pdev->dev.of_node; 474 struct gpio_twl4030_priv *priv; 475 int ret, irq_base; 476 477 priv = devm_kzalloc(&pdev->dev, sizeof(struct gpio_twl4030_priv), 478 GFP_KERNEL); 479 if (!priv) 480 return -ENOMEM; 481 482 /* maybe setup IRQs */ 483 if (is_module()) { 484 dev_err(&pdev->dev, "can't dispatch IRQs from modules\n"); 485 goto no_irqs; 486 } 487 488 irq_base = irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX, 0); 489 if (irq_base < 0) { 490 dev_err(&pdev->dev, "Failed to alloc irq_descs\n"); 491 return irq_base; 492 } 493 494 irq_domain_add_legacy(node, TWL4030_GPIO_MAX, irq_base, 0, 495 &irq_domain_simple_ops, NULL); 496 497 ret = twl4030_sih_setup(&pdev->dev, TWL4030_MODULE_GPIO, irq_base); 498 if (ret < 0) 499 return ret; 500 501 priv->irq_base = irq_base; 502 503 no_irqs: 504 priv->gpio_chip = template_chip; 505 priv->gpio_chip.base = -1; 506 priv->gpio_chip.ngpio = TWL4030_GPIO_MAX; 507 priv->gpio_chip.parent = &pdev->dev; 508 509 mutex_init(&priv->mutex); 510 511 if (node) 512 pdata = of_gpio_twl4030(&pdev->dev, pdata); 513 514 if (pdata == NULL) { 515 dev_err(&pdev->dev, "Platform data is missing\n"); 516 return -ENXIO; 517 } 518 519 /* 520 * NOTE: boards may waste power if they don't set pullups 521 * and pulldowns correctly ... default for non-ULPI pins is 522 * pulldown, and some other pins may have external pullups 523 * or pulldowns. Careful! 524 */ 525 ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns); 526 if (ret) 527 dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n", 528 pdata->pullups, pdata->pulldowns, ret); 529 530 ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd); 531 if (ret) 532 dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n", 533 pdata->debounce, pdata->mmc_cd, ret); 534 535 /* 536 * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE, 537 * is (still) clear if use_leds is set. 538 */ 539 if (pdata->use_leds) 540 priv->gpio_chip.ngpio += 2; 541 542 ret = gpiochip_add_data(&priv->gpio_chip, priv); 543 if (ret < 0) { 544 dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret); 545 priv->gpio_chip.ngpio = 0; 546 gpio_twl4030_remove(pdev); 547 goto out; 548 } 549 550 platform_set_drvdata(pdev, priv); 551 552 if (pdata->setup) { 553 int status; 554 555 status = pdata->setup(&pdev->dev, priv->gpio_chip.base, 556 TWL4030_GPIO_MAX); 557 if (status) 558 dev_dbg(&pdev->dev, "setup --> %d\n", status); 559 } 560 561 out: 562 return ret; 563 } 564 565 /* Cannot use as gpio_twl4030_probe() calls us */ 566 static int gpio_twl4030_remove(struct platform_device *pdev) 567 { 568 struct twl4030_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev); 569 struct gpio_twl4030_priv *priv = platform_get_drvdata(pdev); 570 int status; 571 572 if (pdata && pdata->teardown) { 573 status = pdata->teardown(&pdev->dev, priv->gpio_chip.base, 574 TWL4030_GPIO_MAX); 575 if (status) { 576 dev_dbg(&pdev->dev, "teardown --> %d\n", status); 577 return status; 578 } 579 } 580 581 gpiochip_remove(&priv->gpio_chip); 582 583 if (is_module()) 584 return 0; 585 586 /* REVISIT no support yet for deregistering all the IRQs */ 587 WARN_ON(1); 588 return -EIO; 589 } 590 591 static const struct of_device_id twl_gpio_match[] = { 592 { .compatible = "ti,twl4030-gpio", }, 593 { }, 594 }; 595 MODULE_DEVICE_TABLE(of, twl_gpio_match); 596 597 /* Note: this hardware lives inside an I2C-based multi-function device. */ 598 MODULE_ALIAS("platform:twl4030_gpio"); 599 600 static struct platform_driver gpio_twl4030_driver = { 601 .driver = { 602 .name = "twl4030_gpio", 603 .of_match_table = twl_gpio_match, 604 }, 605 .probe = gpio_twl4030_probe, 606 .remove = gpio_twl4030_remove, 607 }; 608 609 static int __init gpio_twl4030_init(void) 610 { 611 return platform_driver_register(&gpio_twl4030_driver); 612 } 613 subsys_initcall(gpio_twl4030_init); 614 615 static void __exit gpio_twl4030_exit(void) 616 { 617 platform_driver_unregister(&gpio_twl4030_driver); 618 } 619 module_exit(gpio_twl4030_exit); 620 621 MODULE_AUTHOR("Texas Instruments, Inc."); 622 MODULE_DESCRIPTION("GPIO interface for TWL4030"); 623 MODULE_LICENSE("GPL"); 624