Loading...
1/*
2 * Copyright (c) 2013 Andrew Duggan <aduggan@synaptics.com>
3 * Copyright (c) 2013 Synaptics Incorporated
4 * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@gmail.com>
5 * Copyright (c) 2014 Red Hat, Inc
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 */
12
13#include <linux/kernel.h>
14#include <linux/hid.h>
15#include <linux/input.h>
16#include <linux/input/mt.h>
17#include <linux/module.h>
18#include <linux/pm.h>
19#include <linux/slab.h>
20#include <linux/wait.h>
21#include <linux/sched.h>
22#include "hid-ids.h"
23
24#define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */
25#define RMI_WRITE_REPORT_ID 0x09 /* Output Report */
26#define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */
27#define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */
28#define RMI_ATTN_REPORT_ID 0x0c /* Input Report */
29#define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */
30
31/* flags */
32#define RMI_READ_REQUEST_PENDING 0
33#define RMI_READ_DATA_PENDING 1
34#define RMI_STARTED 2
35
36#define RMI_SLEEP_NORMAL 0x0
37#define RMI_SLEEP_DEEP_SLEEP 0x1
38
39/* device flags */
40#define RMI_DEVICE BIT(0)
41#define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1)
42
43/*
44 * retrieve the ctrl registers
45 * the ctrl register has a size of 20 but a fw bug split it into 16 + 4,
46 * and there is no way to know if the first 20 bytes are here or not.
47 * We use only the first 12 bytes, so get only them.
48 */
49#define RMI_F11_CTRL_REG_COUNT 12
50
51enum rmi_mode_type {
52 RMI_MODE_OFF = 0,
53 RMI_MODE_ATTN_REPORTS = 1,
54 RMI_MODE_NO_PACKED_ATTN_REPORTS = 2,
55};
56
57struct rmi_function {
58 unsigned page; /* page of the function */
59 u16 query_base_addr; /* base address for queries */
60 u16 command_base_addr; /* base address for commands */
61 u16 control_base_addr; /* base address for controls */
62 u16 data_base_addr; /* base address for datas */
63 unsigned int interrupt_base; /* cross-function interrupt number
64 * (uniq in the device)*/
65 unsigned int interrupt_count; /* number of interrupts */
66 unsigned int report_size; /* size of a report */
67 unsigned long irq_mask; /* mask of the interrupts
68 * (to be applied against ATTN IRQ) */
69};
70
71/**
72 * struct rmi_data - stores information for hid communication
73 *
74 * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
75 * @page: Keeps track of the current virtual page
76 *
77 * @wait: Used for waiting for read data
78 *
79 * @writeReport: output buffer when writing RMI registers
80 * @readReport: input buffer when reading RMI registers
81 *
82 * @input_report_size: size of an input report (advertised by HID)
83 * @output_report_size: size of an output report (advertised by HID)
84 *
85 * @flags: flags for the current device (started, reading, etc...)
86 *
87 * @f11: placeholder of internal RMI function F11 description
88 * @f30: placeholder of internal RMI function F30 description
89 *
90 * @max_fingers: maximum finger count reported by the device
91 * @max_x: maximum x value reported by the device
92 * @max_y: maximum y value reported by the device
93 *
94 * @gpio_led_count: count of GPIOs + LEDs reported by F30
95 * @button_count: actual physical buttons count
96 * @button_mask: button mask used to decode GPIO ATTN reports
97 * @button_state_mask: pull state of the buttons
98 *
99 * @input: pointer to the kernel input device
100 *
101 * @reset_work: worker which will be called in case of a mouse report
102 * @hdev: pointer to the struct hid_device
103 */
104struct rmi_data {
105 struct mutex page_mutex;
106 int page;
107
108 wait_queue_head_t wait;
109
110 u8 *writeReport;
111 u8 *readReport;
112
113 int input_report_size;
114 int output_report_size;
115
116 unsigned long flags;
117
118 struct rmi_function f01;
119 struct rmi_function f11;
120 struct rmi_function f30;
121
122 unsigned int max_fingers;
123 unsigned int max_x;
124 unsigned int max_y;
125 unsigned int x_size_mm;
126 unsigned int y_size_mm;
127 bool read_f11_ctrl_regs;
128 u8 f11_ctrl_regs[RMI_F11_CTRL_REG_COUNT];
129
130 unsigned int gpio_led_count;
131 unsigned int button_count;
132 unsigned long button_mask;
133 unsigned long button_state_mask;
134
135 struct input_dev *input;
136
137 struct work_struct reset_work;
138 struct hid_device *hdev;
139
140 unsigned long device_flags;
141 unsigned long firmware_id;
142
143 u8 f01_ctrl0;
144 u8 interrupt_enable_mask;
145 bool restore_interrupt_mask;
146};
147
148#define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
149
150static int rmi_write_report(struct hid_device *hdev, u8 *report, int len);
151
152/**
153 * rmi_set_page - Set RMI page
154 * @hdev: The pointer to the hid_device struct
155 * @page: The new page address.
156 *
157 * RMI devices have 16-bit addressing, but some of the physical
158 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
159 * a page address at 0xff of every page so we can reliable page addresses
160 * every 256 registers.
161 *
162 * The page_mutex lock must be held when this function is entered.
163 *
164 * Returns zero on success, non-zero on failure.
165 */
166static int rmi_set_page(struct hid_device *hdev, u8 page)
167{
168 struct rmi_data *data = hid_get_drvdata(hdev);
169 int retval;
170
171 data->writeReport[0] = RMI_WRITE_REPORT_ID;
172 data->writeReport[1] = 1;
173 data->writeReport[2] = 0xFF;
174 data->writeReport[4] = page;
175
176 retval = rmi_write_report(hdev, data->writeReport,
177 data->output_report_size);
178 if (retval != data->output_report_size) {
179 dev_err(&hdev->dev,
180 "%s: set page failed: %d.", __func__, retval);
181 return retval;
182 }
183
184 data->page = page;
185 return 0;
186}
187
188static int rmi_set_mode(struct hid_device *hdev, u8 mode)
189{
190 int ret;
191 u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
192
193 ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, txbuf,
194 sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
195 if (ret < 0) {
196 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode,
197 ret);
198 return ret;
199 }
200
201 return 0;
202}
203
204static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)
205{
206 int ret;
207
208 ret = hid_hw_output_report(hdev, (void *)report, len);
209 if (ret < 0) {
210 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret);
211 return ret;
212 }
213
214 return ret;
215}
216
217static int rmi_read_block(struct hid_device *hdev, u16 addr, void *buf,
218 const int len)
219{
220 struct rmi_data *data = hid_get_drvdata(hdev);
221 int ret;
222 int bytes_read;
223 int bytes_needed;
224 int retries;
225 int read_input_count;
226
227 mutex_lock(&data->page_mutex);
228
229 if (RMI_PAGE(addr) != data->page) {
230 ret = rmi_set_page(hdev, RMI_PAGE(addr));
231 if (ret < 0)
232 goto exit;
233 }
234
235 for (retries = 5; retries > 0; retries--) {
236 data->writeReport[0] = RMI_READ_ADDR_REPORT_ID;
237 data->writeReport[1] = 0; /* old 1 byte read count */
238 data->writeReport[2] = addr & 0xFF;
239 data->writeReport[3] = (addr >> 8) & 0xFF;
240 data->writeReport[4] = len & 0xFF;
241 data->writeReport[5] = (len >> 8) & 0xFF;
242
243 set_bit(RMI_READ_REQUEST_PENDING, &data->flags);
244
245 ret = rmi_write_report(hdev, data->writeReport,
246 data->output_report_size);
247 if (ret != data->output_report_size) {
248 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
249 dev_err(&hdev->dev,
250 "failed to write request output report (%d)\n",
251 ret);
252 goto exit;
253 }
254
255 bytes_read = 0;
256 bytes_needed = len;
257 while (bytes_read < len) {
258 if (!wait_event_timeout(data->wait,
259 test_bit(RMI_READ_DATA_PENDING, &data->flags),
260 msecs_to_jiffies(1000))) {
261 hid_warn(hdev, "%s: timeout elapsed\n",
262 __func__);
263 ret = -EAGAIN;
264 break;
265 }
266
267 read_input_count = data->readReport[1];
268 memcpy(buf + bytes_read, &data->readReport[2],
269 read_input_count < bytes_needed ?
270 read_input_count : bytes_needed);
271
272 bytes_read += read_input_count;
273 bytes_needed -= read_input_count;
274 clear_bit(RMI_READ_DATA_PENDING, &data->flags);
275 }
276
277 if (ret >= 0) {
278 ret = 0;
279 break;
280 }
281 }
282
283exit:
284 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
285 mutex_unlock(&data->page_mutex);
286 return ret;
287}
288
289static inline int rmi_read(struct hid_device *hdev, u16 addr, void *buf)
290{
291 return rmi_read_block(hdev, addr, buf, 1);
292}
293
294static int rmi_write_block(struct hid_device *hdev, u16 addr, void *buf,
295 const int len)
296{
297 struct rmi_data *data = hid_get_drvdata(hdev);
298 int ret;
299
300 mutex_lock(&data->page_mutex);
301
302 if (RMI_PAGE(addr) != data->page) {
303 ret = rmi_set_page(hdev, RMI_PAGE(addr));
304 if (ret < 0)
305 goto exit;
306 }
307
308 data->writeReport[0] = RMI_WRITE_REPORT_ID;
309 data->writeReport[1] = len;
310 data->writeReport[2] = addr & 0xFF;
311 data->writeReport[3] = (addr >> 8) & 0xFF;
312 memcpy(&data->writeReport[4], buf, len);
313
314 ret = rmi_write_report(hdev, data->writeReport,
315 data->output_report_size);
316 if (ret < 0) {
317 dev_err(&hdev->dev,
318 "failed to write request output report (%d)\n",
319 ret);
320 goto exit;
321 }
322 ret = 0;
323
324exit:
325 mutex_unlock(&data->page_mutex);
326 return ret;
327}
328
329static inline int rmi_write(struct hid_device *hdev, u16 addr, void *buf)
330{
331 return rmi_write_block(hdev, addr, buf, 1);
332}
333
334static void rmi_f11_process_touch(struct rmi_data *hdata, int slot,
335 u8 finger_state, u8 *touch_data)
336{
337 int x, y, wx, wy;
338 int wide, major, minor;
339 int z;
340
341 input_mt_slot(hdata->input, slot);
342 input_mt_report_slot_state(hdata->input, MT_TOOL_FINGER,
343 finger_state == 0x01);
344 if (finger_state == 0x01) {
345 x = (touch_data[0] << 4) | (touch_data[2] & 0x0F);
346 y = (touch_data[1] << 4) | (touch_data[2] >> 4);
347 wx = touch_data[3] & 0x0F;
348 wy = touch_data[3] >> 4;
349 wide = (wx > wy);
350 major = max(wx, wy);
351 minor = min(wx, wy);
352 z = touch_data[4];
353
354 /* y is inverted */
355 y = hdata->max_y - y;
356
357 input_event(hdata->input, EV_ABS, ABS_MT_POSITION_X, x);
358 input_event(hdata->input, EV_ABS, ABS_MT_POSITION_Y, y);
359 input_event(hdata->input, EV_ABS, ABS_MT_ORIENTATION, wide);
360 input_event(hdata->input, EV_ABS, ABS_MT_PRESSURE, z);
361 input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
362 input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
363 }
364}
365
366static int rmi_reset_attn_mode(struct hid_device *hdev)
367{
368 struct rmi_data *data = hid_get_drvdata(hdev);
369 int ret;
370
371 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
372 if (ret)
373 return ret;
374
375 if (data->restore_interrupt_mask) {
376 ret = rmi_write(hdev, data->f01.control_base_addr + 1,
377 &data->interrupt_enable_mask);
378 if (ret) {
379 hid_err(hdev, "can not write F01 control register\n");
380 return ret;
381 }
382 }
383
384 return 0;
385}
386
387static void rmi_reset_work(struct work_struct *work)
388{
389 struct rmi_data *hdata = container_of(work, struct rmi_data,
390 reset_work);
391
392 /* switch the device to RMI if we receive a generic mouse report */
393 rmi_reset_attn_mode(hdata->hdev);
394}
395
396static inline int rmi_schedule_reset(struct hid_device *hdev)
397{
398 struct rmi_data *hdata = hid_get_drvdata(hdev);
399 return schedule_work(&hdata->reset_work);
400}
401
402static int rmi_f11_input_event(struct hid_device *hdev, u8 irq, u8 *data,
403 int size)
404{
405 struct rmi_data *hdata = hid_get_drvdata(hdev);
406 int offset;
407 int i;
408
409 if (!(irq & hdata->f11.irq_mask) || size <= 0)
410 return 0;
411
412 offset = (hdata->max_fingers >> 2) + 1;
413 for (i = 0; i < hdata->max_fingers; i++) {
414 int fs_byte_position = i >> 2;
415 int fs_bit_position = (i & 0x3) << 1;
416 int finger_state = (data[fs_byte_position] >> fs_bit_position) &
417 0x03;
418 int position = offset + 5 * i;
419
420 if (position + 5 > size) {
421 /* partial report, go on with what we received */
422 printk_once(KERN_WARNING
423 "%s %s: Detected incomplete finger report. Finger reports may occasionally get dropped on this platform.\n",
424 dev_driver_string(&hdev->dev),
425 dev_name(&hdev->dev));
426 hid_dbg(hdev, "Incomplete finger report\n");
427 break;
428 }
429
430 rmi_f11_process_touch(hdata, i, finger_state, &data[position]);
431 }
432 input_mt_sync_frame(hdata->input);
433 input_sync(hdata->input);
434 return hdata->f11.report_size;
435}
436
437static int rmi_f30_input_event(struct hid_device *hdev, u8 irq, u8 *data,
438 int size)
439{
440 struct rmi_data *hdata = hid_get_drvdata(hdev);
441 int i;
442 int button = 0;
443 bool value;
444
445 if (!(irq & hdata->f30.irq_mask))
446 return 0;
447
448 if (size < (int)hdata->f30.report_size) {
449 hid_warn(hdev, "Click Button pressed, but the click data is missing\n");
450 return 0;
451 }
452
453 for (i = 0; i < hdata->gpio_led_count; i++) {
454 if (test_bit(i, &hdata->button_mask)) {
455 value = (data[i / 8] >> (i & 0x07)) & BIT(0);
456 if (test_bit(i, &hdata->button_state_mask))
457 value = !value;
458 input_event(hdata->input, EV_KEY, BTN_LEFT + button++,
459 value);
460 }
461 }
462 return hdata->f30.report_size;
463}
464
465static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
466{
467 struct rmi_data *hdata = hid_get_drvdata(hdev);
468 unsigned long irq_mask = 0;
469 unsigned index = 2;
470
471 if (!(test_bit(RMI_STARTED, &hdata->flags)))
472 return 0;
473
474 irq_mask |= hdata->f11.irq_mask;
475 irq_mask |= hdata->f30.irq_mask;
476
477 if (data[1] & ~irq_mask)
478 hid_dbg(hdev, "unknown intr source:%02lx %s:%d\n",
479 data[1] & ~irq_mask, __FILE__, __LINE__);
480
481 if (hdata->f11.interrupt_base < hdata->f30.interrupt_base) {
482 index += rmi_f11_input_event(hdev, data[1], &data[index],
483 size - index);
484 index += rmi_f30_input_event(hdev, data[1], &data[index],
485 size - index);
486 } else {
487 index += rmi_f30_input_event(hdev, data[1], &data[index],
488 size - index);
489 index += rmi_f11_input_event(hdev, data[1], &data[index],
490 size - index);
491 }
492
493 return 1;
494}
495
496static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size)
497{
498 struct rmi_data *hdata = hid_get_drvdata(hdev);
499
500 if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) {
501 hid_dbg(hdev, "no read request pending\n");
502 return 0;
503 }
504
505 memcpy(hdata->readReport, data, size < hdata->input_report_size ?
506 size : hdata->input_report_size);
507 set_bit(RMI_READ_DATA_PENDING, &hdata->flags);
508 wake_up(&hdata->wait);
509
510 return 1;
511}
512
513static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size)
514{
515 int valid_size = size;
516 /*
517 * On the Dell XPS 13 9333, the bus sometimes get confused and fills
518 * the report with a sentinel value "ff". Synaptics told us that such
519 * behavior does not comes from the touchpad itself, so we filter out
520 * such reports here.
521 */
522
523 while ((data[valid_size - 1] == 0xff) && valid_size > 0)
524 valid_size--;
525
526 return valid_size;
527}
528
529static int rmi_raw_event(struct hid_device *hdev,
530 struct hid_report *report, u8 *data, int size)
531{
532 size = rmi_check_sanity(hdev, data, size);
533 if (size < 2)
534 return 0;
535
536 switch (data[0]) {
537 case RMI_READ_DATA_REPORT_ID:
538 return rmi_read_data_event(hdev, data, size);
539 case RMI_ATTN_REPORT_ID:
540 return rmi_input_event(hdev, data, size);
541 default:
542 return 1;
543 }
544
545 return 0;
546}
547
548static int rmi_event(struct hid_device *hdev, struct hid_field *field,
549 struct hid_usage *usage, __s32 value)
550{
551 struct rmi_data *data = hid_get_drvdata(hdev);
552
553 if ((data->device_flags & RMI_DEVICE) &&
554 (field->application == HID_GD_POINTER ||
555 field->application == HID_GD_MOUSE)) {
556 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) {
557 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
558 return 0;
559
560 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
561 && !value)
562 return 1;
563 }
564
565 rmi_schedule_reset(hdev);
566 return 1;
567 }
568
569 return 0;
570}
571
572#ifdef CONFIG_PM
573static int rmi_set_sleep_mode(struct hid_device *hdev, int sleep_mode)
574{
575 struct rmi_data *data = hid_get_drvdata(hdev);
576 int ret;
577 u8 f01_ctrl0;
578
579 f01_ctrl0 = (data->f01_ctrl0 & ~0x3) | sleep_mode;
580
581 ret = rmi_write(hdev, data->f01.control_base_addr,
582 &f01_ctrl0);
583 if (ret) {
584 hid_err(hdev, "can not write sleep mode\n");
585 return ret;
586 }
587
588 return 0;
589}
590
591static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
592{
593 struct rmi_data *data = hid_get_drvdata(hdev);
594 int ret;
595 u8 buf[RMI_F11_CTRL_REG_COUNT];
596
597 if (!(data->device_flags & RMI_DEVICE))
598 return 0;
599
600 ret = rmi_read_block(hdev, data->f11.control_base_addr, buf,
601 RMI_F11_CTRL_REG_COUNT);
602 if (ret)
603 hid_warn(hdev, "can not read F11 control registers\n");
604 else
605 memcpy(data->f11_ctrl_regs, buf, RMI_F11_CTRL_REG_COUNT);
606
607
608 if (!device_may_wakeup(hdev->dev.parent))
609 return rmi_set_sleep_mode(hdev, RMI_SLEEP_DEEP_SLEEP);
610
611 return 0;
612}
613
614static int rmi_post_reset(struct hid_device *hdev)
615{
616 struct rmi_data *data = hid_get_drvdata(hdev);
617 int ret;
618
619 if (!(data->device_flags & RMI_DEVICE))
620 return 0;
621
622 ret = rmi_reset_attn_mode(hdev);
623 if (ret) {
624 hid_err(hdev, "can not set rmi mode\n");
625 return ret;
626 }
627
628 if (data->read_f11_ctrl_regs) {
629 ret = rmi_write_block(hdev, data->f11.control_base_addr,
630 data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT);
631 if (ret)
632 hid_warn(hdev,
633 "can not write F11 control registers after reset\n");
634 }
635
636 if (!device_may_wakeup(hdev->dev.parent)) {
637 ret = rmi_set_sleep_mode(hdev, RMI_SLEEP_NORMAL);
638 if (ret) {
639 hid_err(hdev, "can not write sleep mode\n");
640 return ret;
641 }
642 }
643
644 return ret;
645}
646
647static int rmi_post_resume(struct hid_device *hdev)
648{
649 struct rmi_data *data = hid_get_drvdata(hdev);
650
651 if (!(data->device_flags & RMI_DEVICE))
652 return 0;
653
654 return rmi_reset_attn_mode(hdev);
655}
656#endif /* CONFIG_PM */
657
658#define RMI4_MAX_PAGE 0xff
659#define RMI4_PAGE_SIZE 0x0100
660
661#define PDT_START_SCAN_LOCATION 0x00e9
662#define PDT_END_SCAN_LOCATION 0x0005
663#define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff)
664
665struct pdt_entry {
666 u8 query_base_addr:8;
667 u8 command_base_addr:8;
668 u8 control_base_addr:8;
669 u8 data_base_addr:8;
670 u8 interrupt_source_count:3;
671 u8 bits3and4:2;
672 u8 function_version:2;
673 u8 bit7:1;
674 u8 function_number:8;
675} __attribute__((__packed__));
676
677static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count)
678{
679 return GENMASK(irq_count + irq_base - 1, irq_base);
680}
681
682static void rmi_register_function(struct rmi_data *data,
683 struct pdt_entry *pdt_entry, int page, unsigned interrupt_count)
684{
685 struct rmi_function *f = NULL;
686 u16 page_base = page << 8;
687
688 switch (pdt_entry->function_number) {
689 case 0x01:
690 f = &data->f01;
691 break;
692 case 0x11:
693 f = &data->f11;
694 break;
695 case 0x30:
696 f = &data->f30;
697 break;
698 }
699
700 if (f) {
701 f->page = page;
702 f->query_base_addr = page_base | pdt_entry->query_base_addr;
703 f->command_base_addr = page_base | pdt_entry->command_base_addr;
704 f->control_base_addr = page_base | pdt_entry->control_base_addr;
705 f->data_base_addr = page_base | pdt_entry->data_base_addr;
706 f->interrupt_base = interrupt_count;
707 f->interrupt_count = pdt_entry->interrupt_source_count;
708 f->irq_mask = rmi_gen_mask(f->interrupt_base,
709 f->interrupt_count);
710 data->interrupt_enable_mask |= f->irq_mask;
711 }
712}
713
714static int rmi_scan_pdt(struct hid_device *hdev)
715{
716 struct rmi_data *data = hid_get_drvdata(hdev);
717 struct pdt_entry entry;
718 int page;
719 bool page_has_function;
720 int i;
721 int retval;
722 int interrupt = 0;
723 u16 page_start, pdt_start , pdt_end;
724
725 hid_info(hdev, "Scanning PDT...\n");
726
727 for (page = 0; (page <= RMI4_MAX_PAGE); page++) {
728 page_start = RMI4_PAGE_SIZE * page;
729 pdt_start = page_start + PDT_START_SCAN_LOCATION;
730 pdt_end = page_start + PDT_END_SCAN_LOCATION;
731
732 page_has_function = false;
733 for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) {
734 retval = rmi_read_block(hdev, i, &entry, sizeof(entry));
735 if (retval) {
736 hid_err(hdev,
737 "Read of PDT entry at %#06x failed.\n",
738 i);
739 goto error_exit;
740 }
741
742 if (RMI4_END_OF_PDT(entry.function_number))
743 break;
744
745 page_has_function = true;
746
747 hid_info(hdev, "Found F%02X on page %#04x\n",
748 entry.function_number, page);
749
750 rmi_register_function(data, &entry, page, interrupt);
751 interrupt += entry.interrupt_source_count;
752 }
753
754 if (!page_has_function)
755 break;
756 }
757
758 hid_info(hdev, "%s: Done with PDT scan.\n", __func__);
759 retval = 0;
760
761error_exit:
762 return retval;
763}
764
765#define RMI_DEVICE_F01_BASIC_QUERY_LEN 11
766
767static int rmi_populate_f01(struct hid_device *hdev)
768{
769 struct rmi_data *data = hid_get_drvdata(hdev);
770 u8 basic_queries[RMI_DEVICE_F01_BASIC_QUERY_LEN];
771 u8 info[3];
772 int ret;
773 bool has_query42;
774 bool has_lts;
775 bool has_sensor_id;
776 bool has_ds4_queries = false;
777 bool has_build_id_query = false;
778 bool has_package_id_query = false;
779 u16 query_offset = data->f01.query_base_addr;
780 u16 prod_info_addr;
781 u8 ds4_query_len;
782
783 ret = rmi_read_block(hdev, query_offset, basic_queries,
784 RMI_DEVICE_F01_BASIC_QUERY_LEN);
785 if (ret) {
786 hid_err(hdev, "Can not read basic queries from Function 0x1.\n");
787 return ret;
788 }
789
790 has_lts = !!(basic_queries[0] & BIT(2));
791 has_sensor_id = !!(basic_queries[1] & BIT(3));
792 has_query42 = !!(basic_queries[1] & BIT(7));
793
794 query_offset += 11;
795 prod_info_addr = query_offset + 6;
796 query_offset += 10;
797
798 if (has_lts)
799 query_offset += 20;
800
801 if (has_sensor_id)
802 query_offset++;
803
804 if (has_query42) {
805 ret = rmi_read(hdev, query_offset, info);
806 if (ret) {
807 hid_err(hdev, "Can not read query42.\n");
808 return ret;
809 }
810 has_ds4_queries = !!(info[0] & BIT(0));
811 query_offset++;
812 }
813
814 if (has_ds4_queries) {
815 ret = rmi_read(hdev, query_offset, &ds4_query_len);
816 if (ret) {
817 hid_err(hdev, "Can not read DS4 Query length.\n");
818 return ret;
819 }
820 query_offset++;
821
822 if (ds4_query_len > 0) {
823 ret = rmi_read(hdev, query_offset, info);
824 if (ret) {
825 hid_err(hdev, "Can not read DS4 query.\n");
826 return ret;
827 }
828
829 has_package_id_query = !!(info[0] & BIT(0));
830 has_build_id_query = !!(info[0] & BIT(1));
831 }
832 }
833
834 if (has_package_id_query)
835 prod_info_addr++;
836
837 if (has_build_id_query) {
838 ret = rmi_read_block(hdev, prod_info_addr, info, 3);
839 if (ret) {
840 hid_err(hdev, "Can not read product info.\n");
841 return ret;
842 }
843
844 data->firmware_id = info[1] << 8 | info[0];
845 data->firmware_id += info[2] * 65536;
846 }
847
848 ret = rmi_read_block(hdev, data->f01.control_base_addr, info,
849 2);
850
851 if (ret) {
852 hid_err(hdev, "can not read f01 ctrl registers\n");
853 return ret;
854 }
855
856 data->f01_ctrl0 = info[0];
857
858 if (!info[1]) {
859 /*
860 * Do to a firmware bug in some touchpads the F01 interrupt
861 * enable control register will be cleared on reset.
862 * This will stop the touchpad from reporting data, so
863 * if F01 CTRL1 is 0 then we need to explicitly enable
864 * interrupts for the functions we want data for.
865 */
866 data->restore_interrupt_mask = true;
867
868 ret = rmi_write(hdev, data->f01.control_base_addr + 1,
869 &data->interrupt_enable_mask);
870 if (ret) {
871 hid_err(hdev, "can not write to control reg 1: %d.\n",
872 ret);
873 return ret;
874 }
875 }
876
877 return 0;
878}
879
880static int rmi_populate_f11(struct hid_device *hdev)
881{
882 struct rmi_data *data = hid_get_drvdata(hdev);
883 u8 buf[20];
884 int ret;
885 bool has_query9;
886 bool has_query10 = false;
887 bool has_query11;
888 bool has_query12;
889 bool has_query27;
890 bool has_query28;
891 bool has_query36 = false;
892 bool has_physical_props;
893 bool has_gestures;
894 bool has_rel;
895 bool has_data40 = false;
896 bool has_dribble = false;
897 bool has_palm_detect = false;
898 unsigned x_size, y_size;
899 u16 query_offset;
900
901 if (!data->f11.query_base_addr) {
902 hid_err(hdev, "No 2D sensor found, giving up.\n");
903 return -ENODEV;
904 }
905
906 /* query 0 contains some useful information */
907 ret = rmi_read(hdev, data->f11.query_base_addr, buf);
908 if (ret) {
909 hid_err(hdev, "can not get query 0: %d.\n", ret);
910 return ret;
911 }
912 has_query9 = !!(buf[0] & BIT(3));
913 has_query11 = !!(buf[0] & BIT(4));
914 has_query12 = !!(buf[0] & BIT(5));
915 has_query27 = !!(buf[0] & BIT(6));
916 has_query28 = !!(buf[0] & BIT(7));
917
918 /* query 1 to get the max number of fingers */
919 ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf);
920 if (ret) {
921 hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret);
922 return ret;
923 }
924 data->max_fingers = (buf[0] & 0x07) + 1;
925 if (data->max_fingers > 5)
926 data->max_fingers = 10;
927
928 data->f11.report_size = data->max_fingers * 5 +
929 DIV_ROUND_UP(data->max_fingers, 4);
930
931 if (!(buf[0] & BIT(4))) {
932 hid_err(hdev, "No absolute events, giving up.\n");
933 return -ENODEV;
934 }
935
936 has_rel = !!(buf[0] & BIT(3));
937 has_gestures = !!(buf[0] & BIT(5));
938
939 ret = rmi_read(hdev, data->f11.query_base_addr + 5, buf);
940 if (ret) {
941 hid_err(hdev, "can not get absolute data sources: %d.\n", ret);
942 return ret;
943 }
944
945 has_dribble = !!(buf[0] & BIT(4));
946
947 /*
948 * At least 4 queries are guaranteed to be present in F11
949 * +1 for query 5 which is present since absolute events are
950 * reported and +1 for query 12.
951 */
952 query_offset = 6;
953
954 if (has_rel)
955 ++query_offset; /* query 6 is present */
956
957 if (has_gestures) {
958 /* query 8 to find out if query 10 exists */
959 ret = rmi_read(hdev,
960 data->f11.query_base_addr + query_offset + 1, buf);
961 if (ret) {
962 hid_err(hdev, "can not read gesture information: %d.\n",
963 ret);
964 return ret;
965 }
966 has_palm_detect = !!(buf[0] & BIT(0));
967 has_query10 = !!(buf[0] & BIT(2));
968
969 query_offset += 2; /* query 7 and 8 are present */
970 }
971
972 if (has_query9)
973 ++query_offset;
974
975 if (has_query10)
976 ++query_offset;
977
978 if (has_query11)
979 ++query_offset;
980
981 /* query 12 to know if the physical properties are reported */
982 if (has_query12) {
983 ret = rmi_read(hdev, data->f11.query_base_addr
984 + query_offset, buf);
985 if (ret) {
986 hid_err(hdev, "can not get query 12: %d.\n", ret);
987 return ret;
988 }
989 has_physical_props = !!(buf[0] & BIT(5));
990
991 if (has_physical_props) {
992 query_offset += 1;
993 ret = rmi_read_block(hdev,
994 data->f11.query_base_addr
995 + query_offset, buf, 4);
996 if (ret) {
997 hid_err(hdev, "can not read query 15-18: %d.\n",
998 ret);
999 return ret;
1000 }
1001
1002 x_size = buf[0] | (buf[1] << 8);
1003 y_size = buf[2] | (buf[3] << 8);
1004
1005 data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10);
1006 data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10);
1007
1008 hid_info(hdev, "%s: size in mm: %d x %d\n",
1009 __func__, data->x_size_mm, data->y_size_mm);
1010
1011 /*
1012 * query 15 - 18 contain the size of the sensor
1013 * and query 19 - 26 contain bezel dimensions
1014 */
1015 query_offset += 12;
1016 }
1017 }
1018
1019 if (has_query27)
1020 ++query_offset;
1021
1022 if (has_query28) {
1023 ret = rmi_read(hdev, data->f11.query_base_addr
1024 + query_offset, buf);
1025 if (ret) {
1026 hid_err(hdev, "can not get query 28: %d.\n", ret);
1027 return ret;
1028 }
1029
1030 has_query36 = !!(buf[0] & BIT(6));
1031 }
1032
1033 if (has_query36) {
1034 query_offset += 2;
1035 ret = rmi_read(hdev, data->f11.query_base_addr
1036 + query_offset, buf);
1037 if (ret) {
1038 hid_err(hdev, "can not get query 36: %d.\n", ret);
1039 return ret;
1040 }
1041
1042 has_data40 = !!(buf[0] & BIT(5));
1043 }
1044
1045
1046 if (has_data40)
1047 data->f11.report_size += data->max_fingers * 2;
1048
1049 ret = rmi_read_block(hdev, data->f11.control_base_addr,
1050 data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT);
1051 if (ret) {
1052 hid_err(hdev, "can not read ctrl block of size 11: %d.\n", ret);
1053 return ret;
1054 }
1055
1056 /* data->f11_ctrl_regs now contains valid register data */
1057 data->read_f11_ctrl_regs = true;
1058
1059 data->max_x = data->f11_ctrl_regs[6] | (data->f11_ctrl_regs[7] << 8);
1060 data->max_y = data->f11_ctrl_regs[8] | (data->f11_ctrl_regs[9] << 8);
1061
1062 if (has_dribble) {
1063 data->f11_ctrl_regs[0] = data->f11_ctrl_regs[0] & ~BIT(6);
1064 ret = rmi_write(hdev, data->f11.control_base_addr,
1065 data->f11_ctrl_regs);
1066 if (ret) {
1067 hid_err(hdev, "can not write to control reg 0: %d.\n",
1068 ret);
1069 return ret;
1070 }
1071 }
1072
1073 if (has_palm_detect) {
1074 data->f11_ctrl_regs[11] = data->f11_ctrl_regs[11] & ~BIT(0);
1075 ret = rmi_write(hdev, data->f11.control_base_addr + 11,
1076 &data->f11_ctrl_regs[11]);
1077 if (ret) {
1078 hid_err(hdev, "can not write to control reg 11: %d.\n",
1079 ret);
1080 return ret;
1081 }
1082 }
1083
1084 return 0;
1085}
1086
1087static int rmi_populate_f30(struct hid_device *hdev)
1088{
1089 struct rmi_data *data = hid_get_drvdata(hdev);
1090 u8 buf[20];
1091 int ret;
1092 bool has_gpio, has_led;
1093 unsigned bytes_per_ctrl;
1094 u8 ctrl2_addr;
1095 int ctrl2_3_length;
1096 int i;
1097
1098 /* function F30 is for physical buttons */
1099 if (!data->f30.query_base_addr) {
1100 hid_err(hdev, "No GPIO/LEDs found, giving up.\n");
1101 return -ENODEV;
1102 }
1103
1104 ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2);
1105 if (ret) {
1106 hid_err(hdev, "can not get F30 query registers: %d.\n", ret);
1107 return ret;
1108 }
1109
1110 has_gpio = !!(buf[0] & BIT(3));
1111 has_led = !!(buf[0] & BIT(2));
1112 data->gpio_led_count = buf[1] & 0x1f;
1113
1114 /* retrieve ctrl 2 & 3 registers */
1115 bytes_per_ctrl = (data->gpio_led_count + 7) / 8;
1116 /* Ctrl0 is present only if both has_gpio and has_led are set*/
1117 ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0;
1118 /* Ctrl1 is always be present */
1119 ctrl2_addr += bytes_per_ctrl;
1120 ctrl2_3_length = 2 * bytes_per_ctrl;
1121
1122 data->f30.report_size = bytes_per_ctrl;
1123
1124 ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr,
1125 buf, ctrl2_3_length);
1126 if (ret) {
1127 hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n",
1128 ctrl2_3_length, ret);
1129 return ret;
1130 }
1131
1132 for (i = 0; i < data->gpio_led_count; i++) {
1133 int byte_position = i >> 3;
1134 int bit_position = i & 0x07;
1135 u8 dir_byte = buf[byte_position];
1136 u8 data_byte = buf[byte_position + bytes_per_ctrl];
1137 bool dir = (dir_byte >> bit_position) & BIT(0);
1138 bool dat = (data_byte >> bit_position) & BIT(0);
1139
1140 if (dir == 0) {
1141 /* input mode */
1142 if (dat) {
1143 /* actual buttons have pull up resistor */
1144 data->button_count++;
1145 set_bit(i, &data->button_mask);
1146 set_bit(i, &data->button_state_mask);
1147 }
1148 }
1149
1150 }
1151
1152 return 0;
1153}
1154
1155static int rmi_populate(struct hid_device *hdev)
1156{
1157 struct rmi_data *data = hid_get_drvdata(hdev);
1158 int ret;
1159
1160 ret = rmi_scan_pdt(hdev);
1161 if (ret) {
1162 hid_err(hdev, "PDT scan failed with code %d.\n", ret);
1163 return ret;
1164 }
1165
1166 ret = rmi_populate_f01(hdev);
1167 if (ret) {
1168 hid_err(hdev, "Error while initializing F01 (%d).\n", ret);
1169 return ret;
1170 }
1171
1172 ret = rmi_populate_f11(hdev);
1173 if (ret) {
1174 hid_err(hdev, "Error while initializing F11 (%d).\n", ret);
1175 return ret;
1176 }
1177
1178 if (!(data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)) {
1179 ret = rmi_populate_f30(hdev);
1180 if (ret)
1181 hid_warn(hdev, "Error while initializing F30 (%d).\n", ret);
1182 }
1183
1184 return 0;
1185}
1186
1187static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
1188{
1189 struct rmi_data *data = hid_get_drvdata(hdev);
1190 struct input_dev *input = hi->input;
1191 int ret;
1192 int res_x, res_y, i;
1193
1194 data->input = input;
1195
1196 hid_dbg(hdev, "Opening low level driver\n");
1197 ret = hid_hw_open(hdev);
1198 if (ret)
1199 return ret;
1200
1201 if (!(data->device_flags & RMI_DEVICE))
1202 return 0;
1203
1204 /* Allow incoming hid reports */
1205 hid_device_io_start(hdev);
1206
1207 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
1208 if (ret < 0) {
1209 dev_err(&hdev->dev, "failed to set rmi mode\n");
1210 goto exit;
1211 }
1212
1213 ret = rmi_set_page(hdev, 0);
1214 if (ret < 0) {
1215 dev_err(&hdev->dev, "failed to set page select to 0.\n");
1216 goto exit;
1217 }
1218
1219 ret = rmi_populate(hdev);
1220 if (ret)
1221 goto exit;
1222
1223 hid_info(hdev, "firmware id: %ld\n", data->firmware_id);
1224
1225 __set_bit(EV_ABS, input->evbit);
1226 input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0);
1227 input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0);
1228
1229 if (data->x_size_mm && data->y_size_mm) {
1230 res_x = (data->max_x - 1) / data->x_size_mm;
1231 res_y = (data->max_y - 1) / data->y_size_mm;
1232
1233 input_abs_set_res(input, ABS_MT_POSITION_X, res_x);
1234 input_abs_set_res(input, ABS_MT_POSITION_Y, res_y);
1235 }
1236
1237 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0);
1238 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0);
1239 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0);
1240 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0);
1241
1242 ret = input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER);
1243 if (ret < 0)
1244 goto exit;
1245
1246 if (data->button_count) {
1247 __set_bit(EV_KEY, input->evbit);
1248 for (i = 0; i < data->button_count; i++)
1249 __set_bit(BTN_LEFT + i, input->keybit);
1250
1251 if (data->button_count == 1)
1252 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
1253 }
1254
1255 set_bit(RMI_STARTED, &data->flags);
1256
1257exit:
1258 hid_device_io_stop(hdev);
1259 hid_hw_close(hdev);
1260 return ret;
1261}
1262
1263static int rmi_input_mapping(struct hid_device *hdev,
1264 struct hid_input *hi, struct hid_field *field,
1265 struct hid_usage *usage, unsigned long **bit, int *max)
1266{
1267 struct rmi_data *data = hid_get_drvdata(hdev);
1268
1269 /*
1270 * we want to make HID ignore the advertised HID collection
1271 * for RMI deivces
1272 */
1273 if (data->device_flags & RMI_DEVICE) {
1274 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) &&
1275 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
1276 return 0;
1277
1278 return -1;
1279 }
1280
1281 return 0;
1282}
1283
1284static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
1285 unsigned id, struct hid_report **report)
1286{
1287 int i;
1288
1289 *report = hdev->report_enum[type].report_id_hash[id];
1290 if (*report) {
1291 for (i = 0; i < (*report)->maxfield; i++) {
1292 unsigned app = (*report)->field[i]->application;
1293 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR)
1294 return 1;
1295 }
1296 }
1297
1298 return 0;
1299}
1300
1301static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
1302{
1303 struct rmi_data *data = NULL;
1304 int ret;
1305 size_t alloc_size;
1306 struct hid_report *input_report;
1307 struct hid_report *output_report;
1308 struct hid_report *feature_report;
1309
1310 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
1311 if (!data)
1312 return -ENOMEM;
1313
1314 INIT_WORK(&data->reset_work, rmi_reset_work);
1315 data->hdev = hdev;
1316
1317 hid_set_drvdata(hdev, data);
1318
1319 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1320
1321 ret = hid_parse(hdev);
1322 if (ret) {
1323 hid_err(hdev, "parse failed\n");
1324 return ret;
1325 }
1326
1327 if (id->driver_data)
1328 data->device_flags = id->driver_data;
1329
1330 /*
1331 * Check for the RMI specific report ids. If they are misisng
1332 * simply return and let the events be processed by hid-input
1333 */
1334 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT,
1335 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) {
1336 hid_dbg(hdev, "device does not have set mode feature report\n");
1337 goto start;
1338 }
1339
1340 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT,
1341 RMI_ATTN_REPORT_ID, &input_report)) {
1342 hid_dbg(hdev, "device does not have attention input report\n");
1343 goto start;
1344 }
1345
1346 data->input_report_size = hid_report_len(input_report);
1347
1348 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT,
1349 RMI_WRITE_REPORT_ID, &output_report)) {
1350 hid_dbg(hdev,
1351 "device does not have rmi write output report\n");
1352 goto start;
1353 }
1354
1355 data->output_report_size = hid_report_len(output_report);
1356
1357 data->device_flags |= RMI_DEVICE;
1358 alloc_size = data->output_report_size + data->input_report_size;
1359
1360 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
1361 if (!data->writeReport) {
1362 ret = -ENOMEM;
1363 return ret;
1364 }
1365
1366 data->readReport = data->writeReport + data->output_report_size;
1367
1368 init_waitqueue_head(&data->wait);
1369
1370 mutex_init(&data->page_mutex);
1371
1372start:
1373 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1374 if (ret) {
1375 hid_err(hdev, "hw start failed\n");
1376 return ret;
1377 }
1378
1379 if ((data->device_flags & RMI_DEVICE) &&
1380 !test_bit(RMI_STARTED, &data->flags))
1381 /*
1382 * The device maybe in the bootloader if rmi_input_configured
1383 * failed to find F11 in the PDT. Print an error, but don't
1384 * return an error from rmi_probe so that hidraw will be
1385 * accessible from userspace. That way a userspace tool
1386 * can be used to reload working firmware on the touchpad.
1387 */
1388 hid_err(hdev, "Device failed to be properly configured\n");
1389
1390 return 0;
1391}
1392
1393static void rmi_remove(struct hid_device *hdev)
1394{
1395 struct rmi_data *hdata = hid_get_drvdata(hdev);
1396
1397 clear_bit(RMI_STARTED, &hdata->flags);
1398
1399 hid_hw_stop(hdev);
1400}
1401
1402static const struct hid_device_id rmi_id[] = {
1403 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
1404 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
1405 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
1406 { }
1407};
1408MODULE_DEVICE_TABLE(hid, rmi_id);
1409
1410static struct hid_driver rmi_driver = {
1411 .name = "hid-rmi",
1412 .id_table = rmi_id,
1413 .probe = rmi_probe,
1414 .remove = rmi_remove,
1415 .event = rmi_event,
1416 .raw_event = rmi_raw_event,
1417 .input_mapping = rmi_input_mapping,
1418 .input_configured = rmi_input_configured,
1419#ifdef CONFIG_PM
1420 .suspend = rmi_suspend,
1421 .resume = rmi_post_resume,
1422 .reset_resume = rmi_post_reset,
1423#endif
1424};
1425
1426module_hid_driver(rmi_driver);
1427
1428MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
1429MODULE_DESCRIPTION("RMI HID driver");
1430MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) 2013 Andrew Duggan <aduggan@synaptics.com>
4 * Copyright (c) 2013 Synaptics Incorporated
5 * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@gmail.com>
6 * Copyright (c) 2014 Red Hat, Inc
7 */
8
9#include <linux/kernel.h>
10#include <linux/hid.h>
11#include <linux/input.h>
12#include <linux/input/mt.h>
13#include <linux/irq.h>
14#include <linux/irqdomain.h>
15#include <linux/module.h>
16#include <linux/pm.h>
17#include <linux/slab.h>
18#include <linux/wait.h>
19#include <linux/sched.h>
20#include <linux/rmi.h>
21#include "hid-ids.h"
22
23#define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */
24#define RMI_WRITE_REPORT_ID 0x09 /* Output Report */
25#define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */
26#define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */
27#define RMI_ATTN_REPORT_ID 0x0c /* Input Report */
28#define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */
29
30/* flags */
31#define RMI_READ_REQUEST_PENDING 0
32#define RMI_READ_DATA_PENDING 1
33#define RMI_STARTED 2
34
35/* device flags */
36#define RMI_DEVICE BIT(0)
37#define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1)
38#define RMI_DEVICE_OUTPUT_SET_REPORT BIT(2)
39
40/*
41 * retrieve the ctrl registers
42 * the ctrl register has a size of 20 but a fw bug split it into 16 + 4,
43 * and there is no way to know if the first 20 bytes are here or not.
44 * We use only the first 12 bytes, so get only them.
45 */
46#define RMI_F11_CTRL_REG_COUNT 12
47
48enum rmi_mode_type {
49 RMI_MODE_OFF = 0,
50 RMI_MODE_ATTN_REPORTS = 1,
51 RMI_MODE_NO_PACKED_ATTN_REPORTS = 2,
52};
53
54/**
55 * struct rmi_data - stores information for hid communication
56 *
57 * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
58 * @page: Keeps track of the current virtual page
59 * @xport: transport device to be registered with the RMI4 core.
60 *
61 * @wait: Used for waiting for read data
62 *
63 * @writeReport: output buffer when writing RMI registers
64 * @readReport: input buffer when reading RMI registers
65 *
66 * @input_report_size: size of an input report (advertised by HID)
67 * @output_report_size: size of an output report (advertised by HID)
68 *
69 * @flags: flags for the current device (started, reading, etc...)
70 *
71 * @reset_work: worker which will be called in case of a mouse report
72 * @hdev: pointer to the struct hid_device
73 *
74 * @device_flags: flags which describe the device
75 *
76 * @domain: the IRQ domain allocated for this RMI4 device
77 * @rmi_irq: the irq that will be used to generate events to rmi-core
78 */
79struct rmi_data {
80 struct mutex page_mutex;
81 int page;
82 struct rmi_transport_dev xport;
83
84 wait_queue_head_t wait;
85
86 u8 *writeReport;
87 u8 *readReport;
88
89 u32 input_report_size;
90 u32 output_report_size;
91
92 unsigned long flags;
93
94 struct work_struct reset_work;
95 struct hid_device *hdev;
96
97 unsigned long device_flags;
98
99 struct irq_domain *domain;
100 int rmi_irq;
101};
102
103#define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
104
105static int rmi_write_report(struct hid_device *hdev, u8 *report, int len);
106
107/**
108 * rmi_set_page - Set RMI page
109 * @hdev: The pointer to the hid_device struct
110 * @page: The new page address.
111 *
112 * RMI devices have 16-bit addressing, but some of the physical
113 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
114 * a page address at 0xff of every page so we can reliable page addresses
115 * every 256 registers.
116 *
117 * The page_mutex lock must be held when this function is entered.
118 *
119 * Returns zero on success, non-zero on failure.
120 */
121static int rmi_set_page(struct hid_device *hdev, u8 page)
122{
123 struct rmi_data *data = hid_get_drvdata(hdev);
124 int retval;
125
126 data->writeReport[0] = RMI_WRITE_REPORT_ID;
127 data->writeReport[1] = 1;
128 data->writeReport[2] = 0xFF;
129 data->writeReport[4] = page;
130
131 retval = rmi_write_report(hdev, data->writeReport,
132 data->output_report_size);
133 if (retval != data->output_report_size) {
134 dev_err(&hdev->dev,
135 "%s: set page failed: %d.", __func__, retval);
136 return retval;
137 }
138
139 data->page = page;
140 return 0;
141}
142
143static int rmi_set_mode(struct hid_device *hdev, u8 mode)
144{
145 int ret;
146 const u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
147 u8 *buf;
148
149 buf = kmemdup(txbuf, sizeof(txbuf), GFP_KERNEL);
150 if (!buf)
151 return -ENOMEM;
152
153 ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, buf,
154 sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
155 kfree(buf);
156 if (ret < 0) {
157 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode,
158 ret);
159 return ret;
160 }
161
162 return 0;
163}
164
165static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)
166{
167 struct rmi_data *data = hid_get_drvdata(hdev);
168 int ret;
169
170 if (data->device_flags & RMI_DEVICE_OUTPUT_SET_REPORT) {
171 /*
172 * Talk to device by using SET_REPORT requests instead.
173 */
174 ret = hid_hw_raw_request(hdev, report[0], report,
175 len, HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
176 } else {
177 ret = hid_hw_output_report(hdev, (void *)report, len);
178 }
179
180 if (ret < 0) {
181 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret);
182 return ret;
183 }
184
185 return ret;
186}
187
188static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr,
189 void *buf, size_t len)
190{
191 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
192 struct hid_device *hdev = data->hdev;
193 int ret;
194 int bytes_read;
195 int bytes_needed;
196 int retries;
197 int read_input_count;
198
199 mutex_lock(&data->page_mutex);
200
201 if (RMI_PAGE(addr) != data->page) {
202 ret = rmi_set_page(hdev, RMI_PAGE(addr));
203 if (ret < 0)
204 goto exit;
205 }
206
207 for (retries = 5; retries > 0; retries--) {
208 data->writeReport[0] = RMI_READ_ADDR_REPORT_ID;
209 data->writeReport[1] = 0; /* old 1 byte read count */
210 data->writeReport[2] = addr & 0xFF;
211 data->writeReport[3] = (addr >> 8) & 0xFF;
212 data->writeReport[4] = len & 0xFF;
213 data->writeReport[5] = (len >> 8) & 0xFF;
214
215 set_bit(RMI_READ_REQUEST_PENDING, &data->flags);
216
217 ret = rmi_write_report(hdev, data->writeReport,
218 data->output_report_size);
219 if (ret != data->output_report_size) {
220 dev_err(&hdev->dev,
221 "failed to write request output report (%d)\n",
222 ret);
223 goto exit;
224 }
225
226 bytes_read = 0;
227 bytes_needed = len;
228 while (bytes_read < len) {
229 if (!wait_event_timeout(data->wait,
230 test_bit(RMI_READ_DATA_PENDING, &data->flags),
231 msecs_to_jiffies(1000))) {
232 hid_warn(hdev, "%s: timeout elapsed\n",
233 __func__);
234 ret = -EAGAIN;
235 break;
236 }
237
238 read_input_count = data->readReport[1];
239 memcpy(buf + bytes_read, &data->readReport[2],
240 min(read_input_count, bytes_needed));
241
242 bytes_read += read_input_count;
243 bytes_needed -= read_input_count;
244 clear_bit(RMI_READ_DATA_PENDING, &data->flags);
245 }
246
247 if (ret >= 0) {
248 ret = 0;
249 break;
250 }
251 }
252
253exit:
254 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
255 mutex_unlock(&data->page_mutex);
256 return ret;
257}
258
259static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr,
260 const void *buf, size_t len)
261{
262 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
263 struct hid_device *hdev = data->hdev;
264 int ret;
265
266 mutex_lock(&data->page_mutex);
267
268 if (RMI_PAGE(addr) != data->page) {
269 ret = rmi_set_page(hdev, RMI_PAGE(addr));
270 if (ret < 0)
271 goto exit;
272 }
273
274 data->writeReport[0] = RMI_WRITE_REPORT_ID;
275 data->writeReport[1] = len;
276 data->writeReport[2] = addr & 0xFF;
277 data->writeReport[3] = (addr >> 8) & 0xFF;
278 memcpy(&data->writeReport[4], buf, len);
279
280 ret = rmi_write_report(hdev, data->writeReport,
281 data->output_report_size);
282 if (ret < 0) {
283 dev_err(&hdev->dev,
284 "failed to write request output report (%d)\n",
285 ret);
286 goto exit;
287 }
288 ret = 0;
289
290exit:
291 mutex_unlock(&data->page_mutex);
292 return ret;
293}
294
295static int rmi_reset_attn_mode(struct hid_device *hdev)
296{
297 struct rmi_data *data = hid_get_drvdata(hdev);
298 struct rmi_device *rmi_dev = data->xport.rmi_dev;
299 int ret;
300
301 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
302 if (ret)
303 return ret;
304
305 if (test_bit(RMI_STARTED, &data->flags))
306 ret = rmi_dev->driver->reset_handler(rmi_dev);
307
308 return ret;
309}
310
311static void rmi_reset_work(struct work_struct *work)
312{
313 struct rmi_data *hdata = container_of(work, struct rmi_data,
314 reset_work);
315
316 /* switch the device to RMI if we receive a generic mouse report */
317 rmi_reset_attn_mode(hdata->hdev);
318}
319
320static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
321{
322 struct rmi_data *hdata = hid_get_drvdata(hdev);
323 struct rmi_device *rmi_dev = hdata->xport.rmi_dev;
324 unsigned long flags;
325
326 if (!(test_bit(RMI_STARTED, &hdata->flags)))
327 return 0;
328
329 pm_wakeup_event(hdev->dev.parent, 0);
330
331 local_irq_save(flags);
332
333 rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2);
334
335 generic_handle_irq(hdata->rmi_irq);
336
337 local_irq_restore(flags);
338
339 return 1;
340}
341
342static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size)
343{
344 struct rmi_data *hdata = hid_get_drvdata(hdev);
345
346 if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) {
347 hid_dbg(hdev, "no read request pending\n");
348 return 0;
349 }
350
351 memcpy(hdata->readReport, data, min((u32)size, hdata->input_report_size));
352 set_bit(RMI_READ_DATA_PENDING, &hdata->flags);
353 wake_up(&hdata->wait);
354
355 return 1;
356}
357
358static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size)
359{
360 int valid_size = size;
361 /*
362 * On the Dell XPS 13 9333, the bus sometimes get confused and fills
363 * the report with a sentinel value "ff". Synaptics told us that such
364 * behavior does not comes from the touchpad itself, so we filter out
365 * such reports here.
366 */
367
368 while ((data[valid_size - 1] == 0xff) && valid_size > 0)
369 valid_size--;
370
371 return valid_size;
372}
373
374static int rmi_raw_event(struct hid_device *hdev,
375 struct hid_report *report, u8 *data, int size)
376{
377 struct rmi_data *hdata = hid_get_drvdata(hdev);
378
379 if (!(hdata->device_flags & RMI_DEVICE))
380 return 0;
381
382 size = rmi_check_sanity(hdev, data, size);
383 if (size < 2)
384 return 0;
385
386 switch (data[0]) {
387 case RMI_READ_DATA_REPORT_ID:
388 return rmi_read_data_event(hdev, data, size);
389 case RMI_ATTN_REPORT_ID:
390 return rmi_input_event(hdev, data, size);
391 default:
392 return 1;
393 }
394
395 return 0;
396}
397
398static int rmi_event(struct hid_device *hdev, struct hid_field *field,
399 struct hid_usage *usage, __s32 value)
400{
401 struct rmi_data *data = hid_get_drvdata(hdev);
402
403 if ((data->device_flags & RMI_DEVICE) &&
404 (field->application == HID_GD_POINTER ||
405 field->application == HID_GD_MOUSE)) {
406 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) {
407 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
408 return 0;
409
410 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
411 && !value)
412 return 1;
413 }
414
415 schedule_work(&data->reset_work);
416 return 1;
417 }
418
419 return 0;
420}
421
422static void rmi_report(struct hid_device *hid, struct hid_report *report)
423{
424 struct hid_field *field = report->field[0];
425
426 if (!(hid->claimed & HID_CLAIMED_INPUT))
427 return;
428
429 switch (report->id) {
430 case RMI_READ_DATA_REPORT_ID:
431 case RMI_ATTN_REPORT_ID:
432 return;
433 }
434
435 if (field && field->hidinput && field->hidinput->input)
436 input_sync(field->hidinput->input);
437}
438
439static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
440{
441 struct rmi_data *data = hid_get_drvdata(hdev);
442 struct rmi_device *rmi_dev = data->xport.rmi_dev;
443 int ret;
444
445 if (!(data->device_flags & RMI_DEVICE))
446 return 0;
447
448 ret = rmi_driver_suspend(rmi_dev, false);
449 if (ret) {
450 hid_warn(hdev, "Failed to suspend device: %d\n", ret);
451 return ret;
452 }
453
454 return 0;
455}
456
457static int rmi_post_resume(struct hid_device *hdev)
458{
459 struct rmi_data *data = hid_get_drvdata(hdev);
460 struct rmi_device *rmi_dev = data->xport.rmi_dev;
461 int ret;
462
463 if (!(data->device_flags & RMI_DEVICE))
464 return 0;
465
466 /* Make sure the HID device is ready to receive events */
467 ret = hid_hw_open(hdev);
468 if (ret)
469 return ret;
470
471 ret = rmi_reset_attn_mode(hdev);
472 if (ret)
473 goto out;
474
475 ret = rmi_driver_resume(rmi_dev, false);
476 if (ret) {
477 hid_warn(hdev, "Failed to resume device: %d\n", ret);
478 goto out;
479 }
480
481out:
482 hid_hw_close(hdev);
483 return ret;
484}
485
486static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr)
487{
488 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
489 struct hid_device *hdev = data->hdev;
490
491 return rmi_reset_attn_mode(hdev);
492}
493
494static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
495{
496 struct rmi_data *data = hid_get_drvdata(hdev);
497 struct input_dev *input = hi->input;
498 int ret = 0;
499
500 if (!(data->device_flags & RMI_DEVICE))
501 return 0;
502
503 data->xport.input = input;
504
505 hid_dbg(hdev, "Opening low level driver\n");
506 ret = hid_hw_open(hdev);
507 if (ret)
508 return ret;
509
510 /* Allow incoming hid reports */
511 hid_device_io_start(hdev);
512
513 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
514 if (ret < 0) {
515 dev_err(&hdev->dev, "failed to set rmi mode\n");
516 goto exit;
517 }
518
519 ret = rmi_set_page(hdev, 0);
520 if (ret < 0) {
521 dev_err(&hdev->dev, "failed to set page select to 0.\n");
522 goto exit;
523 }
524
525 ret = rmi_register_transport_device(&data->xport);
526 if (ret < 0) {
527 dev_err(&hdev->dev, "failed to register transport driver\n");
528 goto exit;
529 }
530
531 set_bit(RMI_STARTED, &data->flags);
532
533exit:
534 hid_device_io_stop(hdev);
535 hid_hw_close(hdev);
536 return ret;
537}
538
539static int rmi_input_mapping(struct hid_device *hdev,
540 struct hid_input *hi, struct hid_field *field,
541 struct hid_usage *usage, unsigned long **bit, int *max)
542{
543 struct rmi_data *data = hid_get_drvdata(hdev);
544
545 /*
546 * we want to make HID ignore the advertised HID collection
547 * for RMI deivces
548 */
549 if (data->device_flags & RMI_DEVICE) {
550 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) &&
551 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
552 return 0;
553
554 return -1;
555 }
556
557 return 0;
558}
559
560static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
561 unsigned id, struct hid_report **report)
562{
563 int i;
564
565 *report = hdev->report_enum[type].report_id_hash[id];
566 if (*report) {
567 for (i = 0; i < (*report)->maxfield; i++) {
568 unsigned app = (*report)->field[i]->application;
569 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR)
570 return 1;
571 }
572 }
573
574 return 0;
575}
576
577static struct rmi_device_platform_data rmi_hid_pdata = {
578 .sensor_pdata = {
579 .sensor_type = rmi_sensor_touchpad,
580 .axis_align.flip_y = true,
581 .dribble = RMI_REG_STATE_ON,
582 .palm_detect = RMI_REG_STATE_OFF,
583 },
584};
585
586static const struct rmi_transport_ops hid_rmi_ops = {
587 .write_block = rmi_hid_write_block,
588 .read_block = rmi_hid_read_block,
589 .reset = rmi_hid_reset,
590};
591
592static void rmi_irq_teardown(void *data)
593{
594 struct rmi_data *hdata = data;
595 struct irq_domain *domain = hdata->domain;
596
597 if (!domain)
598 return;
599
600 irq_dispose_mapping(irq_find_mapping(domain, 0));
601
602 irq_domain_remove(domain);
603 hdata->domain = NULL;
604 hdata->rmi_irq = 0;
605}
606
607static int rmi_irq_map(struct irq_domain *h, unsigned int virq,
608 irq_hw_number_t hw_irq_num)
609{
610 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
611
612 return 0;
613}
614
615static const struct irq_domain_ops rmi_irq_ops = {
616 .map = rmi_irq_map,
617};
618
619static int rmi_setup_irq_domain(struct hid_device *hdev)
620{
621 struct rmi_data *hdata = hid_get_drvdata(hdev);
622 int ret;
623
624 hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1,
625 &rmi_irq_ops, hdata);
626 if (!hdata->domain)
627 return -ENOMEM;
628
629 ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata);
630 if (ret)
631 return ret;
632
633 hdata->rmi_irq = irq_create_mapping(hdata->domain, 0);
634 if (hdata->rmi_irq <= 0) {
635 hid_err(hdev, "Can't allocate an IRQ\n");
636 return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO;
637 }
638
639 return 0;
640}
641
642static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
643{
644 struct rmi_data *data = NULL;
645 int ret;
646 size_t alloc_size;
647 struct hid_report *input_report;
648 struct hid_report *output_report;
649 struct hid_report *feature_report;
650
651 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
652 if (!data)
653 return -ENOMEM;
654
655 INIT_WORK(&data->reset_work, rmi_reset_work);
656 data->hdev = hdev;
657
658 hid_set_drvdata(hdev, data);
659
660 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
661 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
662
663 ret = hid_parse(hdev);
664 if (ret) {
665 hid_err(hdev, "parse failed\n");
666 return ret;
667 }
668
669 if (id->driver_data)
670 data->device_flags = id->driver_data;
671
672 /*
673 * Check for the RMI specific report ids. If they are misisng
674 * simply return and let the events be processed by hid-input
675 */
676 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT,
677 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) {
678 hid_dbg(hdev, "device does not have set mode feature report\n");
679 goto start;
680 }
681
682 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT,
683 RMI_ATTN_REPORT_ID, &input_report)) {
684 hid_dbg(hdev, "device does not have attention input report\n");
685 goto start;
686 }
687
688 data->input_report_size = hid_report_len(input_report);
689
690 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT,
691 RMI_WRITE_REPORT_ID, &output_report)) {
692 hid_dbg(hdev,
693 "device does not have rmi write output report\n");
694 goto start;
695 }
696
697 data->output_report_size = hid_report_len(output_report);
698
699 data->device_flags |= RMI_DEVICE;
700 alloc_size = data->output_report_size + data->input_report_size;
701
702 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
703 if (!data->writeReport) {
704 hid_err(hdev, "failed to allocate buffer for HID reports\n");
705 return -ENOMEM;
706 }
707
708 data->readReport = data->writeReport + data->output_report_size;
709
710 init_waitqueue_head(&data->wait);
711
712 mutex_init(&data->page_mutex);
713
714 ret = rmi_setup_irq_domain(hdev);
715 if (ret) {
716 hid_err(hdev, "failed to allocate IRQ domain\n");
717 return ret;
718 }
719
720 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)
721 rmi_hid_pdata.gpio_data.disable = true;
722
723 data->xport.dev = hdev->dev.parent;
724 data->xport.pdata = rmi_hid_pdata;
725 data->xport.pdata.irq = data->rmi_irq;
726 data->xport.proto_name = "hid";
727 data->xport.ops = &hid_rmi_ops;
728
729start:
730 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
731 if (ret) {
732 hid_err(hdev, "hw start failed\n");
733 return ret;
734 }
735
736 return 0;
737}
738
739static void rmi_remove(struct hid_device *hdev)
740{
741 struct rmi_data *hdata = hid_get_drvdata(hdev);
742
743 if ((hdata->device_flags & RMI_DEVICE)
744 && test_bit(RMI_STARTED, &hdata->flags)) {
745 clear_bit(RMI_STARTED, &hdata->flags);
746 cancel_work_sync(&hdata->reset_work);
747 rmi_unregister_transport_device(&hdata->xport);
748 }
749
750 hid_hw_stop(hdev);
751}
752
753static const struct hid_device_id rmi_id[] = {
754 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
755 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
756 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
757 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_REZEL) },
758 { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5),
759 .driver_data = RMI_DEVICE_OUTPUT_SET_REPORT },
760 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
761 { }
762};
763MODULE_DEVICE_TABLE(hid, rmi_id);
764
765static struct hid_driver rmi_driver = {
766 .name = "hid-rmi",
767 .id_table = rmi_id,
768 .probe = rmi_probe,
769 .remove = rmi_remove,
770 .event = rmi_event,
771 .raw_event = rmi_raw_event,
772 .report = rmi_report,
773 .input_mapping = rmi_input_mapping,
774 .input_configured = rmi_input_configured,
775 .suspend = pm_ptr(rmi_suspend),
776 .resume = pm_ptr(rmi_post_resume),
777 .reset_resume = pm_ptr(rmi_post_resume),
778};
779
780module_hid_driver(rmi_driver);
781
782MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
783MODULE_DESCRIPTION("RMI HID driver");
784MODULE_LICENSE("GPL");