Orange Pi5 kernel

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Pegasus Mobile Notetaker Pen input tablet driver
 *
 * Copyright (c) 2016 Martin Kepplinger <martink@posteo.de>
 */
 
/*
 * request packet (control endpoint):
 * |-------------------------------------|
 * | Report ID | Nr of bytes | command   |
 * | (1 byte)  | (1 byte)    | (n bytes) |
 * |-------------------------------------|
 * | 0x02      | n           |           |
 * |-------------------------------------|
 *
 * data packet after set xy mode command, 0x80 0xb5 0x02 0x01
 * and pen is in range:
 *
 * byte	byte name		value (bits)
 * --------------------------------------------
 * 0	status			0 1 0 0 0 0 X X
 * 1	color			0 0 0 0 H 0 S T
 * 2	X low
 * 3	X high
 * 4	Y low
 * 5	Y high
 *
 * X X	battery state:
 *	no state reported	0x00
 *	battery low		0x01
 *	battery good		0x02
 *
 * H	Hovering
 * S	Switch 1 (pen button)
 * T	Tip
 */
 
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/input.h>
#include <linux/usb/input.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/mutex.h>
 
/* USB HID defines */
#define USB_REQ_GET_REPORT		0x01
#define USB_REQ_SET_REPORT		0x09
 
#define USB_VENDOR_ID_PEGASUSTECH	0x0e20
#define USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100	0x0101
 
/* device specific defines */
#define NOTETAKER_REPORT_ID		0x02
#define NOTETAKER_SET_CMD		0x80
#define NOTETAKER_SET_MODE		0xb5
 
#define NOTETAKER_LED_MOUSE		0x02
#define PEN_MODE_XY			0x01
 
#define SPECIAL_COMMAND			0x80
#define BUTTON_PRESSED			0xb5
#define COMMAND_VERSION			0xa9
 
/* in xy data packet */
#define BATTERY_NO_REPORT		0x40
#define BATTERY_LOW			0x41
#define BATTERY_GOOD			0x42
#define PEN_BUTTON_PRESSED		BIT(1)
#define PEN_TIP				BIT(0)
 
struct pegasus {
<------>unsigned char *data;
<------>u8 data_len;
<------>dma_addr_t data_dma;
<------>struct input_dev *dev;
<------>struct usb_device *usbdev;
<------>struct usb_interface *intf;
<------>struct urb *irq;
 
<------>/* serialize access to open/suspend */
<------>struct mutex pm_mutex;
<------>bool is_open;
 
<------>char name[128];
<------>char phys[64];
<------>struct work_struct init;
};
 
static int pegasus_control_msg(struct pegasus *pegasus, u8 *data, int len)
{
<------>const int sizeof_buf = len + 2;
<------>int result;
<------>int error;
<------>u8 *cmd_buf;
 
<------>cmd_buf = kmalloc(sizeof_buf, GFP_KERNEL);
<------>if (!cmd_buf)
<------><------>return -ENOMEM;
 
<------>cmd_buf[0] = NOTETAKER_REPORT_ID;
<------>cmd_buf[1] = len;
<------>memcpy(cmd_buf + 2, data, len);
 
<------>result = usb_control_msg(pegasus->usbdev,
<------><------><------><------> usb_sndctrlpipe(pegasus->usbdev, 0),
<------><------><------><------> USB_REQ_SET_REPORT,
<------><------><------><------> USB_TYPE_VENDOR | USB_DIR_OUT,
<------><------><------><------> 0, 0, cmd_buf, sizeof_buf,
<------><------><------><------> USB_CTRL_SET_TIMEOUT);
 
<------>kfree(cmd_buf);
 
<------>if (unlikely(result != sizeof_buf)) {
<------><------>error = result < 0 ? result : -EIO;
<------><------>dev_err(&pegasus->usbdev->dev, "control msg error: %d\n",
<------><------><------>error);
<------><------>return error;
<------>}
 
<------>return 0;
}
 
static int pegasus_set_mode(struct pegasus *pegasus, u8 mode, u8 led)
{
<------>u8 cmd[] = { NOTETAKER_SET_CMD, NOTETAKER_SET_MODE, led, mode };
 
<------>return pegasus_control_msg(pegasus, cmd, sizeof(cmd));
}
 
