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 if (!(data->device_flags & RMI_DEVICE)) 598 return 0; 599 600 ret = rmi_read_block(hdev, data->f11.control_base_addr, buf, 601 RMI_F11_CTRL_REG_COUNT); 602 if (ret) 603 hid_warn(hdev, "can not read F11 control registers\n"); 604 else 605 memcpy(data->f11_ctrl_regs, buf, RMI_F11_CTRL_REG_COUNT); 606 607 608 if (!device_may_wakeup(hdev->dev.parent)) 609 return rmi_set_sleep_mode(hdev, RMI_SLEEP_DEEP_SLEEP); 610 611 return 0; 612 } 613 614 static int rmi_post_reset(struct hid_device *hdev) 615 { 616 struct rmi_data *data = hid_get_drvdata(hdev); 617 int ret; 618 619 if (!(data->device_flags & RMI_DEVICE)) 620 return 0; 621 622 ret = rmi_reset_attn_mode(hdev); 623 if (ret) { 624 hid_err(hdev, "can not set rmi mode\n"); 625 return ret; 626 } 627 628 if (data->read_f11_ctrl_regs) { 629 ret = rmi_write_block(hdev, data->f11.control_base_addr, 630 data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT); 631 if (ret) 632 hid_warn(hdev, 633 "can not write F11 control registers after reset\n"); 634 } 635 636 if (!device_may_wakeup(hdev->dev.parent)) { 637 ret = rmi_set_sleep_mode(hdev, RMI_SLEEP_NORMAL); 638 if (ret) { 639 hid_err(hdev, "can not write sleep mode\n"); 640 return ret; 641 } 642 } 643 644 return ret; 645 } 646 647 static int rmi_post_resume(struct hid_device *hdev) 648 { 649 struct rmi_data *data = hid_get_drvdata(hdev); 650 651 if (!(data->device_flags & RMI_DEVICE)) 652 return 0; 653 654 return rmi_reset_attn_mode(hdev); 655 } 656 #endif /* CONFIG_PM */ 657 658 #define RMI4_MAX_PAGE 0xff 659 #define RMI4_PAGE_SIZE 0x0100 660 661 #define PDT_START_SCAN_LOCATION 0x00e9 662 #define PDT_END_SCAN_LOCATION 0x0005 663 #define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff) 664 665 struct pdt_entry { 666 u8 query_base_addr:8; 667 u8 command_base_addr:8; 668 u8 control_base_addr:8; 669 u8 data_base_addr:8; 670 u8 interrupt_source_count:3; 671 u8 bits3and4:2; 672 u8 function_version:2; 673 u8 bit7:1; 674 u8 function_number:8; 675 } __attribute__((__packed__)); 676 677 static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count) 678 { 679 return GENMASK(irq_count + irq_base - 1, irq_base); 680 } 681 682 static void rmi_register_function(struct rmi_data *data, 683 struct pdt_entry *pdt_entry, int page, unsigned interrupt_count) 684 { 685 struct rmi_function *f = NULL; 686 u16 page_base = page << 8; 687 688 switch (pdt_entry->function_number) { 689 case 0x01: 690 f = &data->f01; 691 break; 692 case 0x11: 693 f = &data->f11; 694 break; 695 case 0x30: 696 f = &data->f30; 697 break; 698 } 699 700 if (f) { 701 f->page = page; 702 f->query_base_addr = page_base | pdt_entry->query_base_addr; 703 f->command_base_addr = page_base | pdt_entry->command_base_addr; 704 f->control_base_addr = page_base | pdt_entry->control_base_addr; 705 f->data_base_addr = page_base | pdt_entry->data_base_addr; 706 f->interrupt_base = interrupt_count; 707 f->interrupt_count = pdt_entry->interrupt_source_count; 708 f->irq_mask = rmi_gen_mask(f->interrupt_base, 709 f->interrupt_count); 710 data->interrupt_enable_mask |= f->irq_mask; 711 } 712 } 713 714 static int rmi_scan_pdt(struct hid_device *hdev) 715 { 716 struct rmi_data *data = hid_get_drvdata(hdev); 717 struct pdt_entry entry; 718 int page; 719 bool page_has_function; 720 int i; 721 int retval; 722 int interrupt = 0; 723 u16 page_start, pdt_start , pdt_end; 724 725 hid_info(hdev, "Scanning PDT...\n"); 726 727 for (page = 0; (page <= RMI4_MAX_PAGE); page++) { 728 page_start = RMI4_PAGE_SIZE * page; 729 pdt_start = page_start + PDT_START_SCAN_LOCATION; 730 pdt_end = page_start + PDT_END_SCAN_LOCATION; 731 732 page_has_function = false; 733 for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) { 734 retval = rmi_read_block(hdev, i, &entry, sizeof(entry)); 735 if (retval) { 736 hid_err(hdev, 737 "Read of PDT entry at %#06x failed.\n", 738 i); 739 goto error_exit; 740 } 741 742 if (RMI4_END_OF_PDT(entry.function_number)) 743 break; 744 745 page_has_function = true; 746 747 hid_info(hdev, "Found F%02X on page %#04x\n", 748 entry.function_number, page); 749 750 rmi_register_function(data, &entry, page, interrupt); 751 interrupt += entry.interrupt_source_count; 752 } 753 754 if (!page_has_function) 755 break; 756 } 757 758 hid_info(hdev, "%s: Done with PDT scan.\n", __func__); 759 retval = 0; 760 761 error_exit: 762 return retval; 763 } 764 765 #define RMI_DEVICE_F01_BASIC_QUERY_LEN 11 766 767 static int rmi_populate_f01(struct hid_device *hdev) 768 { 769 struct rmi_data *data = hid_get_drvdata(hdev); 770 u8 basic_queries[RMI_DEVICE_F01_BASIC_QUERY_LEN]; 771 u8 info[3]; 772 int ret; 773 bool has_query42; 774 bool has_lts; 775 bool has_sensor_id; 776 bool has_ds4_queries = false; 777 bool has_build_id_query = false; 778 bool has_package_id_query = false; 779 u16 query_offset = data->f01.query_base_addr; 780 u16 prod_info_addr; 781 u8 ds4_query_len; 782 783 ret = rmi_read_block(hdev, query_offset, basic_queries, 784 RMI_DEVICE_F01_BASIC_QUERY_LEN); 785 if (ret) { 786 hid_err(hdev, "Can not read basic queries from Function 0x1.\n"); 787 return ret; 788 } 789 790 has_lts = !!(basic_queries[0] & BIT(2)); 791 has_sensor_id = !!(basic_queries[1] & BIT(3)); 792 has_query42 = !!(basic_queries[1] & BIT(7)); 793 794 query_offset += 11; 795 prod_info_addr = query_offset + 6; 796 query_offset += 10; 797 798 if (has_lts) 799 query_offset += 20; 800 801 if (has_sensor_id) 802 query_offset++; 803 804 if (has_query42) { 805 ret = rmi_read(hdev, query_offset, info); 806 if (ret) { 807 hid_err(hdev, "Can not read query42.\n"); 808 return ret; 809 } 810 has_ds4_queries = !!(info[0] & BIT(0)); 811 query_offset++; 812 } 813 814 if (has_ds4_queries) { 815 ret = rmi_read(hdev, query_offset, &ds4_query_len); 816 if (ret) { 817 hid_err(hdev, "Can not read DS4 Query length.\n"); 818 return ret; 819 } 820 query_offset++; 821 822 if (ds4_query_len > 0) { 823 ret = rmi_read(hdev, query_offset, info); 824 if (ret) { 825 hid_err(hdev, "Can not read DS4 query.\n"); 826 return ret; 827 } 828 829 has_package_id_query = !!(info[0] & BIT(0)); 830 has_build_id_query = !!(info[0] & BIT(1)); 831 } 832 } 833 834 if (has_package_id_query) 835 prod_info_addr++; 836 837 if (has_build_id_query) { 838 ret = rmi_read_block(hdev, prod_info_addr, info, 3); 839 if (ret) { 840 hid_err(hdev, "Can not read product info.\n"); 841 return ret; 842 } 843 844 data->firmware_id = info[1] << 8 | info[0]; 845 data->firmware_id += info[2] * 65536; 846 } 847 848 ret = rmi_read_block(hdev, data->f01.control_base_addr, info, 849 2); 850 851 if (ret) { 852 hid_err(hdev, "can not read f01 ctrl registers\n"); 853 return ret; 854 } 855 856 data->f01_ctrl0 = info[0]; 857 858 if (!info[1]) { 859 /* 860 * Do to a firmware bug in some touchpads the F01 interrupt 861 * enable control register will be cleared on reset. 862 * This will stop the touchpad from reporting data, so 863 * if F01 CTRL1 is 0 then we need to explicitly enable 864 * interrupts for the functions we want data for. 865 */ 866 data->restore_interrupt_mask = true; 867 868 ret = rmi_write(hdev, data->f01.control_base_addr + 1, 869 &data->interrupt_enable_mask); 870 if (ret) { 871 hid_err(hdev, "can not write to control reg 1: %d.\n", 872 ret); 873 return ret; 874 } 875 } 876 877 return 0; 878 } 879 880 static int rmi_populate_f11(struct hid_device *hdev) 881 { 882 struct rmi_data *data = hid_get_drvdata(hdev); 883 u8 buf[20]; 884 int ret; 885 bool has_query9; 886 bool has_query10 = false; 887 bool has_query11; 888 bool has_query12; 889 bool has_query27; 890 bool has_query28; 891 bool has_query36 = false; 892 bool has_physical_props; 893 bool has_gestures; 894 bool has_rel; 895 bool has_data40 = false; 896 bool has_dribble = false; 897 bool has_palm_detect = false; 898 unsigned x_size, y_size; 899 u16 query_offset; 900 901 if (!data->f11.query_base_addr) { 902 hid_err(hdev, "No 2D sensor found, giving up.\n"); 903 return -ENODEV; 904 } 905 906 /* query 0 contains some useful information */ 907 ret = rmi_read(hdev, data->f11.query_base_addr, buf); 908 if (ret) { 909 hid_err(hdev, "can not get query 0: %d.\n", ret); 910 return ret; 911 } 912 has_query9 = !!(buf[0] & BIT(3)); 913 has_query11 = !!(buf[0] & BIT(4)); 914 has_query12 = !!(buf[0] & BIT(5)); 915 has_query27 = !!(buf[0] & BIT(6)); 916 has_query28 = !!(buf[0] & BIT(7)); 917 918 /* query 1 to get the max number of fingers */ 919 ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf); 920 if (ret) { 921 hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret); 922 return ret; 923 } 924 data->max_fingers = (buf[0] & 0x07) + 1; 925 if (data->max_fingers > 5) 926 data->max_fingers = 10; 927 928 data->f11.report_size = data->max_fingers * 5 + 929 DIV_ROUND_UP(data->max_fingers, 4); 930 931 if (!(buf[0] & BIT(4))) { 932 hid_err(hdev, "No absolute events, giving up.\n"); 933 return -ENODEV; 934 } 935 936 has_rel = !!(buf[0] & BIT(3)); 937 has_gestures = !!(buf[0] & BIT(5)); 938 939 ret = rmi_read(hdev, data->f11.query_base_addr + 5, buf); 940 if (ret) { 941 hid_err(hdev, "can not get absolute data sources: %d.\n", ret); 942 return ret; 943 } 944 945 has_dribble = !!(buf[0] & BIT(4)); 946 947 /* 948 * At least 4 queries are guaranteed to be present in F11 949 * +1 for query 5 which is present since absolute events are 950 * reported and +1 for query 12. 951 */ 952 query_offset = 6; 953 954 if (has_rel) 955 ++query_offset; /* query 6 is present */ 956 957 if (has_gestures) { 958 /* query 8 to find out if query 10 exists */ 959 ret = rmi_read(hdev, 960 data->f11.query_base_addr + query_offset + 1, buf); 961 if (ret) { 962 hid_err(hdev, "can not read gesture information: %d.\n", 963 ret); 964 return ret; 965 } 966 has_palm_detect = !!(buf[0] & BIT(0)); 967 has_query10 = !!(buf[0] & BIT(2)); 968 969 query_offset += 2; /* query 7 and 8 are present */ 970 } 971 972 if (has_query9) 973 ++query_offset; 974 975 if (has_query10) 976 ++query_offset; 977 978 if (has_query11) 979 ++query_offset; 980 981 /* query 12 to know if the physical properties are reported */ 982 if (has_query12) { 983 ret = rmi_read(hdev, data->f11.query_base_addr 984 + query_offset, buf); 985 if (ret) { 986 hid_err(hdev, "can not get query 12: %d.\n", ret); 987 return ret; 988 } 989 has_physical_props = !!(buf[0] & BIT(5)); 990 991 if (has_physical_props) { 992 query_offset += 1; 993 ret = rmi_read_block(hdev, 994 data->f11.query_base_addr 995 + query_offset, buf, 4); 996 if (ret) { 997 hid_err(hdev, "can not read query 15-18: %d.\n", 998 ret); 999 return ret; 1000 } 1001 1002 x_size = buf[0] | (buf[1] << 8); 1003 y_size = buf[2] | (buf[3] << 8); 1004 1005 data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10); 1006 data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10); 1007 1008 hid_info(hdev, "%s: size in mm: %d x %d\n", 1009 __func__, data->x_size_mm, data->y_size_mm); 1010 1011 /* 1012 * query 15 - 18 contain the size of the sensor 1013 * and query 19 - 26 contain bezel dimensions 1014 */ 1015 query_offset += 12; 1016 } 1017 } 1018 1019 if (has_query27) 1020 ++query_offset; 1021 1022 if (has_query28) { 1023 ret = rmi_read(hdev, data->f11.query_base_addr 1024 + query_offset, buf); 1025 if (ret) { 1026 hid_err(hdev, "can not get query 28: %d.\n", ret); 1027 return ret; 1028 } 1029 1030 has_query36 = !!(buf[0] & BIT(6)); 1031 } 1032 1033 if (has_query36) { 1034 query_offset += 2; 1035 ret = rmi_read(hdev, data->f11.query_base_addr 1036 + query_offset, buf); 1037 if (ret) { 1038 hid_err(hdev, "can not get query 36: %d.\n", ret); 1039 return ret; 1040 } 1041 1042 has_data40 = !!(buf[0] & BIT(5)); 1043 } 1044 1045 1046 if (has_data40) 1047 data->f11.report_size += data->max_fingers * 2; 1048 1049 ret = rmi_read_block(hdev, data->f11.control_base_addr, 1050 data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT); 1051 if (ret) { 1052 hid_err(hdev, "can not read ctrl block of size 11: %d.\n", ret); 1053 return ret; 1054 } 1055 1056 /* data->f11_ctrl_regs now contains valid register data */ 1057 data->read_f11_ctrl_regs = true; 1058 1059 data->max_x = data->f11_ctrl_regs[6] | (data->f11_ctrl_regs[7] << 8); 1060 data->max_y = data->f11_ctrl_regs[8] | (data->f11_ctrl_regs[9] << 8); 1061 1062 if (has_dribble) { 1063 data->f11_ctrl_regs[0] = data->f11_ctrl_regs[0] & ~BIT(6); 1064 ret = rmi_write(hdev, data->f11.control_base_addr, 1065 data->f11_ctrl_regs); 1066 if (ret) { 1067 hid_err(hdev, "can not write to control reg 0: %d.\n", 1068 ret); 1069 return ret; 1070 } 1071 } 1072 1073 if (has_palm_detect) { 1074 data->f11_ctrl_regs[11] = data->f11_ctrl_regs[11] & ~BIT(0); 1075 ret = rmi_write(hdev, data->f11.control_base_addr + 11, 1076 &data->f11_ctrl_regs[11]); 1077 if (ret) { 1078 hid_err(hdev, "can not write to control reg 11: %d.\n", 1079 ret); 1080 return ret; 1081 } 1082 } 1083 1084 return 0; 1085 } 1086 1087 static int rmi_populate_f30(struct hid_device *hdev) 1088 { 1089 struct rmi_data *data = hid_get_drvdata(hdev); 1090 u8 buf[20]; 1091 int ret; 1092 bool has_gpio, has_led; 1093 unsigned bytes_per_ctrl; 1094 u8 ctrl2_addr; 1095 int ctrl2_3_length; 1096 int i; 1097 1098 /* function F30 is for physical buttons */ 1099 if (!data->f30.query_base_addr) { 1100 hid_err(hdev, "No GPIO/LEDs found, giving up.\n"); 1101 return -ENODEV; 1102 } 1103 1104 ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2); 1105 if (ret) { 1106 hid_err(hdev, "can not get F30 query registers: %d.\n", ret); 1107 return ret; 1108 } 1109 1110 has_gpio = !!(buf[0] & BIT(3)); 1111 has_led = !!(buf[0] & BIT(2)); 1112 data->gpio_led_count = buf[1] & 0x1f; 1113 1114 /* retrieve ctrl 2 & 3 registers */ 1115 bytes_per_ctrl = (data->gpio_led_count + 7) / 8; 1116 /* Ctrl0 is present only if both has_gpio and has_led are set*/ 1117 ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0; 1118 /* Ctrl1 is always be present */ 1119 ctrl2_addr += bytes_per_ctrl; 1120 ctrl2_3_length = 2 * bytes_per_ctrl; 1121 1122 data->f30.report_size = bytes_per_ctrl; 1123 1124 ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr, 1125 buf, ctrl2_3_length); 1126 if (ret) { 1127 hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n", 1128 ctrl2_3_length, ret); 1129 return ret; 1130 } 1131 1132 for (i = 0; i < data->gpio_led_count; i++) { 1133 int byte_position = i >> 3; 1134 int bit_position = i & 0x07; 1135 u8 dir_byte = buf[byte_position]; 1136 u8 data_byte = buf[byte_position + bytes_per_ctrl]; 1137 bool dir = (dir_byte >> bit_position) & BIT(0); 1138 bool dat = (data_byte >> bit_position) & BIT(0); 1139 1140 if (dir == 0) { 1141 /* input mode */ 1142 if (dat) { 1143 /* actual buttons have pull up resistor */ 1144 data->button_count++; 1145 set_bit(i, &data->button_mask); 1146 set_bit(i, &data->button_state_mask); 1147 } 1148 } 1149 1150 } 1151 1152 return 0; 1153 } 1154 1155 static int rmi_populate(struct hid_device *hdev) 1156 { 1157 struct rmi_data *data = hid_get_drvdata(hdev); 1158 int ret; 1159 1160 ret = rmi_scan_pdt(hdev); 1161 if (ret) { 1162 hid_err(hdev, "PDT scan failed with code %d.\n", ret); 1163 return ret; 1164 } 1165 1166 ret = rmi_populate_f01(hdev); 1167 if (ret) { 1168 hid_err(hdev, "Error while initializing F01 (%d).\n", ret); 1169 return ret; 1170 } 1171 1172 ret = rmi_populate_f11(hdev); 1173 if (ret) { 1174 hid_err(hdev, "Error while initializing F11 (%d).\n", ret); 1175 return ret; 1176 } 1177 1178 if (!(data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)) { 1179 ret = rmi_populate_f30(hdev); 1180 if (ret) 1181 hid_warn(hdev, "Error while initializing F30 (%d).\n", ret); 1182 } 1183 1184 return 0; 1185 } 1186 1187 static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) 1188 { 1189 struct rmi_data *data = hid_get_drvdata(hdev); 1190 struct input_dev *input = hi->input; 1191 int ret; 1192 int res_x, res_y, i; 1193 1194 data->input = input; 1195 1196 hid_dbg(hdev, "Opening low level driver\n"); 1197 ret = hid_hw_open(hdev); 1198 if (ret) 1199 return ret; 1200 1201 if (!(data->device_flags & RMI_DEVICE)) 1202 return 0; 1203 1204 /* Allow incoming hid reports */ 1205 hid_device_io_start(hdev); 1206 1207 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); 1208 if (ret < 0) { 1209 dev_err(&hdev->dev, "failed to set rmi mode\n"); 1210 goto exit; 1211 } 1212 1213 ret = rmi_set_page(hdev, 0); 1214 if (ret < 0) { 1215 dev_err(&hdev->dev, "failed to set page select to 0.\n"); 1216 goto exit; 1217 } 1218 1219 ret = rmi_populate(hdev); 1220 if (ret) 1221 goto exit; 1222 1223 hid_info(hdev, "firmware id: %ld\n", data->firmware_id); 1224 1225 __set_bit(EV_ABS, input->evbit); 1226 input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0); 1227 input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0); 1228 1229 if (data->x_size_mm && data->y_size_mm) { 1230 res_x = (data->max_x - 1) / data->x_size_mm; 1231 res_y = (data->max_y - 1) / data->y_size_mm; 1232 1233 input_abs_set_res(input, ABS_MT_POSITION_X, res_x); 1234 input_abs_set_res(input, ABS_MT_POSITION_Y, res_y); 1235 } 1236 1237 input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0); 1238 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0); 1239 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0); 1240 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0); 1241 1242 ret = input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER); 1243 if (ret < 0) 1244 goto exit; 1245 1246 if (data->button_count) { 1247 __set_bit(EV_KEY, input->evbit); 1248 for (i = 0; i < data->button_count; i++) 1249 __set_bit(BTN_LEFT + i, input->keybit); 1250 1251 if (data->button_count == 1) 1252 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 1253 } 1254 1255 set_bit(RMI_STARTED, &data->flags); 1256 1257 exit: 1258 hid_device_io_stop(hdev); 1259 hid_hw_close(hdev); 1260 return ret; 1261 } 1262 1263 static int rmi_input_mapping(struct hid_device *hdev, 1264 struct hid_input *hi, struct hid_field *field, 1265 struct hid_usage *usage, unsigned long **bit, int *max) 1266 { 1267 struct rmi_data *data = hid_get_drvdata(hdev); 1268 1269 /* 1270 * we want to make HID ignore the advertised HID collection 1271 * for RMI deivces 1272 */ 1273 if (data->device_flags & RMI_DEVICE) { 1274 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) && 1275 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)) 1276 return 0; 1277 1278 return -1; 1279 } 1280 1281 return 0; 1282 } 1283 1284 static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type, 1285 unsigned id, struct hid_report **report) 1286 { 1287 int i; 1288 1289 *report = hdev->report_enum[type].report_id_hash[id]; 1290 if (*report) { 1291 for (i = 0; i < (*report)->maxfield; i++) { 1292 unsigned app = (*report)->field[i]->application; 1293 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR) 1294 return 1; 1295 } 1296 } 1297 1298 return 0; 1299 } 1300 1301 static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) 1302 { 1303 struct rmi_data *data = NULL; 1304 int ret; 1305 size_t alloc_size; 1306 struct hid_report *input_report; 1307 struct hid_report *output_report; 1308 struct hid_report *feature_report; 1309 1310 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL); 1311 if (!data) 1312 return -ENOMEM; 1313 1314 INIT_WORK(&data->reset_work, rmi_reset_work); 1315 data->hdev = hdev; 1316 1317 hid_set_drvdata(hdev, data); 1318 1319 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1320 1321 ret = hid_parse(hdev); 1322 if (ret) { 1323 hid_err(hdev, "parse failed\n"); 1324 return ret; 1325 } 1326 1327 if (id->driver_data) 1328 data->device_flags = id->driver_data; 1329 1330 /* 1331 * Check for the RMI specific report ids. If they are misisng 1332 * simply return and let the events be processed by hid-input 1333 */ 1334 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT, 1335 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) { 1336 hid_dbg(hdev, "device does not have set mode feature report\n"); 1337 goto start; 1338 } 1339 1340 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT, 1341 RMI_ATTN_REPORT_ID, &input_report)) { 1342 hid_dbg(hdev, "device does not have attention input report\n"); 1343 goto start; 1344 } 1345 1346 data->input_report_size = hid_report_len(input_report); 1347 1348 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT, 1349 RMI_WRITE_REPORT_ID, &output_report)) { 1350 hid_dbg(hdev, 1351 "device does not have rmi write output report\n"); 1352 goto start; 1353 } 1354 1355 data->output_report_size = hid_report_len(output_report); 1356 1357 data->device_flags |= RMI_DEVICE; 1358 alloc_size = data->output_report_size + data->input_report_size; 1359 1360 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL); 1361 if (!data->writeReport) { 1362 ret = -ENOMEM; 1363 return ret; 1364 } 1365 1366 data->readReport = data->writeReport + data->output_report_size; 1367 1368 init_waitqueue_head(&data->wait); 1369 1370 mutex_init(&data->page_mutex); 1371 1372 start: 1373 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1374 if (ret) { 1375 hid_err(hdev, "hw start failed\n"); 1376 return ret; 1377 } 1378 1379 if ((data->device_flags & RMI_DEVICE) && 1380 !test_bit(RMI_STARTED, &data->flags)) 1381 /* 1382 * The device maybe in the bootloader if rmi_input_configured 1383 * failed to find F11 in the PDT. Print an error, but don't 1384 * return an error from rmi_probe so that hidraw will be 1385 * accessible from userspace. That way a userspace tool 1386 * can be used to reload working firmware on the touchpad. 1387 */ 1388 hid_err(hdev, "Device failed to be properly configured\n"); 1389 1390 return 0; 1391 } 1392 1393 static void rmi_remove(struct hid_device *hdev) 1394 { 1395 struct rmi_data *hdata = hid_get_drvdata(hdev); 1396 1397 clear_bit(RMI_STARTED, &hdata->flags); 1398 1399 hid_hw_stop(hdev); 1400 } 1401 1402 static const struct hid_device_id rmi_id[] = { 1403 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14), 1404 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS }, 1405 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) }, 1406 { } 1407 }; 1408 MODULE_DEVICE_TABLE(hid, rmi_id); 1409 1410 static struct hid_driver rmi_driver = { 1411 .name = "hid-rmi", 1412 .id_table = rmi_id, 1413 .probe = rmi_probe, 1414 .remove = rmi_remove, 1415 .event = rmi_event, 1416 .raw_event = rmi_raw_event, 1417 .input_mapping = rmi_input_mapping, 1418 .input_configured = rmi_input_configured, 1419 #ifdef CONFIG_PM 1420 .suspend = rmi_suspend, 1421 .resume = rmi_post_resume, 1422 .reset_resume = rmi_post_reset, 1423 #endif 1424 }; 1425 1426 module_hid_driver(rmi_driver); 1427 1428 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>"); 1429 MODULE_DESCRIPTION("RMI HID driver"); 1430 MODULE_LICENSE("GPL"); 1431