| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Amstrad E3 (Delta) keyboard port driver | |
| * | |
| * Copyright (c) 2006 Matt Callow | |
| * Copyright (c) 2010 Janusz Krzysztofik | |
| * | |
| * Thanks to Cliff Lawson for his help | |
| * | |
| * The Amstrad Delta keyboard (aka mailboard) uses normal PC-AT style serial | |
| * transmission. The keyboard port is formed of two GPIO lines, for clock | |
| * and data. Due to strict timing requirements of the interface, | |
| * the serial data stream is read and processed by a FIQ handler. | |
| * The resulting words are fetched by this driver from a circular buffer. | |
| * | |
| * Standard AT keyboard driver (atkbd) is used for handling the keyboard data. | |
| * However, when used with the E3 mailboard that producecs non-standard | |
| * scancodes, a custom key table must be prepared and loaded from userspace. | |
| */ | |
| #include <linux/irq.h> | |
| #include <linux/platform_data/ams-delta-fiq.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/regulator/consumer.h> | |
| #include <linux/serio.h> | |
| #include <linux/slab.h> | |
| #include <linux/module.h> | |
| #define DRIVER_NAME "ams-delta-serio" | |
| MODULE_AUTHOR("Matt Callow"); | |
| MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver"); | |
| MODULE_LICENSE("GPL"); | |
| struct ams_delta_serio { | |
| struct serio *serio; | |
| struct regulator *vcc; | |
| unsigned int *fiq_buffer; | |
| }; | |
| static int check_data(struct serio *serio, int data) | |
| { | |
| int i, parity = 0; | |
| /* check valid stop bit */ | |
| if (!(data & 0x400)) { | |
| dev_warn(&serio->dev, "invalid stop bit, data=0x%X\n", data); | |
| return SERIO_FRAME; | |
| } | |
| /* calculate the parity */ | |
| for (i = 1; i < 10; i++) { | |
| if (data & (1 << i)) | |
| parity++; | |
| } | |
| /* it should be odd */ | |
| if (!(parity & 0x01)) { | |
| dev_warn(&serio->dev, | |
| "parity check failed, data=0x%X parity=0x%X\n", data, | |
| parity); | |
| return SERIO_PARITY; | |
| } | |
| return 0; | |
| } | |
| static irqreturn_t ams_delta_serio_interrupt(int irq, void *dev_id) | |
| { | |
| struct ams_delta_serio *priv = dev_id; | |
| int *circ_buff = &priv->fiq_buffer[FIQ_CIRC_BUFF]; | |
| int data, dfl; | |
| u8 scancode; | |
| priv->fiq_buffer[FIQ_IRQ_PEND] = 0; | |
| /* | |
| * Read data from the circular buffer, check it | |
| * and then pass it on the serio | |
| */ | |
| while (priv->fiq_buffer[FIQ_KEYS_CNT] > 0) { | |
| data = circ_buff[priv->fiq_buffer[FIQ_HEAD_OFFSET]++]; | |
| priv->fiq_buffer[FIQ_KEYS_CNT]--; | |
| if (priv->fiq_buffer[FIQ_HEAD_OFFSET] == | |
| priv->fiq_buffer[FIQ_BUF_LEN]) | |
| priv->fiq_buffer[FIQ_HEAD_OFFSET] = 0; | |
| dfl = check_data(priv->serio, data); | |
| scancode = (u8) (data >> 1) & 0xFF; | |
| serio_interrupt(priv->serio, scancode, dfl); | |
| } | |
| return IRQ_HANDLED; | |
| } | |
| static int ams_delta_serio_open(struct serio *serio) | |
| { | |
| struct ams_delta_serio *priv = serio->port_data; | |
| /* enable keyboard */ | |
| return regulator_enable(priv->vcc); | |
| } | |
| static void ams_delta_serio_close(struct serio *serio) | |
| { | |
| struct ams_delta_serio *priv = serio->port_data; | |
| /* disable keyboard */ | |
| regulator_disable(priv->vcc); | |
| } | |
| static int ams_delta_serio_init(struct platform_device *pdev) | |
| { | |
| struct ams_delta_serio *priv; | |
| struct serio *serio; | |
| int irq, err; | |
| priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); | |
| if (!priv) | |
| return -ENOMEM; | |
| priv->fiq_buffer = pdev->dev.platform_data; | |
| if (!priv->fiq_buffer) | |
| return -EINVAL; | |
| priv->vcc = devm_regulator_get(&pdev->dev, "vcc"); | |
| if (IS_ERR(priv->vcc)) { | |
| err = PTR_ERR(priv->vcc); | |
| dev_err(&pdev->dev, "regulator request failed (%d)\n", err); | |
| /* | |
| * When running on a non-dt platform and requested regulator | |
| * is not available, devm_regulator_get() never returns | |
| * -EPROBE_DEFER as it is not able to justify if the regulator | |
| * may still appear later. On the other hand, the board can | |
| * still set full constriants flag at late_initcall in order | |
| * to instruct devm_regulator_get() to returnn a dummy one | |
| * if sufficient. Hence, if we get -ENODEV here, let's convert | |
| * it to -EPROBE_DEFER and wait for the board to decide or | |
| * let Deferred Probe infrastructure handle this error. | |
| */ | |
| if (err == -ENODEV) | |
| err = -EPROBE_DEFER; | |
| return err; | |
| } | |
| irq = platform_get_irq(pdev, 0); | |
| if (irq < 0) | |
| return -ENXIO; | |
| err = devm_request_irq(&pdev->dev, irq, ams_delta_serio_interrupt, | |
| IRQ_TYPE_EDGE_RISING, DRIVER_NAME, priv); | |
| if (err < 0) { | |
| dev_err(&pdev->dev, "IRQ request failed (%d)\n", err); | |
| return err; | |
| } | |
| serio = kzalloc_obj(*serio); | |
| if (!serio) | |
| return -ENOMEM; | |
| priv->serio = serio; | |
| serio->id.type = SERIO_8042; | |
| serio->open = ams_delta_serio_open; | |
| serio->close = ams_delta_serio_close; | |
| strscpy(serio->name, "AMS DELTA keyboard adapter", sizeof(serio->name)); | |
| strscpy(serio->phys, dev_name(&pdev->dev), sizeof(serio->phys)); | |
| serio->dev.parent = &pdev->dev; | |
| serio->port_data = priv; | |
| serio_register_port(serio); | |
| platform_set_drvdata(pdev, priv); | |
| dev_info(&serio->dev, "%s\n", serio->name); | |
| return 0; | |
| } | |
| static void ams_delta_serio_exit(struct platform_device *pdev) | |
| { | |
| struct ams_delta_serio *priv = platform_get_drvdata(pdev); | |
| serio_unregister_port(priv->serio); | |
| } | |
| static struct platform_driver ams_delta_serio_driver = { | |
| .probe = ams_delta_serio_init, | |
| .remove = ams_delta_serio_exit, | |
| .driver = { | |
| .name = DRIVER_NAME | |
| }, | |
| }; | |
| module_platform_driver(ams_delta_serio_driver); |