2 * Access to GPIOs on TWL4030/TPS659x0 chips
4 * Copyright (C) 2006-2007 Texas Instruments, Inc.
5 * Copyright (C) 2006 MontaVista Software, Inc.
7 * Code re-arranged and cleaned up by:
8 * Syed Mohammed Khasim <x0khasim@ti.com>
11 * Andy Lowe / Nishanth Menon
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.
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.
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
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>
36 #include <linux/irqdomain.h>
38 #include <linux/i2c/twl.h>
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.
45 * GPIO interrupts can be fed to either of two IRQ lines; this is
46 * intended to support multiple hosts.
48 * There are also two LED pins used sometimes as output-only GPIOs.
51 /* genirq interfaces are not available to modules */
53 #define is_module() true
55 #define is_module() false
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)
63 /* Mask for GPIO registers when aggregated into a 32-bit integer */
64 #define GPIO_32_MASK 0x0003ffff
66 struct gpio_twl4030_priv
{
67 struct gpio_chip gpio_chip
;
71 /* Bitfields for state caching */
72 unsigned int usage_count
;
73 unsigned int direction
;
74 unsigned int out_state
;
77 /*----------------------------------------------------------------------*/
79 static inline struct gpio_twl4030_priv
*to_gpio_twl4030(struct gpio_chip
*chip
)
81 return container_of(chip
, struct gpio_twl4030_priv
, gpio_chip
);
85 * To configure TWL4030 GPIO module registers
87 static inline int gpio_twl4030_write(u8 address
, u8 data
)
89 return twl_i2c_write_u8(TWL4030_MODULE_GPIO
, data
, address
);
92 /*----------------------------------------------------------------------*/
95 * LED register offsets from TWL_MODULE_LED base
96 * PWMs A and B are dedicated to LEDs A and B, respectively.
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
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)
115 #define PWMxON_LENGTH BIT(7)
117 /*----------------------------------------------------------------------*/
120 * To read a TWL4030 GPIO module register
122 static inline int gpio_twl4030_read(u8 address
)
127 ret
= twl_i2c_read_u8(TWL4030_MODULE_GPIO
, &data
, address
);
128 return (ret
< 0) ? ret
: data
;
131 /*----------------------------------------------------------------------*/
133 static u8 cached_leden
;
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".
139 static void twl4030_led_set_value(int led
, int value
)
141 u8 mask
= LEDEN_LEDAON
| LEDEN_LEDAPWM
;
148 cached_leden
&= ~mask
;
150 cached_leden
|= mask
;
151 status
= twl_i2c_write_u8(TWL4030_MODULE_LED
, cached_leden
,
152 TWL4030_LED_LEDEN_REG
);
155 static int twl4030_set_gpio_direction(int gpio
, int is_input
)
157 u8 d_bnk
= gpio
>> 3;
158 u8 d_msk
= BIT(gpio
& 0x7);
160 u8 base
= REG_GPIODATADIR1
+ d_bnk
;
163 ret
= gpio_twl4030_read(base
);
170 ret
= gpio_twl4030_write(base
, reg
);
175 static int twl4030_set_gpio_dataout(int gpio
, int enable
)
177 u8 d_bnk
= gpio
>> 3;
178 u8 d_msk
= BIT(gpio
& 0x7);
182 base
= REG_SETGPIODATAOUT1
+ d_bnk
;
184 base
= REG_CLEARGPIODATAOUT1
+ d_bnk
;
186 return gpio_twl4030_write(base
, d_msk
);
189 static int twl4030_get_gpio_datain(int gpio
)
191 u8 d_bnk
= gpio
>> 3;
192 u8 d_off
= gpio
& 0x7;
196 base
= REG_GPIODATAIN1
+ d_bnk
;
197 ret
= gpio_twl4030_read(base
);
199 ret
= (ret
>> d_off
) & 0x1;
204 /*----------------------------------------------------------------------*/
206 static int twl_request(struct gpio_chip
*chip
, unsigned offset
)
208 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
211 mutex_lock(&priv
->mutex
);
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
;
217 u8 reg
= TWL4030_PWMAON_REG
;
219 offset
-= TWL4030_GPIO_MAX
;
222 reg
= TWL4030_PWMBON_REG
;
225 /* initialize PWM to always-drive */
226 /* Configure PWM OFF register first */
227 status
= twl_i2c_write_u8(TWL4030_MODULE_LED
, 0x7f, reg
+ 1);
231 /* Followed by PWM ON register */
232 status
= twl_i2c_write_u8(TWL4030_MODULE_LED
, 0x7f, reg
);
236 /* init LED to not-driven (high) */
237 status
= twl_i2c_read_u8(TWL4030_MODULE_LED
, &cached_leden
,
238 TWL4030_LED_LEDEN_REG
);
241 cached_leden
&= ~ledclr_mask
;
242 status
= twl_i2c_write_u8(TWL4030_MODULE_LED
, cached_leden
,
243 TWL4030_LED_LEDEN_REG
);
251 /* on first use, turn GPIO module "on" */
252 if (!priv
->usage_count
) {
253 struct twl4030_gpio_platform_data
*pdata
;
254 u8 value
= MASK_GPIO_CTRL_GPIO_ON
;
256 /* optionally have the first two GPIOs switch vMMC1
257 * and vMMC2 power supplies based on card presence.
259 pdata
= dev_get_platdata(chip
->dev
);
261 value
|= pdata
->mmc_cd
& 0x03;
263 status
= gpio_twl4030_write(REG_GPIO_CTRL
, value
);
268 priv
->usage_count
|= BIT(offset
);
270 mutex_unlock(&priv
->mutex
);
274 static void twl_free(struct gpio_chip
*chip
, unsigned offset
)
276 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
278 mutex_lock(&priv
->mutex
);
279 if (offset
>= TWL4030_GPIO_MAX
) {
280 twl4030_led_set_value(offset
- TWL4030_GPIO_MAX
, 1);
284 priv
->usage_count
&= ~BIT(offset
);
286 /* on last use, switch off GPIO module */
287 if (!priv
->usage_count
)
288 gpio_twl4030_write(REG_GPIO_CTRL
, 0x0);
291 mutex_unlock(&priv
->mutex
);
294 static int twl_direction_in(struct gpio_chip
*chip
, unsigned offset
)
296 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
299 mutex_lock(&priv
->mutex
);
300 if (offset
< TWL4030_GPIO_MAX
)
301 ret
= twl4030_set_gpio_direction(offset
, 1);
306 priv
->direction
&= ~BIT(offset
);
308 mutex_unlock(&priv
->mutex
);
313 static int twl_get(struct gpio_chip
*chip
, unsigned offset
)
315 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
319 mutex_lock(&priv
->mutex
);
320 if (!(priv
->usage_count
& BIT(offset
))) {
325 if (priv
->direction
& BIT(offset
))
326 status
= priv
->out_state
& BIT(offset
);
328 status
= twl4030_get_gpio_datain(offset
);
330 ret
= (status
<= 0) ? 0 : 1;
332 mutex_unlock(&priv
->mutex
);
336 static void twl_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
338 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
340 mutex_lock(&priv
->mutex
);
341 if (offset
< TWL4030_GPIO_MAX
)
342 twl4030_set_gpio_dataout(offset
, value
);
344 twl4030_led_set_value(offset
- TWL4030_GPIO_MAX
, value
);
347 priv
->out_state
|= BIT(offset
);
349 priv
->out_state
&= ~BIT(offset
);
351 mutex_unlock(&priv
->mutex
);
354 static int twl_direction_out(struct gpio_chip
*chip
, unsigned offset
, int value
)
356 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
359 mutex_lock(&priv
->mutex
);
360 if (offset
< TWL4030_GPIO_MAX
)
361 ret
= twl4030_set_gpio_direction(offset
, 0);
363 priv
->direction
|= BIT(offset
);
364 mutex_unlock(&priv
->mutex
);
366 twl_set(chip
, offset
, value
);
371 static int twl_to_irq(struct gpio_chip
*chip
, unsigned offset
)
373 struct gpio_twl4030_priv
*priv
= to_gpio_twl4030(chip
);
375 return (priv
->irq_base
&& (offset
< TWL4030_GPIO_MAX
))
376 ? (priv
->irq_base
+ offset
)
380 static struct gpio_chip template_chip
= {
382 .owner
= THIS_MODULE
,
383 .request
= twl_request
,
385 .direction_input
= twl_direction_in
,
387 .direction_output
= twl_direction_out
,
389 .to_irq
= twl_to_irq
,
393 /*----------------------------------------------------------------------*/
395 static int gpio_twl4030_pulls(u32 ups
, u32 downs
)
398 unsigned i
, gpio_bit
;
400 /* For most pins, a pulldown was enabled by default.
401 * We should have data that's specific to this board.
403 for (gpio_bit
= 1, i
= 0; i
< 5; i
++) {
407 for (bit_mask
= 0, j
= 0; j
< 8; j
+= 2, gpio_bit
<<= 1) {
409 bit_mask
|= 1 << (j
+ 1);
410 else if (downs
& gpio_bit
)
411 bit_mask
|= 1 << (j
+ 0);
413 message
[i
] = bit_mask
;
416 return twl_i2c_write(TWL4030_MODULE_GPIO
, message
,
417 REG_GPIOPUPDCTR1
, 5);
420 static int gpio_twl4030_debounce(u32 debounce
, u8 mmc_cd
)
424 /* 30 msec of debouncing is always used for MMC card detect,
425 * and is optional for everything else.
427 message
[0] = (debounce
& 0xff) | (mmc_cd
& 0x03);
429 message
[1] = (debounce
& 0xff);
431 message
[2] = (debounce
& 0x03);
433 return twl_i2c_write(TWL4030_MODULE_GPIO
, message
,
437 static int gpio_twl4030_remove(struct platform_device
*pdev
);
439 static struct twl4030_gpio_platform_data
*of_gpio_twl4030(struct device
*dev
,
440 struct twl4030_gpio_platform_data
*pdata
)
442 struct twl4030_gpio_platform_data
*omap_twl_info
;
444 omap_twl_info
= devm_kzalloc(dev
, sizeof(*omap_twl_info
), GFP_KERNEL
);
449 *omap_twl_info
= *pdata
;
451 omap_twl_info
->use_leds
= of_property_read_bool(dev
->of_node
,
454 of_property_read_u32(dev
->of_node
, "ti,debounce",
455 &omap_twl_info
->debounce
);
456 of_property_read_u32(dev
->of_node
, "ti,mmc-cd",
457 (u32
*)&omap_twl_info
->mmc_cd
);
458 of_property_read_u32(dev
->of_node
, "ti,pullups",
459 &omap_twl_info
->pullups
);
460 of_property_read_u32(dev
->of_node
, "ti,pulldowns",
461 &omap_twl_info
->pulldowns
);
463 return omap_twl_info
;
466 static int gpio_twl4030_probe(struct platform_device
*pdev
)
468 struct twl4030_gpio_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
469 struct device_node
*node
= pdev
->dev
.of_node
;
470 struct gpio_twl4030_priv
*priv
;
473 priv
= devm_kzalloc(&pdev
->dev
, sizeof(struct gpio_twl4030_priv
),
478 /* maybe setup IRQs */
480 dev_err(&pdev
->dev
, "can't dispatch IRQs from modules\n");
484 irq_base
= irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX
, 0);
486 dev_err(&pdev
->dev
, "Failed to alloc irq_descs\n");
490 irq_domain_add_legacy(node
, TWL4030_GPIO_MAX
, irq_base
, 0,
491 &irq_domain_simple_ops
, NULL
);
493 ret
= twl4030_sih_setup(&pdev
->dev
, TWL4030_MODULE_GPIO
, irq_base
);
497 priv
->irq_base
= irq_base
;
500 priv
->gpio_chip
= template_chip
;
501 priv
->gpio_chip
.base
= -1;
502 priv
->gpio_chip
.ngpio
= TWL4030_GPIO_MAX
;
503 priv
->gpio_chip
.dev
= &pdev
->dev
;
505 mutex_init(&priv
->mutex
);
508 pdata
= of_gpio_twl4030(&pdev
->dev
, pdata
);
511 dev_err(&pdev
->dev
, "Platform data is missing\n");
516 * NOTE: boards may waste power if they don't set pullups
517 * and pulldowns correctly ... default for non-ULPI pins is
518 * pulldown, and some other pins may have external pullups
519 * or pulldowns. Careful!
521 ret
= gpio_twl4030_pulls(pdata
->pullups
, pdata
->pulldowns
);
523 dev_dbg(&pdev
->dev
, "pullups %.05x %.05x --> %d\n",
524 pdata
->pullups
, pdata
->pulldowns
, ret
);
526 ret
= gpio_twl4030_debounce(pdata
->debounce
, pdata
->mmc_cd
);
528 dev_dbg(&pdev
->dev
, "debounce %.03x %.01x --> %d\n",
529 pdata
->debounce
, pdata
->mmc_cd
, ret
);
532 * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
533 * is (still) clear if use_leds is set.
536 priv
->gpio_chip
.ngpio
+= 2;
538 ret
= gpiochip_add(&priv
->gpio_chip
);
540 dev_err(&pdev
->dev
, "could not register gpiochip, %d\n", ret
);
541 priv
->gpio_chip
.ngpio
= 0;
542 gpio_twl4030_remove(pdev
);
546 platform_set_drvdata(pdev
, priv
);
548 if (pdata
&& pdata
->setup
) {
551 status
= pdata
->setup(&pdev
->dev
, priv
->gpio_chip
.base
,
554 dev_dbg(&pdev
->dev
, "setup --> %d\n", status
);
561 /* Cannot use as gpio_twl4030_probe() calls us */
562 static int gpio_twl4030_remove(struct platform_device
*pdev
)
564 struct twl4030_gpio_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
565 struct gpio_twl4030_priv
*priv
= platform_get_drvdata(pdev
);
568 if (pdata
&& pdata
->teardown
) {
569 status
= pdata
->teardown(&pdev
->dev
, priv
->gpio_chip
.base
,
572 dev_dbg(&pdev
->dev
, "teardown --> %d\n", status
);
577 status
= gpiochip_remove(&priv
->gpio_chip
);
584 /* REVISIT no support yet for deregistering all the IRQs */
589 static const struct of_device_id twl_gpio_match
[] = {
590 { .compatible
= "ti,twl4030-gpio", },
593 MODULE_DEVICE_TABLE(of
, twl_gpio_match
);
595 /* Note: this hardware lives inside an I2C-based multi-function device. */
596 MODULE_ALIAS("platform:twl4030_gpio");
598 static struct platform_driver gpio_twl4030_driver
= {
600 .name
= "twl4030_gpio",
601 .owner
= THIS_MODULE
,
602 .of_match_table
= twl_gpio_match
,
604 .probe
= gpio_twl4030_probe
,
605 .remove
= gpio_twl4030_remove
,
608 static int __init
gpio_twl4030_init(void)
610 return platform_driver_register(&gpio_twl4030_driver
);
612 subsys_initcall(gpio_twl4030_init
);
614 static void __exit
gpio_twl4030_exit(void)
616 platform_driver_unregister(&gpio_twl4030_driver
);
618 module_exit(gpio_twl4030_exit
);
620 MODULE_AUTHOR("Texas Instruments, Inc.");
621 MODULE_DESCRIPTION("GPIO interface for TWL4030");
622 MODULE_LICENSE("GPL");