[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / gpio / gpio-twl4030.c

/*
 * Access to GPIOs on TWL4030/TPS659x0 chips
 *
 * Copyright (C) 2006-2007 Texas Instruments, Inc.
 * Copyright (C) 2006 MontaVista Software, Inc.
 *
 * Code re-arranged and cleaned up by:
 *	Syed Mohammed Khasim <x0khasim@ti.com>
 *
 * Initial Code:
 *	Andy Lowe / Nishanth Menon
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kthread.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/irqdomain.h>

#include <linux/i2c/twl.h>


/*
 * The GPIO "subchip" supports 18 GPIOs which can be configured as
 * inputs or outputs, with pullups or pulldowns on each pin.  Each
 * GPIO can trigger interrupts on either or both edges.
 *
 * GPIO interrupts can be fed to either of two IRQ lines; this is
 * intended to support multiple hosts.
 *
 * There are also two LED pins used sometimes as output-only GPIOs.
 */


static struct gpio_chip twl_gpiochip;
static int twl4030_gpio_irq_base;

/* genirq interfaces are not available to modules */
#ifdef MODULE
#define is_module()	true
#else
#define is_module()	false
#endif

/* GPIO_CTRL Fields */
#define MASK_GPIO_CTRL_GPIO0CD1		BIT(0)
#define MASK_GPIO_CTRL_GPIO1CD2		BIT(1)
#define MASK_GPIO_CTRL_GPIO_ON		BIT(2)

/* Mask for GPIO registers when aggregated into a 32-bit integer */
#define GPIO_32_MASK			0x0003ffff

/* Data structures */
static DEFINE_MUTEX(gpio_lock);

/* store usage of each GPIO. - each bit represents one GPIO */
static unsigned int gpio_usage_count;

/*----------------------------------------------------------------------*/

/*
 * To configure TWL4030 GPIO module registers
 */
static inline int gpio_twl4030_write(u8 address, u8 data)
{
	return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address);
}

/*----------------------------------------------------------------------*/

/*
 * LED register offsets (use TWL4030_MODULE_{LED,PWMA,PWMB}))
 * PWMs A and B are dedicated to LEDs A and B, respectively.
 */

#define TWL4030_LED_LEDEN	0x0

/* LEDEN bits */
#define LEDEN_LEDAON		BIT(0)
#define LEDEN_LEDBON		BIT(1)
#define LEDEN_LEDAEXT		BIT(2)
#define LEDEN_LEDBEXT		BIT(3)
#define LEDEN_LEDAPWM		BIT(4)
#define LEDEN_LEDBPWM		BIT(5)
#define LEDEN_PWM_LENGTHA	BIT(6)
#define LEDEN_PWM_LENGTHB	BIT(7)

#define TWL4030_PWMx_PWMxON	0x0
#define TWL4030_PWMx_PWMxOFF	0x1

#define PWMxON_LENGTH		BIT(7)

/*----------------------------------------------------------------------*/

/*
 * To read a TWL4030 GPIO module register
 */
static inline int gpio_twl4030_read(u8 address)
{
	u8 data;
	int ret = 0;

	ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address);
	return (ret < 0) ? ret : data;
}

/*----------------------------------------------------------------------*/

static u8 cached_leden;		/* protected by gpio_lock */

/* The LED lines are open drain outputs ... a FET pulls to GND, so an
 * external pullup is needed.  We could also expose the integrated PWM
 * as a LED brightness control; we initialize it as "always on".
 */
static void twl4030_led_set_value(int led, int value)
{
	u8 mask = LEDEN_LEDAON | LEDEN_LEDAPWM;
	int status;

	if (led)
		mask <<= 1;

	mutex_lock(&gpio_lock);
	if (value)
		cached_leden &= ~mask;
	else
		cached_leden |= mask;
	status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
			TWL4030_LED_LEDEN);
	mutex_unlock(&gpio_lock);
}

