1/*
  2 *  Amstrad E3 (Delta) keyboard port driver
  3 *
  4 *  Copyright (c) 2006 Matt Callow
  5 *  Copyright (c) 2010 Janusz Krzysztofik
  6 *
  7 * This program is free software; you can redistribute it and/or modify it
  8 * under the terms of the GNU General Public License version 2 as published by
  9 * the Free Software Foundation.
 10 *
 11 * Thanks to Cliff Lawson for his help
 12 *
 13 * The Amstrad Delta keyboard (aka mailboard) uses normal PC-AT style serial
 14 * transmission.  The keyboard port is formed of two GPIO lines, for clock
 15 * and data.  Due to strict timing requirements of the interface,
 16 * the serial data stream is read and processed by a FIQ handler.
 17 * The resulting words are fetched by this driver from a circular buffer.
 18 *
 19 * Standard AT keyboard driver (atkbd) is used for handling the keyboard data.
 20 * However, when used with the E3 mailboard that producecs non-standard
 21 * scancodes, a custom key table must be prepared and loaded from userspace.
 22 */
 23#include <linux/gpio.h>
 24#include <linux/irq.h>
 25#include <linux/serio.h>
 26#include <linux/slab.h>
 27#include <linux/module.h>
 28
 29#include <asm/mach-types.h>
 30#include <plat/board-ams-delta.h>
 31
 32#include <mach/ams-delta-fiq.h>
 33
 34MODULE_AUTHOR("Matt Callow");
 35MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver");
 36MODULE_LICENSE("GPL");
 37
 38static struct serio *ams_delta_serio;
 39
 40static int check_data(int data)
 41{
 42	int i, parity = 0;
 43
 44	/* check valid stop bit */
 45	if (!(data & 0x400)) {
 46		dev_warn(&ams_delta_serio->dev,
 47				"invalid stop bit, data=0x%X\n",
 48				data);
 49		return SERIO_FRAME;
 50	}
 51	/* calculate the parity */
 52	for (i = 1; i < 10; i++) {
 53		if (data & (1 << i))
 54			parity++;
 55	}
 56	/* it should be odd */
 57	if (!(parity & 0x01)) {
 58		dev_warn(&ams_delta_serio->dev,
 59				"paritiy check failed, data=0x%X parity=0x%X\n",
 60				data, parity);
 61		return SERIO_PARITY;
 62	}
 63	return 0;
 64}
 65
 66static irqreturn_t ams_delta_serio_interrupt(int irq, void *dev_id)
 67{
 68	int *circ_buff = &fiq_buffer[FIQ_CIRC_BUFF];
 69	int data, dfl;
 70	u8 scancode;
 71
 72	fiq_buffer[FIQ_IRQ_PEND] = 0;
 73
 74	/*
 75	 * Read data from the circular buffer, check it
 76	 * and then pass it on the serio
 77	 */
 78	while (fiq_buffer[FIQ_KEYS_CNT] > 0) {
 79
 80		data = circ_buff[fiq_buffer[FIQ_HEAD_OFFSET]++];
 81		fiq_buffer[FIQ_KEYS_CNT]--;
 82		if (fiq_buffer[FIQ_HEAD_OFFSET] == fiq_buffer[FIQ_BUF_LEN])
 83			fiq_buffer[FIQ_HEAD_OFFSET] = 0;
 84
 85		dfl = check_data(data);
 86		scancode = (u8) (data >> 1) & 0xFF;
 87		serio_interrupt(ams_delta_serio, scancode, dfl);
 88	}
 89	return IRQ_HANDLED;
 90}
 91
 92static int ams_delta_serio_open(struct serio *serio)
 93{
 94	/* enable keyboard */
 95	gpio_set_value(AMS_DELTA_GPIO_PIN_KEYBRD_PWR, 1);
 96
 97	return 0;
 98}
 99
100static void ams_delta_serio_close(struct serio *serio)
101{
102	/* disable keyboard */
103	gpio_set_value(AMS_DELTA_GPIO_PIN_KEYBRD_PWR, 0);
104}
105
106static const struct gpio ams_delta_gpios[] __initconst_or_module = {
107	{
108		.gpio	= AMS_DELTA_GPIO_PIN_KEYBRD_DATA,
109		.flags	= GPIOF_DIR_IN,
110		.label	= "serio-data",
111	},
112	{
113		.gpio	= AMS_DELTA_GPIO_PIN_KEYBRD_CLK,
114		.flags	= GPIOF_DIR_IN,
115		.label	= "serio-clock",
116	},
117	{
118		.gpio	= AMS_DELTA_GPIO_PIN_KEYBRD_PWR,
119		.flags	= GPIOF_OUT_INIT_LOW,
120		.label	= "serio-power",
121	},
122	{
123		.gpio	= AMS_DELTA_GPIO_PIN_KEYBRD_DATAOUT,
124		.flags	= GPIOF_OUT_INIT_LOW,
125		.label	= "serio-dataout",
126	},
127};
128
129static int __init ams_delta_serio_init(void)
130{
131	int err;
132
133	if (!machine_is_ams_delta())
134		return -ENODEV;
135
136	ams_delta_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
137	if (!ams_delta_serio)
138		return -ENOMEM;
139
140	ams_delta_serio->id.type = SERIO_8042;
141	ams_delta_serio->open = ams_delta_serio_open;
142	ams_delta_serio->close = ams_delta_serio_close;
143	strlcpy(ams_delta_serio->name, "AMS DELTA keyboard adapter",
144			sizeof(ams_delta_serio->name));
145	strlcpy(ams_delta_serio->phys, "GPIO/serio0",
146			sizeof(ams_delta_serio->phys));
147
148	err = gpio_request_array(ams_delta_gpios,
149				ARRAY_SIZE(ams_delta_gpios));
150	if (err) {
151		pr_err("ams_delta_serio: Couldn't request gpio pins\n");
152		goto serio;
153	}
154
155	err = request_irq(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
156			ams_delta_serio_interrupt, IRQ_TYPE_EDGE_RISING,
157			"ams-delta-serio", 0);
158	if (err < 0) {
159		pr_err("ams_delta_serio: couldn't request gpio interrupt %d\n",
160				gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK));
161		goto gpio;
162	}
163	/*
164	 * Since GPIO register handling for keyboard clock pin is performed
165	 * at FIQ level, switch back from edge to simple interrupt handler
166	 * to avoid bad interaction.
167	 */
168	irq_set_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
169			handle_simple_irq);
170
171	serio_register_port(ams_delta_serio);
172	dev_info(&ams_delta_serio->dev, "%s\n", ams_delta_serio->name);
173
174	return 0;
175gpio:
176	gpio_free_array(ams_delta_gpios,
177			ARRAY_SIZE(ams_delta_gpios));
178serio:
179	kfree(ams_delta_serio);
180	return err;
181}
182module_init(ams_delta_serio_init);
183
184static void __exit ams_delta_serio_exit(void)
185{
186	serio_unregister_port(ams_delta_serio);
187	free_irq(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 0);
188	gpio_free_array(ams_delta_gpios,
189			ARRAY_SIZE(ams_delta_gpios));
190}
191module_exit(ams_delta_serio_exit);