1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Amstrad E3 (Delta) keyboard port driver 4 * 5 * Copyright (c) 2006 Matt Callow 6 * Copyright (c) 2010 Janusz Krzysztofik 7 * 8 * Thanks to Cliff Lawson for his help 9 * 10 * The Amstrad Delta keyboard (aka mailboard) uses normal PC-AT style serial 11 * transmission. The keyboard port is formed of two GPIO lines, for clock 12 * and data. Due to strict timing requirements of the interface, 13 * the serial data stream is read and processed by a FIQ handler. 14 * The resulting words are fetched by this driver from a circular buffer. 15 * 16 * Standard AT keyboard driver (atkbd) is used for handling the keyboard data. 17 * However, when used with the E3 mailboard that producecs non-standard 18 * scancodes, a custom key table must be prepared and loaded from userspace. 19 */ 20 #include <linux/irq.h> 21 #include <linux/platform_data/ams-delta-fiq.h> 22 #include <linux/platform_device.h> 23 #include <linux/regulator/consumer.h> 24 #include <linux/serio.h> 25 #include <linux/slab.h> 26 #include <linux/module.h> 27 28 #define DRIVER_NAME "ams-delta-serio" 29 30 MODULE_AUTHOR("Matt Callow"); 31 MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver"); 32 MODULE_LICENSE("GPL"); 33 34 struct ams_delta_serio { 35 struct serio *serio; 36 struct regulator *vcc; 37 unsigned int *fiq_buffer; 38 }; 39 40 static int check_data(struct serio *serio, int data) 41 { 42 int i, parity = 0; 43 44 /* check valid stop bit */ 45 if (!(data & 0x400)) { 46 dev_warn(&serio->dev, "invalid stop bit, data=0x%X\n", data); 47 return SERIO_FRAME; 48 } 49 /* calculate the parity */ 50 for (i = 1; i < 10; i++) { 51 if (data & (1 << i)) 52 parity++; 53 } 54 /* it should be odd */ 55 if (!(parity & 0x01)) { 56 dev_warn(&serio->dev, 57 "parity check failed, data=0x%X parity=0x%X\n", data, 58 parity); 59 return SERIO_PARITY; 60 } 61 return 0; 62 } 63 64 static irqreturn_t ams_delta_serio_interrupt(int irq, void *dev_id) 65 { 66 struct ams_delta_serio *priv = dev_id; 67 int *circ_buff = &priv->fiq_buffer[FIQ_CIRC_BUFF]; 68 int data, dfl; 69 u8 scancode; 70 71 priv->fiq_buffer[FIQ_IRQ_PEND] = 0; 72 73 /* 74 * Read data from the circular buffer, check it 75 * and then pass it on the serio 76 */ 77 while (priv->fiq_buffer[FIQ_KEYS_CNT] > 0) { 78 79 data = circ_buff[priv->fiq_buffer[FIQ_HEAD_OFFSET]++]; 80 priv->fiq_buffer[FIQ_KEYS_CNT]--; 81 if (priv->fiq_buffer[FIQ_HEAD_OFFSET] == 82 priv->fiq_buffer[FIQ_BUF_LEN]) 83 priv->fiq_buffer[FIQ_HEAD_OFFSET] = 0; 84 85 dfl = check_data(priv->serio, data); 86 scancode = (u8) (data >> 1) & 0xFF; 87 serio_interrupt(priv->serio, scancode, dfl); 88 } 89 return IRQ_HANDLED; 90 } 91 92 static int ams_delta_serio_open(struct serio *serio) 93 { 94 struct ams_delta_serio *priv = serio->port_data; 95 96 /* enable keyboard */ 97 return regulator_enable(priv->vcc); 98 } 99 100 static void ams_delta_serio_close(struct serio *serio) 101 { 102 struct ams_delta_serio *priv = serio->port_data; 103 104 /* disable keyboard */ 105 regulator_disable(priv->vcc); 106 } 107 108 static int ams_delta_serio_init(struct platform_device *pdev) 109 { 110 struct ams_delta_serio *priv; 111 struct serio *serio; 112 int irq, err; 113 114 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 115 if (!priv) 116 return -ENOMEM; 117 118 priv->fiq_buffer = pdev->dev.platform_data; 119 if (!priv->fiq_buffer) 120 return -EINVAL; 121 122 priv->vcc = devm_regulator_get(&pdev->dev, "vcc"); 123 if (IS_ERR(priv->vcc)) { 124 err = PTR_ERR(priv->vcc); 125 dev_err(&pdev->dev, "regulator request failed (%d)\n", err); 126 /* 127 * When running on a non-dt platform and requested regulator 128 * is not available, devm_regulator_get() never returns 129 * -EPROBE_DEFER as it is not able to justify if the regulator 130 * may still appear later. On the other hand, the board can 131 * still set full constriants flag at late_initcall in order 132 * to instruct devm_regulator_get() to returnn a dummy one 133 * if sufficient. Hence, if we get -ENODEV here, let's convert 134 * it to -EPROBE_DEFER and wait for the board to decide or 135 * let Deferred Probe infrastructure handle this error. 136 */ 137 if (err == -ENODEV) 138 err = -EPROBE_DEFER; 139 return err; 140 } 141 142 irq = platform_get_irq(pdev, 0); 143 if (irq < 0) 144 return -ENXIO; 145 146 err = devm_request_irq(&pdev->dev, irq, ams_delta_serio_interrupt, 147 IRQ_TYPE_EDGE_RISING, DRIVER_NAME, priv); 148 if (err < 0) { 149 dev_err(&pdev->dev, "IRQ request failed (%d)\n", err); 150 return err; 151 } 152 153 serio = kzalloc(sizeof(*serio), GFP_KERNEL); 154 if (!serio) 155 return -ENOMEM; 156 157 priv->serio = serio; 158 159 serio->id.type = SERIO_8042; 160 serio->open = ams_delta_serio_open; 161 serio->close = ams_delta_serio_close; 162 strscpy(serio->name, "AMS DELTA keyboard adapter", sizeof(serio->name)); 163 strscpy(serio->phys, dev_name(&pdev->dev), sizeof(serio->phys)); 164 serio->dev.parent = &pdev->dev; 165 serio->port_data = priv; 166 167 serio_register_port(serio); 168 169 platform_set_drvdata(pdev, priv); 170 171 dev_info(&serio->dev, "%s\n", serio->name); 172 173 return 0; 174 } 175 176 static void ams_delta_serio_exit(struct platform_device *pdev) 177 { 178 struct ams_delta_serio *priv = platform_get_drvdata(pdev); 179 180 serio_unregister_port(priv->serio); 181 } 182 183 static struct platform_driver ams_delta_serio_driver = { 184 .probe = ams_delta_serio_init, 185 .remove_new = ams_delta_serio_exit, 186 .driver = { 187 .name = DRIVER_NAME 188 }, 189 }; 190 module_platform_driver(ams_delta_serio_driver); 191