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");