#include #include #include #include #include #include #include #include #include #include // #define ENABLE_DEBUG ENABLE_DEBUG MODULE_LICENSE("GPL"); MODULE_AUTHOR("Markus Koch"); MODULE_DESCRIPTION("LW-35 I/O Controller Driver"); MODULE_VERSION("0.1"); static int debug_level = 0; module_param(debug_level, int, 0); MODULE_PARM_DESC(debug_level, "Debug level"); static struct of_device_id lw35ioc_dt_ids[] = { { .compatible = "brother,lw35", }, { /* sentinel */ } }; MODULE_DEVICE_TABLE(of, lw35ioc_dt_ids); /* Only used for initialization, not for actualy keycode mapping */ static int keycode_map[] = { KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J, KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T, KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z, KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12, KEY_UP, KEY_DOWN, KEY_RIGHT, KEY_LEFT, KEY_PAGEUP, KEY_PAGEDOWN, KEY_102ND, KEY_INSERT, KEY_HOME, KEY_END, KEY_PRINT, KEY_CAPSLOCK, KEY_LEFTCTRL, KEY_LEFTSHIFT, KEY_LEFTALT, KEY_TAB, KEY_MINUS, KEY_COMMA, KEY_SEMICOLON, KEY_RIGHTBRACE, KEY_LEFTBRACE, KEY_GRAVE, KEY_SPACE, KEY_EQUAL, KEY_DOT, KEY_SLASH, KEY_APOSTROPHE, KEY_BACKSLASH, KEY_DELETE, KEY_ESC, KEY_ENTER, KEY_BACKSPACE, KEY_SYSRQ }; enum lw35ioc_state {PASSIVE, PASSTHROUGH, ACTIVE}; enum lw35ioc_packet_state {SYNC, TYPE, KEYBOARD, PRINTER}; struct lw35ioc_packet { enum lw35ioc_packet_state state; }; struct lw35ioc_priv { struct serdev_device *serdev; struct input_dev *input_dev; struct gpio_desc *gpio_rst; /* GPIO to reset both AVRs */ enum lw35ioc_state state; struct lw35ioc_packet packet; }; static int lw35ioc_process_buf(struct serdev_device *serdev, const unsigned char *data, size_t count) { struct lw35ioc_priv *priv = serdev_device_get_drvdata(serdev); unsigned char c; int ev; int i; #ifdef ENABLE_DEBUG dev_info(&serdev->dev, "IRQ.\n"); #endif for (i = 0; i < count; ++i) { c = data[i]; #ifdef ENABLE_DEBUG dev_info(&serdev->dev, " RX [%d]: %02x\n", priv->packet.state, c); #endif switch (priv->packet.state) { case SYNC: if (c == 0xFF) priv->packet.state = TYPE; break; case TYPE: if (c == 0x55) priv->packet.state = KEYBOARD; else if (c == 0xAA) priv->packet.state = PRINTER; else priv->packet.state = SYNC; break; case KEYBOARD: if (c > 127) { c -= 128; ev = 1; } else { ev = 0; } input_report_key(priv->input_dev, c, ev); input_sync(priv->input_dev); priv->packet.state = SYNC; break; case PRINTER: dev_info(&serdev->dev, "Printer not yet implemented.\n"); priv->packet.state = SYNC; break; } } return i; } static int lw35ioc_receive_buf(struct serdev_device *serdev, const unsigned char *data, size_t count) { struct lw35ioc_priv *priv = serdev_device_get_drvdata(serdev); if (priv->state == ACTIVE) return lw35ioc_process_buf(serdev, data, count); return count; /* Pretend we read all data */ } static void lw35ioc_write_wakeup(struct serdev_device *serdev) { dev_info(&serdev->dev, "Write wakeup\n"); // schedule work here } static struct serdev_device_ops lw35ioc_serdev_ops = { .receive_buf = lw35ioc_receive_buf, .write_wakeup = lw35ioc_write_wakeup, }; static void lw35ioc_set_hw_reset(struct serdev_device *serdev, int reset_active) { struct lw35ioc_priv *priv = serdev_device_get_drvdata(serdev); gpiod_set_value(priv->gpio_rst, !reset_active); } static int lw35ioc_probe(struct serdev_device *serdev) { struct lw35ioc_priv *priv = NULL; int ret; int i; u32 speed = 19200; struct input_dev *input_dev; printk(KERN_INFO "lw35ioc: probe\n"); /* Allocate memory */ priv = devm_kzalloc(&serdev->dev, sizeof(struct lw35ioc_priv), GFP_KERNEL); if (!priv) { printk(KERN_ERR "lw35ioc: Not enough memory.\n"); return -ENOMEM; } priv->state = PASSIVE; priv->serdev = serdev; priv->packet.state = SYNC; serdev_device_set_drvdata(serdev, priv); serdev_device_set_client_ops(serdev, &lw35ioc_serdev_ops); /* Register input device */ input_dev = devm_input_allocate_device(&serdev->dev); if (!input_dev) { dev_err(&serdev->dev, "Unable to allocate input device.\n"); return -ENOMEM; } priv->input_dev = input_dev; input_dev->name = "lw35ioc"; input_dev->phys = "lw35ioc/input1"; input_set_capability(input_dev, EV_MSC, MSC_SCAN); __set_bit(EV_KEY, input_dev->evbit); __set_bit(EV_REP, input_dev->evbit); for (i = 0; i < ARRAY_SIZE(keycode_map); i++) __set_bit(keycode_map[i], input_dev->keybit); ret = input_register_device(input_dev); if (ret) { dev_err(&serdev->dev, "Unable to register input device.\n"); goto fail_input; } ret = serdev_device_open(serdev); if (ret) { dev_err(&serdev->dev, "Unable to open device.\n"); goto fail_serdev; } speed = serdev_device_set_baudrate(serdev, speed); dev_info(&serdev->dev, "Using baudrate: %u\n", speed); /* Register GPIO */ priv->gpio_rst = gpiod_get_index(&serdev->dev, "rst", 0, GPIOD_OUT_LOW); lw35ioc_set_hw_reset(serdev, 0); if (IS_ERR(priv->gpio_rst)) { dev_err(&serdev->dev, "Unable to get reset GPIO.\n"); ret = -ENODEV; goto fail_gpio; } dev_info(&serdev->dev, "Loaded driver.\n"); return 0; fail_gpio: fail_serdev: input_unregister_device(input_dev); fail_input: devm_kfree(&serdev->dev, input_dev); return ret; } static void lw35ioc_remove(struct serdev_device *serdev) { struct lw35ioc_priv *priv = serdev_device_get_drvdata(serdev); lw35ioc_set_hw_reset(serdev, 1); gpiod_put(priv->gpio_rst); serdev_device_close(priv->serdev); input_unregister_device(priv->input_dev); dev_info(&serdev->dev, "remove\n"); return; } static struct serdev_device_driver lw35ioc_driver = { .probe = lw35ioc_probe, .remove = lw35ioc_remove, .driver = { .name = "lw35ioc", .owner = THIS_MODULE, .of_match_table = of_match_ptr(lw35ioc_dt_ids), }, }; module_serdev_device_driver(lw35ioc_driver);