static int twl4030_set_gpio_direction(int gpio, int is_input)
{
	u8 d_bnk = gpio >> 3;
	u8 d_msk = BIT(gpio & 0x7);
	u8 reg = 0;
	u8 base = REG_GPIODATADIR1 + d_bnk;
	int ret = 0;

	mutex_lock(&gpio_lock);
	ret = gpio_twl4030_read(base);
	if (ret >= 0) {
		if (is_input)
			reg = ret & ~d_msk;
		else
			reg = ret | d_msk;

		ret = gpio_twl4030_write(base, reg);
	}
	mutex_unlock(&gpio_lock);
	return ret;
}

static int twl4030_set_gpio_dataout(int gpio, int enable)
{
	u8 d_bnk = gpio >> 3;
	u8 d_msk = BIT(gpio & 0x7);
	u8 base = 0;

	if (enable)
		base = REG_SETGPIODATAOUT1 + d_bnk;
	else
		base = REG_CLEARGPIODATAOUT1 + d_bnk;

	return gpio_twl4030_write(base, d_msk);
}

static int twl4030_get_gpio_datain(int gpio)
{
	u8 d_bnk = gpio >> 3;
	u8 d_off = gpio & 0x7;
	u8 base = 0;
	int ret = 0;

	if (unlikely((gpio >= TWL4030_GPIO_MAX)
		|| !(gpio_usage_count & BIT(gpio))))
		return -EPERM;

	base = REG_GPIODATAIN1 + d_bnk;
	ret = gpio_twl4030_read(base);
	if (ret > 0)
		ret = (ret >> d_off) & 0x1;

	return ret;
}

/*----------------------------------------------------------------------*/

static int twl_request(struct gpio_chip *chip, unsigned offset)
{
	int status = 0;

	mutex_lock(&gpio_lock);

	/* Support the two LED outputs as output-only GPIOs. */
	if (offset >= TWL4030_GPIO_MAX) {
		u8	ledclr_mask = LEDEN_LEDAON | LEDEN_LEDAEXT
				| LEDEN_LEDAPWM | LEDEN_PWM_LENGTHA;
		u8	module = TWL4030_MODULE_PWMA;

		offset -= TWL4030_GPIO_MAX;
		if (offset) {
			ledclr_mask <<= 1;
			module = TWL4030_MODULE_PWMB;
		}

		/* initialize PWM to always-drive */
		status = twl_i2c_write_u8(module, 0x7f,
				TWL4030_PWMx_PWMxOFF);
		if (status < 0)
			goto done;
		status = twl_i2c_write_u8(module, 0x7f,
				TWL4030_PWMx_PWMxON);
		if (status < 0)
			goto done;

		/* init LED to not-driven (high) */
		module = TWL4030_MODULE_LED;
		status = twl_i2c_read_u8(module, &cached_leden,
				TWL4030_LED_LEDEN);
		if (status < 0)
			goto done;
		cached_leden &= ~ledclr_mask;
		status = twl_i2c_write_u8(module, cached_leden,
				TWL4030_LED_LEDEN);
		if (status < 0)
			goto done;

		status = 0;
		goto done;
	}

	/* on first use, turn GPIO module "on" */
	if (!gpio_usage_count) {
		struct twl4030_gpio_platform_data *pdata;
		u8 value = MASK_GPIO_CTRL_GPIO_ON;

		/* optionally have the first two GPIOs switch vMMC1
		 * and vMMC2 power supplies based on card presence.
		 */
		pdata = chip->dev->platform_data;
		if (pdata)
			value |= pdata->mmc_cd & 0x03;

		status = gpio_twl4030_write(REG_GPIO_CTRL, value);
	}

	if (!status)
		gpio_usage_count |= (0x1 << offset);

done:
	mutex_unlock(&gpio_lock);
	return status;
}

static void twl_free(struct gpio_chip *chip, unsigned offset)
{
	if (offset >= TWL4030_GPIO_MAX) {
		twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1);
		return;
	}

	mutex_lock(&gpio_lock);

	gpio_usage_count &= ~BIT(offset);

	/* on last use, switch off GPIO module */
	if (!gpio_usage_count)
		gpio_twl4030_write(REG_GPIO_CTRL, 0x0);

	mutex_unlock(&gpio_lock);
}

static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
{
	return (offset < TWL4030_GPIO_MAX)
		? twl4030_set_gpio_direction(offset, 1)
		: -EINVAL;
}

