Loading...
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");
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 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
221 dev_err(&hdev->dev,
222 "failed to write request output report (%d)\n",
223 ret);
224 goto exit;
225 }
226
227 bytes_read = 0;
228 bytes_needed = len;
229 while (bytes_read < len) {
230 if (!wait_event_timeout(data->wait,
231 test_bit(RMI_READ_DATA_PENDING, &data->flags),
232 msecs_to_jiffies(1000))) {
233 hid_warn(hdev, "%s: timeout elapsed\n",
234 __func__);
235 ret = -EAGAIN;
236 break;
237 }
238
239 read_input_count = data->readReport[1];
240 memcpy(buf + bytes_read, &data->readReport[2],
241 read_input_count < bytes_needed ?
242 read_input_count : bytes_needed);
243
244 bytes_read += read_input_count;
245 bytes_needed -= read_input_count;
246 clear_bit(RMI_READ_DATA_PENDING, &data->flags);
247 }
248
249 if (ret >= 0) {
250 ret = 0;
251 break;
252 }
253 }
254
255exit:
256 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
257 mutex_unlock(&data->page_mutex);
258 return ret;
259}
260
261static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr,
262 const void *buf, size_t len)
263{
264 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
265 struct hid_device *hdev = data->hdev;
266 int ret;
267
268 mutex_lock(&data->page_mutex);
269
270 if (RMI_PAGE(addr) != data->page) {
271 ret = rmi_set_page(hdev, RMI_PAGE(addr));
272 if (ret < 0)
273 goto exit;
274 }
275
276 data->writeReport[0] = RMI_WRITE_REPORT_ID;
277 data->writeReport[1] = len;
278 data->writeReport[2] = addr & 0xFF;
279 data->writeReport[3] = (addr >> 8) & 0xFF;
280 memcpy(&data->writeReport[4], buf, len);
281
282 ret = rmi_write_report(hdev, data->writeReport,
283 data->output_report_size);
284 if (ret < 0) {
285 dev_err(&hdev->dev,
286 "failed to write request output report (%d)\n",
287 ret);
288 goto exit;
289 }
290 ret = 0;
291
292exit:
293 mutex_unlock(&data->page_mutex);
294 return ret;
295}
296
297static int rmi_reset_attn_mode(struct hid_device *hdev)
298{
299 struct rmi_data *data = hid_get_drvdata(hdev);
300 struct rmi_device *rmi_dev = data->xport.rmi_dev;
301 int ret;
302
303 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
304 if (ret)
305 return ret;
306
307 if (test_bit(RMI_STARTED, &data->flags))
308 ret = rmi_dev->driver->reset_handler(rmi_dev);
309
310 return ret;
311}
312
313static void rmi_reset_work(struct work_struct *work)
314{
315 struct rmi_data *hdata = container_of(work, struct rmi_data,
316 reset_work);
317
318 /* switch the device to RMI if we receive a generic mouse report */
319 rmi_reset_attn_mode(hdata->hdev);
320}
321
322static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
323{
324 struct rmi_data *hdata = hid_get_drvdata(hdev);
325 struct rmi_device *rmi_dev = hdata->xport.rmi_dev;
326 unsigned long flags;
327
328 if (!(test_bit(RMI_STARTED, &hdata->flags)))
329 return 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, size < hdata->input_report_size ?
352 size : hdata->input_report_size);
353 set_bit(RMI_READ_DATA_PENDING, &hdata->flags);
354 wake_up(&hdata->wait);
355
356 return 1;
357}
358
359static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size)
360{
361 int valid_size = size;
362 /*
363 * On the Dell XPS 13 9333, the bus sometimes get confused and fills
364 * the report with a sentinel value "ff". Synaptics told us that such
365 * behavior does not comes from the touchpad itself, so we filter out
366 * such reports here.
367 */
368
369 while ((data[valid_size - 1] == 0xff) && valid_size > 0)
370 valid_size--;
371
372 return valid_size;
373}
374
375static int rmi_raw_event(struct hid_device *hdev,
376 struct hid_report *report, u8 *data, int size)
377{
378 struct rmi_data *hdata = hid_get_drvdata(hdev);
379
380 if (!(hdata->device_flags & RMI_DEVICE))
381 return 0;
382
383 size = rmi_check_sanity(hdev, data, size);
384 if (size < 2)
385 return 0;
386
387 switch (data[0]) {
388 case RMI_READ_DATA_REPORT_ID:
389 return rmi_read_data_event(hdev, data, size);
390 case RMI_ATTN_REPORT_ID:
391 return rmi_input_event(hdev, data, size);
392 default:
393 return 1;
394 }
395
396 return 0;
397}
398
399static int rmi_event(struct hid_device *hdev, struct hid_field *field,
400 struct hid_usage *usage, __s32 value)
401{
402 struct rmi_data *data = hid_get_drvdata(hdev);
403
404 if ((data->device_flags & RMI_DEVICE) &&
405 (field->application == HID_GD_POINTER ||
406 field->application == HID_GD_MOUSE)) {
407 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) {
408 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
409 return 0;
410
411 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
412 && !value)
413 return 1;
414 }
415
416 schedule_work(&data->reset_work);
417 return 1;
418 }
419
420 return 0;
421}
422
423static void rmi_report(struct hid_device *hid, struct hid_report *report)
424{
425 struct hid_field *field = report->field[0];
426
427 if (!(hid->claimed & HID_CLAIMED_INPUT))
428 return;
429
430 switch (report->id) {
431 case RMI_READ_DATA_REPORT_ID:
432 /* fall-through */
433 case RMI_ATTN_REPORT_ID:
434 return;
435 }
436
437 if (field && field->hidinput && field->hidinput->input)
438 input_sync(field->hidinput->input);
439}
440
441#ifdef CONFIG_PM
442static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
443{
444 struct rmi_data *data = hid_get_drvdata(hdev);
445 struct rmi_device *rmi_dev = data->xport.rmi_dev;
446 int ret;
447
448 if (!(data->device_flags & RMI_DEVICE))
449 return 0;
450
451 ret = rmi_driver_suspend(rmi_dev, false);
452 if (ret) {
453 hid_warn(hdev, "Failed to suspend device: %d\n", ret);
454 return ret;
455 }
456
457 return 0;
458}
459
460static int rmi_post_resume(struct hid_device *hdev)
461{
462 struct rmi_data *data = hid_get_drvdata(hdev);
463 struct rmi_device *rmi_dev = data->xport.rmi_dev;
464 int ret;
465
466 if (!(data->device_flags & RMI_DEVICE))
467 return 0;
468
469 /* Make sure the HID device is ready to receive events */
470 ret = hid_hw_open(hdev);
471 if (ret)
472 return ret;
473
474 ret = rmi_reset_attn_mode(hdev);
475 if (ret)
476 goto out;
477
478 ret = rmi_driver_resume(rmi_dev, false);
479 if (ret) {
480 hid_warn(hdev, "Failed to resume device: %d\n", ret);
481 goto out;
482 }
483
484out:
485 hid_hw_close(hdev);
486 return ret;
487}
488#endif /* CONFIG_PM */
489
490static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr)
491{
492 struct rmi_data *data = container_of(xport, struct rmi_data, xport);
493 struct hid_device *hdev = data->hdev;
494
495 return rmi_reset_attn_mode(hdev);
496}
497
498static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
499{
500 struct rmi_data *data = hid_get_drvdata(hdev);
501 struct input_dev *input = hi->input;
502 int ret = 0;
503
504 if (!(data->device_flags & RMI_DEVICE))
505 return 0;
506
507 data->xport.input = input;
508
509 hid_dbg(hdev, "Opening low level driver\n");
510 ret = hid_hw_open(hdev);
511 if (ret)
512 return ret;
513
514 /* Allow incoming hid reports */
515 hid_device_io_start(hdev);
516
517 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
518 if (ret < 0) {
519 dev_err(&hdev->dev, "failed to set rmi mode\n");
520 goto exit;
521 }
522
523 ret = rmi_set_page(hdev, 0);
524 if (ret < 0) {
525 dev_err(&hdev->dev, "failed to set page select to 0.\n");
526 goto exit;
527 }
528
529 ret = rmi_register_transport_device(&data->xport);
530 if (ret < 0) {
531 dev_err(&hdev->dev, "failed to register transport driver\n");
532 goto exit;
533 }
534
535 set_bit(RMI_STARTED, &data->flags);
536
537exit:
538 hid_device_io_stop(hdev);
539 hid_hw_close(hdev);
540 return ret;
541}
542
543static int rmi_input_mapping(struct hid_device *hdev,
544 struct hid_input *hi, struct hid_field *field,
545 struct hid_usage *usage, unsigned long **bit, int *max)
546{
547 struct rmi_data *data = hid_get_drvdata(hdev);
548
549 /*
550 * we want to make HID ignore the advertised HID collection
551 * for RMI deivces
552 */
553 if (data->device_flags & RMI_DEVICE) {
554 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) &&
555 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
556 return 0;
557
558 return -1;
559 }
560
561 return 0;
562}
563
564static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
565 unsigned id, struct hid_report **report)
566{
567 int i;
568
569 *report = hdev->report_enum[type].report_id_hash[id];
570 if (*report) {
571 for (i = 0; i < (*report)->maxfield; i++) {
572 unsigned app = (*report)->field[i]->application;
573 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR)
574 return 1;
575 }
576 }
577
578 return 0;
579}
580
581static struct rmi_device_platform_data rmi_hid_pdata = {
582 .sensor_pdata = {
583 .sensor_type = rmi_sensor_touchpad,
584 .axis_align.flip_y = true,
585 .dribble = RMI_REG_STATE_ON,
586 .palm_detect = RMI_REG_STATE_OFF,
587 },
588};
589
590static const struct rmi_transport_ops hid_rmi_ops = {
591 .write_block = rmi_hid_write_block,
592 .read_block = rmi_hid_read_block,
593 .reset = rmi_hid_reset,
594};
595
596static void rmi_irq_teardown(void *data)
597{
598 struct rmi_data *hdata = data;
599 struct irq_domain *domain = hdata->domain;
600
601 if (!domain)
602 return;
603
604 irq_dispose_mapping(irq_find_mapping(domain, 0));
605
606 irq_domain_remove(domain);
607 hdata->domain = NULL;
608 hdata->rmi_irq = 0;
609}
610
611static int rmi_irq_map(struct irq_domain *h, unsigned int virq,
612 irq_hw_number_t hw_irq_num)
613{
614 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
615
616 return 0;
617}
618
619static const struct irq_domain_ops rmi_irq_ops = {
620 .map = rmi_irq_map,
621};
622
623static int rmi_setup_irq_domain(struct hid_device *hdev)
624{
625 struct rmi_data *hdata = hid_get_drvdata(hdev);
626 int ret;
627
628 hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1,
629 &rmi_irq_ops, hdata);
630 if (!hdata->domain)
631 return -ENOMEM;
632
633 ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata);
634 if (ret)
635 return ret;
636
637 hdata->rmi_irq = irq_create_mapping(hdata->domain, 0);
638 if (hdata->rmi_irq <= 0) {
639 hid_err(hdev, "Can't allocate an IRQ\n");
640 return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO;
641 }
642
643 return 0;
644}
645
646static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
647{
648 struct rmi_data *data = NULL;
649 int ret;
650 size_t alloc_size;
651 struct hid_report *input_report;
652 struct hid_report *output_report;
653 struct hid_report *feature_report;
654
655 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
656 if (!data)
657 return -ENOMEM;
658
659 INIT_WORK(&data->reset_work, rmi_reset_work);
660 data->hdev = hdev;
661
662 hid_set_drvdata(hdev, data);
663
664 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
665 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
666
667 ret = hid_parse(hdev);
668 if (ret) {
669 hid_err(hdev, "parse failed\n");
670 return ret;
671 }
672
673 if (id->driver_data)
674 data->device_flags = id->driver_data;
675
676 /*
677 * Check for the RMI specific report ids. If they are misisng
678 * simply return and let the events be processed by hid-input
679 */
680 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT,
681 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) {
682 hid_dbg(hdev, "device does not have set mode feature report\n");
683 goto start;
684 }
685
686 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT,
687 RMI_ATTN_REPORT_ID, &input_report)) {
688 hid_dbg(hdev, "device does not have attention input report\n");
689 goto start;
690 }
691
692 data->input_report_size = hid_report_len(input_report);
693
694 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT,
695 RMI_WRITE_REPORT_ID, &output_report)) {
696 hid_dbg(hdev,
697 "device does not have rmi write output report\n");
698 goto start;
699 }
700
701 data->output_report_size = hid_report_len(output_report);
702
703 data->device_flags |= RMI_DEVICE;
704 alloc_size = data->output_report_size + data->input_report_size;
705
706 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
707 if (!data->writeReport) {
708 hid_err(hdev, "failed to allocate buffer for HID reports\n");
709 return -ENOMEM;
710 }
711
712 data->readReport = data->writeReport + data->output_report_size;
713
714 init_waitqueue_head(&data->wait);
715
716 mutex_init(&data->page_mutex);
717
718 ret = rmi_setup_irq_domain(hdev);
719 if (ret) {
720 hid_err(hdev, "failed to allocate IRQ domain\n");
721 return ret;
722 }
723
724 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)
725 rmi_hid_pdata.f30_data.disable = true;
726
727 data->xport.dev = hdev->dev.parent;
728 data->xport.pdata = rmi_hid_pdata;
729 data->xport.pdata.irq = data->rmi_irq;
730 data->xport.proto_name = "hid";
731 data->xport.ops = &hid_rmi_ops;
732
733start:
734 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
735 if (ret) {
736 hid_err(hdev, "hw start failed\n");
737 return ret;
738 }
739
740 return 0;
741}
742
743static void rmi_remove(struct hid_device *hdev)
744{
745 struct rmi_data *hdata = hid_get_drvdata(hdev);
746
747 if (hdata->device_flags & RMI_DEVICE) {
748 clear_bit(RMI_STARTED, &hdata->flags);
749 cancel_work_sync(&hdata->reset_work);
750 rmi_unregister_transport_device(&hdata->xport);
751 }
752
753 hid_hw_stop(hdev);
754}
755
756static const struct hid_device_id rmi_id[] = {
757 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
758 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
759 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
760 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_REZEL) },
761 { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5),
762 .driver_data = RMI_DEVICE_OUTPUT_SET_REPORT },
763 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
764 { }
765};
766MODULE_DEVICE_TABLE(hid, rmi_id);
767
768static struct hid_driver rmi_driver = {
769 .name = "hid-rmi",
770 .id_table = rmi_id,
771 .probe = rmi_probe,
772 .remove = rmi_remove,
773 .event = rmi_event,
774 .raw_event = rmi_raw_event,
775 .report = rmi_report,
776 .input_mapping = rmi_input_mapping,
777 .input_configured = rmi_input_configured,
778#ifdef CONFIG_PM
779 .suspend = rmi_suspend,
780 .resume = rmi_post_resume,
781 .reset_resume = rmi_post_resume,
782#endif
783};
784
785module_hid_driver(rmi_driver);
786
787MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
788MODULE_DESCRIPTION("RMI HID driver");
789MODULE_LICENSE("GPL");