1 // SPDX-License-Identifier: GPL-2.0-or-later
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
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>
17 #include <linux/slab.h>
18 #include <linux/wait.h>
19 #include <linux/sched.h>
20 #include <linux/rmi.h>
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 */
31 #define RMI_READ_REQUEST_PENDING 0
32 #define RMI_READ_DATA_PENDING 1
36 #define RMI_DEVICE BIT(0)
37 #define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1)
40 * retrieve the ctrl registers
41 * the ctrl register has a size of 20 but a fw bug split it into 16 + 4,
42 * and there is no way to know if the first 20 bytes are here or not.
43 * We use only the first 12 bytes, so get only them.
45 #define RMI_F11_CTRL_REG_COUNT 12
49 RMI_MODE_ATTN_REPORTS
= 1,
50 RMI_MODE_NO_PACKED_ATTN_REPORTS
= 2,
54 * struct rmi_data - stores information for hid communication
56 * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
57 * @page: Keeps track of the current virtual page
58 * @xport: transport device to be registered with the RMI4 core.
60 * @wait: Used for waiting for read data
62 * @writeReport: output buffer when writing RMI registers
63 * @readReport: input buffer when reading RMI registers
65 * @input_report_size: size of an input report (advertised by HID)
66 * @output_report_size: size of an output report (advertised by HID)
68 * @flags: flags for the current device (started, reading, etc...)
70 * @reset_work: worker which will be called in case of a mouse report
71 * @hdev: pointer to the struct hid_device
73 * @device_flags: flags which describe the device
75 * @domain: the IRQ domain allocated for this RMI4 device
76 * @rmi_irq: the irq that will be used to generate events to rmi-core
79 struct mutex page_mutex
;
81 struct rmi_transport_dev xport
;
83 wait_queue_head_t wait
;
88 u32 input_report_size
;
89 u32 output_report_size
;
93 struct work_struct reset_work
;
94 struct hid_device
*hdev
;
96 unsigned long device_flags
;
98 struct irq_domain
*domain
;
102 #define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
104 static int rmi_write_report(struct hid_device
*hdev
, u8
*report
, int len
);
107 * rmi_set_page - Set RMI page
108 * @hdev: The pointer to the hid_device struct
109 * @page: The new page address.
111 * RMI devices have 16-bit addressing, but some of the physical
112 * implementations (like SMBus) only have 8-bit addressing. So RMI implements
113 * a page address at 0xff of every page so we can reliable page addresses
114 * every 256 registers.
116 * The page_mutex lock must be held when this function is entered.
118 * Returns zero on success, non-zero on failure.
120 static int rmi_set_page(struct hid_device
*hdev
, u8 page
)
122 struct rmi_data
*data
= hid_get_drvdata(hdev
);
125 data
->writeReport
[0] = RMI_WRITE_REPORT_ID
;
126 data
->writeReport
[1] = 1;
127 data
->writeReport
[2] = 0xFF;
128 data
->writeReport
[4] = page
;
130 retval
= rmi_write_report(hdev
, data
->writeReport
,
131 data
->output_report_size
);
132 if (retval
!= data
->output_report_size
) {
134 "%s: set page failed: %d.", __func__
, retval
);
142 static int rmi_set_mode(struct hid_device
*hdev
, u8 mode
)
145 const u8 txbuf
[2] = {RMI_SET_RMI_MODE_REPORT_ID
, mode
};
148 buf
= kmemdup(txbuf
, sizeof(txbuf
), GFP_KERNEL
);
152 ret
= hid_hw_raw_request(hdev
, RMI_SET_RMI_MODE_REPORT_ID
, buf
,
153 sizeof(txbuf
), HID_FEATURE_REPORT
, HID_REQ_SET_REPORT
);
156 dev_err(&hdev
->dev
, "unable to set rmi mode to %d (%d)\n", mode
,
164 static int rmi_write_report(struct hid_device
*hdev
, u8
*report
, int len
)
168 ret
= hid_hw_output_report(hdev
, (void *)report
, len
);
170 dev_err(&hdev
->dev
, "failed to write hid report (%d)\n", ret
);
177 static int rmi_hid_read_block(struct rmi_transport_dev
*xport
, u16 addr
,
178 void *buf
, size_t len
)
180 struct rmi_data
*data
= container_of(xport
, struct rmi_data
, xport
);
181 struct hid_device
*hdev
= data
->hdev
;
186 int read_input_count
;
188 mutex_lock(&data
->page_mutex
);
190 if (RMI_PAGE(addr
) != data
->page
) {
191 ret
= rmi_set_page(hdev
, RMI_PAGE(addr
));
196 for (retries
= 5; retries
> 0; retries
--) {
197 data
->writeReport
[0] = RMI_READ_ADDR_REPORT_ID
;
198 data
->writeReport
[1] = 0; /* old 1 byte read count */
199 data
->writeReport
[2] = addr
& 0xFF;
200 data
->writeReport
[3] = (addr
>> 8) & 0xFF;
201 data
->writeReport
[4] = len
& 0xFF;
202 data
->writeReport
[5] = (len
>> 8) & 0xFF;
204 set_bit(RMI_READ_REQUEST_PENDING
, &data
->flags
);
206 ret
= rmi_write_report(hdev
, data
->writeReport
,
207 data
->output_report_size
);
208 if (ret
!= data
->output_report_size
) {
209 clear_bit(RMI_READ_REQUEST_PENDING
, &data
->flags
);
211 "failed to write request output report (%d)\n",
218 while (bytes_read
< len
) {
219 if (!wait_event_timeout(data
->wait
,
220 test_bit(RMI_READ_DATA_PENDING
, &data
->flags
),
221 msecs_to_jiffies(1000))) {
222 hid_warn(hdev
, "%s: timeout elapsed\n",
228 read_input_count
= data
->readReport
[1];
229 memcpy(buf
+ bytes_read
, &data
->readReport
[2],
230 read_input_count
< bytes_needed
?
231 read_input_count
: bytes_needed
);
233 bytes_read
+= read_input_count
;
234 bytes_needed
-= read_input_count
;
235 clear_bit(RMI_READ_DATA_PENDING
, &data
->flags
);
245 clear_bit(RMI_READ_REQUEST_PENDING
, &data
->flags
);
246 mutex_unlock(&data
->page_mutex
);
250 static int rmi_hid_write_block(struct rmi_transport_dev
*xport
, u16 addr
,
251 const void *buf
, size_t len
)
253 struct rmi_data
*data
= container_of(xport
, struct rmi_data
, xport
);
254 struct hid_device
*hdev
= data
->hdev
;
257 mutex_lock(&data
->page_mutex
);
259 if (RMI_PAGE(addr
) != data
->page
) {
260 ret
= rmi_set_page(hdev
, RMI_PAGE(addr
));
265 data
->writeReport
[0] = RMI_WRITE_REPORT_ID
;
266 data
->writeReport
[1] = len
;
267 data
->writeReport
[2] = addr
& 0xFF;
268 data
->writeReport
[3] = (addr
>> 8) & 0xFF;
269 memcpy(&data
->writeReport
[4], buf
, len
);
271 ret
= rmi_write_report(hdev
, data
->writeReport
,
272 data
->output_report_size
);
275 "failed to write request output report (%d)\n",
282 mutex_unlock(&data
->page_mutex
);
286 static int rmi_reset_attn_mode(struct hid_device
*hdev
)
288 struct rmi_data
*data
= hid_get_drvdata(hdev
);
289 struct rmi_device
*rmi_dev
= data
->xport
.rmi_dev
;
292 ret
= rmi_set_mode(hdev
, RMI_MODE_ATTN_REPORTS
);
296 if (test_bit(RMI_STARTED
, &data
->flags
))
297 ret
= rmi_dev
->driver
->reset_handler(rmi_dev
);
302 static void rmi_reset_work(struct work_struct
*work
)
304 struct rmi_data
*hdata
= container_of(work
, struct rmi_data
,
307 /* switch the device to RMI if we receive a generic mouse report */
308 rmi_reset_attn_mode(hdata
->hdev
);
311 static int rmi_input_event(struct hid_device
*hdev
, u8
*data
, int size
)
313 struct rmi_data
*hdata
= hid_get_drvdata(hdev
);
314 struct rmi_device
*rmi_dev
= hdata
->xport
.rmi_dev
;
317 if (!(test_bit(RMI_STARTED
, &hdata
->flags
)))
320 local_irq_save(flags
);
322 rmi_set_attn_data(rmi_dev
, data
[1], &data
[2], size
- 2);
324 generic_handle_irq(hdata
->rmi_irq
);
326 local_irq_restore(flags
);
331 static int rmi_read_data_event(struct hid_device
*hdev
, u8
*data
, int size
)
333 struct rmi_data
*hdata
= hid_get_drvdata(hdev
);
335 if (!test_bit(RMI_READ_REQUEST_PENDING
, &hdata
->flags
)) {
336 hid_dbg(hdev
, "no read request pending\n");
340 memcpy(hdata
->readReport
, data
, size
< hdata
->input_report_size
?
341 size
: hdata
->input_report_size
);
342 set_bit(RMI_READ_DATA_PENDING
, &hdata
->flags
);
343 wake_up(&hdata
->wait
);
348 static int rmi_check_sanity(struct hid_device
*hdev
, u8
*data
, int size
)
350 int valid_size
= size
;
352 * On the Dell XPS 13 9333, the bus sometimes get confused and fills
353 * the report with a sentinel value "ff". Synaptics told us that such
354 * behavior does not comes from the touchpad itself, so we filter out
358 while ((data
[valid_size
- 1] == 0xff) && valid_size
> 0)
364 static int rmi_raw_event(struct hid_device
*hdev
,
365 struct hid_report
*report
, u8
*data
, int size
)
367 struct rmi_data
*hdata
= hid_get_drvdata(hdev
);
369 if (!(hdata
->device_flags
& RMI_DEVICE
))
372 size
= rmi_check_sanity(hdev
, data
, size
);
377 case RMI_READ_DATA_REPORT_ID
:
378 return rmi_read_data_event(hdev
, data
, size
);
379 case RMI_ATTN_REPORT_ID
:
380 return rmi_input_event(hdev
, data
, size
);
388 static int rmi_event(struct hid_device
*hdev
, struct hid_field
*field
,
389 struct hid_usage
*usage
, __s32 value
)
391 struct rmi_data
*data
= hid_get_drvdata(hdev
);
393 if ((data
->device_flags
& RMI_DEVICE
) &&
394 (field
->application
== HID_GD_POINTER
||
395 field
->application
== HID_GD_MOUSE
)) {
396 if (data
->device_flags
& RMI_DEVICE_HAS_PHYS_BUTTONS
) {
397 if ((usage
->hid
& HID_USAGE_PAGE
) == HID_UP_BUTTON
)
400 if ((usage
->hid
== HID_GD_X
|| usage
->hid
== HID_GD_Y
)
405 schedule_work(&data
->reset_work
);
412 static void rmi_report(struct hid_device
*hid
, struct hid_report
*report
)
414 struct hid_field
*field
= report
->field
[0];
416 if (!(hid
->claimed
& HID_CLAIMED_INPUT
))
419 switch (report
->id
) {
420 case RMI_READ_DATA_REPORT_ID
:
422 case RMI_ATTN_REPORT_ID
:
426 if (field
&& field
->hidinput
&& field
->hidinput
->input
)
427 input_sync(field
->hidinput
->input
);
431 static int rmi_suspend(struct hid_device
*hdev
, pm_message_t message
)
433 struct rmi_data
*data
= hid_get_drvdata(hdev
);
434 struct rmi_device
*rmi_dev
= data
->xport
.rmi_dev
;
437 if (!(data
->device_flags
& RMI_DEVICE
))
440 ret
= rmi_driver_suspend(rmi_dev
, false);
442 hid_warn(hdev
, "Failed to suspend device: %d\n", ret
);
449 static int rmi_post_resume(struct hid_device
*hdev
)
451 struct rmi_data
*data
= hid_get_drvdata(hdev
);
452 struct rmi_device
*rmi_dev
= data
->xport
.rmi_dev
;
455 if (!(data
->device_flags
& RMI_DEVICE
))
458 /* Make sure the HID device is ready to receive events */
459 ret
= hid_hw_open(hdev
);
463 ret
= rmi_reset_attn_mode(hdev
);
467 ret
= rmi_driver_resume(rmi_dev
, false);
469 hid_warn(hdev
, "Failed to resume device: %d\n", ret
);
477 #endif /* CONFIG_PM */
479 static int rmi_hid_reset(struct rmi_transport_dev
*xport
, u16 reset_addr
)
481 struct rmi_data
*data
= container_of(xport
, struct rmi_data
, xport
);
482 struct hid_device
*hdev
= data
->hdev
;
484 return rmi_reset_attn_mode(hdev
);
487 static int rmi_input_configured(struct hid_device
*hdev
, struct hid_input
*hi
)
489 struct rmi_data
*data
= hid_get_drvdata(hdev
);
490 struct input_dev
*input
= hi
->input
;
493 if (!(data
->device_flags
& RMI_DEVICE
))
496 data
->xport
.input
= input
;
498 hid_dbg(hdev
, "Opening low level driver\n");
499 ret
= hid_hw_open(hdev
);
503 /* Allow incoming hid reports */
504 hid_device_io_start(hdev
);
506 ret
= rmi_set_mode(hdev
, RMI_MODE_ATTN_REPORTS
);
508 dev_err(&hdev
->dev
, "failed to set rmi mode\n");
512 ret
= rmi_set_page(hdev
, 0);
514 dev_err(&hdev
->dev
, "failed to set page select to 0.\n");
518 ret
= rmi_register_transport_device(&data
->xport
);
520 dev_err(&hdev
->dev
, "failed to register transport driver\n");
524 set_bit(RMI_STARTED
, &data
->flags
);
527 hid_device_io_stop(hdev
);
532 static int rmi_input_mapping(struct hid_device
*hdev
,
533 struct hid_input
*hi
, struct hid_field
*field
,
534 struct hid_usage
*usage
, unsigned long **bit
, int *max
)
536 struct rmi_data
*data
= hid_get_drvdata(hdev
);
539 * we want to make HID ignore the advertised HID collection
542 if (data
->device_flags
& RMI_DEVICE
) {
543 if ((data
->device_flags
& RMI_DEVICE_HAS_PHYS_BUTTONS
) &&
544 ((usage
->hid
& HID_USAGE_PAGE
) == HID_UP_BUTTON
))
553 static int rmi_check_valid_report_id(struct hid_device
*hdev
, unsigned type
,
554 unsigned id
, struct hid_report
**report
)
558 *report
= hdev
->report_enum
[type
].report_id_hash
[id
];
560 for (i
= 0; i
< (*report
)->maxfield
; i
++) {
561 unsigned app
= (*report
)->field
[i
]->application
;
562 if ((app
& HID_USAGE_PAGE
) >= HID_UP_MSVENDOR
)
570 static struct rmi_device_platform_data rmi_hid_pdata
= {
572 .sensor_type
= rmi_sensor_touchpad
,
573 .axis_align
.flip_y
= true,
574 .dribble
= RMI_REG_STATE_ON
,
575 .palm_detect
= RMI_REG_STATE_OFF
,
579 static const struct rmi_transport_ops hid_rmi_ops
= {
580 .write_block
= rmi_hid_write_block
,
581 .read_block
= rmi_hid_read_block
,
582 .reset
= rmi_hid_reset
,
585 static void rmi_irq_teardown(void *data
)
587 struct rmi_data
*hdata
= data
;
588 struct irq_domain
*domain
= hdata
->domain
;
593 irq_dispose_mapping(irq_find_mapping(domain
, 0));
595 irq_domain_remove(domain
);
596 hdata
->domain
= NULL
;
600 static int rmi_irq_map(struct irq_domain
*h
, unsigned int virq
,
601 irq_hw_number_t hw_irq_num
)
603 irq_set_chip_and_handler(virq
, &dummy_irq_chip
, handle_simple_irq
);
608 static const struct irq_domain_ops rmi_irq_ops
= {
612 static int rmi_setup_irq_domain(struct hid_device
*hdev
)
614 struct rmi_data
*hdata
= hid_get_drvdata(hdev
);
617 hdata
->domain
= irq_domain_create_linear(hdev
->dev
.fwnode
, 1,
618 &rmi_irq_ops
, hdata
);
622 ret
= devm_add_action_or_reset(&hdev
->dev
, &rmi_irq_teardown
, hdata
);
626 hdata
->rmi_irq
= irq_create_mapping(hdata
->domain
, 0);
627 if (hdata
->rmi_irq
<= 0) {
628 hid_err(hdev
, "Can't allocate an IRQ\n");
629 return hdata
->rmi_irq
< 0 ? hdata
->rmi_irq
: -ENXIO
;
635 static int rmi_probe(struct hid_device
*hdev
, const struct hid_device_id
*id
)
637 struct rmi_data
*data
= NULL
;
640 struct hid_report
*input_report
;
641 struct hid_report
*output_report
;
642 struct hid_report
*feature_report
;
644 data
= devm_kzalloc(&hdev
->dev
, sizeof(struct rmi_data
), GFP_KERNEL
);
648 INIT_WORK(&data
->reset_work
, rmi_reset_work
);
651 hid_set_drvdata(hdev
, data
);
653 hdev
->quirks
|= HID_QUIRK_NO_INIT_REPORTS
;
654 hdev
->quirks
|= HID_QUIRK_NO_INPUT_SYNC
;
656 ret
= hid_parse(hdev
);
658 hid_err(hdev
, "parse failed\n");
663 data
->device_flags
= id
->driver_data
;
666 * Check for the RMI specific report ids. If they are misisng
667 * simply return and let the events be processed by hid-input
669 if (!rmi_check_valid_report_id(hdev
, HID_FEATURE_REPORT
,
670 RMI_SET_RMI_MODE_REPORT_ID
, &feature_report
)) {
671 hid_dbg(hdev
, "device does not have set mode feature report\n");
675 if (!rmi_check_valid_report_id(hdev
, HID_INPUT_REPORT
,
676 RMI_ATTN_REPORT_ID
, &input_report
)) {
677 hid_dbg(hdev
, "device does not have attention input report\n");
681 data
->input_report_size
= hid_report_len(input_report
);
683 if (!rmi_check_valid_report_id(hdev
, HID_OUTPUT_REPORT
,
684 RMI_WRITE_REPORT_ID
, &output_report
)) {
686 "device does not have rmi write output report\n");
690 data
->output_report_size
= hid_report_len(output_report
);
692 data
->device_flags
|= RMI_DEVICE
;
693 alloc_size
= data
->output_report_size
+ data
->input_report_size
;
695 data
->writeReport
= devm_kzalloc(&hdev
->dev
, alloc_size
, GFP_KERNEL
);
696 if (!data
->writeReport
) {
697 hid_err(hdev
, "failed to allocate buffer for HID reports\n");
701 data
->readReport
= data
->writeReport
+ data
->output_report_size
;
703 init_waitqueue_head(&data
->wait
);
705 mutex_init(&data
->page_mutex
);
707 ret
= rmi_setup_irq_domain(hdev
);
709 hid_err(hdev
, "failed to allocate IRQ domain\n");
713 if (data
->device_flags
& RMI_DEVICE_HAS_PHYS_BUTTONS
)
714 rmi_hid_pdata
.f30_data
.disable
= true;
716 data
->xport
.dev
= hdev
->dev
.parent
;
717 data
->xport
.pdata
= rmi_hid_pdata
;
718 data
->xport
.pdata
.irq
= data
->rmi_irq
;
719 data
->xport
.proto_name
= "hid";
720 data
->xport
.ops
= &hid_rmi_ops
;
723 ret
= hid_hw_start(hdev
, HID_CONNECT_DEFAULT
);
725 hid_err(hdev
, "hw start failed\n");
732 static void rmi_remove(struct hid_device
*hdev
)
734 struct rmi_data
*hdata
= hid_get_drvdata(hdev
);
736 if (hdata
->device_flags
& RMI_DEVICE
) {
737 clear_bit(RMI_STARTED
, &hdata
->flags
);
738 cancel_work_sync(&hdata
->reset_work
);
739 rmi_unregister_transport_device(&hdata
->xport
);
745 static const struct hid_device_id rmi_id
[] = {
746 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER
, USB_DEVICE_ID_RAZER_BLADE_14
),
747 .driver_data
= RMI_DEVICE_HAS_PHYS_BUTTONS
},
748 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO
, USB_DEVICE_ID_LENOVO_X1_COVER
) },
749 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX
, USB_DEVICE_ID_PRIMAX_REZEL
) },
750 { HID_DEVICE(HID_BUS_ANY
, HID_GROUP_RMI
, HID_ANY_ID
, HID_ANY_ID
) },
753 MODULE_DEVICE_TABLE(hid
, rmi_id
);
755 static struct hid_driver rmi_driver
= {
759 .remove
= rmi_remove
,
761 .raw_event
= rmi_raw_event
,
762 .report
= rmi_report
,
763 .input_mapping
= rmi_input_mapping
,
764 .input_configured
= rmi_input_configured
,
766 .suspend
= rmi_suspend
,
767 .resume
= rmi_post_resume
,
768 .reset_resume
= rmi_post_resume
,
772 module_hid_driver(rmi_driver
);
774 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
775 MODULE_DESCRIPTION("RMI HID driver");
776 MODULE_LICENSE("GPL");