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

/*
 * wm8350-core.c  --  Device access for Wolfson WM8350
 *
 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
 *
 * Author: Liam Girdwood
 *
 *  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.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>

#include <linux/mfd/wm8350/core.h>
#include <linux/mfd/wm8350/gpio.h>
#include <linux/mfd/wm8350/pmic.h>

static int gpio_set_dir(struct wm8350 *wm8350, int gpio, int dir)
{
	int ret;

	wm8350_reg_unlock(wm8350);
	if (dir == WM8350_GPIO_DIR_OUT)
		ret = wm8350_clear_bits(wm8350,
					WM8350_GPIO_CONFIGURATION_I_O,
					1 << gpio);
	else
		ret = wm8350_set_bits(wm8350,
				      WM8350_GPIO_CONFIGURATION_I_O,
				      1 << gpio);
	wm8350_reg_lock(wm8350);
	return ret;
}

static int wm8350_gpio_set_debounce(struct wm8350 *wm8350, int gpio, int db)
{
	if (db == WM8350_GPIO_DEBOUNCE_ON)
		return wm8350_set_bits(wm8350, WM8350_GPIO_DEBOUNCE,
				       1 << gpio);
	else
		return wm8350_clear_bits(wm8350,
					 WM8350_GPIO_DEBOUNCE, 1 << gpio);
}

static int gpio_set_func(struct wm8350 *wm8350, int gpio, int func)
{
	u16 reg;

	wm8350_reg_unlock(wm8350);
	switch (gpio) {
	case 0:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
		    & ~WM8350_GP0_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
				 reg | ((func & 0xf) << 0));
		break;
	case 1:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
		    & ~WM8350_GP1_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
				 reg | ((func & 0xf) << 4));
		break;
	case 2:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
		    & ~WM8350_GP2_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
				 reg | ((func & 0xf) << 8));
		break;
	case 3:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
		    & ~WM8350_GP3_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
				 reg | ((func & 0xf) << 12));
		break;
	case 4:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
		    & ~WM8350_GP4_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
				 reg | ((func & 0xf) << 0));
		break;
	case 5:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
		    & ~WM8350_GP5_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
				 reg | ((func & 0xf) << 4));
		break;
	case 6:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
		    & ~WM8350_GP6_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
				 reg | ((func & 0xf) << 8));
		break;
	case 7:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
		    & ~WM8350_GP7_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
				 reg | ((func & 0xf) << 12));
		break;
	case 8:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
		    & ~WM8350_GP8_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
				 reg | ((func & 0xf) << 0));
		break;
	case 9:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
		    & ~WM8350_GP9_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
				 reg | ((func & 0xf) << 4));
		break;
	case 10:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
		    & ~WM8350_GP10_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
				 reg | ((func & 0xf) << 8));
		break;
	case 11:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
		    & ~WM8350_GP11_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
				 reg | ((func & 0xf) << 12));
		break;
	case 12:
		reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_4)
		    & ~WM8350_GP12_FN_MASK;
		wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_4,
				 reg | ((func & 0xf) << 0));
		break;
	default:
		wm8350_reg_lock(wm8350);
		return -EINVAL;
	}

	wm8350_reg_lock(wm8350);
	return 0;
}

static int gpio_set_pull_up(struct wm8350 *wm8350, int gpio, int up)
{
	if (up)
		return wm8350_set_bits(wm8350,
				       WM8350_GPIO_PIN_PULL_UP_CONTROL,
				       1 << gpio);
	else
		return wm8350_clear_bits(wm8350,
					 WM8350_GPIO_PIN_PULL_UP_CONTROL,
					 1 << gpio);
}

static int gpio_set_pull_down(struct wm8350 *wm8350, int gpio, int down)
{
	if (down)
		return wm8350_set_bits(wm8350,
				       WM8350_GPIO_PULL_DOWN_CONTROL,
				       1 << gpio);
	else
		return wm8350_clear_bits(wm8350,
					 WM8350_GPIO_PULL_DOWN_CONTROL,
					 1 << gpio);
}

static int gpio_set_polarity(struct wm8350 *wm8350, int gpio, int pol)
{
	if (pol == WM8350_GPIO_ACTIVE_HIGH)
		return wm8350_set_bits(wm8350,
				       WM8350_GPIO_PIN_POLARITY_TYPE,
				       1 << gpio);
	else
		return wm8350_clear_bits(wm8350,
					 WM8350_GPIO_PIN_POLARITY_TYPE,
					 1 << gpio);
}

static int gpio_set_invert(struct wm8350 *wm8350, int gpio, int invert)
{
	if (invert == WM8350_GPIO_INVERT_ON)
		return wm8350_set_bits(wm8350, WM8350_GPIO_INT_MODE, 1 << gpio);
	else
		return wm8350_clear_bits(wm8350,
					 WM8350_GPIO_INT_MODE, 1 << gpio);
}

int wm8350_gpio_config(struct wm8350 *wm8350, int gpio, int dir, int func,
		       int pol, int pull, int invert, int debounce)
{
	/* make sure we never pull up and down at the same time */
	if (pull == WM8350_GPIO_PULL_NONE) {
		if (gpio_set_pull_up(wm8350, gpio, 0))
			goto err;
		if (gpio_set_pull_down(wm8350, gpio, 0))
			goto err;
	} else if (pull == WM8350_GPIO_PULL_UP) {
		if (gpio_set_pull_down(wm8350, gpio, 0))
			goto err;
		if (gpio_set_pull_up(wm8350, gpio, 1))
			goto err;
	} else if (pull == WM8350_GPIO_PULL_DOWN) {
		if (gpio_set_pull_up(wm8350, gpio, 0))
			goto err;
		if (gpio_set_pull_down(wm8350, gpio, 1))
			goto err;
	}

	if (gpio_set_invert(wm8350, gpio, invert))
		goto err;
	if (gpio_set_polarity(wm8350, gpio, pol))
		goto err;
	if (wm8350_gpio_set_debounce(wm8350, gpio, debounce))
		goto err;
	if (gpio_set_dir(wm8350, gpio, dir))
		goto err;
	return gpio_set_func(wm8350, gpio, func);

