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         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");