static int twl_get(struct gpio_chip *chip, unsigned offset)
{
	int status = 0;

	if (offset < TWL4030_GPIO_MAX)
		status = twl4030_get_gpio_datain(offset);
	else if (offset == TWL4030_GPIO_MAX)
		status = cached_leden & LEDEN_LEDAON;
	else
		status = cached_leden & LEDEN_LEDBON;
	return (status < 0) ? 0 : status;
}

static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
{
	if (offset < TWL4030_GPIO_MAX) {
		twl4030_set_gpio_dataout(offset, value);
		return twl4030_set_gpio_direction(offset, 0);
	} else {
		twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
		return 0;
	}
}

static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
{
	if (offset < TWL4030_GPIO_MAX)
		twl4030_set_gpio_dataout(offset, value);
	else
		twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
}

static int twl_to_irq(struct gpio_chip *chip, unsigned offset)
{
	return (twl4030_gpio_irq_base && (offset < TWL4030_GPIO_MAX))
		? (twl4030_gpio_irq_base + offset)
		: -EINVAL;
}

static struct gpio_chip twl_gpiochip = {
	.label			= "twl4030",
	.owner			= THIS_MODULE,
	.request		= twl_request,
	.free			= twl_free,
	.direction_input	= twl_direction_in,
	.get			= twl_get,
	.direction_output	= twl_direction_out,
	.set			= twl_set,
	.to_irq			= twl_to_irq,
	.can_sleep		= 1,
};

/*----------------------------------------------------------------------*/

static int __devinit gpio_twl4030_pulls(u32 ups, u32 downs)
{
	u8		message[6];
	unsigned	i, gpio_bit;

	/* For most pins, a pulldown was enabled by default.
	 * We should have data that's specific to this board.
	 */
	for (gpio_bit = 1, i = 1; i < 6; i++) {
		u8		bit_mask;
		unsigned	j;

		for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) {
			if (ups & gpio_bit)
				bit_mask |= 1 << (j + 1);
			else if (downs & gpio_bit)
				bit_mask |= 1 << (j + 0);
		}
		message[i] = bit_mask;
	}

	return twl_i2c_write(TWL4030_MODULE_GPIO, message,
				REG_GPIOPUPDCTR1, 5);
}

static int __devinit gpio_twl4030_debounce(u32 debounce, u8 mmc_cd)
{
	u8		message[4];

	/* 30 msec of debouncing is always used for MMC card detect,
	 * and is optional for everything else.
	 */
	message[1] = (debounce & 0xff) | (mmc_cd & 0x03);
	debounce >>= 8;
	message[2] = (debounce & 0xff);
	debounce >>= 8;
	message[3] = (debounce & 0x03);

	return twl_i2c_write(TWL4030_MODULE_GPIO, message,
				REG_GPIO_DEBEN1, 3);
}

static int gpio_twl4030_remove(struct platform_device *pdev);

static int __devinit gpio_twl4030_probe(struct platform_device *pdev)
{
	struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
	struct device_node *node = pdev->dev.of_node;
	int ret, irq_base;

	/* maybe setup IRQs */
	if (is_module()) {
		dev_err(&pdev->dev, "can't dispatch IRQs from modules\n");
		goto no_irqs;
	}

	irq_base = irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX, 0);
	if (irq_base < 0) {
		dev_err(&pdev->dev, "Failed to alloc irq_descs\n");
		return irq_base;
	}

	irq_domain_add_legacy(node, TWL4030_GPIO_MAX, irq_base, 0,
			      &irq_domain_simple_ops, NULL);

	ret = twl4030_sih_setup(&pdev->dev, TWL4030_MODULE_GPIO, irq_base);
	if (ret < 0)
		return ret;

	twl4030_gpio_irq_base = irq_base;

