drivers/hid/hid-rmi.c

   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         size = rmi_check_sanity(hdev, data, size);
 372         if (size < 2)
 373                 return 0;
 374
 375         switch (data[0]) {
 376         case RMI_READ_DATA_REPORT_ID:
 377                 return rmi_read_data_event(hdev, data, size);
 378         case RMI_ATTN_REPORT_ID:
 379                 return rmi_input_event(hdev, data, size);
 380         default:
 381                 return 1;
 382         }
 383
 384         return 0;
 385 }
 386
 387 static int rmi_event(struct hid_device *hdev, struct hid_field *field,
 388                         struct hid_usage *usage, __s32 value)
 389 {
 390         struct rmi_data *data = hid_get_drvdata(hdev);
 391
 392         if ((data->device_flags & RMI_DEVICE) &&
 393             (field->application == HID_GD_POINTER ||
 394             field->application == HID_GD_MOUSE)) {
 395                 if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) {
 396                         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
 397                                 return 0;
 398
 399                         if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
 400                             && !value)
 401                                 return 1;
 402                 }
 403
 404                 schedule_work(&data->reset_work);
 405                 return 1;
 406         }
 407
 408         return 0;
 409 }
 410
 411 #ifdef CONFIG_PM
 412 static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
 413 {
 414         struct rmi_data *data = hid_get_drvdata(hdev);
 415         struct rmi_device *rmi_dev = data->xport.rmi_dev;
 416         int ret;
 417
 418         if (!(data->device_flags & RMI_DEVICE))
 419                 return 0;
 420
 421         ret = rmi_driver_suspend(rmi_dev, false);
 422         if (ret) {
 423                 hid_warn(hdev, "Failed to suspend device: %d\n", ret);
 424                 return ret;
 425         }
 426
 427         return 0;
 428 }
 429
 430 static int rmi_post_resume(struct hid_device *hdev)
 431 {
 432         struct rmi_data *data = hid_get_drvdata(hdev);
 433         struct rmi_device *rmi_dev = data->xport.rmi_dev;
 434         int ret;
 435
 436         if (!(data->device_flags & RMI_DEVICE))
 437                 return 0;
 438
 439         /* Make sure the HID device is ready to receive events */
 440         ret = hid_hw_open(hdev);
 441         if (ret)
 442                 return ret;
 443
 444         ret = rmi_reset_attn_mode(hdev);
 445         if (ret)
 446                 goto out;
 447
 448         ret = rmi_driver_resume(rmi_dev, false);
 449         if (ret) {
 450                 hid_warn(hdev, "Failed to resume device: %d\n", ret);
 451                 goto out;
 452         }
 453
 454 out:
 455         hid_hw_close(hdev);
 456         return ret;
 457 }
 458 #endif /* CONFIG_PM */
 459
 460 static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr)
 461 {
 462         struct rmi_data *data = container_of(xport, struct rmi_data, xport);
 463         struct hid_device *hdev = data->hdev;
 464
 465         return rmi_reset_attn_mode(hdev);
 466 }
 467
 468 static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
 469 {
 470         struct rmi_data *data = hid_get_drvdata(hdev);
 471         struct input_dev *input = hi->input;
 472         int ret = 0;
 473
 474         if (!(data->device_flags & RMI_DEVICE))
 475                 return 0;
 476
 477         data->xport.input = input;
 478
 479         hid_dbg(hdev, "Opening low level driver\n");
 480         ret = hid_hw_open(hdev);
 481         if (ret)
 482                 return ret;
 483
 484         /* Allow incoming hid reports */
 485         hid_device_io_start(hdev);
 486
 487         ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
 488         if (ret < 0) {
 489                 dev_err(&hdev->dev, "failed to set rmi mode\n");
 490                 goto exit;
 491         }
 492
 493         ret = rmi_set_page(hdev, 0);
 494         if (ret < 0) {
 495                 dev_err(&hdev->dev, "failed to set page select to 0.\n");
 496                 goto exit;
 497         }
 498
 499         ret = rmi_register_transport_device(&data->xport);
 500         if (ret < 0) {
 501                 dev_err(&hdev->dev, "failed to register transport driver\n");
 502                 goto exit;
 503         }
 504
 505         set_bit(RMI_STARTED, &data->flags);
 506
 507 exit:
 508         hid_device_io_stop(hdev);
 509         hid_hw_close(hdev);
 510         return ret;
 511 }
 512
 513 static int rmi_input_mapping(struct hid_device *hdev,
 514                 struct hid_input *hi, struct hid_field *field,
 515                 struct hid_usage *usage, unsigned long **bit, int *max)
 516 {
 517         struct rmi_data *data = hid_get_drvdata(hdev);
 518
 519         /*
 520          * we want to make HID ignore the advertised HID collection
 521          * for RMI deivces
 522          */
 523         if (data->device_flags & RMI_DEVICE) {
 524                 if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) &&
 525                     ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
 526                         return 0;
 527
 528                 return -1;
 529         }
 530
 531         return 0;
 532 }
 533
 534 static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
 535                 unsigned id, struct hid_report **report)
 536 {
 537         int i;
 538
 539         *report = hdev->report_enum[type].report_id_hash[id];
 540         if (*report) {
 541                 for (i = 0; i < (*report)->maxfield; i++) {
 542                         unsigned app = (*report)->field[i]->application;
 543                         if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR)
 544                                 return 1;
 545                 }
 546         }
 547
 548         return 0;
 549 }
 550
 551 static struct rmi_device_platform_data rmi_hid_pdata = {
 552         .sensor_pdata = {
 553                 .sensor_type = rmi_sensor_touchpad,
 554                 .axis_align.flip_y = true,
 555                 .dribble = RMI_REG_STATE_ON,
 556                 .palm_detect = RMI_REG_STATE_OFF,
 557         },
 558 };
 559
 560 static const struct rmi_transport_ops hid_rmi_ops = {
 561         .write_block    = rmi_hid_write_block,
 562         .read_block     = rmi_hid_read_block,
 563         .reset          = rmi_hid_reset,
 564 };
 565
 566 static void rmi_irq_teardown(void *data)
 567 {
 568         struct rmi_data *hdata = data;
 569         struct irq_domain *domain = hdata->domain;
 570
 571         if (!domain)
 572                 return;
 573
 574         irq_dispose_mapping(irq_find_mapping(domain, 0));
 575
 576         irq_domain_remove(domain);
 577         hdata->domain = NULL;
 578         hdata->rmi_irq = 0;
 579 }
 580
 581 static int rmi_irq_map(struct irq_domain *h, unsigned int virq,
 582                        irq_hw_number_t hw_irq_num)
 583 {
 584         irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
 585
 586         return 0;
 587 }
 588
 589 static const struct irq_domain_ops rmi_irq_ops = {
 590         .map = rmi_irq_map,
 591 };
 592
 593 static int rmi_setup_irq_domain(struct hid_device *hdev)
 594 {
 595         struct rmi_data *hdata = hid_get_drvdata(hdev);
 596         int ret;
 597
 598         hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1,
 599                                                  &rmi_irq_ops, hdata);
 600         if (!hdata->domain)
 601                 return -ENOMEM;
 602
 603         ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata);
 604         if (ret)
 605                 return ret;
 606
 607         hdata->rmi_irq = irq_create_mapping(hdata->domain, 0);
 608         if (hdata->rmi_irq <= 0) {
 609                 hid_err(hdev, "Can't allocate an IRQ\n");
 610                 return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO;
 611         }
 612
 613         return 0;
 614 }
 615
 616 static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
 617 {
 618         struct rmi_data *data = NULL;
 619         int ret;
 620         size_t alloc_size;
 621         struct hid_report *input_report;
 622         struct hid_report *output_report;
 623         struct hid_report *feature_report;
 624
 625         data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
 626         if (!data)
 627                 return -ENOMEM;
 628
 629         INIT_WORK(&data->reset_work, rmi_reset_work);
 630         data->hdev = hdev;
 631
 632         hid_set_drvdata(hdev, data);
 633
 634         hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
 635
 636         ret = hid_parse(hdev);
 637         if (ret) {
 638                 hid_err(hdev, "parse failed\n");
 639                 return ret;
 640         }
 641
 642         if (id->driver_data)
 643                 data->device_flags = id->driver_data;
 644
 645         /*
 646          * Check for the RMI specific report ids. If they are misisng
 647          * simply return and let the events be processed by hid-input
 648          */
 649         if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT,
 650             RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) {
 651                 hid_dbg(hdev, "device does not have set mode feature report\n");
 652                 goto start;
 653         }
 654
 655         if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT,
 656             RMI_ATTN_REPORT_ID, &input_report)) {
 657                 hid_dbg(hdev, "device does not have attention input report\n");
 658                 goto start;
 659         }
 660
 661         data->input_report_size = hid_report_len(input_report);
 662
 663         if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT,
 664             RMI_WRITE_REPORT_ID, &output_report)) {
 665                 hid_dbg(hdev,
 666                         "device does not have rmi write output report\n");
 667                 goto start;
 668         }
 669
 670         data->output_report_size = hid_report_len(output_report);
 671
 672         data->device_flags |= RMI_DEVICE;
 673         alloc_size = data->output_report_size + data->input_report_size;
 674
 675         data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
 676         if (!data->writeReport) {
 677                 hid_err(hdev, "failed to allocate buffer for HID reports\n");
 678                 return -ENOMEM;
 679         }
 680
 681         data->readReport = data->writeReport + data->output_report_size;
 682
 683         init_waitqueue_head(&data->wait);
 684
 685         mutex_init(&data->page_mutex);
 686
 687         ret = rmi_setup_irq_domain(hdev);
 688         if (ret) {
 689                 hid_err(hdev, "failed to allocate IRQ domain\n");
 690                 return ret;
 691         }
 692
 693         if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)
 694                 rmi_hid_pdata.f30_data.disable = true;
 695
 696         data->xport.dev = hdev->dev.parent;
 697         data->xport.pdata = rmi_hid_pdata;
 698         data->xport.pdata.irq = data->rmi_irq;
 699         data->xport.proto_name = "hid";
 700         data->xport.ops = &hid_rmi_ops;
 701
 702 start:
 703         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 704         if (ret) {
 705                 hid_err(hdev, "hw start failed\n");
 706                 return ret;
 707         }
 708
 709         return 0;
 710 }
 711
 712 static void rmi_remove(struct hid_device *hdev)
 713 {
 714         struct rmi_data *hdata = hid_get_drvdata(hdev);
 715
 716         clear_bit(RMI_STARTED, &hdata->flags);
 717         cancel_work_sync(&hdata->reset_work);
 718         rmi_unregister_transport_device(&hdata->xport);
 719
 720         hid_hw_stop(hdev);
 721 }
 722
 723 static const struct hid_device_id rmi_id[] = {
 724         { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
 725                 .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
 726         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
 727         { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
 728         { }
 729 };
 730 MODULE_DEVICE_TABLE(hid, rmi_id);
 731
 732 static struct hid_driver rmi_driver = {
 733         .name = "hid-rmi",
 734         .id_table               = rmi_id,
 735         .probe                  = rmi_probe,
 736         .remove                 = rmi_remove,
 737         .event                  = rmi_event,
 738         .raw_event              = rmi_raw_event,
 739         .input_mapping          = rmi_input_mapping,
 740         .input_configured       = rmi_input_configured,
 741 #ifdef CONFIG_PM
 742         .suspend                = rmi_suspend,
 743         .resume                 = rmi_post_resume,
 744         .reset_resume           = rmi_post_resume,
 745 #endif
 746 };
 747
 748 module_hid_driver(rmi_driver);
 749
 750 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
 751 MODULE_DESCRIPTION("RMI HID driver");
 752 MODULE_LICENSE("GPL");