static void pegasus_parse_packet(struct pegasus *pegasus)
{
<------>unsigned char *data = pegasus->data;
<------>struct input_dev *dev = pegasus->dev;
<------>u16 x, y;
 
<------>switch (data[0]) {
<------>case SPECIAL_COMMAND:
<------><------>/* device button pressed */
<------><------>if (data[1] == BUTTON_PRESSED)
<------><------><------>schedule_work(&pegasus->init);
 
<------><------>break;
 
<------>/* xy data */
<------>case BATTERY_LOW:
<------><------>dev_warn_once(&dev->dev, "Pen battery low\n");
<------><------>fallthrough;
 
<------>case BATTERY_NO_REPORT:
<------>case BATTERY_GOOD:
<------><------>x = le16_to_cpup((__le16 *)&data[2]);
<------><------>y = le16_to_cpup((__le16 *)&data[4]);
 
<------><------>/* pen-up event */
<------><------>if (x == 0 && y == 0)
<------><------><------>break;
 
<------><------>input_report_key(dev, BTN_TOUCH, data[1] & PEN_TIP);
<------><------>input_report_key(dev, BTN_RIGHT, data[1] & PEN_BUTTON_PRESSED);
<------><------>input_report_key(dev, BTN_TOOL_PEN, 1);
<------><------>input_report_abs(dev, ABS_X, (s16)x);
<------><------>input_report_abs(dev, ABS_Y, y);
 
<------><------>input_sync(dev);
<------><------>break;
 
<------>default:
<------><------>dev_warn_once(&pegasus->usbdev->dev,
<------><------><------>      "unknown answer from device\n");
<------>}
}
 
static void pegasus_irq(struct urb *urb)
{
<------>struct pegasus *pegasus = urb->context;
<------>struct usb_device *dev = pegasus->usbdev;
<------>int retval;
 
<------>switch (urb->status) {
<------>case 0:
<------><------>pegasus_parse_packet(pegasus);
<------><------>usb_mark_last_busy(pegasus->usbdev);
<------><------>break;
 
<------>case -ECONNRESET:
<------>case -ENOENT:
<------>case -ESHUTDOWN:
<------><------>dev_err(&dev->dev, "%s - urb shutting down with status: %d",
<------><------><------>__func__, urb->status);
<------><------>return;
 
<------>default:
<------><------>dev_err(&dev->dev, "%s - nonzero urb status received: %d",
<------><------><------>__func__, urb->status);
<------><------>break;
<------>}
 
<------>retval = usb_submit_urb(urb, GFP_ATOMIC);
<------>if (retval)
<------><------>dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
<------><------><------>__func__, retval);
}
 
static void pegasus_init(struct work_struct *work)
{
<------>struct pegasus *pegasus = container_of(work, struct pegasus, init);
<------>int error;
 
<------>error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
<------>if (error)
<------><------>dev_err(&pegasus->usbdev->dev, "pegasus_set_mode error: %d\n",
<------><------><------>error);
}
 
static int pegasus_open(struct input_dev *dev)
{
<------>struct pegasus *pegasus = input_get_drvdata(dev);
<------>int error;
 
<------>error = usb_autopm_get_interface(pegasus->intf);
<------>if (error)
<------><------>return error;
 
<------>mutex_lock(&pegasus->pm_mutex);
<------>pegasus->irq->dev = pegasus->usbdev;
<------>if (usb_submit_urb(pegasus->irq, GFP_KERNEL)) {
<------><------>error = -EIO;
<------><------>goto err_autopm_put;
<------>}
 
<------>error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
<------>if (error)
<------><------>goto err_kill_urb;
 
<------>pegasus->is_open = true;
<------>mutex_unlock(&pegasus->pm_mutex);
<------>return 0;
 
err_kill_urb:
<------>usb_kill_urb(pegasus->irq);
<------>cancel_work_sync(&pegasus->init);
err_autopm_put:
<------>mutex_unlock(&pegasus->pm_mutex);
<------>usb_autopm_put_interface(pegasus->intf);
<------>return error;
}
 
