Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
9fb6bf02 BT |
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 | |
9fb6bf02 BT |
7 | */ |
8 | ||
9 | #include <linux/kernel.h> | |
10 | #include <linux/hid.h> | |
11 | #include <linux/input.h> | |
12 | #include <linux/input/mt.h> | |
0b2c7a89 AD |
13 | #include <linux/irq.h> |
14 | #include <linux/irqdomain.h> | |
9fb6bf02 BT |
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> | |
0b2c7a89 | 20 | #include <linux/rmi.h> |
9fb6bf02 BT |
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 */ | |
af43c408 DC |
31 | #define RMI_READ_REQUEST_PENDING 0 |
32 | #define RMI_READ_DATA_PENDING 1 | |
33 | #define RMI_STARTED 2 | |
9fb6bf02 | 34 | |
2f43de60 AD |
35 | /* device flags */ |
36 | #define RMI_DEVICE BIT(0) | |
79364d87 | 37 | #define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1) |
10235380 | 38 | #define RMI_DEVICE_OUTPUT_SET_REPORT BIT(2) |
2f43de60 | 39 | |
7035f3a4 AD |
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 | ||
9fb6bf02 BT |
48 | enum rmi_mode_type { |
49 | RMI_MODE_OFF = 0, | |
50 | RMI_MODE_ATTN_REPORTS = 1, | |
51 | RMI_MODE_NO_PACKED_ATTN_REPORTS = 2, | |
52 | }; | |
53 | ||
9fb6bf02 BT |
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 | |
0b2c7a89 | 59 | * @xport: transport device to be registered with the RMI4 core. |
9fb6bf02 BT |
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 | * | |
9fb6bf02 BT |
71 | * @reset_work: worker which will be called in case of a mouse report |
72 | * @hdev: pointer to the struct hid_device | |
0b2c7a89 AD |
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 | |
9fb6bf02 BT |
78 | */ |
79 | struct rmi_data { | |
80 | struct mutex page_mutex; | |
81 | int page; | |
0b2c7a89 | 82 | struct rmi_transport_dev xport; |
9fb6bf02 BT |
83 | |
84 | wait_queue_head_t wait; | |
85 | ||
86 | u8 *writeReport; | |
87 | u8 *readReport; | |
88 | ||
3064a03b AM |
89 | u32 input_report_size; |
90 | u32 output_report_size; | |
9fb6bf02 BT |
91 | |
92 | unsigned long flags; | |
93 | ||
9fb6bf02 BT |
94 | struct work_struct reset_work; |
95 | struct hid_device *hdev; | |
2f43de60 AD |
96 | |
97 | unsigned long device_flags; | |
09256360 | 98 | |
0b2c7a89 AD |
99 | struct irq_domain *domain; |
100 | int rmi_irq; | |
9fb6bf02 BT |
101 | }; |
102 | ||
103 | #define RMI_PAGE(addr) (((addr) >> 8) & 0xff) | |
104 | ||
105 | static 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 | */ | |
121 | static 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 | ||
143 | static int rmi_set_mode(struct hid_device *hdev, u8 mode) | |
144 | { | |
145 | int ret; | |
6dab07df BT |
146 | const u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode}; |
147 | u8 *buf; | |
9fb6bf02 | 148 | |
6dab07df BT |
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, | |
9fb6bf02 | 154 | sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT); |
6dab07df | 155 | kfree(buf); |
9fb6bf02 BT |
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 | ||
165 | static int rmi_write_report(struct hid_device *hdev, u8 *report, int len) | |
166 | { | |
10235380 | 167 | struct rmi_data *data = hid_get_drvdata(hdev); |
9fb6bf02 BT |
168 | int ret; |
169 | ||
10235380 TA |
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 | ||
9fb6bf02 BT |
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 | ||
0b2c7a89 AD |
188 | static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr, |
189 | void *buf, size_t len) | |
9fb6bf02 | 190 | { |
0b2c7a89 AD |
191 | struct rmi_data *data = container_of(xport, struct rmi_data, xport); |
192 | struct hid_device *hdev = data->hdev; | |
9fb6bf02 BT |
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) { | |
9fb6bf02 BT |
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], | |
486da113 | 240 | min(read_input_count, bytes_needed)); |
9fb6bf02 BT |
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 | ||
253 | exit: | |
254 | clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); | |
255 | mutex_unlock(&data->page_mutex); | |
256 | return ret; | |
257 | } | |
258 | ||
0b2c7a89 AD |
259 | static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr, |
260 | const void *buf, size_t len) | |
dd8df284 | 261 | { |
0b2c7a89 AD |
262 | struct rmi_data *data = container_of(xport, struct rmi_data, xport); |
263 | struct hid_device *hdev = data->hdev; | |
dd8df284 AD |
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 | ||
290 | exit: | |
291 | mutex_unlock(&data->page_mutex); | |
292 | return ret; | |
293 | } | |
294 | ||
9a98b338 AD |
295 | static int rmi_reset_attn_mode(struct hid_device *hdev) |
296 | { | |
297 | struct rmi_data *data = hid_get_drvdata(hdev); | |
0b2c7a89 | 298 | struct rmi_device *rmi_dev = data->xport.rmi_dev; |
9a98b338 AD |
299 | int ret; |
300 | ||
301 | ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); | |
302 | if (ret) | |
303 | return ret; | |
304 | ||
0b2c7a89 AD |
305 | if (test_bit(RMI_STARTED, &data->flags)) |
306 | ret = rmi_dev->driver->reset_handler(rmi_dev); | |
9a98b338 | 307 | |
0b2c7a89 | 308 | return ret; |
9a98b338 AD |
309 | } |
310 | ||
9fb6bf02 BT |
311 | static 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 */ | |
9a98b338 | 317 | rmi_reset_attn_mode(hdata->hdev); |
9fb6bf02 BT |
318 | } |
319 | ||
0b2c7a89 | 320 | static int rmi_input_event(struct hid_device *hdev, u8 *data, int size) |
9fb6bf02 BT |
321 | { |
322 | struct rmi_data *hdata = hid_get_drvdata(hdev); | |
0b2c7a89 AD |
323 | struct rmi_device *rmi_dev = hdata->xport.rmi_dev; |
324 | unsigned long flags; | |
9fb6bf02 | 325 | |
0b2c7a89 | 326 | if (!(test_bit(RMI_STARTED, &hdata->flags))) |
9fb6bf02 BT |
327 | return 0; |
328 | ||
9984fbf5 DT |
329 | pm_wakeup_event(hdev->dev.parent, 0); |
330 | ||
0b2c7a89 | 331 | local_irq_save(flags); |
5b65c2a0 | 332 | |
0b2c7a89 | 333 | rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2); |
9fb6bf02 | 334 | |
0b2c7a89 | 335 | generic_handle_irq(hdata->rmi_irq); |
9fb6bf02 | 336 | |
0b2c7a89 | 337 | local_irq_restore(flags); |
9fb6bf02 BT |
338 | |
339 | return 1; | |
340 | } | |
341 | ||
342 | static 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)) { | |
01a5f8a4 | 347 | hid_dbg(hdev, "no read request pending\n"); |
9fb6bf02 BT |
348 | return 0; |
349 | } | |
350 | ||
486da113 | 351 | memcpy(hdata->readReport, data, min((u32)size, hdata->input_report_size)); |
9fb6bf02 BT |
352 | set_bit(RMI_READ_DATA_PENDING, &hdata->flags); |
353 | wake_up(&hdata->wait); | |
354 | ||
355 | return 1; | |
356 | } | |
357 | ||
5b65c2a0 BT |
358 | static 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 | ||
9fb6bf02 BT |
374 | static int rmi_raw_event(struct hid_device *hdev, |
375 | struct hid_report *report, u8 *data, int size) | |
376 | { | |
ef14a4bf AD |
377 | struct rmi_data *hdata = hid_get_drvdata(hdev); |
378 | ||
379 | if (!(hdata->device_flags & RMI_DEVICE)) | |
380 | return 0; | |
381 | ||
5b65c2a0 BT |
382 | size = rmi_check_sanity(hdev, data, size); |
383 | if (size < 2) | |
384 | return 0; | |
385 | ||
9fb6bf02 BT |
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); | |
2f43de60 AD |
391 | default: |
392 | return 1; | |
393 | } | |
394 | ||
395 | return 0; | |
396 | } | |
397 | ||
398 | static 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)) { | |
79364d87 AD |
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 | ||
0b2c7a89 | 415 | schedule_work(&data->reset_work); |
2f43de60 | 416 | return 1; |
9fb6bf02 BT |
417 | } |
418 | ||
419 | return 0; | |
420 | } | |
421 | ||
c94ba060 BT |
422 | static 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: | |
c94ba060 BT |
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 | ||
a278e268 | 439 | #ifdef CONFIG_PM |
09256360 AD |
440 | static int rmi_suspend(struct hid_device *hdev, pm_message_t message) |
441 | { | |
7035f3a4 | 442 | struct rmi_data *data = hid_get_drvdata(hdev); |
0b2c7a89 | 443 | struct rmi_device *rmi_dev = data->xport.rmi_dev; |
09256360 AD |
444 | int ret; |
445 | ||
b786ae8e AD |
446 | if (!(data->device_flags & RMI_DEVICE)) |
447 | return 0; | |
448 | ||
0b2c7a89 | 449 | ret = rmi_driver_suspend(rmi_dev, false); |
09256360 | 450 | if (ret) { |
0b2c7a89 | 451 | hid_warn(hdev, "Failed to suspend device: %d\n", ret); |
09256360 AD |
452 | return ret; |
453 | } | |
454 | ||
0b2c7a89 | 455 | return 0; |
9fb6bf02 BT |
456 | } |
457 | ||
458 | static int rmi_post_resume(struct hid_device *hdev) | |
459 | { | |
b786ae8e | 460 | struct rmi_data *data = hid_get_drvdata(hdev); |
0b2c7a89 AD |
461 | struct rmi_device *rmi_dev = data->xport.rmi_dev; |
462 | int ret; | |
b786ae8e AD |
463 | |
464 | if (!(data->device_flags & RMI_DEVICE)) | |
465 | return 0; | |
466 | ||
cac72b99 L |
467 | /* Make sure the HID device is ready to receive events */ |
468 | ret = hid_hw_open(hdev); | |
0b2c7a89 | 469 | if (ret) |
05ba999f | 470 | return ret; |
8414947a | 471 | |
cac72b99 L |
472 | ret = rmi_reset_attn_mode(hdev); |
473 | if (ret) | |
474 | goto out; | |
475 | ||
0b2c7a89 | 476 | ret = rmi_driver_resume(rmi_dev, false); |
9fb6bf02 | 477 | if (ret) { |
0b2c7a89 | 478 | hid_warn(hdev, "Failed to resume device: %d\n", ret); |
cac72b99 | 479 | goto out; |
9fb6bf02 BT |
480 | } |
481 | ||
cac72b99 L |
482 | out: |
483 | hid_hw_close(hdev); | |
484 | return ret; | |
9fb6bf02 | 485 | } |
0b2c7a89 | 486 | #endif /* CONFIG_PM */ |
9fb6bf02 | 487 | |
0b2c7a89 | 488 | static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr) |
9fb6bf02 | 489 | { |
0b2c7a89 AD |
490 | struct rmi_data *data = container_of(xport, struct rmi_data, xport); |
491 | struct hid_device *hdev = data->hdev; | |
9fb6bf02 | 492 | |
0b2c7a89 | 493 | return rmi_reset_attn_mode(hdev); |
9fb6bf02 BT |
494 | } |
495 | ||
9154301a | 496 | static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) |
9fb6bf02 BT |
497 | { |
498 | struct rmi_data *data = hid_get_drvdata(hdev); | |
499 | struct input_dev *input = hi->input; | |
0b2c7a89 AD |
500 | int ret = 0; |
501 | ||
502 | if (!(data->device_flags & RMI_DEVICE)) | |
503 | return 0; | |
9fb6bf02 | 504 | |
0b2c7a89 | 505 | data->xport.input = input; |
9fb6bf02 BT |
506 | |
507 | hid_dbg(hdev, "Opening low level driver\n"); | |
508 | ret = hid_hw_open(hdev); | |
509 | if (ret) | |
9154301a | 510 | return ret; |
9fb6bf02 BT |
511 | |
512 | /* Allow incoming hid reports */ | |
513 | hid_device_io_start(hdev); | |
514 | ||
515 | ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); | |
516 | if (ret < 0) { | |
517 | dev_err(&hdev->dev, "failed to set rmi mode\n"); | |
518 | goto exit; | |
519 | } | |
520 | ||
521 | ret = rmi_set_page(hdev, 0); | |
522 | if (ret < 0) { | |
523 | dev_err(&hdev->dev, "failed to set page select to 0.\n"); | |
524 | goto exit; | |
525 | } | |
526 | ||
0b2c7a89 AD |
527 | ret = rmi_register_transport_device(&data->xport); |
528 | if (ret < 0) { | |
529 | dev_err(&hdev->dev, "failed to register transport driver\n"); | |
9154301a | 530 | goto exit; |
9fb6bf02 BT |
531 | } |
532 | ||
533 | set_bit(RMI_STARTED, &data->flags); | |
534 | ||
535 | exit: | |
536 | hid_device_io_stop(hdev); | |
537 | hid_hw_close(hdev); | |
9154301a | 538 | return ret; |
9fb6bf02 BT |
539 | } |
540 | ||
541 | static int rmi_input_mapping(struct hid_device *hdev, | |
542 | struct hid_input *hi, struct hid_field *field, | |
543 | struct hid_usage *usage, unsigned long **bit, int *max) | |
544 | { | |
2f43de60 AD |
545 | struct rmi_data *data = hid_get_drvdata(hdev); |
546 | ||
547 | /* | |
548 | * we want to make HID ignore the advertised HID collection | |
549 | * for RMI deivces | |
550 | */ | |
79364d87 AD |
551 | if (data->device_flags & RMI_DEVICE) { |
552 | if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) && | |
553 | ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)) | |
554 | return 0; | |
555 | ||
2f43de60 | 556 | return -1; |
79364d87 | 557 | } |
2f43de60 AD |
558 | |
559 | return 0; | |
560 | } | |
561 | ||
562 | static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type, | |
563 | unsigned id, struct hid_report **report) | |
564 | { | |
565 | int i; | |
566 | ||
567 | *report = hdev->report_enum[type].report_id_hash[id]; | |
568 | if (*report) { | |
569 | for (i = 0; i < (*report)->maxfield; i++) { | |
570 | unsigned app = (*report)->field[i]->application; | |
571 | if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR) | |
572 | return 1; | |
573 | } | |
574 | } | |
575 | ||
576 | return 0; | |
9fb6bf02 BT |
577 | } |
578 | ||
0b2c7a89 AD |
579 | static struct rmi_device_platform_data rmi_hid_pdata = { |
580 | .sensor_pdata = { | |
581 | .sensor_type = rmi_sensor_touchpad, | |
582 | .axis_align.flip_y = true, | |
583 | .dribble = RMI_REG_STATE_ON, | |
584 | .palm_detect = RMI_REG_STATE_OFF, | |
585 | }, | |
586 | }; | |
587 | ||
588 | static const struct rmi_transport_ops hid_rmi_ops = { | |
589 | .write_block = rmi_hid_write_block, | |
590 | .read_block = rmi_hid_read_block, | |
591 | .reset = rmi_hid_reset, | |
592 | }; | |
593 | ||
594 | static void rmi_irq_teardown(void *data) | |
595 | { | |
596 | struct rmi_data *hdata = data; | |
597 | struct irq_domain *domain = hdata->domain; | |
598 | ||
599 | if (!domain) | |
600 | return; | |
601 | ||
602 | irq_dispose_mapping(irq_find_mapping(domain, 0)); | |
603 | ||
604 | irq_domain_remove(domain); | |
605 | hdata->domain = NULL; | |
606 | hdata->rmi_irq = 0; | |
607 | } | |
608 | ||
609 | static int rmi_irq_map(struct irq_domain *h, unsigned int virq, | |
610 | irq_hw_number_t hw_irq_num) | |
611 | { | |
612 | irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq); | |
613 | ||
614 | return 0; | |
615 | } | |
616 | ||
617 | static const struct irq_domain_ops rmi_irq_ops = { | |
618 | .map = rmi_irq_map, | |
619 | }; | |
620 | ||
621 | static int rmi_setup_irq_domain(struct hid_device *hdev) | |
622 | { | |
623 | struct rmi_data *hdata = hid_get_drvdata(hdev); | |
624 | int ret; | |
625 | ||
626 | hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1, | |
627 | &rmi_irq_ops, hdata); | |
628 | if (!hdata->domain) | |
629 | return -ENOMEM; | |
630 | ||
631 | ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata); | |
632 | if (ret) | |
633 | return ret; | |
634 | ||
635 | hdata->rmi_irq = irq_create_mapping(hdata->domain, 0); | |
636 | if (hdata->rmi_irq <= 0) { | |
637 | hid_err(hdev, "Can't allocate an IRQ\n"); | |
638 | return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO; | |
639 | } | |
640 | ||
641 | return 0; | |
642 | } | |
643 | ||
9fb6bf02 BT |
644 | static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) |
645 | { | |
646 | struct rmi_data *data = NULL; | |
647 | int ret; | |
648 | size_t alloc_size; | |
dd3edeb6 AD |
649 | struct hid_report *input_report; |
650 | struct hid_report *output_report; | |
2f43de60 | 651 | struct hid_report *feature_report; |
9fb6bf02 BT |
652 | |
653 | data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL); | |
654 | if (!data) | |
655 | return -ENOMEM; | |
656 | ||
657 | INIT_WORK(&data->reset_work, rmi_reset_work); | |
658 | data->hdev = hdev; | |
659 | ||
660 | hid_set_drvdata(hdev, data); | |
661 | ||
662 | hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; | |
c94ba060 | 663 | hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; |
9fb6bf02 BT |
664 | |
665 | ret = hid_parse(hdev); | |
666 | if (ret) { | |
667 | hid_err(hdev, "parse failed\n"); | |
668 | return ret; | |
669 | } | |
670 | ||
79364d87 AD |
671 | if (id->driver_data) |
672 | data->device_flags = id->driver_data; | |
673 | ||
2f43de60 AD |
674 | /* |
675 | * Check for the RMI specific report ids. If they are misisng | |
676 | * simply return and let the events be processed by hid-input | |
677 | */ | |
678 | if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT, | |
679 | RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) { | |
680 | hid_dbg(hdev, "device does not have set mode feature report\n"); | |
681 | goto start; | |
682 | } | |
683 | ||
684 | if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT, | |
685 | RMI_ATTN_REPORT_ID, &input_report)) { | |
686 | hid_dbg(hdev, "device does not have attention input report\n"); | |
687 | goto start; | |
dd3edeb6 AD |
688 | } |
689 | ||
b8aed6ea | 690 | data->input_report_size = hid_report_len(input_report); |
dd3edeb6 | 691 | |
2f43de60 AD |
692 | if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT, |
693 | RMI_WRITE_REPORT_ID, &output_report)) { | |
694 | hid_dbg(hdev, | |
695 | "device does not have rmi write output report\n"); | |
696 | goto start; | |
dd3edeb6 AD |
697 | } |
698 | ||
b8aed6ea | 699 | data->output_report_size = hid_report_len(output_report); |
9fb6bf02 | 700 | |
2f43de60 | 701 | data->device_flags |= RMI_DEVICE; |
9fb6bf02 BT |
702 | alloc_size = data->output_report_size + data->input_report_size; |
703 | ||
704 | data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL); | |
705 | if (!data->writeReport) { | |
0b2c7a89 AD |
706 | hid_err(hdev, "failed to allocate buffer for HID reports\n"); |
707 | return -ENOMEM; | |
9fb6bf02 BT |
708 | } |
709 | ||
710 | data->readReport = data->writeReport + data->output_report_size; | |
711 | ||
712 | init_waitqueue_head(&data->wait); | |
713 | ||
714 | mutex_init(&data->page_mutex); | |
715 | ||
0b2c7a89 AD |
716 | ret = rmi_setup_irq_domain(hdev); |
717 | if (ret) { | |
718 | hid_err(hdev, "failed to allocate IRQ domain\n"); | |
719 | return ret; | |
720 | } | |
721 | ||
722 | if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) | |
261bfb33 | 723 | rmi_hid_pdata.gpio_data.disable = true; |
0b2c7a89 AD |
724 | |
725 | data->xport.dev = hdev->dev.parent; | |
726 | data->xport.pdata = rmi_hid_pdata; | |
727 | data->xport.pdata.irq = data->rmi_irq; | |
728 | data->xport.proto_name = "hid"; | |
729 | data->xport.ops = &hid_rmi_ops; | |
730 | ||
2f43de60 | 731 | start: |
9fb6bf02 BT |
732 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); |
733 | if (ret) { | |
734 | hid_err(hdev, "hw start failed\n"); | |
735 | return ret; | |
736 | } | |
737 | ||
9fb6bf02 BT |
738 | return 0; |
739 | } | |
740 | ||
741 | static void rmi_remove(struct hid_device *hdev) | |
742 | { | |
743 | struct rmi_data *hdata = hid_get_drvdata(hdev); | |
744 | ||
8725aa4f AD |
745 | if ((hdata->device_flags & RMI_DEVICE) |
746 | && test_bit(RMI_STARTED, &hdata->flags)) { | |
ef14a4bf AD |
747 | clear_bit(RMI_STARTED, &hdata->flags); |
748 | cancel_work_sync(&hdata->reset_work); | |
749 | rmi_unregister_transport_device(&hdata->xport); | |
750 | } | |
9fb6bf02 BT |
751 | |
752 | hid_hw_stop(hdev); | |
753 | } | |
754 | ||
755 | static const struct hid_device_id rmi_id[] = { | |
e9287099 AD |
756 | { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14), |
757 | .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS }, | |
c7821d0f | 758 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) }, |
c5293409 | 759 | { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_REZEL) }, |
10235380 TA |
760 | { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5), |
761 | .driver_data = RMI_DEVICE_OUTPUT_SET_REPORT }, | |
ba391e5a | 762 | { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) }, |
9fb6bf02 BT |
763 | { } |
764 | }; | |
765 | MODULE_DEVICE_TABLE(hid, rmi_id); | |
766 | ||
767 | static struct hid_driver rmi_driver = { | |
768 | .name = "hid-rmi", | |
769 | .id_table = rmi_id, | |
770 | .probe = rmi_probe, | |
771 | .remove = rmi_remove, | |
2f43de60 | 772 | .event = rmi_event, |
9fb6bf02 | 773 | .raw_event = rmi_raw_event, |
c94ba060 | 774 | .report = rmi_report, |
9fb6bf02 BT |
775 | .input_mapping = rmi_input_mapping, |
776 | .input_configured = rmi_input_configured, | |
777 | #ifdef CONFIG_PM | |
09256360 | 778 | .suspend = rmi_suspend, |
9fb6bf02 | 779 | .resume = rmi_post_resume, |
0b2c7a89 | 780 | .reset_resume = rmi_post_resume, |
9fb6bf02 BT |
781 | #endif |
782 | }; | |
783 | ||
784 | module_hid_driver(rmi_driver); | |
785 | ||
786 | MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>"); | |
787 | MODULE_DESCRIPTION("RMI HID driver"); | |
788 | MODULE_LICENSE("GPL"); |