/arch/arm/mach-fsm/board-trout-gpio.c

  1/* arch/arm/mach-msm/board-trout-gpio.c
  2 *
  3 * Copyright (C) 2008 Google, Inc.
  4 *
  5 * This software is licensed under the terms of the GNU General Public
  6 * License version 2, as published by the Free Software Foundation, and
  7 * may be copied, distributed, and modified under those terms.
  8 *
  9 * This program is distributed in the hope that it will be useful,
 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 * GNU General Public License for more details.
 13 *
 14 */
 15
 16#include <linux/kernel.h>
 17#include <linux/errno.h>
 18#include <linux/irq.h>
 19#include <linux/pm.h>
 20#include <linux/sysdev.h>
 21
 22#include <asm/io.h>
 23#include <asm/gpio.h>
 24#include <asm/mach-types.h>
 25
 26#include <mach/htc_pwrsink.h>
 27
 28#include "board-trout.h"
 29#include "gpio_chip.h"
 30
 31#undef MODULE_PARAM_PREFIX
 32#define MODULE_PARAM_PREFIX "board_trout."
 33
 34static uint cpld_usb_h2w_sw;
 35module_param_named(usb_h2w_sw, cpld_usb_h2w_sw, uint, 0);
 36
 37static uint8_t trout_cpld_shadow[4] = {
 38#if defined(CONFIG_MSM_DEBUG_UART1)
 39	/* H2W pins <-> UART1 */
 40        [0] = 0x40, // for serial debug, low current
 41#else
 42	/* H2W pins <-> UART3, Bluetooth <-> UART1 */
 43        [0] = 0x80, // for serial debug, low current
 44#endif
 45        [1] = 0x04, // I2C_PULL
 46        [3] = 0x04, // mmdi 32k en
 47};
 48static uint8_t trout_int_mask[2] = {
 49        [0] = 0xff, /* mask all interrupts */
 50        [1] = 0xff,
 51};
 52static uint8_t trout_sleep_int_mask[] = {
 53        [0] = 0xff,
 54        [1] = 0xff,
 55};
 56static int trout_suspended;
 57
 58static int trout_gpio_read(struct gpio_chip *chip, unsigned n)
 59{
 60	uint8_t b;
 61	int reg;
 62	if (n >= TROUT_GPIO_VIRTUAL_BASE)
 63		n += TROUT_GPIO_VIRTUAL_TO_REAL_OFFSET;
 64	b = 1U << (n & 7);
 65	reg = (n & 0x78) >> 2; // assumes base is 128
 66	return !!(readb(TROUT_CPLD_BASE + reg) & b);
 67}
 68
 69static void update_pwrsink(unsigned gpio, unsigned on)
 70{
 71	switch(gpio) {
 72	case TROUT_GPIO_UI_LED_EN:
 73		htc_pwrsink_set(PWRSINK_LED_BUTTON, on ? 100 : 0);
 74		break;
 75	case TROUT_GPIO_QTKEY_LED_EN:
 76		htc_pwrsink_set(PWRSINK_LED_KEYBOARD, on ? 100 : 0);
 77		break;
 78	}
 79}
 80
 81static uint8_t trout_gpio_write_shadow(unsigned n, unsigned on)
 82{
 83	uint8_t b = 1U << (n & 7);
 84	int reg = (n & 0x78) >> 2; // assumes base is 128
 85
 86	if(on)
 87		return trout_cpld_shadow[reg >> 1] |= b;
 88	else
 89		return trout_cpld_shadow[reg >> 1] &= ~b;
 90}
 91
 92static int trout_gpio_write(struct gpio_chip *chip, unsigned n, unsigned on)
 93{
 94	int reg = (n & 0x78) >> 2; // assumes base is 128
 95	unsigned long flags;
 96	uint8_t reg_val;
 97
 98	if ((reg >> 1) >= ARRAY_SIZE(trout_cpld_shadow)) {
 99		printk(KERN_ERR "trout_gpio_write called on input %d\n", n);
100		return -ENOTSUPP;
101	}
102
103	local_irq_save(flags);
104	update_pwrsink(n, on);
105	reg_val = trout_gpio_write_shadow(n, on);
106	writeb(reg_val, TROUT_CPLD_BASE + reg);
107	local_irq_restore(flags);
108	return 0;
109}
110
111static int trout_gpio_configure(struct gpio_chip *chip, unsigned int gpio, unsigned long flags)
112{
113	if(flags & (GPIOF_OUTPUT_LOW | GPIOF_OUTPUT_HIGH))
114		trout_gpio_write(chip, gpio, flags & GPIOF_OUTPUT_HIGH);
115	return 0;
116}
117
118static int trout_gpio_get_irq_num(struct gpio_chip *chip, unsigned int gpio, unsigned int *irqp, unsigned long *irqnumflagsp)
119{
120	if ((gpio < TROUT_GPIO_BANK0_FIRST_INT_SOURCE ||
121	     gpio > TROUT_GPIO_BANK0_LAST_INT_SOURCE) &&
122	    (gpio < TROUT_GPIO_BANK1_FIRST_INT_SOURCE ||
123	     gpio > TROUT_GPIO_BANK1_LAST_INT_SOURCE))
124		return -ENOENT;
125	*irqp = TROUT_GPIO_TO_INT(gpio);
126	if(irqnumflagsp)
127		*irqnumflagsp = 0;
128	return 0;
129}
130
131static void trout_gpio_irq_ack(unsigned int irq)
132{
133	int bank = TROUT_INT_TO_BANK(irq);
134	uint8_t mask = TROUT_INT_TO_MASK(irq);
135	int reg = TROUT_BANK_TO_STAT_REG(bank);
136	/*printk(KERN_INFO "trout_gpio_irq_ack irq %d\n", irq);*/
137	writeb(mask, TROUT_CPLD_BASE + reg);
138}
139
140static void trout_gpio_irq_mask(unsigned int irq)
141{
142	unsigned long flags;
143	uint8_t reg_val;
144	int bank = TROUT_INT_TO_BANK(irq);
145	uint8_t mask = TROUT_INT_TO_MASK(irq);
146	int reg = TROUT_BANK_TO_MASK_REG(bank);
147
148	local_irq_save(flags);
149	reg_val = trout_int_mask[bank] |= mask;
150	/*printk(KERN_INFO "trout_gpio_irq_mask irq %d => %d:%02x\n",
151	       irq, bank, reg_val);*/
152	if (!trout_suspended)
153		writeb(reg_val, TROUT_CPLD_BASE + reg);
154	local_irq_restore(flags);
155}
156
157static void trout_gpio_irq_unmask(unsigned int irq)
158{
159	unsigned long flags;
160	uint8_t reg_val;
161	int bank = TROUT_INT_TO_BANK(irq);
162	uint8_t mask = TROUT_INT_TO_MASK(irq);
163	int reg = TROUT_BANK_TO_MASK_REG(bank);
164
165	local_irq_save(flags);
166	reg_val = trout_int_mask[bank] &= ~mask;
167	/*printk(KERN_INFO "trout_gpio_irq_unmask irq %d => %d:%02x\n",
168	       irq, bank, reg_val);*/
169	if (!trout_suspended)
170		writeb(reg_val, TROUT_CPLD_BASE + reg);
171	local_irq_restore(flags);
172}
173
174int trout_gpio_irq_set_wake(unsigned int irq, unsigned int on)
175{
176	unsigned long flags;
177	int bank = TROUT_INT_TO_BANK(irq);
178	uint8_t mask = TROUT_INT_TO_MASK(irq);
179
180	local_irq_save(flags);
181	if(on)
182		trout_sleep_int_mask[bank] &= ~mask;
183	else
184		trout_sleep_int_mask[bank] |= mask;
185	local_irq_restore(flags);
186	return 0;
187}
188
189static void trout_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
190{
191	int j, m;
192	unsigned v;
193	int bank;
194	int stat_reg;
195	int int_base = TROUT_INT_START;
196	uint8_t int_mask;
197
198	for (bank = 0; bank < 2; bank++) {
199		stat_reg = TROUT_BANK_TO_STAT_REG(bank);
200		v = readb(TROUT_CPLD_BASE + stat_reg);
201		int_mask = trout_int_mask[bank];
202		if (v & int_mask) {
203			writeb(v & int_mask, TROUT_CPLD_BASE + stat_reg);
204			printk(KERN_ERR "trout_gpio_irq_handler: got masked "
205			       "interrupt: %d:%02x\n", bank, v & int_mask);
206		}
207		v &= ~int_mask;
208		while (v) {
209			m = v & -v;
210			j = fls(m) - 1;
211			/*printk(KERN_INFO "msm_gpio_irq_handler %d:%02x %02x b"
212			       "it %d irq %d\n", bank, v, m, j, int_base + j);*/
213			v &= ~m;
214			generic_handle_irq(int_base + j);
215		}
216		int_base += TROUT_INT_BANK0_COUNT;
217	}
218	desc->chip->ack(irq);
219}
220
221static int trout_sysdev_suspend(struct sys_device *dev, pm_message_t state)
222{
223	trout_suspended = 1;
224	writeb(trout_sleep_int_mask[0],
225	       TROUT_CPLD_BASE + TROUT_GPIO_INT_MASK0_REG);
226	writeb(trout_sleep_int_mask[1],
227	       TROUT_CPLD_BASE + TROUT_GPIO_INT_MASK1_REG);
228	writeb(trout_sleep_int_mask[0],
229	       TROUT_CPLD_BASE + TROUT_GPIO_INT_STAT0_REG);
230	writeb(trout_sleep_int_mask[1],
231	       TROUT_CPLD_BASE + TROUT_GPIO_INT_STAT1_REG);
232	return 0;
233}
234
235int trout_sysdev_resume(struct sys_device *dev)
236{
237	writeb(trout_int_mask[0], TROUT_CPLD_BASE + TROUT_GPIO_INT_MASK0_REG);
238	writeb(trout_int_mask[1], TROUT_CPLD_BASE + TROUT_GPIO_INT_MASK1_REG);
239	trout_suspended = 0;
240	return 0;
241}
242
243static struct irq_chip trout_gpio_irq_chip = {
244	.name      = "troutgpio",
245	.ack       = trout_gpio_irq_ack,
246	.mask      = trout_gpio_irq_mask,
247	.unmask    = trout_gpio_irq_unmask,
248	.set_wake  = trout_gpio_irq_set_wake,
249	//.set_type  = trout_gpio_irq_set_type,
250};
251
252static struct gpio_chip trout_gpio_chip = {
253	.start = TROUT_GPIO_START,
254	.end = TROUT_GPIO_END,
255	.configure = trout_gpio_configure,
256	.get_irq_num = trout_gpio_get_irq_num,
257	.read = trout_gpio_read,
258	.write = trout_gpio_write,
259//	.read_detect_status = trout_gpio_read_detect_status,
260//	.clear_detect_status = trout_gpio_clear_detect_status
261};
262
263struct sysdev_class trout_sysdev_class = {
264	.name = "troutgpio_irq",
265	.suspend = trout_sysdev_suspend,
266	.resume = trout_sysdev_resume,
267};
268
269static struct sys_device trout_irq_device = {
270	.cls    = &trout_sysdev_class,
271};
272
273static int __init trout_init_gpio(void)
274{
275	int i;
276
277	if (!machine_is_trout())
278		return 0;
279
280	/* adjust GPIOs based on bootloader request */
281	pr_info("trout_init_gpio: cpld_usb_hw2_sw = %d\n", cpld_usb_h2w_sw);
282	trout_gpio_write_shadow(TROUT_GPIO_USB_H2W_SW, cpld_usb_h2w_sw);
283
284	for(i = 0; i < ARRAY_SIZE(trout_cpld_shadow); i++)
285		writeb(trout_cpld_shadow[i], TROUT_CPLD_BASE + i * 2);
286
287	for(i = TROUT_INT_START; i <= TROUT_INT_END; i++) {
288		set_irq_chip(i, &trout_gpio_irq_chip);
289		set_irq_handler(i, handle_edge_irq);
290		set_irq_flags(i, IRQF_VALID);
291	}
292
293	register_gpio_chip(&trout_gpio_chip);
294
295	set_irq_type(MSM_GPIO_TO_INT(17), IRQF_TRIGGER_HIGH);
296	set_irq_chained_handler(MSM_GPIO_TO_INT(17), trout_gpio_irq_handler);
297	set_irq_wake(MSM_GPIO_TO_INT(17), 1);
298
299	if(sysdev_class_register(&trout_sysdev_class) == 0)
300		sysdev_register(&trout_irq_device);
301
302	return 0;
303}
304
305postcore_initcall(trout_init_gpio);