static void pegasus_close(struct input_dev *dev)
{
<------>struct pegasus *pegasus = input_get_drvdata(dev);
 
<------>mutex_lock(&pegasus->pm_mutex);
<------>usb_kill_urb(pegasus->irq);
<------>cancel_work_sync(&pegasus->init);
<------>pegasus->is_open = false;
<------>mutex_unlock(&pegasus->pm_mutex);
 
<------>usb_autopm_put_interface(pegasus->intf);
}
 
static int pegasus_probe(struct usb_interface *intf,
<------><------><------> const struct usb_device_id *id)
{
<------>struct usb_device *dev = interface_to_usbdev(intf);
<------>struct usb_endpoint_descriptor *endpoint;
<------>struct pegasus *pegasus;
<------>struct input_dev *input_dev;
<------>int error;
<------>int pipe;
 
<------>/* We control interface 0 */
<------>if (intf->cur_altsetting->desc.bInterfaceNumber >= 1)
<------><------>return -ENODEV;
 
<------>/* Sanity check that the device has an endpoint */
<------>if (intf->cur_altsetting->desc.bNumEndpoints < 1) {
<------><------>dev_err(&intf->dev, "Invalid number of endpoints\n");
<------><------>return -EINVAL;
<------>}
 
<------>endpoint = &intf->cur_altsetting->endpoint[0].desc;
 
<------>pegasus = kzalloc(sizeof(*pegasus), GFP_KERNEL);
<------>input_dev = input_allocate_device();
<------>if (!pegasus || !input_dev) {
<------><------>error = -ENOMEM;
<------><------>goto err_free_mem;
<------>}
 
<------>mutex_init(&pegasus->pm_mutex);
 
<------>pegasus->usbdev = dev;
<------>pegasus->dev = input_dev;
<------>pegasus->intf = intf;
 
<------>pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
<------>pegasus->data_len = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
 
<------>pegasus->data = usb_alloc_coherent(dev, pegasus->data_len, GFP_KERNEL,
<------><------><------><------><------>   &pegasus->data_dma);
<------>if (!pegasus->data) {
<------><------>error = -ENOMEM;
<------><------>goto err_free_mem;
<------>}
 
<------>pegasus->irq = usb_alloc_urb(0, GFP_KERNEL);
<------>if (!pegasus->irq) {
<------><------>error = -ENOMEM;
<------><------>goto err_free_dma;
<------>}
 
<------>usb_fill_int_urb(pegasus->irq, dev, pipe,
<------><------><------> pegasus->data, pegasus->data_len,
<------><------><------> pegasus_irq, pegasus, endpoint->bInterval);
 
<------>pegasus->irq->transfer_dma = pegasus->data_dma;
<------>pegasus->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
<------>if (dev->manufacturer)
<------><------>strlcpy(pegasus->name, dev->manufacturer,
<------><------><------>sizeof(pegasus->name));
 
<------>if (dev->product) {
<------><------>if (dev->manufacturer)
<------><------><------>strlcat(pegasus->name, " ", sizeof(pegasus->name));
<------><------>strlcat(pegasus->name, dev->product, sizeof(pegasus->name));
<------>}
 
<------>if (!strlen(pegasus->name))
<------><------>snprintf(pegasus->name, sizeof(pegasus->name),
<------><------><------> "USB Pegasus Device %04x:%04x",
<------><------><------> le16_to_cpu(dev->descriptor.idVendor),
<------><------><------> le16_to_cpu(dev->descriptor.idProduct));
 
<------>usb_make_path(dev, pegasus->phys, sizeof(pegasus->phys));
<------>strlcat(pegasus->phys, "/input0", sizeof(pegasus->phys));
 
<------>INIT_WORK(&pegasus->init, pegasus_init);
 
<------>usb_set_intfdata(intf, pegasus);
 
<------>input_dev->name = pegasus->name;
<------>input_dev->phys = pegasus->phys;
<------>usb_to_input_id(dev, &input_dev->id);
<------>input_dev->dev.parent = &intf->dev;
 
<------>input_set_drvdata(input_dev, pegasus);
 
<------>input_dev->open = pegasus_open;
<------>input_dev->close = pegasus_close;
 
<------>__set_bit(EV_ABS, input_dev->evbit);
<------>__set_bit(EV_KEY, input_dev->evbit);
 
<------>__set_bit(ABS_X, input_dev->absbit);
<------>__set_bit(ABS_Y, input_dev->absbit);
 
<------>__set_bit(BTN_TOUCH, input_dev->keybit);
<------>__set_bit(BTN_RIGHT, input_dev->keybit);
<------>__set_bit(BTN_TOOL_PEN, input_dev->keybit);
 
<------>__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
<------>__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
 
<------>input_set_abs_params(input_dev, ABS_X, -1500, 1500, 8, 0);
<------>input_set_abs_params(input_dev, ABS_Y, 1600, 3000, 8, 0);
 
<------>error = input_register_device(pegasus->dev);
<------>if (error)
<------><------>goto err_free_urb;
 
<------>return 0;
 
err_free_urb:
<------>usb_free_urb(pegasus->irq);
err_free_dma:
<------>usb_free_coherent(dev, pegasus->data_len,
<------><------><------>  pegasus->data, pegasus->data_dma);
err_free_mem:
<------>input_free_device(input_dev);
<------>kfree(pegasus);
<------>usb_set_intfdata(intf, NULL);
 
<------>return error;
}
 