err:
	return -EIO;
}
EXPORT_SYMBOL_GPL(wm8350_gpio_config);
Commit	Line	Data
0e720393 MB	1	/*
	2	* wm8350-core.c -- Device access for Wolfson WM8350
	3	*
	4	* Copyright 2007, 2008 Wolfson Microelectronics PLC.
	5	*
	6	* Author: Liam Girdwood
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/errno.h>
	18
	19	#include <linux/mfd/wm8350/core.h>
	20	#include <linux/mfd/wm8350/gpio.h>
	21	#include <linux/mfd/wm8350/pmic.h>
	22
	23	static int gpio_set_dir(struct wm8350 *wm8350, int gpio, int dir)
	24	{
	25	int ret;
	26
	27	wm8350_reg_unlock(wm8350);
	28	if (dir == WM8350_GPIO_DIR_OUT)
	29	ret = wm8350_clear_bits(wm8350,
	30	WM8350_GPIO_CONFIGURATION_I_O,
	31	1 << gpio);
	32	else
	33	ret = wm8350_set_bits(wm8350,
	34	WM8350_GPIO_CONFIGURATION_I_O,
	35	1 << gpio);
	36	wm8350_reg_lock(wm8350);
	37	return ret;
	38	}
	39
aa9d842c	40	static int wm8350_gpio_set_debounce(struct wm8350 *wm8350, int gpio, int db)
0e720393 MB	41	{
	42	if (db == WM8350_GPIO_DEBOUNCE_ON)
	43	return wm8350_set_bits(wm8350, WM8350_GPIO_DEBOUNCE,
	44	1 << gpio);
	45	else
	46	return wm8350_clear_bits(wm8350,
	47	WM8350_GPIO_DEBOUNCE, 1 << gpio);
	48	}
	49
	50	static int gpio_set_func(struct wm8350 *wm8350, int gpio, int func)
	51	{
	52	u16 reg;
	53
	54	wm8350_reg_unlock(wm8350);
	55	switch (gpio) {
	56	case 0:
	57	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
	58	& ~WM8350_GP0_FN_MASK;
	59	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
	60	reg \| ((func & 0xf) << 0));
	61	break;
	62	case 1:
	63	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
	64	& ~WM8350_GP1_FN_MASK;
	65	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
	66	reg \| ((func & 0xf) << 4));
	67	break;
	68	case 2:
	69	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
	70	& ~WM8350_GP2_FN_MASK;
	71	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
	72	reg \| ((func & 0xf) << 8));
	73	break;
	74	case 3:
	75	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_1)
	76	& ~WM8350_GP3_FN_MASK;
	77	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_1,
	78	reg \| ((func & 0xf) << 12));
	79	break;
	80	case 4:
	81	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
	82	& ~WM8350_GP4_FN_MASK;
	83	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
	84	reg \| ((func & 0xf) << 0));
	85	break;
	86	case 5:
	87	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
	88	& ~WM8350_GP5_FN_MASK;
	89	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
	90	reg \| ((func & 0xf) << 4));
	91	break;
	92	case 6:
	93	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
	94	& ~WM8350_GP6_FN_MASK;
	95	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
	96	reg \| ((func & 0xf) << 8));
	97	break;
	98	case 7:
	99	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_2)
	100	& ~WM8350_GP7_FN_MASK;
	101	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_2,
	102	reg \| ((func & 0xf) << 12));
	103	break;
	104	case 8:
105	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
106	& ~WM8350_GP8_FN_MASK;
107	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
108	reg \| ((func & 0xf) << 0));
109	break;
110	case 9:
111	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
112	& ~WM8350_GP9_FN_MASK;
113	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
114	reg \| ((func & 0xf) << 4));
115	break;
116	case 10:
117	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
118	& ~WM8350_GP10_FN_MASK;
119	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
120	reg \| ((func & 0xf) << 8));
121	break;
122	case 11:
123	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_3)
124	& ~WM8350_GP11_FN_MASK;
125	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_3,
126	reg \| ((func & 0xf) << 12));
127	break;
128	case 12:
129	reg = wm8350_reg_read(wm8350, WM8350_GPIO_FUNCTION_SELECT_4)
130	& ~WM8350_GP12_FN_MASK;
131	wm8350_reg_write(wm8350, WM8350_GPIO_FUNCTION_SELECT_4,
132	reg \| ((func & 0xf) << 0));
133	break;
134	default:
135	wm8350_reg_lock(wm8350);
136	return -EINVAL;
137	}
138
139	wm8350_reg_lock(wm8350);
140	return 0;
141	}
142
143	static int gpio_set_pull_up(struct wm8350 *wm8350, int gpio, int up)
144	{
145	if (up)
146	return wm8350_set_bits(wm8350,
147	WM8350_GPIO_PIN_PULL_UP_CONTROL,
148	1 << gpio);
149	else
150	return wm8350_clear_bits(wm8350,
151	WM8350_GPIO_PIN_PULL_UP_CONTROL,
152	1 << gpio);
153	}
154
155	static int gpio_set_pull_down(struct wm8350 *wm8350, int gpio, int down)
156	{
157	if (down)
158	return wm8350_set_bits(wm8350,
159	WM8350_GPIO_PULL_DOWN_CONTROL,
160	1 << gpio);
161	else
162	return wm8350_clear_bits(wm8350,
163	WM8350_GPIO_PULL_DOWN_CONTROL,
164	1 << gpio);
165	}
166
167	static int gpio_set_polarity(struct wm8350 *wm8350, int gpio, int pol)
168	{
169	if (pol == WM8350_GPIO_ACTIVE_HIGH)
170	return wm8350_set_bits(wm8350,
171	WM8350_GPIO_PIN_POLARITY_TYPE,
172	1 << gpio);
173	else
174	return wm8350_clear_bits(wm8350,
175	WM8350_GPIO_PIN_POLARITY_TYPE,
176	1 << gpio);
177	}
178
179	static int gpio_set_invert(struct wm8350 *wm8350, int gpio, int invert)
180	{
181	if (invert == WM8350_GPIO_INVERT_ON)
182	return wm8350_set_bits(wm8350, WM8350_GPIO_INT_MODE, 1 << gpio);
183	else
184	return wm8350_clear_bits(wm8350,
185	WM8350_GPIO_INT_MODE, 1 << gpio);
186	}
187
188	int wm8350_gpio_config(struct wm8350 *wm8350, int gpio, int dir, int func,
189	int pol, int pull, int invert, int debounce)
190	{
191	/* make sure we never pull up and down at the same time */
192	if (pull == WM8350_GPIO_PULL_NONE) {
193	if (gpio_set_pull_up(wm8350, gpio, 0))
194	goto err;
195	if (gpio_set_pull_down(wm8350, gpio, 0))
196	goto err;
197	} else if (pull == WM8350_GPIO_PULL_UP) {
198	if (gpio_set_pull_down(wm8350, gpio, 0))
199	goto err;
200	if (gpio_set_pull_up(wm8350, gpio, 1))
201	goto err;
202	} else if (pull == WM8350_GPIO_PULL_DOWN) {
203	if (gpio_set_pull_up(wm8350, gpio, 0))
204	goto err;
205	if (gpio_set_pull_down(wm8350, gpio, 1))
206	goto err;
207	}
208
209	if (gpio_set_invert(wm8350, gpio, invert))
210	goto err;
211	if (gpio_set_polarity(wm8350, gpio, pol))
212	goto err;
aa9d842c	213	if (wm8350_gpio_set_debounce(wm8350, gpio, debounce))
0e720393 MB	214	goto err;
	215	if (gpio_set_dir(wm8350, gpio, dir))
	216	goto err;
	217	return gpio_set_func(wm8350, gpio, func);
	218
	219	err:
	220	return -EIO;
	221	}
	222	EXPORT_SYMBOL_GPL(wm8350_gpio_config);