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 input_dev * dev)217 static 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
241 err_kill_urb:
242 usb_kill_urb(pegasus->irq);
243 cancel_work_sync(&pegasus->init);
244 err_autopm_put:
245 mutex_unlock(&pegasus->pm_mutex);
246 usb_autopm_put_interface(pegasus->intf);
247 return error;
248 }
249
pegasus_close(struct input_dev * dev)250 static 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
pegasus_probe(struct usb_interface * intf,const struct usb_device_id * id)263 static 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
382 err_free_urb:
383 usb_free_urb(pegasus->irq);
384 err_free_dma:
385 usb_free_coherent(dev, pegasus->data_len,
386 pegasus->data, pegasus->data_dma);
387 err_free_mem:
388 input_free_device(input_dev);
389 kfree(pegasus);
390 usb_set_intfdata(intf, NULL);
391
392 return error;
393 }
394
pegasus_disconnect(struct usb_interface * intf)395 static 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
pegasus_suspend(struct usb_interface * intf,pm_message_t message)410 static 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
pegasus_resume(struct usb_interface * intf)422 static 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
pegasus_reset_resume(struct usb_interface * intf)435 static 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
452 static const struct usb_device_id pegasus_ids[] = {
453 { USB_DEVICE(USB_VENDOR_ID_PEGASUSTECH,
454 USB_DEVICE_ID_PEGASUS_NOTETAKER_EN100) },
455 { }
456 };
457 MODULE_DEVICE_TABLE(usb, pegasus_ids);
458
459 static 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
470 module_usb_driver(pegasus_driver);
471
472 MODULE_AUTHOR("Martin Kepplinger <martink@posteo.de>");
473 MODULE_DESCRIPTION("Pegasus Mobile Notetaker Pen tablet driver");
474 MODULE_LICENSE("GPL");
475