no_irqs:
	twl_gpiochip.base = -1;
	twl_gpiochip.ngpio = TWL4030_GPIO_MAX;
	twl_gpiochip.dev = &pdev->dev;

	if (pdata) {
		twl_gpiochip.base = pdata->gpio_base;

		/*
		 * NOTE:  boards may waste power if they don't set pullups
		 * and pulldowns correctly ... default for non-ULPI pins is
		 * pulldown, and some other pins may have external pullups
		 * or pulldowns.  Careful!
		 */
		ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns);
		if (ret)
			dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n",
					pdata->pullups, pdata->pulldowns,
					ret);

		ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd);
		if (ret)
			dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n",
					pdata->debounce, pdata->mmc_cd,
					ret);

		/*
		 * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
		 * is (still) clear if use_leds is set.
		 */
		if (pdata->use_leds)
			twl_gpiochip.ngpio += 2;
	}

	ret = gpiochip_add(&twl_gpiochip);
	if (ret < 0) {
		dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
		twl_gpiochip.ngpio = 0;
		gpio_twl4030_remove(pdev);
	} else if (pdata && pdata->setup) {
		int status;

		status = pdata->setup(&pdev->dev,
				pdata->gpio_base, TWL4030_GPIO_MAX);
		if (status)
			dev_dbg(&pdev->dev, "setup --> %d\n", status);
	}

	return ret;
}

/* Cannot use __devexit as gpio_twl4030_probe() calls us */
static int gpio_twl4030_remove(struct platform_device *pdev)
{
	struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
	int status;

	if (pdata && pdata->teardown) {
		status = pdata->teardown(&pdev->dev,
				pdata->gpio_base, TWL4030_GPIO_MAX);
		if (status) {
			dev_dbg(&pdev->dev, "teardown --> %d\n", status);
			return status;
		}
	}

	status = gpiochip_remove(&twl_gpiochip);
	if (status < 0)
		return status;

	if (is_module())
		return 0;

	/* REVISIT no support yet for deregistering all the IRQs */
	WARN_ON(1);
	return -EIO;
}

static const struct of_device_id twl_gpio_match[] = {
	{ .compatible = "ti,twl4030-gpio", },
	{ },
};
MODULE_DEVICE_TABLE(of, twl_gpio_match);

/* Note:  this hardware lives inside an I2C-based multi-function device. */
MODULE_ALIAS("platform:twl4030_gpio");

static struct platform_driver gpio_twl4030_driver = {
	.driver = {
		.name	= "twl4030_gpio",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(twl_gpio_match),
	},
	.probe		= gpio_twl4030_probe,
	.remove		= gpio_twl4030_remove,
};

static int __init gpio_twl4030_init(void)
{
	return platform_driver_register(&gpio_twl4030_driver);
}
subsys_initcall(gpio_twl4030_init);

static void __exit gpio_twl4030_exit(void)
{
	platform_driver_unregister(&gpio_twl4030_driver);
}
module_exit(gpio_twl4030_exit);

