1 /* 2 * Copyright (c) 2013 Andrew Duggan <aduggan@synaptics.com> 3 * Copyright (c) 2013 Synaptics Incorporated 4 * Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@gmail.com> 5 * Copyright (c) 2014 Red Hat, Inc 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the Free 9 * Software Foundation; either version 2 of the License, or (at your option) 10 * any later version. 11 */ 12 13 #include <linux/kernel.h> 14 #include <linux/hid.h> 15 #include <linux/input.h> 16 #include <linux/input/mt.h> 17 #include <linux/module.h> 18 #include <linux/pm.h> 19 #include <linux/slab.h> 20 #include <linux/wait.h> 21 #include <linux/sched.h> 22 #include "hid-ids.h" 23 24 #define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */ 25 #define RMI_WRITE_REPORT_ID 0x09 /* Output Report */ 26 #define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */ 27 #define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */ 28 #define RMI_ATTN_REPORT_ID 0x0c /* Input Report */ 29 #define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */ 30 31 /* flags */ 32 #define RMI_READ_REQUEST_PENDING 0 33 #define RMI_READ_DATA_PENDING 1 34 #define RMI_STARTED 2 35 36 #define RMI_SLEEP_NORMAL 0x0 37 #define RMI_SLEEP_DEEP_SLEEP 0x1 38 39 /* device flags */ 40 #define RMI_DEVICE BIT(0) 41 #define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1) 42 43 /* 44 * retrieve the ctrl registers 45 * the ctrl register has a size of 20 but a fw bug split it into 16 + 4, 46 * and there is no way to know if the first 20 bytes are here or not. 47 * We use only the first 12 bytes, so get only them. 48 */ 49 #define RMI_F11_CTRL_REG_COUNT 12 50 51 enum rmi_mode_type { 52 RMI_MODE_OFF = 0, 53 RMI_MODE_ATTN_REPORTS = 1, 54 RMI_MODE_NO_PACKED_ATTN_REPORTS = 2, 55 }; 56 57 struct rmi_function { 58 unsigned page; /* page of the function */ 59 u16 query_base_addr; /* base address for queries */ 60 u16 command_base_addr; /* base address for commands */ 61 u16 control_base_addr; /* base address for controls */ 62 u16 data_base_addr; /* base address for datas */ 63 unsigned int interrupt_base; /* cross-function interrupt number 64 * (uniq in the device)*/ 65 unsigned int interrupt_count; /* number of interrupts */ 66 unsigned int report_size; /* size of a report */ 67 unsigned long irq_mask; /* mask of the interrupts 68 * (to be applied against ATTN IRQ) */ 69 }; 70 71 /** 72 * struct rmi_data - stores information for hid communication 73 * 74 * @page_mutex: Locks current page to avoid changing pages in unexpected ways. 75 * @page: Keeps track of the current virtual page 76 * 77 * @wait: Used for waiting for read data 78 * 79 * @writeReport: output buffer when writing RMI registers 80 * @readReport: input buffer when reading RMI registers 81 * 82 * @input_report_size: size of an input report (advertised by HID) 83 * @output_report_size: size of an output report (advertised by HID) 84 * 85 * @flags: flags for the current device (started, reading, etc...) 86 * 87 * @f11: placeholder of internal RMI function F11 description 88 * @f30: placeholder of internal RMI function F30 description 89 * 90 * @max_fingers: maximum finger count reported by the device 91 * @max_x: maximum x value reported by the device 92 * @max_y: maximum y value reported by the device 93 * 94 * @gpio_led_count: count of GPIOs + LEDs reported by F30 95 * @button_count: actual physical buttons count 96 * @button_mask: button mask used to decode GPIO ATTN reports 97 * @button_state_mask: pull state of the buttons 98 * 99 * @input: pointer to the kernel input device 100 * 101 * @reset_work: worker which will be called in case of a mouse report 102 * @hdev: pointer to the struct hid_device 103 */ 104 struct rmi_data { 105 struct mutex page_mutex; 106 int page; 107 108 wait_queue_head_t wait; 109 110 u8 *writeReport; 111 u8 *readReport; 112 113 int input_report_size; 114 int output_report_size; 115 116 unsigned long flags; 117 118 struct rmi_function f01; 119 struct rmi_function f11; 120 struct rmi_function f30; 121 122 unsigned int max_fingers; 123 unsigned int max_x; 124 unsigned int max_y; 125 unsigned int x_size_mm; 126 unsigned int y_size_mm; 127 bool read_f11_ctrl_regs; 128 u8 f11_ctrl_regs[RMI_F11_CTRL_REG_COUNT]; 129 130 unsigned int gpio_led_count; 131 unsigned int button_count; 132 unsigned long button_mask; 133 unsigned long button_state_mask; 134 135 struct input_dev *input; 136 137 struct work_struct reset_work; 138 struct hid_device *hdev; 139 140 unsigned long device_flags; 141 unsigned long firmware_id; 142 143 u8 f01_ctrl0; 144 u8 interrupt_enable_mask; 145 bool restore_interrupt_mask; 146 }; 147 148 #define RMI_PAGE(addr) (((addr) >> 8) & 0xff) 149 150 static int rmi_write_report(struct hid_device *hdev, u8 *report, int len); 151 152 /** 153 * rmi_set_page - Set RMI page 154 * @hdev: The pointer to the hid_device struct 155 * @page: The new page address. 156 * 157 * RMI devices have 16-bit addressing, but some of the physical 158 * implementations (like SMBus) only have 8-bit addressing. So RMI implements 159 * a page address at 0xff of every page so we can reliable page addresses 160 * every 256 registers. 161 * 162 * The page_mutex lock must be held when this function is entered. 163 * 164 * Returns zero on success, non-zero on failure. 165 */ 166 static int rmi_set_page(struct hid_device *hdev, u8 page) 167 { 168 struct rmi_data *data = hid_get_drvdata(hdev); 169 int retval; 170 171 data->writeReport[0] = RMI_WRITE_REPORT_ID; 172 data->writeReport[1] = 1; 173 data->writeReport[2] = 0xFF; 174 data->writeReport[4] = page; 175 176 retval = rmi_write_report(hdev, data->writeReport, 177 data->output_report_size); 178 if (retval != data->output_report_size) { 179 dev_err(&hdev->dev, 180 "%s: set page failed: %d.", __func__, retval); 181 return retval; 182 } 183 184 data->page = page; 185 return 0; 186 } 187 188 static int rmi_set_mode(struct hid_device *hdev, u8 mode) 189 { 190 int ret; 191 u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode}; 192 193 ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, txbuf, 194 sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 195 if (ret < 0) { 196 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode, 197 ret); 198 return ret; 199 } 200 201 return 0; 202 } 203 204 static int rmi_write_report(struct hid_device *hdev, u8 *report, int len) 205 { 206 int ret; 207 208 ret = hid_hw_output_report(hdev, (void *)report, len); 209 if (ret < 0) { 210 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret); 211 return ret; 212 } 213 214 return ret; 215 } 216 217 static int rmi_read_block(struct hid_device *hdev, u16 addr, void *buf, 218 const int len) 219 { 220 struct rmi_data *data = hid_get_drvdata(hdev); 221 int ret; 222 int bytes_read; 223 int bytes_needed; 224 int retries; 225 int read_input_count; 226 227 mutex_lock(&data->page_mutex); 228 229 if (RMI_PAGE(addr) != data->page) { 230 ret = rmi_set_page(hdev, RMI_PAGE(addr)); 231 if (ret < 0) 232 goto exit; 233 } 234 235 for (retries = 5; retries > 0; retries--) { 236 data->writeReport[0] = RMI_READ_ADDR_REPORT_ID; 237 data->writeReport[1] = 0; /* old 1 byte read count */ 238 data->writeReport[2] = addr & 0xFF; 239 data->writeReport[3] = (addr >> 8) & 0xFF; 240 data->writeReport[4] = len & 0xFF; 241 data->writeReport[5] = (len >> 8) & 0xFF; 242 243 set_bit(RMI_READ_REQUEST_PENDING, &data->flags); 244 245 ret = rmi_write_report(hdev, data->writeReport, 246 data->output_report_size); 247 if (ret != data->output_report_size) { 248 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); 249 dev_err(&hdev->dev, 250 "failed to write request output report (%d)\n", 251 ret); 252 goto exit; 253 } 254 255 bytes_read = 0; 256 bytes_needed = len; 257 while (bytes_read < len) { 258 if (!wait_event_timeout(data->wait, 259 test_bit(RMI_READ_DATA_PENDING, &data->flags), 260 msecs_to_jiffies(1000))) { 261 hid_warn(hdev, "%s: timeout elapsed\n", 262 __func__); 263 ret = -EAGAIN; 264 break; 265 } 266 267 read_input_count = data->readReport[1]; 268 memcpy(buf + bytes_read, &data->readReport[2], 269 read_input_count < bytes_needed ? 270 read_input_count : bytes_needed); 271 272 bytes_read += read_input_count; 273 bytes_needed -= read_input_count; 274 clear_bit(RMI_READ_DATA_PENDING, &data->flags); 275 } 276 277 if (ret >= 0) { 278 ret = 0; 279 break; 280 } 281 } 282 283 exit: 284 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); 285 mutex_unlock(&data->page_mutex); 286 return ret; 287 } 288 289 static inline int rmi_read(struct hid_device *hdev, u16 addr, void *buf) 290 { 291 return rmi_read_block(hdev, addr, buf, 1); 292 } 293 294 static int rmi_write_block(struct hid_device *hdev, u16 addr, void *buf, 295 const int len) 296 { 297 struct rmi_data *data = hid_get_drvdata(hdev); 298 int ret; 299 300 mutex_lock(&data->page_mutex); 301 302 if (RMI_PAGE(addr) != data->page) { 303 ret = rmi_set_page(hdev, RMI_PAGE(addr)); 304 if (ret < 0) 305 goto exit; 306 } 307 308 data->writeReport[0] = RMI_WRITE_REPORT_ID; 309 data->writeReport[1] = len; 310 data->writeReport[2] = addr & 0xFF; 311 data->writeReport[3] = (addr >> 8) & 0xFF; 312 memcpy(&data->writeReport[4], buf, len); 313 314 ret = rmi_write_report(hdev, data->writeReport, 315 data->output_report_size); 316 if (ret < 0) { 317 dev_err(&hdev->dev, 318 "failed to write request output report (%d)\n", 319 ret); 320 goto exit; 321 } 322 ret = 0; 323 324 exit: 325 mutex_unlock(&data->page_mutex); 326 return ret; 327 } 328 329 static inline int rmi_write(struct hid_device *hdev, u16 addr, void *buf) 330 { 331 return rmi_write_block(hdev, addr, buf, 1); 332 } 333 334 static void rmi_f11_process_touch(struct rmi_data *hdata, int slot, 335 u8 finger_state, u8 *touch_data) 336 { 337 int x, y, wx, wy; 338 int wide, major, minor; 339 int z; 340 341 input_mt_slot(hdata->input, slot); 342 input_mt_report_slot_state(hdata->input, MT_TOOL_FINGER, 343 finger_state == 0x01); 344 if (finger_state == 0x01) { 345 x = (touch_data[0] << 4) | (touch_data[2] & 0x0F); 346 y = (touch_data[1] << 4) | (touch_data[2] >> 4); 347 wx = touch_data[3] & 0x0F; 348 wy = touch_data[3] >> 4; 349 wide = (wx > wy); 350 major = max(wx, wy); 351 minor = min(wx, wy); 352 z = touch_data[4]; 353 354 /* y is inverted */ 355 y = hdata->max_y - y; 356 357 input_event(hdata->input, EV_ABS, ABS_MT_POSITION_X, x); 358 input_event(hdata->input, EV_ABS, ABS_MT_POSITION_Y, y); 359 input_event(hdata->input, EV_ABS, ABS_MT_ORIENTATION, wide); 360 input_event(hdata->input, EV_ABS, ABS_MT_PRESSURE, z); 361 input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); 362 input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); 363 } 364 } 365 366 static int rmi_reset_attn_mode(struct hid_device *hdev) 367 { 368 struct rmi_data *data = hid_get_drvdata(hdev); 369 int ret; 370 371 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); 372 if (ret) 373 return ret; 374 375 if (data->restore_interrupt_mask) { 376 ret = rmi_write(hdev, data->f01.control_base_addr + 1, 377 &data->interrupt_enable_mask); 378 if (ret) { 379 hid_err(hdev, "can not write F01 control register\n"); 380 return ret; 381 } 382 } 383 384 return 0; 385 } 386 387 static void rmi_reset_work(struct work_struct *work) 388 { 389 struct rmi_data *hdata = container_of(work, struct rmi_data, 390 reset_work); 391 392 /* switch the device to RMI if we receive a generic mouse report */ 393 rmi_reset_attn_mode(hdata->hdev); 394 } 395 396 static inline int rmi_schedule_reset(struct hid_device *hdev) 397 { 398 struct rmi_data *hdata = hid_get_drvdata(hdev); 399 return schedule_work(&hdata->reset_work); 400 } 401 402 static int rmi_f11_input_event(struct hid_device *hdev, u8 irq, u8 *data, 403 int size) 404 { 405 struct rmi_data *hdata = hid_get_drvdata(hdev); 406 int offset; 407 int i; 408 409 if (!(irq & hdata->f11.irq_mask) || size <= 0) 410 return 0; 411 412 offset = (hdata->max_fingers >> 2) + 1; 413 for (i = 0; i < hdata->max_fingers; i++) { 414 int fs_byte_position = i >> 2; 415 int fs_bit_position = (i & 0x3) << 1; 416 int finger_state = (data[fs_byte_position] >> fs_bit_position) & 417 0x03; 418 int position = offset + 5 * i; 419 420 if (position + 5 > size) { 421 /* partial report, go on with what we received */ 422 printk_once(KERN_WARNING 423 "%s %s: Detected incomplete finger report. Finger reports may occasionally get dropped on this platform.\n", 424 dev_driver_string(&hdev->dev), 425 dev_name(&hdev->dev)); 426 hid_dbg(hdev, "Incomplete finger report\n"); 427 break; 428 } 429 430 rmi_f11_process_touch(hdata, i, finger_state, &data[position]); 431 } 432 input_mt_sync_frame(hdata->input); 433 input_sync(hdata->input); 434 return hdata->f11.report_size; 435 } 436 437 static int rmi_f30_input_event(struct hid_device *hdev, u8 irq, u8 *data, 438 int size) 439 { 440 struct rmi_data *hdata = hid_get_drvdata(hdev); 441 int i; 442 int button = 0; 443 bool value; 444 445 if (!(irq & hdata->f30.irq_mask)) 446 return 0; 447 448 if (size < (int)hdata->f30.report_size) { 449 hid_warn(hdev, "Click Button pressed, but the click data is missing\n"); 450 return 0; 451 } 452 453 for (i = 0; i < hdata->gpio_led_count; i++) { 454 if (test_bit(i, &hdata->button_mask)) { 455 value = (data[i / 8] >> (i & 0x07)) & BIT(0); 456 if (test_bit(i, &hdata->button_state_mask)) 457 value = !value; 458 input_event(hdata->input, EV_KEY, BTN_LEFT + button++, 459 value); 460 } 461 } 462 return hdata->f30.report_size; 463 } 464 465 static int rmi_input_event(struct hid_device *hdev, u8 *data, int size) 466 { 467 struct rmi_data *hdata = hid_get_drvdata(hdev); 468 unsigned long irq_mask = 0; 469 unsigned index = 2; 470 471 if (!(test_bit(RMI_STARTED, &hdata->flags))) 472 return 0; 473 474 irq_mask |= hdata->f11.irq_mask; 475 irq_mask |= hdata->f30.irq_mask; 476 477 if (data[1] & ~irq_mask) 478 hid_dbg(hdev, "unknown intr source:%02lx %s:%d\n", 479 data[1] & ~irq_mask, __FILE__, __LINE__); 480 481 if (hdata->f11.interrupt_base < hdata->f30.interrupt_base) { 482 index += rmi_f11_input_event(hdev, data[1], &data[index], 483 size - index); 484 index += rmi_f30_input_event(hdev, data[1], &data[index], 485 size - index); 486 } else { 487 index += rmi_f30_input_event(hdev, data[1], &data[index], 488 size - index); 489 index += rmi_f11_input_event(hdev, data[1], &data[index], 490 size - index); 491 } 492 493 return 1; 494 } 495 496 static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size) 497 { 498 struct rmi_data *hdata = hid_get_drvdata(hdev); 499 500 if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) { 501 hid_dbg(hdev, "no read request pending\n"); 502 return 0; 503 } 504 505 memcpy(hdata->readReport, data, size < hdata->input_report_size ? 506 size : hdata->input_report_size); 507 set_bit(RMI_READ_DATA_PENDING, &hdata->flags); 508 wake_up(&hdata->wait); 509 510 return 1; 511 } 512 513 static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size) 514 { 515 int valid_size = size; 516 /* 517 * On the Dell XPS 13 9333, the bus sometimes get confused and fills 518 * the report with a sentinel value "ff". Synaptics told us that such 519 * behavior does not comes from the touchpad itself, so we filter out 520 * such reports here. 521 */ 522 523 while ((data[valid_size - 1] == 0xff) && valid_size > 0) 524 valid_size--; 525 526 return valid_size; 527 } 528 529 static int rmi_raw_event(struct hid_device *hdev, 530 struct hid_report *report, u8 *data, int size) 531 { 532 size = rmi_check_sanity(hdev, data, size); 533 if (size < 2) 534 return 0; 535 536 switch (data[0]) { 537 case RMI_READ_DATA_REPORT_ID: 538 return rmi_read_data_event(hdev, data, size); 539 case RMI_ATTN_REPORT_ID: 540 return rmi_input_event(hdev, data, size); 541 default: 542 return 1; 543 } 544 545 return 0; 546 } 547 548 static int rmi_event(struct hid_device *hdev, struct hid_field *field, 549 struct hid_usage *usage, __s32 value) 550 { 551 struct rmi_data *data = hid_get_drvdata(hdev); 552 553 if ((data->device_flags & RMI_DEVICE) && 554 (field->application == HID_GD_POINTER || 555 field->application == HID_GD_MOUSE)) { 556 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) { 557 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 558 return 0; 559 560 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y) 561 && !value) 562 return 1; 563 } 564 565 rmi_schedule_reset(hdev); 566 return 1; 567 } 568 569 return 0; 570 } 571 572 #ifdef CONFIG_PM 573 static int rmi_set_sleep_mode(struct hid_device *hdev, int sleep_mode) 574 { 575 struct rmi_data *data = hid_get_drvdata(hdev); 576 int ret; 577 u8 f01_ctrl0; 578 579 f01_ctrl0 = (data->f01_ctrl0 & ~0x3) | sleep_mode; 580 581 ret = rmi_write(hdev, data->f01.control_base_addr, 582 &f01_ctrl0); 583 if (ret) { 584 hid_err(hdev, "can not write sleep mode\n"); 585 return ret; 586 } 587 588 return 0; 589 } 590 591 static int rmi_suspend(struct hid_device *hdev, pm_message_t message) 592 { 593 struct rmi_data *data = hid_get_drvdata(hdev); 594 int ret; 595 u8 buf[RMI_F11_CTRL_REG_COUNT]; 596 597 ret = rmi_read_block(hdev, data->f11.control_base_addr, buf, 598 RMI_F11_CTRL_REG_COUNT); 599 if (ret) 600 hid_warn(hdev, "can not read F11 control registers\n"); 601 else 602 memcpy(data->f11_ctrl_regs, buf, RMI_F11_CTRL_REG_COUNT); 603 604 605 if (!device_may_wakeup(hdev->dev.parent)) 606 return rmi_set_sleep_mode(hdev, RMI_SLEEP_DEEP_SLEEP); 607 608 return 0; 609 } 610 611 static int rmi_post_reset(struct hid_device *hdev) 612 { 613 struct rmi_data *data = hid_get_drvdata(hdev); 614 int ret; 615 616 ret = rmi_reset_attn_mode(hdev); 617 if (ret) { 618 hid_err(hdev, "can not set rmi mode\n"); 619 return ret; 620 } 621 622 if (data->read_f11_ctrl_regs) { 623 ret = rmi_write_block(hdev, data->f11.control_base_addr, 624 data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT); 625 if (ret) 626 hid_warn(hdev, 627 "can not write F11 control registers after reset\n"); 628 } 629 630 if (!device_may_wakeup(hdev->dev.parent)) { 631 ret = rmi_set_sleep_mode(hdev, RMI_SLEEP_NORMAL); 632 if (ret) { 633 hid_err(hdev, "can not write sleep mode\n"); 634 return ret; 635 } 636 } 637 638 return ret; 639 } 640 641 static int rmi_post_resume(struct hid_device *hdev) 642 { 643 return rmi_reset_attn_mode(hdev); 644 } 645 #endif /* CONFIG_PM */ 646 647 #define RMI4_MAX_PAGE 0xff 648 #define RMI4_PAGE_SIZE 0x0100 649 650 #define PDT_START_SCAN_LOCATION 0x00e9 651 #define PDT_END_SCAN_LOCATION 0x0005 652 #define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff) 653 654 struct pdt_entry { 655 u8 query_base_addr:8; 656 u8 command_base_addr:8; 657 u8 control_base_addr:8; 658 u8 data_base_addr:8; 659 u8 interrupt_source_count:3; 660 u8 bits3and4:2; 661 u8 function_version:2; 662 u8 bit7:1; 663 u8 function_number:8; 664 } __attribute__((__packed__)); 665 666 static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count) 667 { 668 return GENMASK(irq_count + irq_base - 1, irq_base); 669 } 670 671 static void rmi_register_function(struct rmi_data *data, 672 struct pdt_entry *pdt_entry, int page, unsigned interrupt_count) 673 { 674 struct rmi_function *f = NULL; 675 u16 page_base = page << 8; 676 677 switch (pdt_entry->function_number) { 678 case 0x01: 679 f = &data->f01; 680 break; 681 case 0x11: 682 f = &data->f11; 683 break; 684 case 0x30: 685 f = &data->f30; 686 break; 687 } 688 689 if (f) { 690 f->page = page; 691 f->query_base_addr = page_base | pdt_entry->query_base_addr; 692 f->command_base_addr = page_base | pdt_entry->command_base_addr; 693 f->control_base_addr = page_base | pdt_entry->control_base_addr; 694 f->data_base_addr = page_base | pdt_entry->data_base_addr; 695 f->interrupt_base = interrupt_count; 696 f->interrupt_count = pdt_entry->interrupt_source_count; 697 f->irq_mask = rmi_gen_mask(f->interrupt_base, 698 f->interrupt_count); 699 data->interrupt_enable_mask |= f->irq_mask; 700 } 701 } 702 703 static int rmi_scan_pdt(struct hid_device *hdev) 704 { 705 struct rmi_data *data = hid_get_drvdata(hdev); 706 struct pdt_entry entry; 707 int page; 708 bool page_has_function; 709 int i; 710 int retval; 711 int interrupt = 0; 712 u16 page_start, pdt_start , pdt_end; 713 714 hid_info(hdev, "Scanning PDT...\n"); 715 716 for (page = 0; (page <= RMI4_MAX_PAGE); page++) { 717 page_start = RMI4_PAGE_SIZE * page; 718 pdt_start = page_start + PDT_START_SCAN_LOCATION; 719 pdt_end = page_start + PDT_END_SCAN_LOCATION; 720 721 page_has_function = false; 722 for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) { 723 retval = rmi_read_block(hdev, i, &entry, sizeof(entry)); 724 if (retval) { 725 hid_err(hdev, 726 "Read of PDT entry at %#06x failed.\n", 727 i); 728 goto error_exit; 729 } 730 731 if (RMI4_END_OF_PDT(entry.function_number)) 732 break; 733 734 page_has_function = true; 735 736 hid_info(hdev, "Found F%02X on page %#04x\n", 737 entry.function_number, page); 738 739 rmi_register_function(data, &entry, page, interrupt); 740 interrupt += entry.interrupt_source_count; 741 } 742 743 if (!page_has_function) 744 break; 745 } 746 747 hid_info(hdev, "%s: Done with PDT scan.\n", __func__); 748 retval = 0; 749 750 error_exit: 751 return retval; 752 } 753 754 #define RMI_DEVICE_F01_BASIC_QUERY_LEN 11 755 756 static int rmi_populate_f01(struct hid_device *hdev) 757 { 758 struct rmi_data *data = hid_get_drvdata(hdev); 759 u8 basic_queries[RMI_DEVICE_F01_BASIC_QUERY_LEN]; 760 u8 info[3]; 761 int ret; 762 bool has_query42; 763 bool has_lts; 764 bool has_sensor_id; 765 bool has_ds4_queries = false; 766 bool has_build_id_query = false; 767 bool has_package_id_query = false; 768 u16 query_offset = data->f01.query_base_addr; 769 u16 prod_info_addr; 770 u8 ds4_query_len; 771 772 ret = rmi_read_block(hdev, query_offset, basic_queries, 773 RMI_DEVICE_F01_BASIC_QUERY_LEN); 774 if (ret) { 775 hid_err(hdev, "Can not read basic queries from Function 0x1.\n"); 776 return ret; 777 } 778 779 has_lts = !!(basic_queries[0] & BIT(2)); 780 has_sensor_id = !!(basic_queries[1] & BIT(3)); 781 has_query42 = !!(basic_queries[1] & BIT(7)); 782 783 query_offset += 11; 784 prod_info_addr = query_offset + 6; 785 query_offset += 10; 786 787 if (has_lts) 788 query_offset += 20; 789 790 if (has_sensor_id) 791 query_offset++; 792 793 if (has_query42) { 794 ret = rmi_read(hdev, query_offset, info); 795 if (ret) { 796 hid_err(hdev, "Can not read query42.\n"); 797 return ret; 798 } 799 has_ds4_queries = !!(info[0] & BIT(0)); 800 query_offset++; 801 } 802 803 if (has_ds4_queries) { 804 ret = rmi_read(hdev, query_offset, &ds4_query_len); 805 if (ret) { 806 hid_err(hdev, "Can not read DS4 Query length.\n"); 807 return ret; 808 } 809 query_offset++; 810 811 if (ds4_query_len > 0) { 812 ret = rmi_read(hdev, query_offset, info); 813 if (ret) { 814 hid_err(hdev, "Can not read DS4 query.\n"); 815 return ret; 816 } 817 818 has_package_id_query = !!(info[0] & BIT(0)); 819 has_build_id_query = !!(info[0] & BIT(1)); 820 } 821 } 822 823 if (has_package_id_query) 824 prod_info_addr++; 825 826 if (has_build_id_query) { 827 ret = rmi_read_block(hdev, prod_info_addr, info, 3); 828 if (ret) { 829 hid_err(hdev, "Can not read product info.\n"); 830 return ret; 831 } 832 833 data->firmware_id = info[1] << 8 | info[0]; 834 data->firmware_id += info[2] * 65536; 835 } 836 837 ret = rmi_read_block(hdev, data->f01.control_base_addr, info, 838 2); 839 840 if (ret) { 841 hid_err(hdev, "can not read f01 ctrl registers\n"); 842 return ret; 843 } 844 845 data->f01_ctrl0 = info[0]; 846 847 if (!info[1]) { 848 /* 849 * Do to a firmware bug in some touchpads the F01 interrupt 850 * enable control register will be cleared on reset. 851 * This will stop the touchpad from reporting data, so 852 * if F01 CTRL1 is 0 then we need to explicitly enable 853 * interrupts for the functions we want data for. 854 */ 855 data->restore_interrupt_mask = true; 856 857 ret = rmi_write(hdev, data->f01.control_base_addr + 1, 858 &data->interrupt_enable_mask); 859 if (ret) { 860 hid_err(hdev, "can not write to control reg 1: %d.\n", 861 ret); 862 return ret; 863 } 864 } 865 866 return 0; 867 } 868 869 static int rmi_populate_f11(struct hid_device *hdev) 870 { 871 struct rmi_data *data = hid_get_drvdata(hdev); 872 u8 buf[20]; 873 int ret; 874 bool has_query9; 875 bool has_query10 = false; 876 bool has_query11; 877 bool has_query12; 878 bool has_query27; 879 bool has_query28; 880 bool has_query36 = false; 881 bool has_physical_props; 882 bool has_gestures; 883 bool has_rel; 884 bool has_data40 = false; 885 bool has_dribble = false; 886 bool has_palm_detect = false; 887 unsigned x_size, y_size; 888 u16 query_offset; 889 890 if (!data->f11.query_base_addr) { 891 hid_err(hdev, "No 2D sensor found, giving up.\n"); 892 return -ENODEV; 893 } 894 895 /* query 0 contains some useful information */ 896 ret = rmi_read(hdev, data->f11.query_base_addr, buf); 897 if (ret) { 898 hid_err(hdev, "can not get query 0: %d.\n", ret); 899 return ret; 900 } 901 has_query9 = !!(buf[0] & BIT(3)); 902 has_query11 = !!(buf[0] & BIT(4)); 903 has_query12 = !!(buf[0] & BIT(5)); 904 has_query27 = !!(buf[0] & BIT(6)); 905 has_query28 = !!(buf[0] & BIT(7)); 906 907 /* query 1 to get the max number of fingers */ 908 ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf); 909 if (ret) { 910 hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret); 911 return ret; 912 } 913 data->max_fingers = (buf[0] & 0x07) + 1; 914 if (data->max_fingers > 5) 915 data->max_fingers = 10; 916 917 data->f11.report_size = data->max_fingers * 5 + 918 DIV_ROUND_UP(data->max_fingers, 4); 919 920 if (!(buf[0] & BIT(4))) { 921 hid_err(hdev, "No absolute events, giving up.\n"); 922 return -ENODEV; 923 } 924 925 has_rel = !!(buf[0] & BIT(3)); 926 has_gestures = !!(buf[0] & BIT(5)); 927 928 ret = rmi_read(hdev, data->f11.query_base_addr + 5, buf); 929 if (ret) { 930 hid_err(hdev, "can not get absolute data sources: %d.\n", ret); 931 return ret; 932 } 933 934 has_dribble = !!(buf[0] & BIT(4)); 935 936 /* 937 * At least 4 queries are guaranteed to be present in F11 938 * +1 for query 5 which is present since absolute events are 939 * reported and +1 for query 12. 940 */ 941 query_offset = 6; 942 943 if (has_rel) 944 ++query_offset; /* query 6 is present */ 945 946 if (has_gestures) { 947 /* query 8 to find out if query 10 exists */ 948 ret = rmi_read(hdev, 949 data->f11.query_base_addr + query_offset + 1, buf); 950 if (ret) { 951 hid_err(hdev, "can not read gesture information: %d.\n", 952 ret); 953 return ret; 954 } 955 has_palm_detect = !!(buf[0] & BIT(0)); 956 has_query10 = !!(buf[0] & BIT(2)); 957 958 query_offset += 2; /* query 7 and 8 are present */ 959 } 960 961 if (has_query9) 962 ++query_offset; 963 964 if (has_query10) 965 ++query_offset; 966 967 if (has_query11) 968 ++query_offset; 969 970 /* query 12 to know if the physical properties are reported */ 971 if (has_query12) { 972 ret = rmi_read(hdev, data->f11.query_base_addr 973 + query_offset, buf); 974 if (ret) { 975 hid_err(hdev, "can not get query 12: %d.\n", ret); 976 return ret; 977 } 978 has_physical_props = !!(buf[0] & BIT(5)); 979 980 if (has_physical_props) { 981 query_offset += 1; 982 ret = rmi_read_block(hdev, 983 data->f11.query_base_addr 984 + query_offset, buf, 4); 985 if (ret) { 986 hid_err(hdev, "can not read query 15-18: %d.\n", 987 ret); 988 return ret; 989 } 990 991 x_size = buf[0] | (buf[1] << 8); 992 y_size = buf[2] | (buf[3] << 8); 993 994 data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10); 995 data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10); 996 997 hid_info(hdev, "%s: size in mm: %d x %d\n", 998 __func__, data->x_size_mm, data->y_size_mm); 999 1000 /* 1001 * query 15 - 18 contain the size of the sensor 1002 * and query 19 - 26 contain bezel dimensions 1003 */ 1004 query_offset += 12; 1005 } 1006 } 1007 1008 if (has_query27) 1009 ++query_offset; 1010 1011 if (has_query28) { 1012 ret = rmi_read(hdev, data->f11.query_base_addr 1013 + query_offset, buf); 1014 if (ret) { 1015 hid_err(hdev, "can not get query 28: %d.\n", ret); 1016 return ret; 1017 } 1018 1019 has_query36 = !!(buf[0] & BIT(6)); 1020 } 1021 1022 if (has_query36) { 1023 query_offset += 2; 1024 ret = rmi_read(hdev, data->f11.query_base_addr 1025 + query_offset, buf); 1026 if (ret) { 1027 hid_err(hdev, "can not get query 36: %d.\n", ret); 1028 return ret; 1029 } 1030 1031 has_data40 = !!(buf[0] & BIT(5)); 1032 } 1033 1034 1035 if (has_data40) 1036 data->f11.report_size += data->max_fingers * 2; 1037 1038 ret = rmi_read_block(hdev, data->f11.control_base_addr, 1039 data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT); 1040 if (ret) { 1041 hid_err(hdev, "can not read ctrl block of size 11: %d.\n", ret); 1042 return ret; 1043 } 1044 1045 /* data->f11_ctrl_regs now contains valid register data */ 1046 data->read_f11_ctrl_regs = true; 1047 1048 data->max_x = data->f11_ctrl_regs[6] | (data->f11_ctrl_regs[7] << 8); 1049 data->max_y = data->f11_ctrl_regs[8] | (data->f11_ctrl_regs[9] << 8); 1050 1051 if (has_dribble) { 1052 data->f11_ctrl_regs[0] = data->f11_ctrl_regs[0] & ~BIT(6); 1053 ret = rmi_write(hdev, data->f11.control_base_addr, 1054 data->f11_ctrl_regs); 1055 if (ret) { 1056 hid_err(hdev, "can not write to control reg 0: %d.\n", 1057 ret); 1058 return ret; 1059 } 1060 } 1061 1062 if (has_palm_detect) { 1063 data->f11_ctrl_regs[11] = data->f11_ctrl_regs[11] & ~BIT(0); 1064 ret = rmi_write(hdev, data->f11.control_base_addr + 11, 1065 &data->f11_ctrl_regs[11]); 1066 if (ret) { 1067 hid_err(hdev, "can not write to control reg 11: %d.\n", 1068 ret); 1069 return ret; 1070 } 1071 } 1072 1073 return 0; 1074 } 1075 1076 static int rmi_populate_f30(struct hid_device *hdev) 1077 { 1078 struct rmi_data *data = hid_get_drvdata(hdev); 1079 u8 buf[20]; 1080 int ret; 1081 bool has_gpio, has_led; 1082 unsigned bytes_per_ctrl; 1083 u8 ctrl2_addr; 1084 int ctrl2_3_length; 1085 int i; 1086 1087 /* function F30 is for physical buttons */ 1088 if (!data->f30.query_base_addr) { 1089 hid_err(hdev, "No GPIO/LEDs found, giving up.\n"); 1090 return -ENODEV; 1091 } 1092 1093 ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2); 1094 if (ret) { 1095 hid_err(hdev, "can not get F30 query registers: %d.\n", ret); 1096 return ret; 1097 } 1098 1099 has_gpio = !!(buf[0] & BIT(3)); 1100 has_led = !!(buf[0] & BIT(2)); 1101 data->gpio_led_count = buf[1] & 0x1f; 1102 1103 /* retrieve ctrl 2 & 3 registers */ 1104 bytes_per_ctrl = (data->gpio_led_count + 7) / 8; 1105 /* Ctrl0 is present only if both has_gpio and has_led are set*/ 1106 ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0; 1107 /* Ctrl1 is always be present */ 1108 ctrl2_addr += bytes_per_ctrl; 1109 ctrl2_3_length = 2 * bytes_per_ctrl; 1110 1111 data->f30.report_size = bytes_per_ctrl; 1112 1113 ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr, 1114 buf, ctrl2_3_length); 1115 if (ret) { 1116 hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n", 1117 ctrl2_3_length, ret); 1118 return ret; 1119 } 1120 1121 for (i = 0; i < data->gpio_led_count; i++) { 1122 int byte_position = i >> 3; 1123 int bit_position = i & 0x07; 1124 u8 dir_byte = buf[byte_position]; 1125 u8 data_byte = buf[byte_position + bytes_per_ctrl]; 1126 bool dir = (dir_byte >> bit_position) & BIT(0); 1127 bool dat = (data_byte >> bit_position) & BIT(0); 1128 1129 if (dir == 0) { 1130 /* input mode */ 1131 if (dat) { 1132 /* actual buttons have pull up resistor */ 1133 data->button_count++; 1134 set_bit(i, &data->button_mask); 1135 set_bit(i, &data->button_state_mask); 1136 } 1137 } 1138 1139 } 1140 1141 return 0; 1142 } 1143 1144 static int rmi_populate(struct hid_device *hdev) 1145 { 1146 struct rmi_data *data = hid_get_drvdata(hdev); 1147 int ret; 1148 1149 ret = rmi_scan_pdt(hdev); 1150 if (ret) { 1151 hid_err(hdev, "PDT scan failed with code %d.\n", ret); 1152 return ret; 1153 } 1154 1155 ret = rmi_populate_f01(hdev); 1156 if (ret) { 1157 hid_err(hdev, "Error while initializing F01 (%d).\n", ret); 1158 return ret; 1159 } 1160 1161 ret = rmi_populate_f11(hdev); 1162 if (ret) { 1163 hid_err(hdev, "Error while initializing F11 (%d).\n", ret); 1164 return ret; 1165 } 1166 1167 if (!(data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)) { 1168 ret = rmi_populate_f30(hdev); 1169 if (ret) 1170 hid_warn(hdev, "Error while initializing F30 (%d).\n", ret); 1171 } 1172 1173 return 0; 1174 } 1175 1176 static void rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) 1177 { 1178 struct rmi_data *data = hid_get_drvdata(hdev); 1179 struct input_dev *input = hi->input; 1180 int ret; 1181 int res_x, res_y, i; 1182 1183 data->input = input; 1184 1185 hid_dbg(hdev, "Opening low level driver\n"); 1186 ret = hid_hw_open(hdev); 1187 if (ret) 1188 return; 1189 1190 if (!(data->device_flags & RMI_DEVICE)) 1191 return; 1192 1193 /* Allow incoming hid reports */ 1194 hid_device_io_start(hdev); 1195 1196 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); 1197 if (ret < 0) { 1198 dev_err(&hdev->dev, "failed to set rmi mode\n"); 1199 goto exit; 1200 } 1201 1202 ret = rmi_set_page(hdev, 0); 1203 if (ret < 0) { 1204 dev_err(&hdev->dev, "failed to set page select to 0.\n"); 1205 goto exit; 1206 } 1207 1208 ret = rmi_populate(hdev); 1209 if (ret) 1210 goto exit; 1211 1212 hid_info(hdev, "firmware id: %ld\n", data->firmware_id); 1213 1214 __set_bit(EV_ABS, input->evbit); 1215 input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0); 1216 input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0); 1217 1218 if (data->x_size_mm && data->y_size_mm) { 1219 res_x = (data->max_x - 1) / data->x_size_mm; 1220 res_y = (data->max_y - 1) / data->y_size_mm; 1221 1222 input_abs_set_res(input, ABS_MT_POSITION_X, res_x); 1223 input_abs_set_res(input, ABS_MT_POSITION_Y, res_y); 1224 } 1225 1226 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0); 1227 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0); 1228 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0); 1229 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0); 1230 1231 input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER); 1232 1233 if (data->button_count) { 1234 __set_bit(EV_KEY, input->evbit); 1235 for (i = 0; i < data->button_count; i++) 1236 __set_bit(BTN_LEFT + i, input->keybit); 1237 1238 if (data->button_count == 1) 1239 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 1240 } 1241 1242 set_bit(RMI_STARTED, &data->flags); 1243 1244 exit: 1245 hid_device_io_stop(hdev); 1246 hid_hw_close(hdev); 1247 } 1248 1249 static int rmi_input_mapping(struct hid_device *hdev, 1250 struct hid_input *hi, struct hid_field *field, 1251 struct hid_usage *usage, unsigned long **bit, int *max) 1252 { 1253 struct rmi_data *data = hid_get_drvdata(hdev); 1254 1255 /* 1256 * we want to make HID ignore the advertised HID collection 1257 * for RMI deivces 1258 */ 1259 if (data->device_flags & RMI_DEVICE) { 1260 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) && 1261 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)) 1262 return 0; 1263 1264 return -1; 1265 } 1266 1267 return 0; 1268 } 1269 1270 static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type, 1271 unsigned id, struct hid_report **report) 1272 { 1273 int i; 1274 1275 *report = hdev->report_enum[type].report_id_hash[id]; 1276 if (*report) { 1277 for (i = 0; i < (*report)->maxfield; i++) { 1278 unsigned app = (*report)->field[i]->application; 1279 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR) 1280 return 1; 1281 } 1282 } 1283 1284 return 0; 1285 } 1286 1287 static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) 1288 { 1289 struct rmi_data *data = NULL; 1290 int ret; 1291 size_t alloc_size; 1292 struct hid_report *input_report; 1293 struct hid_report *output_report; 1294 struct hid_report *feature_report; 1295 1296 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL); 1297 if (!data) 1298 return -ENOMEM; 1299 1300 INIT_WORK(&data->reset_work, rmi_reset_work); 1301 data->hdev = hdev; 1302 1303 hid_set_drvdata(hdev, data); 1304 1305 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1306 1307 ret = hid_parse(hdev); 1308 if (ret) { 1309 hid_err(hdev, "parse failed\n"); 1310 return ret; 1311 } 1312 1313 if (id->driver_data) 1314 data->device_flags = id->driver_data; 1315 1316 /* 1317 * Check for the RMI specific report ids. If they are misisng 1318 * simply return and let the events be processed by hid-input 1319 */ 1320 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT, 1321 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) { 1322 hid_dbg(hdev, "device does not have set mode feature report\n"); 1323 goto start; 1324 } 1325 1326 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT, 1327 RMI_ATTN_REPORT_ID, &input_report)) { 1328 hid_dbg(hdev, "device does not have attention input report\n"); 1329 goto start; 1330 } 1331 1332 data->input_report_size = hid_report_len(input_report); 1333 1334 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT, 1335 RMI_WRITE_REPORT_ID, &output_report)) { 1336 hid_dbg(hdev, 1337 "device does not have rmi write output report\n"); 1338 goto start; 1339 } 1340 1341 data->output_report_size = hid_report_len(output_report); 1342 1343 data->device_flags |= RMI_DEVICE; 1344 alloc_size = data->output_report_size + data->input_report_size; 1345 1346 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL); 1347 if (!data->writeReport) { 1348 ret = -ENOMEM; 1349 return ret; 1350 } 1351 1352 data->readReport = data->writeReport + data->output_report_size; 1353 1354 init_waitqueue_head(&data->wait); 1355 1356 mutex_init(&data->page_mutex); 1357 1358 start: 1359 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1360 if (ret) { 1361 hid_err(hdev, "hw start failed\n"); 1362 return ret; 1363 } 1364 1365 if ((data->device_flags & RMI_DEVICE) && 1366 !test_bit(RMI_STARTED, &data->flags)) 1367 /* 1368 * The device maybe in the bootloader if rmi_input_configured 1369 * failed to find F11 in the PDT. Print an error, but don't 1370 * return an error from rmi_probe so that hidraw will be 1371 * accessible from userspace. That way a userspace tool 1372 * can be used to reload working firmware on the touchpad. 1373 */ 1374 hid_err(hdev, "Device failed to be properly configured\n"); 1375 1376 return 0; 1377 } 1378 1379 static void rmi_remove(struct hid_device *hdev) 1380 { 1381 struct rmi_data *hdata = hid_get_drvdata(hdev); 1382 1383 clear_bit(RMI_STARTED, &hdata->flags); 1384 1385 hid_hw_stop(hdev); 1386 } 1387 1388 static const struct hid_device_id rmi_id[] = { 1389 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14), 1390 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS }, 1391 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) }, 1392 { } 1393 }; 1394 MODULE_DEVICE_TABLE(hid, rmi_id); 1395 1396 static struct hid_driver rmi_driver = { 1397 .name = "hid-rmi", 1398 .id_table = rmi_id, 1399 .probe = rmi_probe, 1400 .remove = rmi_remove, 1401 .event = rmi_event, 1402 .raw_event = rmi_raw_event, 1403 .input_mapping = rmi_input_mapping, 1404 .input_configured = rmi_input_configured, 1405 #ifdef CONFIG_PM 1406 .suspend = rmi_suspend, 1407 .resume = rmi_post_resume, 1408 .reset_resume = rmi_post_reset, 1409 #endif 1410 }; 1411 1412 module_hid_driver(rmi_driver); 1413 1414 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>"); 1415 MODULE_DESCRIPTION("RMI HID driver"); 1416 MODULE_LICENSE("GPL"); 1417