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>
42 * The GPIO "subchip" supports 18 GPIOs which can be configured as
43 * inputs or outputs, with pullups or pulldowns on each pin. Each
44 * GPIO can trigger interrupts on either or both edges.
46 * GPIO interrupts can be fed to either of two IRQ lines; this is
47 * intended to support multiple hosts.
49 * There are also two LED pins used sometimes as output-only GPIOs.
53 static struct gpio_chip twl_gpiochip
;
54 static int twl4030_gpio_base
;
55 static int twl4030_gpio_irq_base
;
57 /* genirq interfaces are not available to modules */
59 #define is_module() true
61 #define is_module() false
64 /* GPIO_CTRL Fields */
65 #define MASK_GPIO_CTRL_GPIO0CD1 BIT(0)
66 #define MASK_GPIO_CTRL_GPIO1CD2 BIT(1)
67 #define MASK_GPIO_CTRL_GPIO_ON BIT(2)
69 /* Mask for GPIO registers when aggregated into a 32-bit integer */
70 #define GPIO_32_MASK 0x0003ffff
73 static DEFINE_MUTEX(gpio_lock
);
75 /* store usage of each GPIO. - each bit represents one GPIO */
76 static unsigned int gpio_usage_count
;
78 /*----------------------------------------------------------------------*/
81 * To configure TWL4030 GPIO module registers
83 static inline int gpio_twl4030_write(u8 address
, u8 data
)
85 return twl_i2c_write_u8(TWL4030_MODULE_GPIO
, data
, address
);
88 /*----------------------------------------------------------------------*/
91 * LED register offsets (use TWL4030_MODULE_{LED,PWMA,PWMB}))
92 * PWMs A and B are dedicated to LEDs A and B, respectively.
95 #define TWL4030_LED_LEDEN 0x0
98 #define LEDEN_LEDAON BIT(0)
99 #define LEDEN_LEDBON BIT(1)
100 #define LEDEN_LEDAEXT BIT(2)
101 #define LEDEN_LEDBEXT BIT(3)
102 #define LEDEN_LEDAPWM BIT(4)
103 #define LEDEN_LEDBPWM BIT(5)
104 #define LEDEN_PWM_LENGTHA BIT(6)
105 #define LEDEN_PWM_LENGTHB BIT(7)
107 #define TWL4030_PWMx_PWMxON 0x0
108 #define TWL4030_PWMx_PWMxOFF 0x1
110 #define PWMxON_LENGTH BIT(7)
112 /*----------------------------------------------------------------------*/
115 * To read a TWL4030 GPIO module register
117 static inline int gpio_twl4030_read(u8 address
)
122 ret
= twl_i2c_read_u8(TWL4030_MODULE_GPIO
, &data
, address
);
123 return (ret
< 0) ? ret
: data
;
126 /*----------------------------------------------------------------------*/
128 static u8 cached_leden
; /* protected by gpio_lock */
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".
134 static void twl4030_led_set_value(int led
, int value
)
136 u8 mask
= LEDEN_LEDAON
| LEDEN_LEDAPWM
;
142 mutex_lock(&gpio_lock
);
144 cached_leden
&= ~mask
;
146 cached_leden
|= mask
;
147 status
= twl_i2c_write_u8(TWL4030_MODULE_LED
, cached_leden
,
149 mutex_unlock(&gpio_lock
);
152 static int twl4030_set_gpio_direction(int gpio
, int is_input
)
154 u8 d_bnk
= gpio
>> 3;
155 u8 d_msk
= BIT(gpio
& 0x7);
157 u8 base
= REG_GPIODATADIR1
+ d_bnk
;
160 mutex_lock(&gpio_lock
);
161 ret
= gpio_twl4030_read(base
);
168 ret
= gpio_twl4030_write(base
, reg
);
170 mutex_unlock(&gpio_lock
);
174 static int twl4030_set_gpio_dataout(int gpio
, int enable
)
176 u8 d_bnk
= gpio
>> 3;
177 u8 d_msk
= BIT(gpio
& 0x7);
181 base
= REG_SETGPIODATAOUT1
+ d_bnk
;
183 base
= REG_CLEARGPIODATAOUT1
+ d_bnk
;
185 return gpio_twl4030_write(base
, d_msk
);
188 static int twl4030_get_gpio_datain(int gpio
)
190 u8 d_bnk
= gpio
>> 3;
191 u8 d_off
= gpio
& 0x7;
195 if (unlikely((gpio
>= TWL4030_GPIO_MAX
)
196 || !(gpio_usage_count
& BIT(gpio
))))
199 base
= REG_GPIODATAIN1
+ d_bnk
;
200 ret
= gpio_twl4030_read(base
);
202 ret
= (ret
>> d_off
) & 0x1;
207 /*----------------------------------------------------------------------*/
209 static int twl_request(struct gpio_chip
*chip
, unsigned offset
)
213 mutex_lock(&gpio_lock
);
215 /* Support the two LED outputs as output-only GPIOs. */
216 if (offset
>= TWL4030_GPIO_MAX
) {
217 u8 ledclr_mask
= LEDEN_LEDAON
| LEDEN_LEDAEXT
218 | LEDEN_LEDAPWM
| LEDEN_PWM_LENGTHA
;
219 u8 module
= TWL4030_MODULE_PWMA
;
221 offset
-= TWL4030_GPIO_MAX
;
224 module
= TWL4030_MODULE_PWMB
;
227 /* initialize PWM to always-drive */
228 status
= twl_i2c_write_u8(module
, 0x7f,
229 TWL4030_PWMx_PWMxOFF
);
232 status
= twl_i2c_write_u8(module
, 0x7f,
233 TWL4030_PWMx_PWMxON
);
237 /* init LED to not-driven (high) */
238 module
= TWL4030_MODULE_LED
;
239 status
= twl_i2c_read_u8(module
, &cached_leden
,
243 cached_leden
&= ~ledclr_mask
;
244 status
= twl_i2c_write_u8(module
, cached_leden
,
253 /* on first use, turn GPIO module "on" */
254 if (!gpio_usage_count
) {
255 struct twl4030_gpio_platform_data
*pdata
;
256 u8 value
= MASK_GPIO_CTRL_GPIO_ON
;
258 /* optionally have the first two GPIOs switch vMMC1
259 * and vMMC2 power supplies based on card presence.
261 pdata
= chip
->dev
->platform_data
;
263 value
|= pdata
->mmc_cd
& 0x03;
265 status
= gpio_twl4030_write(REG_GPIO_CTRL
, value
);
269 gpio_usage_count
|= (0x1 << offset
);
272 mutex_unlock(&gpio_lock
);
276 static void twl_free(struct gpio_chip
*chip
, unsigned offset
)
278 if (offset
>= TWL4030_GPIO_MAX
) {
279 twl4030_led_set_value(offset
- TWL4030_GPIO_MAX
, 1);
283 mutex_lock(&gpio_lock
);
285 gpio_usage_count
&= ~BIT(offset
);
287 /* on last use, switch off GPIO module */
288 if (!gpio_usage_count
)
289 gpio_twl4030_write(REG_GPIO_CTRL
, 0x0);
291 mutex_unlock(&gpio_lock
);
294 static int twl_direction_in(struct gpio_chip
*chip
, unsigned offset
)
296 return (offset
< TWL4030_GPIO_MAX
)
297 ? twl4030_set_gpio_direction(offset
, 1)
301 static int twl_get(struct gpio_chip
*chip
, unsigned offset
)
305 if (offset
< TWL4030_GPIO_MAX
)
306 status
= twl4030_get_gpio_datain(offset
);
307 else if (offset
== TWL4030_GPIO_MAX
)
308 status
= cached_leden
& LEDEN_LEDAON
;
310 status
= cached_leden
& LEDEN_LEDBON
;
311 return (status
< 0) ? 0 : status
;
314 static int twl_direction_out(struct gpio_chip
*chip
, unsigned offset
, int value
)
316 if (offset
< TWL4030_GPIO_MAX
) {
317 twl4030_set_gpio_dataout(offset
, value
);
318 return twl4030_set_gpio_direction(offset
, 0);
320 twl4030_led_set_value(offset
- TWL4030_GPIO_MAX
, value
);
325 static void twl_set(struct gpio_chip
*chip
, unsigned offset
, int value
)
327 if (offset
< TWL4030_GPIO_MAX
)
328 twl4030_set_gpio_dataout(offset
, value
);
330 twl4030_led_set_value(offset
- TWL4030_GPIO_MAX
, value
);
333 static int twl_to_irq(struct gpio_chip
*chip
, unsigned offset
)
335 return (twl4030_gpio_irq_base
&& (offset
< TWL4030_GPIO_MAX
))
336 ? (twl4030_gpio_irq_base
+ offset
)
340 static struct gpio_chip twl_gpiochip
= {
342 .owner
= THIS_MODULE
,
343 .request
= twl_request
,
345 .direction_input
= twl_direction_in
,
347 .direction_output
= twl_direction_out
,
349 .to_irq
= twl_to_irq
,
353 /*----------------------------------------------------------------------*/
355 static int __devinit
gpio_twl4030_pulls(u32 ups
, u32 downs
)
358 unsigned i
, gpio_bit
;
360 /* For most pins, a pulldown was enabled by default.
361 * We should have data that's specific to this board.
363 for (gpio_bit
= 1, i
= 1; i
< 6; i
++) {
367 for (bit_mask
= 0, j
= 0; j
< 8; j
+= 2, gpio_bit
<<= 1) {
369 bit_mask
|= 1 << (j
+ 1);
370 else if (downs
& gpio_bit
)
371 bit_mask
|= 1 << (j
+ 0);
373 message
[i
] = bit_mask
;
376 return twl_i2c_write(TWL4030_MODULE_GPIO
, message
,
377 REG_GPIOPUPDCTR1
, 5);
380 static int __devinit
gpio_twl4030_debounce(u32 debounce
, u8 mmc_cd
)
384 /* 30 msec of debouncing is always used for MMC card detect,
385 * and is optional for everything else.
387 message
[1] = (debounce
& 0xff) | (mmc_cd
& 0x03);
389 message
[2] = (debounce
& 0xff);
391 message
[3] = (debounce
& 0x03);
393 return twl_i2c_write(TWL4030_MODULE_GPIO
, message
,
397 static int gpio_twl4030_remove(struct platform_device
*pdev
);
399 static struct twl4030_gpio_platform_data
*of_gpio_twl4030(struct device
*dev
)
401 struct twl4030_gpio_platform_data
*omap_twl_info
;
403 omap_twl_info
= devm_kzalloc(dev
, sizeof(*omap_twl_info
), GFP_KERNEL
);
407 omap_twl_info
->use_leds
= of_property_read_bool(dev
->of_node
,
410 of_property_read_u32(dev
->of_node
, "ti,debounce",
411 &omap_twl_info
->debounce
);
412 of_property_read_u32(dev
->of_node
, "ti,mmc-cd",
413 (u32
*)&omap_twl_info
->mmc_cd
);
414 of_property_read_u32(dev
->of_node
, "ti,pullups",
415 &omap_twl_info
->pullups
);
416 of_property_read_u32(dev
->of_node
, "ti,pulldowns",
417 &omap_twl_info
->pulldowns
);
419 return omap_twl_info
;
422 static int __devinit
gpio_twl4030_probe(struct platform_device
*pdev
)
424 struct twl4030_gpio_platform_data
*pdata
= pdev
->dev
.platform_data
;
425 struct device_node
*node
= pdev
->dev
.of_node
;
428 /* maybe setup IRQs */
430 dev_err(&pdev
->dev
, "can't dispatch IRQs from modules\n");
434 irq_base
= irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX
, 0);
436 dev_err(&pdev
->dev
, "Failed to alloc irq_descs\n");
440 irq_domain_add_legacy(node
, TWL4030_GPIO_MAX
, irq_base
, 0,
441 &irq_domain_simple_ops
, NULL
);
443 ret
= twl4030_sih_setup(&pdev
->dev
, TWL4030_MODULE_GPIO
, irq_base
);
447 twl4030_gpio_irq_base
= irq_base
;
450 twl_gpiochip
.base
= -1;
451 twl_gpiochip
.ngpio
= TWL4030_GPIO_MAX
;
452 twl_gpiochip
.dev
= &pdev
->dev
;
455 pdata
= of_gpio_twl4030(&pdev
->dev
);
458 dev_err(&pdev
->dev
, "Platform data is missing\n");
463 * NOTE: boards may waste power if they don't set pullups
464 * and pulldowns correctly ... default for non-ULPI pins is
465 * pulldown, and some other pins may have external pullups
466 * or pulldowns. Careful!
468 ret
= gpio_twl4030_pulls(pdata
->pullups
, pdata
->pulldowns
);
470 dev_dbg(&pdev
->dev
, "pullups %.05x %.05x --> %d\n",
471 pdata
->pullups
, pdata
->pulldowns
, ret
);
473 ret
= gpio_twl4030_debounce(pdata
->debounce
, pdata
->mmc_cd
);
475 dev_dbg(&pdev
->dev
, "debounce %.03x %.01x --> %d\n",
476 pdata
->debounce
, pdata
->mmc_cd
, ret
);
479 * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
480 * is (still) clear if use_leds is set.
483 twl_gpiochip
.ngpio
+= 2;
485 ret
= gpiochip_add(&twl_gpiochip
);
487 dev_err(&pdev
->dev
, "could not register gpiochip, %d\n", ret
);
488 twl_gpiochip
.ngpio
= 0;
489 gpio_twl4030_remove(pdev
);
493 twl4030_gpio_base
= twl_gpiochip
.base
;
495 if (pdata
&& pdata
->setup
) {
498 status
= pdata
->setup(&pdev
->dev
,
499 twl4030_gpio_base
, TWL4030_GPIO_MAX
);
501 dev_dbg(&pdev
->dev
, "setup --> %d\n", status
);
508 /* Cannot use __devexit as gpio_twl4030_probe() calls us */
509 static int gpio_twl4030_remove(struct platform_device
*pdev
)
511 struct twl4030_gpio_platform_data
*pdata
= pdev
->dev
.platform_data
;
514 if (pdata
&& pdata
->teardown
) {
515 status
= pdata
->teardown(&pdev
->dev
,
516 twl4030_gpio_base
, TWL4030_GPIO_MAX
);
518 dev_dbg(&pdev
->dev
, "teardown --> %d\n", status
);
523 status
= gpiochip_remove(&twl_gpiochip
);
530 /* REVISIT no support yet for deregistering all the IRQs */
535 static const struct of_device_id twl_gpio_match
[] = {
536 { .compatible
= "ti,twl4030-gpio", },
539 MODULE_DEVICE_TABLE(of
, twl_gpio_match
);
541 /* Note: this hardware lives inside an I2C-based multi-function device. */
542 MODULE_ALIAS("platform:twl4030_gpio");
544 static struct platform_driver gpio_twl4030_driver
= {
546 .name
= "twl4030_gpio",
547 .owner
= THIS_MODULE
,
548 .of_match_table
= of_match_ptr(twl_gpio_match
),
550 .probe
= gpio_twl4030_probe
,
551 .remove
= gpio_twl4030_remove
,
554 static int __init
gpio_twl4030_init(void)
556 return platform_driver_register(&gpio_twl4030_driver
);
558 subsys_initcall(gpio_twl4030_init
);
560 static void __exit
gpio_twl4030_exit(void)
562 platform_driver_unregister(&gpio_twl4030_driver
);
564 module_exit(gpio_twl4030_exit
);
566 MODULE_AUTHOR("Texas Instruments, Inc.");
567 MODULE_DESCRIPTION("GPIO interface for TWL4030");
568 MODULE_LICENSE("GPL");