MODULE_AUTHOR("Texas Instruments, Inc.");
MODULE_DESCRIPTION("GPIO interface for TWL4030");
MODULE_LICENSE("GPL");
Commit	Line	Data
e9d35947	1	/*
c103de24	2	* Access to GPIOs on TWL4030/TPS659x0 chips
e9d35947 DB	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>
b8589e2a BC	35	#include <linux/of.h>
b8589e2a BC	36	#include <linux/irqdomain.h>
e9d35947	37
b07682b6	38	#include <linux/i2c/twl.h>
e9d35947 DB	39
	40
	41	/*
	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.
	45	*
	46	* GPIO interrupts can be fed to either of two IRQ lines; this is
	47	* intended to support multiple hosts.
	48	*
	49	* There are also two LED pins used sometimes as output-only GPIOs.
	50	*/
	51
	52
	53	static struct gpio_chip twl_gpiochip;
	54	static int twl4030_gpio_irq_base;
	55
	56	/* genirq interfaces are not available to modules */
	57	#ifdef MODULE
	58	#define is_module() true
	59	#else
	60	#define is_module() false
	61	#endif
	62
	63	/* GPIO_CTRL Fields */
	64	#define MASK_GPIO_CTRL_GPIO0CD1 BIT(0)
	65	#define MASK_GPIO_CTRL_GPIO1CD2 BIT(1)
	66	#define MASK_GPIO_CTRL_GPIO_ON BIT(2)
	67
	68	/* Mask for GPIO registers when aggregated into a 32-bit integer */
	69	#define GPIO_32_MASK 0x0003ffff
	70
	71	/* Data structures */
	72	static DEFINE_MUTEX(gpio_lock);
	73
	74	/* store usage of each GPIO. - each bit represents one GPIO */
	75	static unsigned int gpio_usage_count;
	76
	77	/----------------------------------------------------------------------/
	78
	79	/*
	80	* To configure TWL4030 GPIO module registers
	81	*/
	82	static inline int gpio_twl4030_write(u8 address, u8 data)
	83	{
fc7b92fc	84	return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address);
e9d35947 DB	85	}
	86
	87	/----------------------------------------------------------------------/
	88
	89	/*
	90	* LED register offsets (use TWL4030_MODULE_{LED,PWMA,PWMB}))
	91	* PWMs A and B are dedicated to LEDs A and B, respectively.
	92	*/
	93
	94	#define TWL4030_LED_LEDEN 0x0
	95
	96	/* LEDEN bits */
	97	#define LEDEN_LEDAON BIT(0)
	98	#define LEDEN_LEDBON BIT(1)
	99	#define LEDEN_LEDAEXT BIT(2)
	100	#define LEDEN_LEDBEXT BIT(3)
	101	#define LEDEN_LEDAPWM BIT(4)
	102	#define LEDEN_LEDBPWM BIT(5)
	103	#define LEDEN_PWM_LENGTHA BIT(6)
	104	#define LEDEN_PWM_LENGTHB BIT(7)
	105
	106	#define TWL4030_PWMx_PWMxON 0x0
	107	#define TWL4030_PWMx_PWMxOFF 0x1
	108
	109	#define PWMxON_LENGTH BIT(7)
	110
	111	/----------------------------------------------------------------------/
	112
	113	/*
	114	* To read a TWL4030 GPIO module register
	115	*/
	116	static inline int gpio_twl4030_read(u8 address)
	117	{
	118	u8 data;
	119	int ret = 0;
	120
fc7b92fc	121	ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address);
e9d35947 DB	122	return (ret < 0) ? ret : data;
	123	}
	124
	125	/----------------------------------------------------------------------/
	126
	127	static u8 cached_leden; /* protected by gpio_lock */
	128
	129	/* The LED lines are open drain outputs ... a FET pulls to GND, so an
	130	* external pullup is needed. We could also expose the integrated PWM
	131	* as a LED brightness control; we initialize it as "always on".
	132	*/
	133	static void twl4030_led_set_value(int led, int value)
	134	{
	135	u8 mask = LEDEN_LEDAON \| LEDEN_LEDAPWM;
	136	int status;
	137
	138	if (led)
	139	mask <<= 1;
	140
	141	mutex_lock(&gpio_lock);
	142	if (value)
	143	cached_leden &= ~mask;
	144	else
	145	cached_leden \|= mask;
fc7b92fc	146	status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
e9d35947 DB	147	TWL4030_LED_LEDEN);
	148	mutex_unlock(&gpio_lock);
	149	}
	150
	151	static int twl4030_set_gpio_direction(int gpio, int is_input)
	152	{
	153	u8 d_bnk = gpio >> 3;
	154	u8 d_msk = BIT(gpio & 0x7);
	155	u8 reg = 0;
	156	u8 base = REG_GPIODATADIR1 + d_bnk;
	157	int ret = 0;
	158
	159	mutex_lock(&gpio_lock);
	160	ret = gpio_twl4030_read(base);
	161	if (ret >= 0) {
	162	if (is_input)
	163	reg = ret & ~d_msk;
	164	else
	165	reg = ret \| d_msk;
	166
	167	ret = gpio_twl4030_write(base, reg);
	168	}
	169	mutex_unlock(&gpio_lock);
	170	return ret;
	171	}
	172
	173	static int twl4030_set_gpio_dataout(int gpio, int enable)
	174	{
	175	u8 d_bnk = gpio >> 3;
	176	u8 d_msk = BIT(gpio & 0x7);
	177	u8 base = 0;
	178
	179	if (enable)
	180	base = REG_SETGPIODATAOUT1 + d_bnk;
	181	else
	182	base = REG_CLEARGPIODATAOUT1 + d_bnk;
	183
	184	return gpio_twl4030_write(base, d_msk);
	185	}
	186
	187	static int twl4030_get_gpio_datain(int gpio)
	188	{
	189	u8 d_bnk = gpio >> 3;
	190	u8 d_off = gpio & 0x7;
	191	u8 base = 0;
	192	int ret = 0;
	193
	194	if (unlikely((gpio >= TWL4030_GPIO_MAX)
	195	\|\| !(gpio_usage_count & BIT(gpio))))
	196	return -EPERM;
	197
	198	base = REG_GPIODATAIN1 + d_bnk;
	199	ret = gpio_twl4030_read(base);
	200	if (ret > 0)
	201	ret = (ret >> d_off) & 0x1;
	202
	203	return ret;
	204	}
	205
