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
73 struct 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
pegasus_control_msg(struct pegasus * pegasus,u8 * data,int len)91 static 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
pegasus_set_mode(struct pegasus * pegasus,u8 mode,u8 led)125 static 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
pegasus_parse_packet(struct pegasus * pegasus)132 static 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
pegasus_irq(struct urb * urb)175 static 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
pegasus_init(struct work_struct * work)206 static 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
__pegasus_open(struct pegasus * pegasus)217 static int __pegasus_open(struct pegasus *pegasus)
218 {
219 int error;
220
221 guard(mutex)(&pegasus->pm_mutex);
222
223 pegasus->irq->dev = pegasus->usbdev;
224 if (usb_submit_urb(pegasus->irq, GFP_KERNEL))
225 return -EIO;
226
227 error = pegasus_set_mode(pegasus, PEN_MODE_XY, NOTETAKER_LED_MOUSE);
228 if (error) {
229 usb_kill_urb(pegasus->irq);
230 cancel_work_sync(&pegasus->init);
231 return error;
232 }
233
234 pegasus->is_open = true;
235
236 return 0;
237 }
238
pegasus_open(struct input_dev * dev)239 static int pegasus_open(struct input_dev *dev)
240 {
241 struct pegasus *pegasus = input_get_drvdata(dev);
242 int error;
243
244 error = usb_autopm_get_interface(pegasus->intf);
245 if (error)
246 return error;
247
248 error = __pegasus_open(pegasus);
249 if (error) {
250 usb_autopm_put_interface(pegasus->intf);
251 return error;
252 }
253
254 return 0;
255 }
256
pegasus_close(struct input_dev * dev)257 static void pegasus_close(struct input_dev *dev)
258 {
259 struct pegasus *pegasus = input_get_drvdata(dev);
260
261 scoped_guard(mutex, &pegasus->pm_mutex) {
262 usb_kill_urb(pegasus->irq);
263 cancel_work_sync(&pegasus->init);
264
265 pegasus->is_open = false;
266 }
267
268 usb_autopm_put_interface(pegasus->intf);
269 }
270
pegasus_probe(struct usb_interface * intf,const struct usb_device_id * id)271 static int pegasus_probe(struct usb_interface *intf,
272 const struct usb_device_id *id)
273 {
274 struct usb_device *dev = interface_to_usbdev(intf);
275 struct usb_endpoint_descriptor *endpoint;
276 struct pegasus *pegasus;
277 struct input_dev *input_dev;
278 int error;
279 int pipe;
280
281 /* We control interface 0 */
282 if (intf->cur_altsetting->desc.bInterfaceNumber >= 1)
283 return -ENODEV;
284
285 /* Sanity check that the device has an endpoint */
286 if (intf->cur_altsetting->desc.bNumEndpoints < 1) {
287 dev_err(&intf->dev, "Invalid number of endpoints\n");
288 return -EINVAL;
289 }
290
291 endpoint = &intf->cur_altsetting->endpoint[0].desc;
292
293 pegasus = kzalloc(sizeof(*pegasus), GFP_KERNEL);
294 input_dev = input_allocate_device();
295 if (!pegasus || !input_dev) {
296 error = -ENOMEM;
297 goto err_free_mem;
298 }
299
300 mutex_init(&pegasus->pm_mutex);
301
302 pegasus->usbdev = dev;
303 pegasus->dev = input_dev;
304 pegasus->intf = intf;
305
306 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
307 /* Sanity check that pipe's type matches endpoint's type */
308 if (usb_pipe_type_check(dev, pipe)) {
309 error = -EINVAL;
310 goto err_free_mem;
311 }
312
313 pegasus->data_len = usb_maxpacket(dev, pipe);
314
315 pegasus->data = usb_alloc_coherent(dev, pegasus->data_len, GFP_KERNEL,
316 &pegasus->data_dma);
317 if (!pegasus->data) {
318 error = -ENOMEM;
319 goto err_free_mem;
320 }
321
322 pegasus->irq = usb_alloc_urb(0, GFP_KERNEL);
323 if (!pegasus->irq) {
324 error = -ENOMEM;
325 goto err_free_dma;
326 }
327
328 usb_fill_int_urb(pegasus->irq, dev, pipe,
329 pegasus->data, pegasus->data_len,
330 pegasus_irq, pegasus, endpoint->bInterval);
331
332 pegasus->irq->transfer_dma = pegasus->data_dma;
333 pegasus->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
334
335 if (dev->manufacturer)
336 strscpy(pegasus->name, dev->manufacturer,
337 sizeof(pegasus->name));
338
339 if (dev->product) {
340 if (dev->manufacturer)
341 strlcat(pegasus->name, " ", sizeof(pegasus->name));
342 strlcat(pegasus->name, dev->product, sizeof(pegasus->name));
343 }
344
345 if (!strlen(pegasus->name))
346 snprintf(pegasus->name, sizeof(pegasus->name),
347 "USB Pegasus Device %04x:%04x",
348 le16_to_cpu(dev->descriptor.idVendor),
349 le16_to_cpu(dev->descriptor.idProduct));
350
351 usb_make_path(dev, pegasus->phys, sizeof(pegasus->phys));
352 strlcat(pegasus->phys, "/input0", sizeof(pegasus->phys));
353
354 INIT_WORK(&pegasus->init, pegasus_init);
355
356 usb_set_intfdata(intf, pegasus);
357
358 input_dev->name = pegasus->name;
359 input_dev->phys = pegasus->phys;
360 usb_to_input_id(dev, &input_dev->id);
361 input_dev->dev.parent = &intf->dev;
362
363 input_set_drvdata(input_dev, pegasus);
364
365 input_dev->open = pegasus_open;
366 input_dev->close = pegasus_close;
367
368 __set_bit(EV_ABS, input_dev->evbit);
369 __set_bit(EV_KEY, input_dev->evbit);
370
371 __set_bit(ABS_X, input_dev->absbit);
372 __set_bit(ABS_Y, input_dev->absbit);
373
374 __set_bit(BTN_TOUCH, input_dev->keybit);
375 __set_bit(BTN_RIGHT, input_dev->keybit);
376 __set_bit(BTN_TOOL_PEN, input_dev->keybit);
377
378 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
379 __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
380
381 input_set_abs_params(input_dev, ABS_X, -1500, 1500, 8, 0);
382 input_set_abs_params(input_dev, ABS_Y, 1600, 3000, 8, 0);
383
384 error = input_register_device(pegasus->dev);
385 if (error)
386 goto err_free_urb;
387
388 return 0;
389
390 err_free_urb:
391 usb_free_urb(pegasus->irq);
392 err_free_dma:
393 usb_free_coherent(dev, pegasus->data_len,
394 pegasus->data, pegasus->data_dma);
395 err_free_mem:
396 input_free_device(input_dev);
397 kfree(pegasus);
398 usb_set_intfdata(intf, NULL);
399
400 return error;
401 }
402
pegasus_disconnect(struct usb_interface * intf)403 static void pegasus_disconnect(struct usb_interface *intf)
404 {
405 struct pegasus *pegasus = usb_get_intfdata(intf);
406
407 input_unregister_device(pegasus->dev);
408
409 usb_free_urb(pegasus->irq);
410 usb_free_coherent(interface_to_usbdev(intf),
411 pegasus->data_len, pegasus->data,
412 pegasus->data_dma);
413
414 kfree(pegasus);
415 usb_set_intfdata(intf, NULL);
416 }
417
pegasus_suspend(struct usb_interface * intf,pm_message_t message)418 static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
419 {
420 struct pegasus *pegasus = usb_get_intfdata(intf);
421
422 guard(mutex)(&pegasus->pm_mutex);
423
424 usb_kill_urb(pegasus->irq);
425 cancel_work_sync(&pegasus->init);
426
427 return 0;
428 }
429
pegasus_resume(struct usb_interface * intf)430 static int pegasus_resume(struct usb_interface *intf)
431 {
432 struct pegasus *pegasus = usb_get_intfdata(intf);
433
434 guard(mutex)(&pegasus->pm_mutex);
435
436 if (pegasus->is_open && usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
437 return -EIO;
438
439 return 0;
440 }
441
pegasus_reset_resume(struct usb_interface * intf)442 static int pegasus_reset_resume(struct usb_interface *intf)
443 {
444 struct pegasus *pegasus = usb_get_intfdata(intf);
445 int error;
446
447 guard(mutex)(&pegasus->pm_mutex);
448
449 if (pegasus->is_open) {
450 error = pegasus_set_mode(pegasus, PEN_MODE_XY,
451 NOTETAKER_LED_MOUSE);
452 if (error)
453 return error;
454
455 if (usb_submit_urb(pegasus->irq, GFP_NOIO) < 0)
456 return -EIO;
457 }
458
459 return 0;
460 }
461
462 static const struct usb_device_id pegasus_ids[] = {
463 { USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
464 USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
465 { }
466 };
467 MODULE_DEVICE_TABLE(usb, pegasus_ids);
468
469 static struct usb_driver pegasus_driver = {
470 .name = "pegasus_notetaker",
471 .probe = pegasus_probe,
472 .disconnect = pegasus_disconnect,
473 .suspend = pegasus_suspend,
474 .resume = pegasus_resume,
475 .reset_resume = pegasus_reset_resume,
476 .id_table = pegasus_ids,
477 .supports_autosuspend = 1,
478 };
479
480 module_usb_driver(pegasus_driver);
481
482 MODULE_AUTHOR("Martin Kepplinger <martink@posteo.de>");
483 MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
484 MODULE_LICENSE("GPL");
485