static void pegasus_disconnect(struct usb_interface *intf)
{
<------>struct pegasus *pegasus = usb_get_intfdata(intf);
 
<------>input_unregister_device(pegasus->dev);
 
<------>usb_free_urb(pegasus->irq);
<------>usb_free_coherent(interface_to_usbdev(intf),
<------><------><------>  pegasus->data_len, pegasus->data,
<------><------><------>  pegasus->data_dma);
 
<------>kfree(pegasus);
<------>usb_set_intfdata(intf, NULL);
}
 
static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
{
<------>struct pegasus *pegasus = usb_get_intfdata(intf);
 
<------>mutex_lock(&pegasus->pm_mutex);
<------>usb_kill_urb(pegasus->irq);
<------>cancel_work_sync(&pegasus->init);
<------>mutex_unlock(&pegasus->pm_mutex);
 
<------>return 0;
}
 
static int pegasus_resume(struct usb_interface *intf)
{
<------>struct pegasus *pegasus = usb_get_intfdata(intf);
<------>int retval = 0;
 
<------>mutex_lock(&pegasus->pm_mutex);
<------>if (pegasus->is_open && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
<------><------>retval = -EIO;
<------>mutex_unlock(&pegasus->pm_mutex);
 
<------>return retval;
}
 
static int pegasus_reset_resume(struct usb_interface *intf)
{
<------>struct pegasus *pegasus = usb_get_intfdata(intf);
<------>int retval = 0;
 
<------>mutex_lock(&pegasus->pm_mutex);
<------>if (pegasus->is_open) {
<------><------>retval = pegasus_set_mode(pegasus, PEN_MODE_XY,
<------><------><------><------><------>  NOTETAKER_LED_MOUSE);
<------><------>if (!retval && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
<------><------><------>retval = -EIO;
<------>}
<------>mutex_unlock(&pegasus->pm_mutex);
 
<------>return retval;
}
 
static const struct usb_device_id pegasus_ids[] = {
<------>{ USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
<------><------>     USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
<------>{ }
};
MODULE_DEVICE_TABLE(usb, pegasus_ids);
 
static struct usb_driver pegasus_driver = {
<------>.name		= "pegasus_notetaker",
<------>.probe		= pegasus_probe,
<------>.disconnect	= pegasus_disconnect,
<------>.suspend	= pegasus_suspend,
<------>.resume		= pegasus_resume,
<------>.reset_resume	= pegasus_reset_resume,
<------>.id_table	= pegasus_ids,
<------>.supports_autosuspend = 1,
};
 
module_usb_driver(pegasus_driver);
 
MODULE_AUTHOR("Martin Kepplinger <martink@posteo.de>");
MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
MODULE_LICENSE("GPL");