e9d35947 DB	206	/----------------------------------------------------------------------/
	207
	208	static int twl_request(struct gpio_chip *chip, unsigned offset)
	209	{
	210	int status = 0;
	211
	212	mutex_lock(&gpio_lock);
	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 module = TWL4030_MODULE_PWMA;
	219
	220	offset -= TWL4030_GPIO_MAX;
	221	if (offset) {
	222	ledclr_mask <<= 1;
	223	module = TWL4030_MODULE_PWMB;
	224	}
	225
	226	/* initialize PWM to always-drive */
fc7b92fc	227	status = twl_i2c_write_u8(module, 0x7f,
e9d35947 DB	228	TWL4030_PWMx_PWMxOFF);
	229	if (status < 0)
	230	goto done;
fc7b92fc	231	status = twl_i2c_write_u8(module, 0x7f,
e9d35947 DB	232	TWL4030_PWMx_PWMxON);
	233	if (status < 0)
	234	goto done;
	235
	236	/* init LED to not-driven (high) */
	237	module = TWL4030_MODULE_LED;
fc7b92fc	238	status = twl_i2c_read_u8(module, &cached_leden,
e9d35947 DB	239	TWL4030_LED_LEDEN);
	240	if (status < 0)
	241	goto done;
	242	cached_leden &= ~ledclr_mask;
fc7b92fc	243	status = twl_i2c_write_u8(module, cached_leden,
e9d35947 DB	244	TWL4030_LED_LEDEN);
	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 (!gpio_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 = chip->dev->platform_data;
b8589e2a BC	261	if (pdata)
b8589e2a BC	262	value \|= pdata->mmc_cd & 0x03;
e9d35947 DB	263
	264	status = gpio_twl4030_write(REG_GPIO_CTRL, value);
	265	}
	266
	267	if (!status)
	268	gpio_usage_count \|= (0x1 << offset);
	269
	270	done:
	271	mutex_unlock(&gpio_lock);
	272	return status;
	273	}
	274
	275	static void twl_free(struct gpio_chip *chip, unsigned offset)
	276	{
	277	if (offset >= TWL4030_GPIO_MAX) {
	278	twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1);
	279	return;
	280	}
	281
	282	mutex_lock(&gpio_lock);
	283
	284	gpio_usage_count &= ~BIT(offset);
	285
	286	/* on last use, switch off GPIO module */
	287	if (!gpio_usage_count)
	288	gpio_twl4030_write(REG_GPIO_CTRL, 0x0);
	289
	290	mutex_unlock(&gpio_lock);
	291	}
	292
	293	static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
	294	{
	295	return (offset < TWL4030_GPIO_MAX)
	296	? twl4030_set_gpio_direction(offset, 1)
	297	: -EINVAL;
	298	}
	299
	300	static int twl_get(struct gpio_chip *chip, unsigned offset)
	301	{
	302	int status = 0;
	303
	304	if (offset < TWL4030_GPIO_MAX)
	305	status = twl4030_get_gpio_datain(offset);
	306	else if (offset == TWL4030_GPIO_MAX)
	307	status = cached_leden & LEDEN_LEDAON;
	308	else
	309	status = cached_leden & LEDEN_LEDBON;
	310	return (status < 0) ? 0 : status;
	311	}
	312
	313	static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
	314	{
	315	if (offset < TWL4030_GPIO_MAX) {
	316	twl4030_set_gpio_dataout(offset, value);
	317	return twl4030_set_gpio_direction(offset, 0);
	318	} else {
	319	twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
	320	return 0;
	321	}
	322	}
	323
	324	static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
	325	{
	326	if (offset < TWL4030_GPIO_MAX)
327	twl4030_set_gpio_dataout(offset, value);
328	else
329	twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
330	}
331
332	static int twl_to_irq(struct gpio_chip *chip, unsigned offset)
333	{
334	return (twl4030_gpio_irq_base && (offset < TWL4030_GPIO_MAX))
335	? (twl4030_gpio_irq_base + offset)
336	: -EINVAL;
337	}
338
339	static struct gpio_chip twl_gpiochip = {
340	.label = "twl4030",
341	.owner = THIS_MODULE,
342	.request = twl_request,
343	.free = twl_free,
344	.direction_input = twl_direction_in,
345	.get = twl_get,
346	.direction_output = twl_direction_out,
347	.set = twl_set,
348	.to_irq = twl_to_irq,
349	.can_sleep = 1,
350	};
351
352	/----------------------------------------------------------------------/
353
354	static int __devinit gpio_twl4030_pulls(u32 ups, u32 downs)
355	{
356	u8 message[6];
357	unsigned i, gpio_bit;
358
359	/* For most pins, a pulldown was enabled by default.
360	* We should have data that's specific to this board.
361	*/
362	for (gpio_bit = 1, i = 1; i < 6; i++) {
363	u8 bit_mask;
364	unsigned j;
365
366	for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) {
367	if (ups & gpio_bit)
368	bit_mask \|= 1 << (j + 1);
369	else if (downs & gpio_bit)
370	bit_mask \|= 1 << (j + 0);
371	}
372	message[i] = bit_mask;
373	}
374
fc7b92fc	375	return twl_i2c_write(TWL4030_MODULE_GPIO, message,
e9d35947 DB	376	REG_GPIOPUPDCTR1, 5);
	377	}
	378
