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