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