cabb3fc4 DB	379	static int __devinit gpio_twl4030_debounce(u32 debounce, u8 mmc_cd)
	380	{
	381	u8 message[4];
	382
	383	/* 30 msec of debouncing is always used for MMC card detect,
	384	* and is optional for everything else.
	385	*/
	386	message[1] = (debounce & 0xff) \| (mmc_cd & 0x03);
	387	debounce >>= 8;
	388	message[2] = (debounce & 0xff);
	389	debounce >>= 8;
	390	message[3] = (debounce & 0x03);
	391
fc7b92fc	392	return twl_i2c_write(TWL4030_MODULE_GPIO, message,
cabb3fc4 DB	393	REG_GPIO_DEBEN1, 3);
	394	}
	395
e9d35947 DB	396	static int gpio_twl4030_remove(struct platform_device *pdev);
	397
	398	static int __devinit gpio_twl4030_probe(struct platform_device *pdev)
	399	{
	400	struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
b8589e2a	401	struct device_node *node = pdev->dev.of_node;
2d9dd99b	402	int ret, irq_base;
e9d35947 DB	403
e9d35947 DB	404	/* maybe setup IRQs */
2d9dd99b BC	405	if (is_module()) {
	406	dev_err(&pdev->dev, "can't dispatch IRQs from modules\n");
	407	goto no_irqs;
	408	}
	409
	410	irq_base = irq_alloc_descs(-1, 0, TWL4030_GPIO_MAX, 0);
	411	if (irq_base < 0) {
	412	dev_err(&pdev->dev, "Failed to alloc irq_descs\n");
	413	return irq_base;
e9d35947 DB	414	}
e9d35947 DB	415
b8589e2a BC	416	irq_domain_add_legacy(node, TWL4030_GPIO_MAX, irq_base, 0,
	417	&irq_domain_simple_ops, NULL);
	418
2d9dd99b BC	419	ret = twl4030_sih_setup(&pdev->dev, TWL4030_MODULE_GPIO, irq_base);
	420	if (ret < 0)
	421	return ret;
	422
	423	twl4030_gpio_irq_base = irq_base;
	424
e9d35947	425	no_irqs:
b8589e2a	426	twl_gpiochip.base = -1;
e9d35947 DB	427	twl_gpiochip.ngpio = TWL4030_GPIO_MAX;
	428	twl_gpiochip.dev = &pdev->dev;
	429
b8589e2a BC	430	if (pdata) {
	431	twl_gpiochip.base = pdata->gpio_base;
	432
	433	/*
	434	* NOTE: boards may waste power if they don't set pullups
	435	* and pulldowns correctly ... default for non-ULPI pins is
	436	* pulldown, and some other pins may have external pullups
	437	* or pulldowns. Careful!
	438	*/
	439	ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns);
	440	if (ret)
	441	dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n",
	442	pdata->pullups, pdata->pulldowns,
	443	ret);
	444
	445	ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd);
	446	if (ret)
	447	dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n",
	448	pdata->debounce, pdata->mmc_cd,
	449	ret);
	450
	451	/*
	452	* NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
	453	* is (still) clear if use_leds is set.
	454	*/
	455	if (pdata->use_leds)
	456	twl_gpiochip.ngpio += 2;
	457	}
