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/irq.h> 18 #include <linux/irqdomain.h> 19 #include <linux/module.h> 20 #include <linux/pm.h> 21 #include <linux/slab.h> 22 #include <linux/wait.h> 23 #include <linux/sched.h> 24 #include <linux/rmi.h> 25 #include "hid-ids.h" 26 27 #define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */ 28 #define RMI_WRITE_REPORT_ID 0x09 /* Output Report */ 29 #define RMI_READ_ADDR_REPORT_ID 0x0a /* Output Report */ 30 #define RMI_READ_DATA_REPORT_ID 0x0b /* Input Report */ 31 #define RMI_ATTN_REPORT_ID 0x0c /* Input Report */ 32 #define RMI_SET_RMI_MODE_REPORT_ID 0x0f /* Feature Report */ 33 34 /* flags */ 35 #define RMI_READ_REQUEST_PENDING 0 36 #define RMI_READ_DATA_PENDING 1 37 #define RMI_STARTED 2 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 /** 58 * struct rmi_data - stores information for hid communication 59 * 60 * @page_mutex: Locks current page to avoid changing pages in unexpected ways. 61 * @page: Keeps track of the current virtual page 62 * @xport: transport device to be registered with the RMI4 core. 63 * 64 * @wait: Used for waiting for read data 65 * 66 * @writeReport: output buffer when writing RMI registers 67 * @readReport: input buffer when reading RMI registers 68 * 69 * @input_report_size: size of an input report (advertised by HID) 70 * @output_report_size: size of an output report (advertised by HID) 71 * 72 * @flags: flags for the current device (started, reading, etc...) 73 * 74 * @reset_work: worker which will be called in case of a mouse report 75 * @hdev: pointer to the struct hid_device 76 * 77 * @device_flags: flags which describe the device 78 * 79 * @domain: the IRQ domain allocated for this RMI4 device 80 * @rmi_irq: the irq that will be used to generate events to rmi-core 81 */ 82 struct rmi_data { 83 struct mutex page_mutex; 84 int page; 85 struct rmi_transport_dev xport; 86 87 wait_queue_head_t wait; 88 89 u8 *writeReport; 90 u8 *readReport; 91 92 u32 input_report_size; 93 u32 output_report_size; 94 95 unsigned long flags; 96 97 struct work_struct reset_work; 98 struct hid_device *hdev; 99 100 unsigned long device_flags; 101 102 struct irq_domain *domain; 103 int rmi_irq; 104 }; 105 106 #define RMI_PAGE(addr) (((addr) >> 8) & 0xff) 107 108 static int rmi_write_report(struct hid_device *hdev, u8 *report, int len); 109 110 /** 111 * rmi_set_page - Set RMI page 112 * @hdev: The pointer to the hid_device struct 113 * @page: The new page address. 114 * 115 * RMI devices have 16-bit addressing, but some of the physical 116 * implementations (like SMBus) only have 8-bit addressing. So RMI implements 117 * a page address at 0xff of every page so we can reliable page addresses 118 * every 256 registers. 119 * 120 * The page_mutex lock must be held when this function is entered. 121 * 122 * Returns zero on success, non-zero on failure. 123 */ 124 static int rmi_set_page(struct hid_device *hdev, u8 page) 125 { 126 struct rmi_data *data = hid_get_drvdata(hdev); 127 int retval; 128 129 data->writeReport[0] = RMI_WRITE_REPORT_ID; 130 data->writeReport[1] = 1; 131 data->writeReport[2] = 0xFF; 132 data->writeReport[4] = page; 133 134 retval = rmi_write_report(hdev, data->writeReport, 135 data->output_report_size); 136 if (retval != data->output_report_size) { 137 dev_err(&hdev->dev, 138 "%s: set page failed: %d.", __func__, retval); 139 return retval; 140 } 141 142 data->page = page; 143 return 0; 144 } 145 146 static int rmi_set_mode(struct hid_device *hdev, u8 mode) 147 { 148 int ret; 149 const u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode}; 150 u8 *buf; 151 152 buf = kmemdup(txbuf, sizeof(txbuf), GFP_KERNEL); 153 if (!buf) 154 return -ENOMEM; 155 156 ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, buf, 157 sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 158 kfree(buf); 159 if (ret < 0) { 160 dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode, 161 ret); 162 return ret; 163 } 164 165 return 0; 166 } 167 168 static int rmi_write_report(struct hid_device *hdev, u8 *report, int len) 169 { 170 int ret; 171 172 ret = hid_hw_output_report(hdev, (void *)report, len); 173 if (ret < 0) { 174 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret); 175 return ret; 176 } 177 178 return ret; 179 } 180 181 static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr, 182 void *buf, size_t len) 183 { 184 struct rmi_data *data = container_of(xport, struct rmi_data, xport); 185 struct hid_device *hdev = data->hdev; 186 int ret; 187 int bytes_read; 188 int bytes_needed; 189 int retries; 190 int read_input_count; 191 192 mutex_lock(&data->page_mutex); 193 194 if (RMI_PAGE(addr) != data->page) { 195 ret = rmi_set_page(hdev, RMI_PAGE(addr)); 196 if (ret < 0) 197 goto exit; 198 } 199 200 for (retries = 5; retries > 0; retries--) { 201 data->writeReport[0] = RMI_READ_ADDR_REPORT_ID; 202 data->writeReport[1] = 0; /* old 1 byte read count */ 203 data->writeReport[2] = addr & 0xFF; 204 data->writeReport[3] = (addr >> 8) & 0xFF; 205 data->writeReport[4] = len & 0xFF; 206 data->writeReport[5] = (len >> 8) & 0xFF; 207 208 set_bit(RMI_READ_REQUEST_PENDING, &data->flags); 209 210 ret = rmi_write_report(hdev, data->writeReport, 211 data->output_report_size); 212 if (ret != data->output_report_size) { 213 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); 214 dev_err(&hdev->dev, 215 "failed to write request output report (%d)\n", 216 ret); 217 goto exit; 218 } 219 220 bytes_read = 0; 221 bytes_needed = len; 222 while (bytes_read < len) { 223 if (!wait_event_timeout(data->wait, 224 test_bit(RMI_READ_DATA_PENDING, &data->flags), 225 msecs_to_jiffies(1000))) { 226 hid_warn(hdev, "%s: timeout elapsed\n", 227 __func__); 228 ret = -EAGAIN; 229 break; 230 } 231 232 read_input_count = data->readReport[1]; 233 memcpy(buf + bytes_read, &data->readReport[2], 234 read_input_count < bytes_needed ? 235 read_input_count : bytes_needed); 236 237 bytes_read += read_input_count; 238 bytes_needed -= read_input_count; 239 clear_bit(RMI_READ_DATA_PENDING, &data->flags); 240 } 241 242 if (ret >= 0) { 243 ret = 0; 244 break; 245 } 246 } 247 248 exit: 249 clear_bit(RMI_READ_REQUEST_PENDING, &data->flags); 250 mutex_unlock(&data->page_mutex); 251 return ret; 252 } 253 254 static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr, 255 const void *buf, size_t len) 256 { 257 struct rmi_data *data = container_of(xport, struct rmi_data, xport); 258 struct hid_device *hdev = data->hdev; 259 int ret; 260 261 mutex_lock(&data->page_mutex); 262 263 if (RMI_PAGE(addr) != data->page) { 264 ret = rmi_set_page(hdev, RMI_PAGE(addr)); 265 if (ret < 0) 266 goto exit; 267 } 268 269 data->writeReport[0] = RMI_WRITE_REPORT_ID; 270 data->writeReport[1] = len; 271 data->writeReport[2] = addr & 0xFF; 272 data->writeReport[3] = (addr >> 8) & 0xFF; 273 memcpy(&data->writeReport[4], buf, len); 274 275 ret = rmi_write_report(hdev, data->writeReport, 276 data->output_report_size); 277 if (ret < 0) { 278 dev_err(&hdev->dev, 279 "failed to write request output report (%d)\n", 280 ret); 281 goto exit; 282 } 283 ret = 0; 284 285 exit: 286 mutex_unlock(&data->page_mutex); 287 return ret; 288 } 289 290 static int rmi_reset_attn_mode(struct hid_device *hdev) 291 { 292 struct rmi_data *data = hid_get_drvdata(hdev); 293 struct rmi_device *rmi_dev = data->xport.rmi_dev; 294 int ret; 295 296 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); 297 if (ret) 298 return ret; 299 300 if (test_bit(RMI_STARTED, &data->flags)) 301 ret = rmi_dev->driver->reset_handler(rmi_dev); 302 303 return ret; 304 } 305 306 static void rmi_reset_work(struct work_struct *work) 307 { 308 struct rmi_data *hdata = container_of(work, struct rmi_data, 309 reset_work); 310 311 /* switch the device to RMI if we receive a generic mouse report */ 312 rmi_reset_attn_mode(hdata->hdev); 313 } 314 315 static int rmi_input_event(struct hid_device *hdev, u8 *data, int size) 316 { 317 struct rmi_data *hdata = hid_get_drvdata(hdev); 318 struct rmi_device *rmi_dev = hdata->xport.rmi_dev; 319 unsigned long flags; 320 321 if (!(test_bit(RMI_STARTED, &hdata->flags))) 322 return 0; 323 324 local_irq_save(flags); 325 326 rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2); 327 328 generic_handle_irq(hdata->rmi_irq); 329 330 local_irq_restore(flags); 331 332 return 1; 333 } 334 335 static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size) 336 { 337 struct rmi_data *hdata = hid_get_drvdata(hdev); 338 339 if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) { 340 hid_dbg(hdev, "no read request pending\n"); 341 return 0; 342 } 343 344 memcpy(hdata->readReport, data, size < hdata->input_report_size ? 345 size : hdata->input_report_size); 346 set_bit(RMI_READ_DATA_PENDING, &hdata->flags); 347 wake_up(&hdata->wait); 348 349 return 1; 350 } 351 352 static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size) 353 { 354 int valid_size = size; 355 /* 356 * On the Dell XPS 13 9333, the bus sometimes get confused and fills 357 * the report with a sentinel value "ff". Synaptics told us that such 358 * behavior does not comes from the touchpad itself, so we filter out 359 * such reports here. 360 */ 361 362 while ((data[valid_size - 1] == 0xff) && valid_size > 0) 363 valid_size--; 364 365 return valid_size; 366 } 367 368 static int rmi_raw_event(struct hid_device *hdev, 369 struct hid_report *report, u8 *data, int size) 370 { 371 struct rmi_data *hdata = hid_get_drvdata(hdev); 372 373 if (!(hdata->device_flags & RMI_DEVICE)) 374 return 0; 375 376 size = rmi_check_sanity(hdev, data, size); 377 if (size < 2) 378 return 0; 379 380 switch (data[0]) { 381 case RMI_READ_DATA_REPORT_ID: 382 return rmi_read_data_event(hdev, data, size); 383 case RMI_ATTN_REPORT_ID: 384 return rmi_input_event(hdev, data, size); 385 default: 386 return 1; 387 } 388 389 return 0; 390 } 391 392 static int rmi_event(struct hid_device *hdev, struct hid_field *field, 393 struct hid_usage *usage, __s32 value) 394 { 395 struct rmi_data *data = hid_get_drvdata(hdev); 396 397 if ((data->device_flags & RMI_DEVICE) && 398 (field->application == HID_GD_POINTER || 399 field->application == HID_GD_MOUSE)) { 400 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) { 401 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) 402 return 0; 403 404 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y) 405 && !value) 406 return 1; 407 } 408 409 schedule_work(&data->reset_work); 410 return 1; 411 } 412 413 return 0; 414 } 415 416 static void rmi_report(struct hid_device *hid, struct hid_report *report) 417 { 418 struct hid_field *field = report->field[0]; 419 420 if (!(hid->claimed & HID_CLAIMED_INPUT)) 421 return; 422 423 switch (report->id) { 424 case RMI_READ_DATA_REPORT_ID: 425 /* fall-through */ 426 case RMI_ATTN_REPORT_ID: 427 return; 428 } 429 430 if (field && field->hidinput && field->hidinput->input) 431 input_sync(field->hidinput->input); 432 } 433 434 #ifdef CONFIG_PM 435 static int rmi_suspend(struct hid_device *hdev, pm_message_t message) 436 { 437 struct rmi_data *data = hid_get_drvdata(hdev); 438 struct rmi_device *rmi_dev = data->xport.rmi_dev; 439 int ret; 440 441 if (!(data->device_flags & RMI_DEVICE)) 442 return 0; 443 444 ret = rmi_driver_suspend(rmi_dev, false); 445 if (ret) { 446 hid_warn(hdev, "Failed to suspend device: %d\n", ret); 447 return ret; 448 } 449 450 return 0; 451 } 452 453 static int rmi_post_resume(struct hid_device *hdev) 454 { 455 struct rmi_data *data = hid_get_drvdata(hdev); 456 struct rmi_device *rmi_dev = data->xport.rmi_dev; 457 int ret; 458 459 if (!(data->device_flags & RMI_DEVICE)) 460 return 0; 461 462 /* Make sure the HID device is ready to receive events */ 463 ret = hid_hw_open(hdev); 464 if (ret) 465 return ret; 466 467 ret = rmi_reset_attn_mode(hdev); 468 if (ret) 469 goto out; 470 471 ret = rmi_driver_resume(rmi_dev, false); 472 if (ret) { 473 hid_warn(hdev, "Failed to resume device: %d\n", ret); 474 goto out; 475 } 476 477 out: 478 hid_hw_close(hdev); 479 return ret; 480 } 481 #endif /* CONFIG_PM */ 482 483 static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr) 484 { 485 struct rmi_data *data = container_of(xport, struct rmi_data, xport); 486 struct hid_device *hdev = data->hdev; 487 488 return rmi_reset_attn_mode(hdev); 489 } 490 491 static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) 492 { 493 struct rmi_data *data = hid_get_drvdata(hdev); 494 struct input_dev *input = hi->input; 495 int ret = 0; 496 497 if (!(data->device_flags & RMI_DEVICE)) 498 return 0; 499 500 data->xport.input = input; 501 502 hid_dbg(hdev, "Opening low level driver\n"); 503 ret = hid_hw_open(hdev); 504 if (ret) 505 return ret; 506 507 /* Allow incoming hid reports */ 508 hid_device_io_start(hdev); 509 510 ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); 511 if (ret < 0) { 512 dev_err(&hdev->dev, "failed to set rmi mode\n"); 513 goto exit; 514 } 515 516 ret = rmi_set_page(hdev, 0); 517 if (ret < 0) { 518 dev_err(&hdev->dev, "failed to set page select to 0.\n"); 519 goto exit; 520 } 521 522 ret = rmi_register_transport_device(&data->xport); 523 if (ret < 0) { 524 dev_err(&hdev->dev, "failed to register transport driver\n"); 525 goto exit; 526 } 527 528 set_bit(RMI_STARTED, &data->flags); 529 530 exit: 531 hid_device_io_stop(hdev); 532 hid_hw_close(hdev); 533 return ret; 534 } 535 536 static int rmi_input_mapping(struct hid_device *hdev, 537 struct hid_input *hi, struct hid_field *field, 538 struct hid_usage *usage, unsigned long **bit, int *max) 539 { 540 struct rmi_data *data = hid_get_drvdata(hdev); 541 542 /* 543 * we want to make HID ignore the advertised HID collection 544 * for RMI deivces 545 */ 546 if (data->device_flags & RMI_DEVICE) { 547 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) && 548 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)) 549 return 0; 550 551 return -1; 552 } 553 554 return 0; 555 } 556 557 static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type, 558 unsigned id, struct hid_report **report) 559 { 560 int i; 561 562 *report = hdev->report_enum[type].report_id_hash[id]; 563 if (*report) { 564 for (i = 0; i < (*report)->maxfield; i++) { 565 unsigned app = (*report)->field[i]->application; 566 if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR) 567 return 1; 568 } 569 } 570 571 return 0; 572 } 573 574 static struct rmi_device_platform_data rmi_hid_pdata = { 575 .sensor_pdata = { 576 .sensor_type = rmi_sensor_touchpad, 577 .axis_align.flip_y = true, 578 .dribble = RMI_REG_STATE_ON, 579 .palm_detect = RMI_REG_STATE_OFF, 580 }, 581 }; 582 583 static const struct rmi_transport_ops hid_rmi_ops = { 584 .write_block = rmi_hid_write_block, 585 .read_block = rmi_hid_read_block, 586 .reset = rmi_hid_reset, 587 }; 588 589 static void rmi_irq_teardown(void *data) 590 { 591 struct rmi_data *hdata = data; 592 struct irq_domain *domain = hdata->domain; 593 594 if (!domain) 595 return; 596 597 irq_dispose_mapping(irq_find_mapping(domain, 0)); 598 599 irq_domain_remove(domain); 600 hdata->domain = NULL; 601 hdata->rmi_irq = 0; 602 } 603 604 static int rmi_irq_map(struct irq_domain *h, unsigned int virq, 605 irq_hw_number_t hw_irq_num) 606 { 607 irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq); 608 609 return 0; 610 } 611 612 static const struct irq_domain_ops rmi_irq_ops = { 613 .map = rmi_irq_map, 614 }; 615 616 static int rmi_setup_irq_domain(struct hid_device *hdev) 617 { 618 struct rmi_data *hdata = hid_get_drvdata(hdev); 619 int ret; 620 621 hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1, 622 &rmi_irq_ops, hdata); 623 if (!hdata->domain) 624 return -ENOMEM; 625 626 ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata); 627 if (ret) 628 return ret; 629 630 hdata->rmi_irq = irq_create_mapping(hdata->domain, 0); 631 if (hdata->rmi_irq <= 0) { 632 hid_err(hdev, "Can't allocate an IRQ\n"); 633 return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO; 634 } 635 636 return 0; 637 } 638 639 static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) 640 { 641 struct rmi_data *data = NULL; 642 int ret; 643 size_t alloc_size; 644 struct hid_report *input_report; 645 struct hid_report *output_report; 646 struct hid_report *feature_report; 647 648 data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL); 649 if (!data) 650 return -ENOMEM; 651 652 INIT_WORK(&data->reset_work, rmi_reset_work); 653 data->hdev = hdev; 654 655 hid_set_drvdata(hdev, data); 656 657 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 658 hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; 659 660 ret = hid_parse(hdev); 661 if (ret) { 662 hid_err(hdev, "parse failed\n"); 663 return ret; 664 } 665 666 if (id->driver_data) 667 data->device_flags = id->driver_data; 668 669 /* 670 * Check for the RMI specific report ids. If they are misisng 671 * simply return and let the events be processed by hid-input 672 */ 673 if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT, 674 RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) { 675 hid_dbg(hdev, "device does not have set mode feature report\n"); 676 goto start; 677 } 678 679 if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT, 680 RMI_ATTN_REPORT_ID, &input_report)) { 681 hid_dbg(hdev, "device does not have attention input report\n"); 682 goto start; 683 } 684 685 data->input_report_size = hid_report_len(input_report); 686 687 if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT, 688 RMI_WRITE_REPORT_ID, &output_report)) { 689 hid_dbg(hdev, 690 "device does not have rmi write output report\n"); 691 goto start; 692 } 693 694 data->output_report_size = hid_report_len(output_report); 695 696 data->device_flags |= RMI_DEVICE; 697 alloc_size = data->output_report_size + data->input_report_size; 698 699 data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL); 700 if (!data->writeReport) { 701 hid_err(hdev, "failed to allocate buffer for HID reports\n"); 702 return -ENOMEM; 703 } 704 705 data->readReport = data->writeReport + data->output_report_size; 706 707 init_waitqueue_head(&data->wait); 708 709 mutex_init(&data->page_mutex); 710 711 ret = rmi_setup_irq_domain(hdev); 712 if (ret) { 713 hid_err(hdev, "failed to allocate IRQ domain\n"); 714 return ret; 715 } 716 717 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) 718 rmi_hid_pdata.f30_data.disable = true; 719 720 data->xport.dev = hdev->dev.parent; 721 data->xport.pdata = rmi_hid_pdata; 722 data->xport.pdata.irq = data->rmi_irq; 723 data->xport.proto_name = "hid"; 724 data->xport.ops = &hid_rmi_ops; 725 726 start: 727 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 728 if (ret) { 729 hid_err(hdev, "hw start failed\n"); 730 return ret; 731 } 732 733 return 0; 734 } 735 736 static void rmi_remove(struct hid_device *hdev) 737 { 738 struct rmi_data *hdata = hid_get_drvdata(hdev); 739 740 if (hdata->device_flags & RMI_DEVICE) { 741 clear_bit(RMI_STARTED, &hdata->flags); 742 cancel_work_sync(&hdata->reset_work); 743 rmi_unregister_transport_device(&hdata->xport); 744 } 745 746 hid_hw_stop(hdev); 747 } 748 749 static const struct hid_device_id rmi_id[] = { 750 { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14), 751 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS }, 752 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) }, 753 { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_REZEL) }, 754 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) }, 755 { } 756 }; 757 MODULE_DEVICE_TABLE(hid, rmi_id); 758 759 static struct hid_driver rmi_driver = { 760 .name = "hid-rmi", 761 .id_table = rmi_id, 762 .probe = rmi_probe, 763 .remove = rmi_remove, 764 .event = rmi_event, 765 .raw_event = rmi_raw_event, 766 .report = rmi_report, 767 .input_mapping = rmi_input_mapping, 768 .input_configured = rmi_input_configured, 769 #ifdef CONFIG_PM 770 .suspend = rmi_suspend, 771 .resume = rmi_post_resume, 772 .reset_resume = rmi_post_resume, 773 #endif 774 }; 775 776 module_hid_driver(rmi_driver); 777 778 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>"); 779 MODULE_DESCRIPTION("RMI HID driver"); 780 MODULE_LICENSE("GPL"); 781