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 34 MODULE_AUTHOR("Matt Callow"); 35 MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver"); 36 MODULE_LICENSE("GPL"); 37 38 static struct serio *ams_delta_serio; 39 40 static 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 66 static 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 92 static int ams_delta_serio_open(struct serio *serio) 93 { 94 /* enable keyboard */ 95 ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR, 96 AMD_DELTA_LATCH2_KEYBRD_PWR); 97 98 return 0; 99 } 100 101 static void ams_delta_serio_close(struct serio *serio) 102 { 103 /* disable keyboard */ 104 ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR, 0); 105 } 106 107 static int __init ams_delta_serio_init(void) 108 { 109 int err; 110 111 if (!machine_is_ams_delta()) 112 return -ENODEV; 113 114 ams_delta_serio = kzalloc(sizeof(struct serio), GFP_KERNEL); 115 if (!ams_delta_serio) 116 return -ENOMEM; 117 118 ams_delta_serio->id.type = SERIO_8042; 119 ams_delta_serio->open = ams_delta_serio_open; 120 ams_delta_serio->close = ams_delta_serio_close; 121 strlcpy(ams_delta_serio->name, "AMS DELTA keyboard adapter", 122 sizeof(ams_delta_serio->name)); 123 strlcpy(ams_delta_serio->phys, "GPIO/serio0", 124 sizeof(ams_delta_serio->phys)); 125 126 err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_DATA, "serio-data"); 127 if (err) { 128 pr_err("ams_delta_serio: Couldn't request gpio pin for data\n"); 129 goto serio; 130 } 131 gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_DATA); 132 133 err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_CLK, "serio-clock"); 134 if (err) { 135 pr_err("ams_delta_serio: couldn't request gpio pin for clock\n"); 136 goto gpio_data; 137 } 138 gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_CLK); 139 140 err = request_irq(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 141 ams_delta_serio_interrupt, IRQ_TYPE_EDGE_RISING, 142 "ams-delta-serio", 0); 143 if (err < 0) { 144 pr_err("ams_delta_serio: couldn't request gpio interrupt %d\n", 145 gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK)); 146 goto gpio_clk; 147 } 148 /* 149 * Since GPIO register handling for keyboard clock pin is performed 150 * at FIQ level, switch back from edge to simple interrupt handler 151 * to avoid bad interaction. 152 */ 153 irq_set_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 154 handle_simple_irq); 155 156 serio_register_port(ams_delta_serio); 157 dev_info(&ams_delta_serio->dev, "%s\n", ams_delta_serio->name); 158 159 return 0; 160 gpio_clk: 161 gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK); 162 gpio_data: 163 gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA); 164 serio: 165 kfree(ams_delta_serio); 166 return err; 167 } 168 module_init(ams_delta_serio_init); 169 170 static void __exit ams_delta_serio_exit(void) 171 { 172 serio_unregister_port(ams_delta_serio); 173 free_irq(OMAP_GPIO_IRQ(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 0); 174 gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK); 175 gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA); 176 } 177 module_exit(ams_delta_serio_exit); 178