1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Pegasus Mobile Notetaker Pen input tablet driver
4 *
5 * Copyright (c) 2016 Martin Kepplinger <martink@posteo.de>
6 */
7
8/*
9 * request packet (control endpoint):
10 * |-------------------------------------|
11 * | Report ID | Nr of bytes | command   |
12 * | (1 byte)  | (1 byte)    | (n bytes) |
13 * |-------------------------------------|
14 * | 0x02      | n           |           |
15 * |-------------------------------------|
16 *
17 * data packet after set xy mode command, 0x80 0xb5 0x02 0x01
18 * and pen is in range:
19 *
20 * byte	byte name		value (bits)
21 * --------------------------------------------
22 * 0	status			0 1 0 0 0 0 X X
23 * 1	color			0 0 0 0 H 0 S T
24 * 2	X low
25 * 3	X high
26 * 4	Y low
27 * 5	Y high
28 *
29 * X X	battery state:
30 *	no state reported	0x00
31 *	battery low		0x01
32 *	battery good		0x02
33 *
34 * H	Hovering
35 * S	Switch 1 (pen button)
36 * T	Tip
37 */
38
39#include <linux/kernel.h>
40#include <linux/module.h>
41#include <linux/input.h>
42#include <linux/usb/input.h>
43#include <linux/slab.h>
44#include <linux/workqueue.h>
45#include <linux/mutex.h>
46
47/* USB HID defines */
48#define USB_REQ_GET_REPORT		0x01
49#define USB_REQ_SET_REPORT		0x09
50
51#define USB_VENDOR_ID_PEGASUSTECH	0x0e20
52#define USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100	0x0101
53
54/* device specific defines */
55#define NOTETAKER_REPORT_ID		0x02
56#define NOTETAKER_SET_CMD		0x80
57#define NOTETAKER_SET_MODE		0xb5
58
59#define NOTETAKER_LED_MOUSE		0x02
60#define PEN_MODE_XY			0x01
61
62#define SPECIAL_COMMAND			0x80
63#define BUTTON_PRESSED			0xb5
64#define COMMAND_VERSION			0xa9
65
66/* in xy data packet */
67#define BATTERY_NO_REPORT		0x40
68#define BATTERY_LOW			0x41
69#define BATTERY_GOOD			0x42
70#define PEN_BUTTON_PRESSED		BIT(1)
71#define PEN_TIP				BIT(0)
72
73struct pegasus {
74	unsigned char *data;
75	u8 data_len;
76	dma_addr_t data_dma;
77	struct input_dev *dev;
78	struct usb_device *usbdev;
79	struct usb_interface *intf;
80	struct urb *irq;
81
82	/* serialize access to open/suspend */
83	struct mutex pm_mutex;
84	bool is_open;
85
86	char name[128];
87	char phys[64];
88	struct work_struct init;
89};
90
91static int pegasus_control_msg(struct pegasus *pegasus, u8 *data, int len)
92{
93	const int sizeof_buf = len + 2;
94	int result;
95	int error;
96	u8 *cmd_buf;
97
98	cmd_buf = kmalloc(sizeof_buf, GFP_KERNEL);
99	if (!cmd_buf)
100		return -ENOMEM;
101
102	cmd_buf[0] = NOTETAKER_REPORT_ID;
103	cmd_buf[1] = len;
104	memcpy(cmd_buf + 2, data, len);
105
106	result = usb_control_msg(pegasus->usbdev,
107				 usb_sndctrlpipe(pegasus->usbdev, 0),
108				 USB_REQ_SET_REPORT,
109				 USB_TYPE_VENDOR | USB_DIR_OUT,
110				 0, 0, cmd_buf, sizeof_buf,
111				 USB_CTRL_SET_TIMEOUT);
112
113	kfree(cmd_buf);
114
115	if (unlikely(result != sizeof_buf)) {
116		error = result < 0 ? result : -EIO;
117		dev_err(&pegasus->usbdev->dev, "control msg error: %d\n",
118			error);
119		return error;
120	}
121
122	return 0;
123}
124
125static int pegasus_set_mode(struct pegasus *pegasus, u8 mode, u8 led)
126{
127	u8 cmd[] = { NOTETAKER_SET_CMD, NOTETAKER_SET_MODE, led, mode };
128
129	return pegasus_control_msg(pegasus, cmd, sizeof(cmd));
130}
131
132static void pegasus_parse_packet(struct pegasus *pegasus)
133{
134	unsigned char *data = pegasus->data;
135	struct input_dev *dev = pegasus->dev;
136	u16 x, y;
137
138	switch (data[0]) {
139	case SPECIAL_COMMAND:
140		/* device button pressed */
141		if (data[1] == BUTTON_PRESSED)
142			schedule_work(&pegasus->init);
143
144		break;
145
146	/* xy data */
147	case BATTERY_LOW:
148		dev_warn_once(&dev->dev, "Pen battery low\n");
149		fallthrough;
150
151	case BATTERY_NO_REPORT:
152	case BATTERY_GOOD:
153		x = le16_to_cpup((__le16 *)&data[2]);
154		y = le16_to_cpup((__le16 *)&data[4]);
155
156		/* pen-up event */
157		if (x == 0 && y == 0)
158			break;
159
160		input_report_key(dev, BTN_TOUCH, data[1] & PEN_TIP);
161		input_report_key(dev, BTN_RIGHT, data[1] & PEN_BUTTON_PRESSED);
162		input_report_key(dev, BTN_TOOL_PEN, 1);
163		input_report_abs(dev, ABS_X, (s16)x);
164		input_report_abs(dev, ABS_Y, y);
165
166		input_sync(dev);
167		break;
168
169	default:
170		dev_warn_once(&pegasus->usbdev->dev,
171			      "unknown answer from device\n");
172	}
173}
174
175static void pegasus_irq(struct urb *urb)
176{
177	struct pegasus *pegasus = urb->context;
178	struct usb_device *dev = pegasus->usbdev;
179	int retval;
180
181	switch (urb->status) {
182	case 0:
183		pegasus_parse_packet(pegasus);
184		usb_mark_last_busy(pegasus->usbdev);
185		break;
186
187	case -ECONNRESET:
188	case -ENOENT:
189	case -ESHUTDOWN:
190		dev_err(&dev->dev, "%s - urb shutting down with status: %d",
191			__func__, urb->status);
192		return;
193
194	default:
195		dev_err(&dev->dev, "%s - nonzero urb status received: %d",
196			__func__, urb->status);
197		break;
198	}
199
200	retval = usb_submit_urb(urb, GFP_ATOMIC);
201	if (retval)
202		dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
203			__func__, retval);
204}
205
206static void pegasus_init(struct work_struct *work)
207{
208	struct pegasus *pegasus = container_of(work, struct pegasus, init);
209	int error;
210
211	error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
212	if (error)
213		dev_err(&pegasus->usbdev->dev, "pegasus_set_mode error: %d\n",
214			error);
215}
216
217static int pegasus_open(struct input_dev *dev)
218{
219	struct pegasus *pegasus = input_get_drvdata(dev);
220	int error;
221
222	error = usb_autopm_get_interface(pegasus->intf);
223	if (error)
224		return error;
225
226	mutex_lock(&pegasus->pm_mutex);
227	pegasus->irq->dev = pegasus->usbdev;
228	if (usb_submit_urb(pegasus->irq, GFP_KERNEL)) {
229		error = -EIO;
230		goto err_autopm_put;
231	}
232
233	error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
234	if (error)
235		goto err_kill_urb;
236
237	pegasus->is_open = true;
238	mutex_unlock(&pegasus->pm_mutex);
239	return 0;
240
241err_kill_urb:
242	usb_kill_urb(pegasus->irq);
243	cancel_work_sync(&pegasus->init);
244err_autopm_put:
245	mutex_unlock(&pegasus->pm_mutex);
246	usb_autopm_put_interface(pegasus->intf);
247	return error;
248}
249
250static void pegasus_close(struct input_dev *dev)
251{
252	struct pegasus *pegasus = input_get_drvdata(dev);
253
254	mutex_lock(&pegasus->pm_mutex);
255	usb_kill_urb(pegasus->irq);
256	cancel_work_sync(&pegasus->init);
257	pegasus->is_open = false;
258	mutex_unlock(&pegasus->pm_mutex);
259
260	usb_autopm_put_interface(pegasus->intf);
261}
262
263static int pegasus_probe(struct usb_interface *intf,
264			 const struct usb_device_id *id)
265{
266	struct usb_device *dev = interface_to_usbdev(intf);
267	struct usb_endpoint_descriptor *endpoint;
268	struct pegasus *pegasus;
269	struct input_dev *input_dev;
270	int error;
271	int pipe;
272
273	/* We control interface 0 */
274	if (intf->cur_altsetting->desc.bInterfaceNumber >= 1)
275		return -ENODEV;
276
277	/* Sanity check that the device has an endpoint */
278	if (intf->cur_altsetting->desc.bNumEndpoints < 1) {
279		dev_err(&intf->dev, "Invalid number of endpoints\n");
280		return -EINVAL;
281	}
282
283	endpoint = &intf->cur_altsetting->endpoint[0].desc;
284
285	pegasus = kzalloc(sizeof(*pegasus), GFP_KERNEL);
286	input_dev = input_allocate_device();
287	if (!pegasus || !input_dev) {
288		error = -ENOMEM;
289		goto err_free_mem;
290	}
291
292	mutex_init(&pegasus->pm_mutex);
293
294	pegasus->usbdev = dev;
295	pegasus->dev = input_dev;
296	pegasus->intf = intf;
297
298	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
299	/* Sanity check that pipe's type matches endpoint's type */
300	if (usb_pipe_type_check(dev, pipe)) {
301		error = -EINVAL;
302		goto err_free_mem;
303	}
304
305	pegasus->data_len = usb_maxpacket(dev, pipe);
306
307	pegasus->data = usb_alloc_coherent(dev, pegasus->data_len, GFP_KERNEL,
308					   &pegasus->data_dma);
309	if (!pegasus->data) {
310		error = -ENOMEM;
311		goto err_free_mem;
312	}
313
314	pegasus->irq = usb_alloc_urb(0, GFP_KERNEL);
315	if (!pegasus->irq) {
316		error = -ENOMEM;
317		goto err_free_dma;
318	}
319
320	usb_fill_int_urb(pegasus->irq, dev, pipe,
321			 pegasus->data, pegasus->data_len,
322			 pegasus_irq, pegasus, endpoint->bInterval);
323
324	pegasus->irq->transfer_dma = pegasus->data_dma;
325	pegasus->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
326
327	if (dev->manufacturer)
328		strscpy(pegasus->name, dev->manufacturer,
329			sizeof(pegasus->name));
330
331	if (dev->product) {
332		if (dev->manufacturer)
333			strlcat(pegasus->name, " ", sizeof(pegasus->name));
334		strlcat(pegasus->name, dev->product, sizeof(pegasus->name));
335	}
336
337	if (!strlen(pegasus->name))
338		snprintf(pegasus->name, sizeof(pegasus->name),
339			 "USB Pegasus Device %04x:%04x",
340			 le16_to_cpu(dev->descriptor.idVendor),
341			 le16_to_cpu(dev->descriptor.idProduct));
342
343	usb_make_path(dev, pegasus->phys, sizeof(pegasus->phys));
344	strlcat(pegasus->phys, "/input0", sizeof(pegasus->phys));
345
346	INIT_WORK(&pegasus->init, pegasus_init);
347
348	usb_set_intfdata(intf, pegasus);
349
350	input_dev->name = pegasus->name;
351	input_dev->phys = pegasus->phys;
352	usb_to_input_id(dev, &input_dev->id);
353	input_dev->dev.parent = &intf->dev;
354
355	input_set_drvdata(input_dev, pegasus);
356
357	input_dev->open = pegasus_open;
358	input_dev->close = pegasus_close;
359
360	__set_bit(EV_ABS, input_dev->evbit);
361	__set_bit(EV_KEY, input_dev->evbit);
362
363	__set_bit(ABS_X, input_dev->absbit);
364	__set_bit(ABS_Y, input_dev->absbit);
365
366	__set_bit(BTN_TOUCH, input_dev->keybit);
367	__set_bit(BTN_RIGHT, input_dev->keybit);
368	__set_bit(BTN_TOOL_PEN, input_dev->keybit);
369
370	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
371	__set_bit(INPUT_PROP_POINTER, input_dev->propbit);
372
373	input_set_abs_params(input_dev, ABS_X, -1500, 1500, 8, 0);
374	input_set_abs_params(input_dev, ABS_Y, 1600, 3000, 8, 0);
375
376	error = input_register_device(pegasus->dev);
377	if (error)
378		goto err_free_urb;
379
380	return 0;
381
382err_free_urb:
383	usb_free_urb(pegasus->irq);
384err_free_dma:
385	usb_free_coherent(dev, pegasus->data_len,
386			  pegasus->data, pegasus->data_dma);
387err_free_mem:
388	input_free_device(input_dev);
389	kfree(pegasus);
390	usb_set_intfdata(intf, NULL);
391
392	return error;
393}
394
395static void pegasus_disconnect(struct usb_interface *intf)
396{
397	struct pegasus *pegasus = usb_get_intfdata(intf);
398
399	input_unregister_device(pegasus->dev);
400
401	usb_free_urb(pegasus->irq);
402	usb_free_coherent(interface_to_usbdev(intf),
403			  pegasus->data_len, pegasus->data,
404			  pegasus->data_dma);
405
406	kfree(pegasus);
407	usb_set_intfdata(intf, NULL);
408}
409
410static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
411{
412	struct pegasus *pegasus = usb_get_intfdata(intf);
413
414	mutex_lock(&pegasus->pm_mutex);
415	usb_kill_urb(pegasus->irq);
416	cancel_work_sync(&pegasus->init);
417	mutex_unlock(&pegasus->pm_mutex);
418
419	return 0;
420}
421
422static int pegasus_resume(struct usb_interface *intf)
423{
424	struct pegasus *pegasus = usb_get_intfdata(intf);
425	int retval = 0;
426
427	mutex_lock(&pegasus->pm_mutex);
428	if (pegasus->is_open && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
429		retval = -EIO;
430	mutex_unlock(&pegasus->pm_mutex);
431
432	return retval;
433}
434
435static int pegasus_reset_resume(struct usb_interface *intf)
436{
437	struct pegasus *pegasus = usb_get_intfdata(intf);
438	int retval = 0;
439
440	mutex_lock(&pegasus->pm_mutex);
441	if (pegasus->is_open) {
442		retval = pegasus_set_mode(pegasus, PEN_MODE_XY,
443					  NOTETAKER_LED_MOUSE);
444		if (!retval && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
445			retval = -EIO;
446	}
447	mutex_unlock(&pegasus->pm_mutex);
448
449	return retval;
450}
451
452static const struct usb_device_id pegasus_ids[] = {
453	{ USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
454		     USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
455	{ }
456};
457MODULE_DEVICE_TABLE(usb, pegasus_ids);
458
459static struct usb_driver pegasus_driver = {
460	.name		= "pegasus_notetaker",
461	.probe		= pegasus_probe,
462	.disconnect	= pegasus_disconnect,
463	.suspend	= pegasus_suspend,
464	.resume		= pegasus_resume,
465	.reset_resume	= pegasus_reset_resume,
466	.id_table	= pegasus_ids,
467	.supports_autosuspend = 1,
468};
469
470module_usb_driver(pegasus_driver);
471
472MODULE_AUTHOR("Martin Kepplinger <martink@posteo.de>");
473MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
474MODULE_LICENSE("GPL");
475