mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
468 lines
11 KiB
468 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Pegasus Mobile Notetaker Pen input tablet driver |
|
* |
|
* Copyright (c) 2016 Martin Kepplinger <[email protected]> |
|
*/ |
|
|
|
/* |
|
* 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 <[email protected]>"); |
|
MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver"); |
|
MODULE_LICENSE("GPL");
|
|
|