e9d35947 DB	458
	459	ret = gpiochip_add(&twl_gpiochip);
	460	if (ret < 0) {
2d9dd99b	461	dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
e9d35947 DB	462	twl_gpiochip.ngpio = 0;
e9d35947 DB	463	gpio_twl4030_remove(pdev);
b8589e2a	464	} else if (pdata && pdata->setup) {
e9d35947 DB	465	int status;
	466
	467	status = pdata->setup(&pdev->dev,
	468	pdata->gpio_base, TWL4030_GPIO_MAX);
	469	if (status)
	470	dev_dbg(&pdev->dev, "setup --> %d\n", status);
	471	}
	472
	473	return ret;
	474	}
	475
46c529cf MF	476	/* Cannot use __devexit as gpio_twl4030_probe() calls us */
46c529cf MF	477	static int gpio_twl4030_remove(struct platform_device *pdev)
e9d35947 DB	478	{
	479	struct twl4030_gpio_platform_data *pdata = pdev->dev.platform_data;
	480	int status;
	481
b8589e2a	482	if (pdata && pdata->teardown) {
e9d35947 DB	483	status = pdata->teardown(&pdev->dev,
	484	pdata->gpio_base, TWL4030_GPIO_MAX);
	485	if (status) {
	486	dev_dbg(&pdev->dev, "teardown --> %d\n", status);
	487	return status;
	488	}
	489	}
	490
	491	status = gpiochip_remove(&twl_gpiochip);
	492	if (status < 0)
	493	return status;
	494
	495	if (is_module())
	496	return 0;
	497
	498	/* REVISIT no support yet for deregistering all the IRQs */
	499	WARN_ON(1);
	500	return -EIO;
	501	}
	502
b8589e2a BC	503	static const struct of_device_id twl_gpio_match[] = {
	504	{ .compatible = "ti,twl4030-gpio", },
	505	{ },
	506	};
	507	MODULE_DEVICE_TABLE(of, twl_gpio_match);
	508
e9d35947 DB	509	/* Note: this hardware lives inside an I2C-based multi-function device. */
	510	MODULE_ALIAS("platform:twl4030_gpio");
	511
	512	static struct platform_driver gpio_twl4030_driver = {
b8589e2a BC	513	.driver = {
	514	.name = "twl4030_gpio",
	515	.owner = THIS_MODULE,
	516	.of_match_table = of_match_ptr(twl_gpio_match),
	517	},
e9d35947	518	.probe = gpio_twl4030_probe,
46c529cf	519	.remove = gpio_twl4030_remove,
e9d35947 DB	520	};
	521
	522	static int __init gpio_twl4030_init(void)
	523	{
	524	return platform_driver_register(&gpio_twl4030_driver);
	525	}
	526	subsys_initcall(gpio_twl4030_init);
	527
	528	static void __exit gpio_twl4030_exit(void)
	529	{
	530	platform_driver_unregister(&gpio_twl4030_driver);
	531	}
	532	module_exit(gpio_twl4030_exit);
	533
	534	MODULE_AUTHOR("Texas Instruments, Inc.");
	535	MODULE_DESCRIPTION("GPIO interface for TWL4030");
	536	MODULE_LICENSE("GPL");