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/irq.h>
18#include <linux/irqdomain.h>
19#include <linux/module.h>
20#include <linux/pm.h>
21#include <linux/slab.h>
22#include <linux/wait.h>
23#include <linux/sched.h>
24#include <linux/rmi.h>
25#include "hid-ids.h"
26
27#define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */
28#define RMI_WRITE_REPORT_ID 0x09 /* Output Report */
29#define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */
30#define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */
31#define RMI_ATTN_REPORT_ID 0x0c /* Input Report */
32#define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */
33
34/* flags */
35#define RMI_READ_REQUEST_PENDING 0
36#define RMI_READ_DATA_PENDING 1
37#define RMI_STARTED 2
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
57/**
58 * struct rmi_data - stores information for hid communication
59 *
60 * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
61 * @page: Keeps track of the current virtual page
62 * @xport: transport device to be registered with the RMI4 core.
63 *
64 * @wait: Used for waiting for read data
65 *
66 * @writeReport: output buffer when writing RMI registers
67 * @readReport: input buffer when reading RMI registers
68 *
69 * @input_report_size: size of an input report (advertised by HID)
70 * @output_report_size: size of an output report (advertised by HID)
71 *
72 * @flags: flags for the current device (started, reading, etc...)
73 *
74 * @reset_work: worker which will be called in case of a mouse report
75 * @hdev: pointer to the struct hid_device
76 *
77 * @device_flags: flags which describe the device
78 *
79 * @domain: the IRQ domain allocated for this RMI4 device
80 * @rmi_irq: the irq that will be used to generate events to rmi-core
81 */
82struct rmi_data {
83 struct mutex page_mutex;
84 int page;
85 struct rmi_transport_dev xport;
86
87 wait_queue_head_t wait;
88
89 u8 *writeReport;
90 u8 *readReport;
91
92 u32 input_report_size;
93 u32 output_report_size;
94
95 unsigned long flags;
96
97 struct work_struct reset_work;
98 struct hid_device *hdev;
99
100 unsigned long device_flags;
101
102 struct irq_domain *domain;
103 int rmi_irq;
104};
105
106#define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
107
108static int rmi_write_report(struct hid_device *hdev, u8 *report, int len);
109
110/**
111 * rmi_set_page - Set RMI page
112 * @hdev: The pointer to the hid_device struct
113 * @page: The new page address.
114 *
115 * RMI devices have 16-bit addressing, but some of the physical
116 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
117 * a page address at 0xff of every page so we can reliable page addresses
118 * every 256 registers.
119 *
120 * The page_mutex lock must be held when this function is entered.
121 *
122 * Returns zero on success, non-zero on failure.
123 */
124static int rmi_set_page(struct hid_device *hdev, u8 page)
125{
126 struct rmi_data *data = hid_get_drvdata(hdev);
127 int retval;
128
129 data->writeReport[0] = RMI_WRITE_REPORT_ID;
130 data->writeReport[1] = 1;
131 data->writeReport[2] = 0xFF;
132 data->writeReport[4] = page;
133
134 retval = rmi_write_report(hdev, data->writeReport,
135 data->output_report_size);
136 if (retval != data->output_report_size) {
137 dev_err(&hdev->dev,
138 "%s: set page failed: %d.", __func__, retval);
139 return retval;
140 }
141
142 data->page = page;
143 return 0;
144}
145
146static int rmi_set_mode(struct hid_device *hdev, u8 mode)
147{
148 int ret;
149 const u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
150 u8 *buf;
151
152 buf = kmemdup(txbuf, sizeof(txbuf), GFP_KERNEL);
153 if (!buf)
154 return -ENOMEM;
155
156 ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, buf,
157 sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
158 kfree(buf);
159 if (ret < 0) {
160 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode,
161 ret);
162 return ret;
163 }
164
165 return 0;
166}
167
168static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)
169{
170 int ret;
171
172 ret = hid_hw_output_report(hdev, (void *)report, len);
173 if (ret < 0) {
174 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret);
175 return ret;
176 }
177
178 return ret;
179}
180
181static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr,
182 void *buf, size_t len)
183{
184 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
185 struct hid_device *hdev = data->hdev;
186 int ret;
187 int bytes_read;
188 int bytes_needed;
189 int retries;
190 int read_input_count;
191
192 mutex_lock(&data->page_mutex);
193
194 if (RMI_PAGE(addr) != data->page) {
195 ret = rmi_set_page(hdev, RMI_PAGE(addr));
196 if (ret < 0)
197 goto exit;
198 }
199
200 for (retries = 5; retries > 0; retries--) {
201 data->writeReport[0] = RMI_READ_ADDR_REPORT_ID;
202 data->writeReport[1] = 0; /* old 1 byte read count */
203 data->writeReport[2] = addr & 0xFF;
204 data->writeReport[3] = (addr >> 8) & 0xFF;
205 data->writeReport[4] = len & 0xFF;
206 data->writeReport[5] = (len >> 8) & 0xFF;
207
208 set_bit(RMI_READ_REQUEST_PENDING, &data->flags);
209
210 ret = rmi_write_report(hdev, data->writeReport,
211 data->output_report_size);
212 if (ret != data->output_report_size) {
213 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
214 dev_err(&hdev->dev,
215 "failed to write request output report (%d)\n",
216 ret);
217 goto exit;
218 }
219
220 bytes_read = 0;
221 bytes_needed = len;
222 while (bytes_read < len) {
223 if (!wait_event_timeout(data->wait,
224 test_bit(RMI_READ_DATA_PENDING, &data->flags),
225 msecs_to_jiffies(1000))) {
226 hid_warn(hdev, "%s: timeout elapsed\n",
227 __func__);
228 ret = -EAGAIN;
229 break;
230 }
231
232 read_input_count = data->readReport[1];
233 memcpy(buf + bytes_read, &data->readReport[2],
234 read_input_count < bytes_needed ?
235 read_input_count : bytes_needed);
236
237 bytes_read += read_input_count;
238 bytes_needed -= read_input_count;
239 clear_bit(RMI_READ_DATA_PENDING, &data->flags);
240 }
241
242 if (ret >= 0) {
243 ret = 0;
244 break;
245 }
246 }
247
248exit:
249 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
250 mutex_unlock(&data->page_mutex);
251 return ret;
252}
253
254static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr,
255 const void *buf, size_t len)
256{
257 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
258 struct hid_device *hdev = data->hdev;
259 int ret;
260
261 mutex_lock(&data->page_mutex);
262
263 if (RMI_PAGE(addr) != data->page) {
264 ret = rmi_set_page(hdev, RMI_PAGE(addr));
265 if (ret < 0)
266 goto exit;
267 }
268
269 data->writeReport[0] = RMI_WRITE_REPORT_ID;
270 data->writeReport[1] = len;
271 data->writeReport[2] = addr & 0xFF;
272 data->writeReport[3] = (addr >> 8) & 0xFF;
273 memcpy(&data->writeReport[4], buf, len);
274
275 ret = rmi_write_report(hdev, data->writeReport,
276 data->output_report_size);
277 if (ret < 0) {
278 dev_err(&hdev->dev,
279 "failed to write request output report (%d)\n",
280 ret);
281 goto exit;
282 }
283 ret = 0;
284
285exit:
286 mutex_unlock(&data->page_mutex);
287 return ret;
288}
289
290static int rmi_reset_attn_mode(struct hid_device *hdev)
291{
292 struct rmi_data *data = hid_get_drvdata(hdev);
293 struct rmi_device *rmi_dev = data->xport.rmi_dev;
294 int ret;
295
296 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
297 if (ret)
298 return ret;
299
300 if (test_bit(RMI_STARTED, &data->flags))
301 ret = rmi_dev->driver->reset_handler(rmi_dev);
302
303 return ret;
304}
305
306static void rmi_reset_work(struct work_struct *work)
307{
308 struct rmi_data *hdata = container_of(work, struct rmi_data,
309 reset_work);
310
311 /* switch the device to RMI if we receive a generic mouse report */
312 rmi_reset_attn_mode(hdata->hdev);
313}
314
315static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
316{
317 struct rmi_data *hdata = hid_get_drvdata(hdev);
318 struct rmi_device *rmi_dev = hdata->xport.rmi_dev;
319 unsigned long flags;
320
321 if (!(test_bit(RMI_STARTED, &hdata->flags)))
322 return 0;
323
324 local_irq_save(flags);
325
326 rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2);
327
328 generic_handle_irq(hdata->rmi_irq);
329
330 local_irq_restore(flags);
331
332 return 1;
333}
334
335static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size)
336{
337 struct rmi_data *hdata = hid_get_drvdata(hdev);
338
339 if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) {
340 hid_dbg(hdev, "no read request pending\n");
341 return 0;
342 }
343
344 memcpy(hdata->readReport, data, size < hdata->input_report_size ?
345 size : hdata->input_report_size);
346 set_bit(RMI_READ_DATA_PENDING, &hdata->flags);
347 wake_up(&hdata->wait);
348
349 return 1;
350}
351
352static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size)
353{
354 int valid_size = size;
355 /*
356 * On the Dell XPS 13 9333, the bus sometimes get confused and fills
357 * the report with a sentinel value "ff". Synaptics told us that such
358 * behavior does not comes from the touchpad itself, so we filter out
359 * such reports here.
360 */
361
362 while ((data[valid_size - 1] == 0xff) && valid_size > 0)
363 valid_size--;
364
365 return valid_size;
366}
367
368static int rmi_raw_event(struct hid_device *hdev,
369 struct hid_report *report, u8 *data, int size)
370{
371 struct rmi_data *hdata = hid_get_drvdata(hdev);
372
373 if (!(hdata->device_flags & RMI_DEVICE))
374 return 0;
375
376 size = rmi_check_sanity(hdev, data, size);
377 if (size < 2)
378 return 0;
379
380 switch (data[0]) {
381 case RMI_READ_DATA_REPORT_ID:
382 return rmi_read_data_event(hdev, data, size);
383 case RMI_ATTN_REPORT_ID:
384 return rmi_input_event(hdev, data, size);
385 default:
386 return 1;
387 }
388
389 return 0;
390}
391
392static int rmi_event(struct hid_device *hdev, struct hid_field *field,
393 struct hid_usage *usage, __s32 value)
394{
395 struct rmi_data *data = hid_get_drvdata(hdev);
396
397 if ((data->device_flags & RMI_DEVICE) &&
398 (field->application == HID_GD_POINTER ||
399 field->application == HID_GD_MOUSE)) {
400 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) {
401 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
402 return 0;
403
404 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
405 && !value)
406 return 1;
407 }
408
409 schedule_work(&data->reset_work);
410 return 1;
411 }
412
413 return 0;
414}
415
416static void rmi_report(struct hid_device *hid, struct hid_report *report)
417{
418 struct hid_field *field = report->field[0];
419
420 if (!(hid->claimed & HID_CLAIMED_INPUT))
421 return;
422
423 switch (report->id) {
424 case RMI_READ_DATA_REPORT_ID:
425 /* fall-through */
426 case RMI_ATTN_REPORT_ID:
427 return;
428 }
429
430 if (field && field->hidinput && field->hidinput->input)
431 input_sync(field->hidinput->input);
432}
433
434#ifdef CONFIG_PM
435static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
436{
437 struct rmi_data *data = hid_get_drvdata(hdev);
438 struct rmi_device *rmi_dev = data->xport.rmi_dev;
439 int ret;
440
441 if (!(data->device_flags & RMI_DEVICE))
442 return 0;
443
444 ret = rmi_driver_suspend(rmi_dev, false);
445 if (ret) {
446 hid_warn(hdev, "Failed to suspend device: %d\n", ret);
447 return ret;
448 }
449
450 return 0;
451}
452
453static int rmi_post_resume(struct hid_device *hdev)
454{
455 struct rmi_data *data = hid_get_drvdata(hdev);
456 struct rmi_device *rmi_dev = data->xport.rmi_dev;
457 int ret;
458
459 if (!(data->device_flags & RMI_DEVICE))
460 return 0;
461
462 /* Make sure the HID device is ready to receive events */
463 ret = hid_hw_open(hdev);
464 if (ret)
465 return ret;
466
467 ret = rmi_reset_attn_mode(hdev);
468 if (ret)
469 goto out;
470
471 ret = rmi_driver_resume(rmi_dev, false);
472 if (ret) {
473 hid_warn(hdev, "Failed to resume device: %d\n", ret);
474 goto out;
475 }
476
477out:
478 hid_hw_close(hdev);
479 return ret;
480}
481#endif /* CONFIG_PM */
482
483static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr)
484{
485 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
486 struct hid_device *hdev = data->hdev;
487
488 return rmi_reset_attn_mode(hdev);
489}
490
491static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
492{
493 struct rmi_data *data = hid_get_drvdata(hdev);
494 struct input_dev *input = hi->input;
495 int ret = 0;
496
497 if (!(data->device_flags & RMI_DEVICE))
498 return 0;
499
500 data->xport.input = input;
501
502 hid_dbg(hdev, "Opening low level driver\n");
503 ret = hid_hw_open(hdev);
504 if (ret)
505 return ret;
506
507 /* Allow incoming hid reports */
508 hid_device_io_start(hdev);
509
510 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
511 if (ret < 0) {
512 dev_err(&hdev->dev, "failed to set rmi mode\n");
513 goto exit;
514 }
515
516 ret = rmi_set_page(hdev, 0);
517 if (ret < 0) {
518 dev_err(&hdev->dev, "failed to set page select to 0.\n");
519 goto exit;
520 }
521
522 ret = rmi_register_transport_device(&data->xport);
523 if (ret < 0) {
524 dev_err(&hdev->dev, "failed to register transport driver\n");
525 goto exit;
526 }
527
528 set_bit(RMI_STARTED, &data->flags);
529
530exit:
531 hid_device_io_stop(hdev);
532 hid_hw_close(hdev);
533 return ret;
534}
535
536static int rmi_input_mapping(struct hid_device *hdev,
537 struct hid_input *hi, struct hid_field *field,
538 struct hid_usage *usage, unsigned long **bit, int *max)
539{
540 struct rmi_data *data = hid_get_drvdata(hdev);
541
542 /*
543 * we want to make HID ignore the advertised HID collection
544 * for RMI deivces
545 */
546 if (data->device_flags & RMI_DEVICE) {
547 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) &&
548 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
549 return 0;
550
551 return -1;
552 }
553
554 return 0;
555}
556
557static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
558 unsigned id, struct hid_report **report)
559{
560 int i;
561
562 *report = hdev->report_enum[type].report_id_hash[id];
563 if (*report) {
564 for (i = 0; i < (*report)->maxfield; i++) {
565 unsigned app = (*report)->field[i]->application;
566 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR)
567 return 1;
568 }
569 }
570
571 return 0;
572}
573
574static struct rmi_device_platform_data rmi_hid_pdata = {
575 .sensor_pdata = {
576 .sensor_type = rmi_sensor_touchpad,
577 .axis_align.flip_y = true,
578 .dribble = RMI_REG_STATE_ON,
579 .palm_detect = RMI_REG_STATE_OFF,
580 },
581};
582
583static const struct rmi_transport_ops hid_rmi_ops = {
584 .write_block = rmi_hid_write_block,
585 .read_block = rmi_hid_read_block,
586 .reset = rmi_hid_reset,
587};
588
589static void rmi_irq_teardown(void *data)
590{
591 struct rmi_data *hdata = data;
592 struct irq_domain *domain = hdata->domain;
593
594 if (!domain)
595 return;
596
597 irq_dispose_mapping(irq_find_mapping(domain, 0));
598
599 irq_domain_remove(domain);
600 hdata->domain = NULL;
601 hdata->rmi_irq = 0;
602}
603
604static int rmi_irq_map(struct irq_domain *h, unsigned int virq,
605 irq_hw_number_t hw_irq_num)
606{
607 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
608
609 return 0;
610}
611
612static const struct irq_domain_ops rmi_irq_ops = {
613 .map = rmi_irq_map,
614};
615
616static int rmi_setup_irq_domain(struct hid_device *hdev)
617{
618 struct rmi_data *hdata = hid_get_drvdata(hdev);
619 int ret;
620
621 hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1,
622 &rmi_irq_ops, hdata);
623 if (!hdata->domain)
624 return -ENOMEM;
625
626 ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata);
627 if (ret)
628 return ret;
629
630 hdata->rmi_irq = irq_create_mapping(hdata->domain, 0);
631 if (hdata->rmi_irq <= 0) {
632 hid_err(hdev, "Can't allocate an IRQ\n");
633 return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO;
634 }
635
636 return 0;
637}
638
639static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
640{
641 struct rmi_data *data = NULL;
642 int ret;
643 size_t alloc_size;
644 struct hid_report *input_report;
645 struct hid_report *output_report;
646 struct hid_report *feature_report;
647
648 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
649 if (!data)
650 return -ENOMEM;
651
652 INIT_WORK(&data->reset_work, rmi_reset_work);
653 data->hdev = hdev;
654
655 hid_set_drvdata(hdev, data);
656
657 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
658 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
659
660 ret = hid_parse(hdev);
661 if (ret) {
662 hid_err(hdev, "parse failed\n");
663 return ret;
664 }
665
666 if (id->driver_data)
667 data->device_flags = id->driver_data;
668
669 /*
670 * Check for the RMI specific report ids. If they are misisng
671 * simply return and let the events be processed by hid-input
672 */
673 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT,
674 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) {
675 hid_dbg(hdev, "device does not have set mode feature report\n");
676 goto start;
677 }
678
679 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT,
680 RMI_ATTN_REPORT_ID, &input_report)) {
681 hid_dbg(hdev, "device does not have attention input report\n");
682 goto start;
683 }
684
685 data->input_report_size = hid_report_len(input_report);
686
687 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT,
688 RMI_WRITE_REPORT_ID, &output_report)) {
689 hid_dbg(hdev,
690 "device does not have rmi write output report\n");
691 goto start;
692 }
693
694 data->output_report_size = hid_report_len(output_report);
695
696 data->device_flags |= RMI_DEVICE;
697 alloc_size = data->output_report_size + data->input_report_size;
698
699 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
700 if (!data->writeReport) {
701 hid_err(hdev, "failed to allocate buffer for HID reports\n");
702 return -ENOMEM;
703 }
704
705 data->readReport = data->writeReport + data->output_report_size;
706
707 init_waitqueue_head(&data->wait);
708
709 mutex_init(&data->page_mutex);
710
711 ret = rmi_setup_irq_domain(hdev);
712 if (ret) {
713 hid_err(hdev, "failed to allocate IRQ domain\n");
714 return ret;
715 }
716
717 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)
718 rmi_hid_pdata.f30_data.disable = true;
719
720 data->xport.dev = hdev->dev.parent;
721 data->xport.pdata = rmi_hid_pdata;
722 data->xport.pdata.irq = data->rmi_irq;
723 data->xport.proto_name = "hid";
724 data->xport.ops = &hid_rmi_ops;
725
726start:
727 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
728 if (ret) {
729 hid_err(hdev, "hw start failed\n");
730 return ret;
731 }
732
733 return 0;
734}
735
736static void rmi_remove(struct hid_device *hdev)
737{
738 struct rmi_data *hdata = hid_get_drvdata(hdev);
739
740 if (hdata->device_flags & RMI_DEVICE) {
741 clear_bit(RMI_STARTED, &hdata->flags);
742 cancel_work_sync(&hdata->reset_work);
743 rmi_unregister_transport_device(&hdata->xport);
744 }
745
746 hid_hw_stop(hdev);
747}
748
749static const struct hid_device_id rmi_id[] = {
750 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
751 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
752 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
753 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_REZEL) },
754 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
755 { }
756};
757MODULE_DEVICE_TABLE(hid, rmi_id);
758
759static struct hid_driver rmi_driver = {
760 .name = "hid-rmi",
761 .id_table = rmi_id,
762 .probe = rmi_probe,
763 .remove = rmi_remove,
764 .event = rmi_event,
765 .raw_event = rmi_raw_event,
766 .report = rmi_report,
767 .input_mapping = rmi_input_mapping,
768 .input_configured = rmi_input_configured,
769#ifdef CONFIG_PM
770 .suspend = rmi_suspend,
771 .resume = rmi_post_resume,
772 .reset_resume = rmi_post_resume,
773#endif
774};
775
776module_hid_driver(rmi_driver);
777
778MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
779MODULE_DESCRIPTION("RMI HID driver");
780MODULE_LICENSE("GPL");
781