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