Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (c) 2013 Andrew Duggan <aduggan@synaptics.com>
0004  *  Copyright (c) 2013 Synaptics Incorporated
0005  *  Copyright (c) 2014 Benjamin Tissoires <benjamin.tissoires@gmail.com>
0006  *  Copyright (c) 2014 Red Hat, Inc
0007  */
0008 
0009 #include <linux/kernel.h>
0010 #include <linux/hid.h>
0011 #include <linux/input.h>
0012 #include <linux/input/mt.h>
0013 #include <linux/irq.h>
0014 #include <linux/irqdomain.h>
0015 #include <linux/module.h>
0016 #include <linux/pm.h>
0017 #include <linux/slab.h>
0018 #include <linux/wait.h>
0019 #include <linux/sched.h>
0020 #include <linux/rmi.h>
0021 #include "hid-ids.h"
0022 
0023 #define RMI_MOUSE_REPORT_ID     0x01 /* Mouse emulation Report */
0024 #define RMI_WRITE_REPORT_ID     0x09 /* Output Report */
0025 #define RMI_READ_ADDR_REPORT_ID     0x0a /* Output Report */
0026 #define RMI_READ_DATA_REPORT_ID     0x0b /* Input Report */
0027 #define RMI_ATTN_REPORT_ID      0x0c /* Input Report */
0028 #define RMI_SET_RMI_MODE_REPORT_ID  0x0f /* Feature Report */
0029 
0030 /* flags */
0031 #define RMI_READ_REQUEST_PENDING    0
0032 #define RMI_READ_DATA_PENDING       1
0033 #define RMI_STARTED         2
0034 
0035 /* device flags */
0036 #define RMI_DEVICE          BIT(0)
0037 #define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1)
0038 #define RMI_DEVICE_OUTPUT_SET_REPORT    BIT(2)
0039 
0040 /*
0041  * retrieve the ctrl registers
0042  * the ctrl register has a size of 20 but a fw bug split it into 16 + 4,
0043  * and there is no way to know if the first 20 bytes are here or not.
0044  * We use only the first 12 bytes, so get only them.
0045  */
0046 #define RMI_F11_CTRL_REG_COUNT      12
0047 
0048 enum rmi_mode_type {
0049     RMI_MODE_OFF            = 0,
0050     RMI_MODE_ATTN_REPORTS       = 1,
0051     RMI_MODE_NO_PACKED_ATTN_REPORTS = 2,
0052 };
0053 
0054 /**
0055  * struct rmi_data - stores information for hid communication
0056  *
0057  * @page_mutex: Locks current page to avoid changing pages in unexpected ways.
0058  * @page: Keeps track of the current virtual page
0059  * @xport: transport device to be registered with the RMI4 core.
0060  *
0061  * @wait: Used for waiting for read data
0062  *
0063  * @writeReport: output buffer when writing RMI registers
0064  * @readReport: input buffer when reading RMI registers
0065  *
0066  * @input_report_size: size of an input report (advertised by HID)
0067  * @output_report_size: size of an output report (advertised by HID)
0068  *
0069  * @flags: flags for the current device (started, reading, etc...)
0070  *
0071  * @reset_work: worker which will be called in case of a mouse report
0072  * @hdev: pointer to the struct hid_device
0073  *
0074  * @device_flags: flags which describe the device
0075  *
0076  * @domain: the IRQ domain allocated for this RMI4 device
0077  * @rmi_irq: the irq that will be used to generate events to rmi-core
0078  */
0079 struct rmi_data {
0080     struct mutex page_mutex;
0081     int page;
0082     struct rmi_transport_dev xport;
0083 
0084     wait_queue_head_t wait;
0085 
0086     u8 *writeReport;
0087     u8 *readReport;
0088 
0089     u32 input_report_size;
0090     u32 output_report_size;
0091 
0092     unsigned long flags;
0093 
0094     struct work_struct reset_work;
0095     struct hid_device *hdev;
0096 
0097     unsigned long device_flags;
0098 
0099     struct irq_domain *domain;
0100     int rmi_irq;
0101 };
0102 
0103 #define RMI_PAGE(addr) (((addr) >> 8) & 0xff)
0104 
0105 static int rmi_write_report(struct hid_device *hdev, u8 *report, int len);
0106 
0107 /**
0108  * rmi_set_page - Set RMI page
0109  * @hdev: The pointer to the hid_device struct
0110  * @page: The new page address.
0111  *
0112  * RMI devices have 16-bit addressing, but some of the physical
0113  * implementations (like SMBus) only have 8-bit addressing. So RMI implements
0114  * a page address at 0xff of every page so we can reliable page addresses
0115  * every 256 registers.
0116  *
0117  * The page_mutex lock must be held when this function is entered.
0118  *
0119  * Returns zero on success, non-zero on failure.
0120  */
0121 static int rmi_set_page(struct hid_device *hdev, u8 page)
0122 {
0123     struct rmi_data *data = hid_get_drvdata(hdev);
0124     int retval;
0125 
0126     data->writeReport[0] = RMI_WRITE_REPORT_ID;
0127     data->writeReport[1] = 1;
0128     data->writeReport[2] = 0xFF;
0129     data->writeReport[4] = page;
0130 
0131     retval = rmi_write_report(hdev, data->writeReport,
0132             data->output_report_size);
0133     if (retval != data->output_report_size) {
0134         dev_err(&hdev->dev,
0135             "%s: set page failed: %d.", __func__, retval);
0136         return retval;
0137     }
0138 
0139     data->page = page;
0140     return 0;
0141 }
0142 
0143 static int rmi_set_mode(struct hid_device *hdev, u8 mode)
0144 {
0145     int ret;
0146     const u8 txbuf[2] = {RMI_SET_RMI_MODE_REPORT_ID, mode};
0147     u8 *buf;
0148 
0149     buf = kmemdup(txbuf, sizeof(txbuf), GFP_KERNEL);
0150     if (!buf)
0151         return -ENOMEM;
0152 
0153     ret = hid_hw_raw_request(hdev, RMI_SET_RMI_MODE_REPORT_ID, buf,
0154             sizeof(txbuf), HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
0155     kfree(buf);
0156     if (ret < 0) {
0157         dev_err(&hdev->dev, "unable to set rmi mode to %d (%d)\n", mode,
0158             ret);
0159         return ret;
0160     }
0161 
0162     return 0;
0163 }
0164 
0165 static int rmi_write_report(struct hid_device *hdev, u8 *report, int len)
0166 {
0167     struct rmi_data *data = hid_get_drvdata(hdev);
0168     int ret;
0169 
0170     if (data->device_flags & RMI_DEVICE_OUTPUT_SET_REPORT) {
0171         /*
0172          * Talk to device by using SET_REPORT requests instead.
0173          */
0174         ret = hid_hw_raw_request(hdev, report[0], report,
0175                 len, HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
0176     } else {
0177         ret = hid_hw_output_report(hdev, (void *)report, len);
0178     }
0179 
0180     if (ret < 0) {
0181         dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret);
0182         return ret;
0183     }
0184 
0185     return ret;
0186 }
0187 
0188 static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr,
0189         void *buf, size_t len)
0190 {
0191     struct rmi_data *data = container_of(xport, struct rmi_data, xport);
0192     struct hid_device *hdev = data->hdev;
0193     int ret;
0194     int bytes_read;
0195     int bytes_needed;
0196     int retries;
0197     int read_input_count;
0198 
0199     mutex_lock(&data->page_mutex);
0200 
0201     if (RMI_PAGE(addr) != data->page) {
0202         ret = rmi_set_page(hdev, RMI_PAGE(addr));
0203         if (ret < 0)
0204             goto exit;
0205     }
0206 
0207     for (retries = 5; retries > 0; retries--) {
0208         data->writeReport[0] = RMI_READ_ADDR_REPORT_ID;
0209         data->writeReport[1] = 0; /* old 1 byte read count */
0210         data->writeReport[2] = addr & 0xFF;
0211         data->writeReport[3] = (addr >> 8) & 0xFF;
0212         data->writeReport[4] = len  & 0xFF;
0213         data->writeReport[5] = (len >> 8) & 0xFF;
0214 
0215         set_bit(RMI_READ_REQUEST_PENDING, &data->flags);
0216 
0217         ret = rmi_write_report(hdev, data->writeReport,
0218                         data->output_report_size);
0219         if (ret != data->output_report_size) {
0220             dev_err(&hdev->dev,
0221                 "failed to write request output report (%d)\n",
0222                 ret);
0223             goto exit;
0224         }
0225 
0226         bytes_read = 0;
0227         bytes_needed = len;
0228         while (bytes_read < len) {
0229             if (!wait_event_timeout(data->wait,
0230                 test_bit(RMI_READ_DATA_PENDING, &data->flags),
0231                     msecs_to_jiffies(1000))) {
0232                 hid_warn(hdev, "%s: timeout elapsed\n",
0233                      __func__);
0234                 ret = -EAGAIN;
0235                 break;
0236             }
0237 
0238             read_input_count = data->readReport[1];
0239             memcpy(buf + bytes_read, &data->readReport[2],
0240                 read_input_count < bytes_needed ?
0241                     read_input_count : bytes_needed);
0242 
0243             bytes_read += read_input_count;
0244             bytes_needed -= read_input_count;
0245             clear_bit(RMI_READ_DATA_PENDING, &data->flags);
0246         }
0247 
0248         if (ret >= 0) {
0249             ret = 0;
0250             break;
0251         }
0252     }
0253 
0254 exit:
0255     clear_bit(RMI_READ_REQUEST_PENDING, &data->flags);
0256     mutex_unlock(&data->page_mutex);
0257     return ret;
0258 }
0259 
0260 static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr,
0261         const void *buf, size_t len)
0262 {
0263     struct rmi_data *data = container_of(xport, struct rmi_data, xport);
0264     struct hid_device *hdev = data->hdev;
0265     int ret;
0266 
0267     mutex_lock(&data->page_mutex);
0268 
0269     if (RMI_PAGE(addr) != data->page) {
0270         ret = rmi_set_page(hdev, RMI_PAGE(addr));
0271         if (ret < 0)
0272             goto exit;
0273     }
0274 
0275     data->writeReport[0] = RMI_WRITE_REPORT_ID;
0276     data->writeReport[1] = len;
0277     data->writeReport[2] = addr & 0xFF;
0278     data->writeReport[3] = (addr >> 8) & 0xFF;
0279     memcpy(&data->writeReport[4], buf, len);
0280 
0281     ret = rmi_write_report(hdev, data->writeReport,
0282                     data->output_report_size);
0283     if (ret < 0) {
0284         dev_err(&hdev->dev,
0285             "failed to write request output report (%d)\n",
0286             ret);
0287         goto exit;
0288     }
0289     ret = 0;
0290 
0291 exit:
0292     mutex_unlock(&data->page_mutex);
0293     return ret;
0294 }
0295 
0296 static int rmi_reset_attn_mode(struct hid_device *hdev)
0297 {
0298     struct rmi_data *data = hid_get_drvdata(hdev);
0299     struct rmi_device *rmi_dev = data->xport.rmi_dev;
0300     int ret;
0301 
0302     ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
0303     if (ret)
0304         return ret;
0305 
0306     if (test_bit(RMI_STARTED, &data->flags))
0307         ret = rmi_dev->driver->reset_handler(rmi_dev);
0308 
0309     return ret;
0310 }
0311 
0312 static void rmi_reset_work(struct work_struct *work)
0313 {
0314     struct rmi_data *hdata = container_of(work, struct rmi_data,
0315                         reset_work);
0316 
0317     /* switch the device to RMI if we receive a generic mouse report */
0318     rmi_reset_attn_mode(hdata->hdev);
0319 }
0320 
0321 static int rmi_input_event(struct hid_device *hdev, u8 *data, int size)
0322 {
0323     struct rmi_data *hdata = hid_get_drvdata(hdev);
0324     struct rmi_device *rmi_dev = hdata->xport.rmi_dev;
0325     unsigned long flags;
0326 
0327     if (!(test_bit(RMI_STARTED, &hdata->flags)))
0328         return 0;
0329 
0330     local_irq_save(flags);
0331 
0332     rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2);
0333 
0334     generic_handle_irq(hdata->rmi_irq);
0335 
0336     local_irq_restore(flags);
0337 
0338     return 1;
0339 }
0340 
0341 static int rmi_read_data_event(struct hid_device *hdev, u8 *data, int size)
0342 {
0343     struct rmi_data *hdata = hid_get_drvdata(hdev);
0344 
0345     if (!test_bit(RMI_READ_REQUEST_PENDING, &hdata->flags)) {
0346         hid_dbg(hdev, "no read request pending\n");
0347         return 0;
0348     }
0349 
0350     memcpy(hdata->readReport, data, size < hdata->input_report_size ?
0351             size : hdata->input_report_size);
0352     set_bit(RMI_READ_DATA_PENDING, &hdata->flags);
0353     wake_up(&hdata->wait);
0354 
0355     return 1;
0356 }
0357 
0358 static int rmi_check_sanity(struct hid_device *hdev, u8 *data, int size)
0359 {
0360     int valid_size = size;
0361     /*
0362      * On the Dell XPS 13 9333, the bus sometimes get confused and fills
0363      * the report with a sentinel value "ff". Synaptics told us that such
0364      * behavior does not comes from the touchpad itself, so we filter out
0365      * such reports here.
0366      */
0367 
0368     while ((data[valid_size - 1] == 0xff) && valid_size > 0)
0369         valid_size--;
0370 
0371     return valid_size;
0372 }
0373 
0374 static int rmi_raw_event(struct hid_device *hdev,
0375         struct hid_report *report, u8 *data, int size)
0376 {
0377     struct rmi_data *hdata = hid_get_drvdata(hdev);
0378 
0379     if (!(hdata->device_flags & RMI_DEVICE))
0380         return 0;
0381 
0382     size = rmi_check_sanity(hdev, data, size);
0383     if (size < 2)
0384         return 0;
0385 
0386     switch (data[0]) {
0387     case RMI_READ_DATA_REPORT_ID:
0388         return rmi_read_data_event(hdev, data, size);
0389     case RMI_ATTN_REPORT_ID:
0390         return rmi_input_event(hdev, data, size);
0391     default:
0392         return 1;
0393     }
0394 
0395     return 0;
0396 }
0397 
0398 static int rmi_event(struct hid_device *hdev, struct hid_field *field,
0399             struct hid_usage *usage, __s32 value)
0400 {
0401     struct rmi_data *data = hid_get_drvdata(hdev);
0402 
0403     if ((data->device_flags & RMI_DEVICE) &&
0404         (field->application == HID_GD_POINTER ||
0405         field->application == HID_GD_MOUSE)) {
0406         if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) {
0407             if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
0408                 return 0;
0409 
0410             if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
0411                 && !value)
0412                 return 1;
0413         }
0414 
0415         schedule_work(&data->reset_work);
0416         return 1;
0417     }
0418 
0419     return 0;
0420 }
0421 
0422 static void rmi_report(struct hid_device *hid, struct hid_report *report)
0423 {
0424     struct hid_field *field = report->field[0];
0425 
0426     if (!(hid->claimed & HID_CLAIMED_INPUT))
0427         return;
0428 
0429     switch (report->id) {
0430     case RMI_READ_DATA_REPORT_ID:
0431     case RMI_ATTN_REPORT_ID:
0432         return;
0433     }
0434 
0435     if (field && field->hidinput && field->hidinput->input)
0436         input_sync(field->hidinput->input);
0437 }
0438 
0439 #ifdef CONFIG_PM
0440 static int rmi_suspend(struct hid_device *hdev, pm_message_t message)
0441 {
0442     struct rmi_data *data = hid_get_drvdata(hdev);
0443     struct rmi_device *rmi_dev = data->xport.rmi_dev;
0444     int ret;
0445 
0446     if (!(data->device_flags & RMI_DEVICE))
0447         return 0;
0448 
0449     ret = rmi_driver_suspend(rmi_dev, false);
0450     if (ret) {
0451         hid_warn(hdev, "Failed to suspend device: %d\n", ret);
0452         return ret;
0453     }
0454 
0455     return 0;
0456 }
0457 
0458 static int rmi_post_resume(struct hid_device *hdev)
0459 {
0460     struct rmi_data *data = hid_get_drvdata(hdev);
0461     struct rmi_device *rmi_dev = data->xport.rmi_dev;
0462     int ret;
0463 
0464     if (!(data->device_flags & RMI_DEVICE))
0465         return 0;
0466 
0467     /* Make sure the HID device is ready to receive events */
0468     ret = hid_hw_open(hdev);
0469     if (ret)
0470         return ret;
0471 
0472     ret = rmi_reset_attn_mode(hdev);
0473     if (ret)
0474         goto out;
0475 
0476     ret = rmi_driver_resume(rmi_dev, false);
0477     if (ret) {
0478         hid_warn(hdev, "Failed to resume device: %d\n", ret);
0479         goto out;
0480     }
0481 
0482 out:
0483     hid_hw_close(hdev);
0484     return ret;
0485 }
0486 #endif /* CONFIG_PM */
0487 
0488 static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr)
0489 {
0490     struct rmi_data *data = container_of(xport, struct rmi_data, xport);
0491     struct hid_device *hdev = data->hdev;
0492 
0493     return rmi_reset_attn_mode(hdev);
0494 }
0495 
0496 static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi)
0497 {
0498     struct rmi_data *data = hid_get_drvdata(hdev);
0499     struct input_dev *input = hi->input;
0500     int ret = 0;
0501 
0502     if (!(data->device_flags & RMI_DEVICE))
0503         return 0;
0504 
0505     data->xport.input = input;
0506 
0507     hid_dbg(hdev, "Opening low level driver\n");
0508     ret = hid_hw_open(hdev);
0509     if (ret)
0510         return ret;
0511 
0512     /* Allow incoming hid reports */
0513     hid_device_io_start(hdev);
0514 
0515     ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS);
0516     if (ret < 0) {
0517         dev_err(&hdev->dev, "failed to set rmi mode\n");
0518         goto exit;
0519     }
0520 
0521     ret = rmi_set_page(hdev, 0);
0522     if (ret < 0) {
0523         dev_err(&hdev->dev, "failed to set page select to 0.\n");
0524         goto exit;
0525     }
0526 
0527     ret = rmi_register_transport_device(&data->xport);
0528     if (ret < 0) {
0529         dev_err(&hdev->dev, "failed to register transport driver\n");
0530         goto exit;
0531     }
0532 
0533     set_bit(RMI_STARTED, &data->flags);
0534 
0535 exit:
0536     hid_device_io_stop(hdev);
0537     hid_hw_close(hdev);
0538     return ret;
0539 }
0540 
0541 static int rmi_input_mapping(struct hid_device *hdev,
0542         struct hid_input *hi, struct hid_field *field,
0543         struct hid_usage *usage, unsigned long **bit, int *max)
0544 {
0545     struct rmi_data *data = hid_get_drvdata(hdev);
0546 
0547     /*
0548      * we want to make HID ignore the advertised HID collection
0549      * for RMI deivces
0550      */
0551     if (data->device_flags & RMI_DEVICE) {
0552         if ((data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) &&
0553             ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
0554             return 0;
0555 
0556         return -1;
0557     }
0558 
0559     return 0;
0560 }
0561 
0562 static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type,
0563         unsigned id, struct hid_report **report)
0564 {
0565     int i;
0566 
0567     *report = hdev->report_enum[type].report_id_hash[id];
0568     if (*report) {
0569         for (i = 0; i < (*report)->maxfield; i++) {
0570             unsigned app = (*report)->field[i]->application;
0571             if ((app & HID_USAGE_PAGE) >= HID_UP_MSVENDOR)
0572                 return 1;
0573         }
0574     }
0575 
0576     return 0;
0577 }
0578 
0579 static struct rmi_device_platform_data rmi_hid_pdata = {
0580     .sensor_pdata = {
0581         .sensor_type = rmi_sensor_touchpad,
0582         .axis_align.flip_y = true,
0583         .dribble = RMI_REG_STATE_ON,
0584         .palm_detect = RMI_REG_STATE_OFF,
0585     },
0586 };
0587 
0588 static const struct rmi_transport_ops hid_rmi_ops = {
0589     .write_block    = rmi_hid_write_block,
0590     .read_block = rmi_hid_read_block,
0591     .reset      = rmi_hid_reset,
0592 };
0593 
0594 static void rmi_irq_teardown(void *data)
0595 {
0596     struct rmi_data *hdata = data;
0597     struct irq_domain *domain = hdata->domain;
0598 
0599     if (!domain)
0600         return;
0601 
0602     irq_dispose_mapping(irq_find_mapping(domain, 0));
0603 
0604     irq_domain_remove(domain);
0605     hdata->domain = NULL;
0606     hdata->rmi_irq = 0;
0607 }
0608 
0609 static int rmi_irq_map(struct irq_domain *h, unsigned int virq,
0610                irq_hw_number_t hw_irq_num)
0611 {
0612     irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq);
0613 
0614     return 0;
0615 }
0616 
0617 static const struct irq_domain_ops rmi_irq_ops = {
0618     .map = rmi_irq_map,
0619 };
0620 
0621 static int rmi_setup_irq_domain(struct hid_device *hdev)
0622 {
0623     struct rmi_data *hdata = hid_get_drvdata(hdev);
0624     int ret;
0625 
0626     hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1,
0627                          &rmi_irq_ops, hdata);
0628     if (!hdata->domain)
0629         return -ENOMEM;
0630 
0631     ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata);
0632     if (ret)
0633         return ret;
0634 
0635     hdata->rmi_irq = irq_create_mapping(hdata->domain, 0);
0636     if (hdata->rmi_irq <= 0) {
0637         hid_err(hdev, "Can't allocate an IRQ\n");
0638         return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO;
0639     }
0640 
0641     return 0;
0642 }
0643 
0644 static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id)
0645 {
0646     struct rmi_data *data = NULL;
0647     int ret;
0648     size_t alloc_size;
0649     struct hid_report *input_report;
0650     struct hid_report *output_report;
0651     struct hid_report *feature_report;
0652 
0653     data = devm_kzalloc(&hdev->dev, sizeof(struct rmi_data), GFP_KERNEL);
0654     if (!data)
0655         return -ENOMEM;
0656 
0657     INIT_WORK(&data->reset_work, rmi_reset_work);
0658     data->hdev = hdev;
0659 
0660     hid_set_drvdata(hdev, data);
0661 
0662     hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
0663     hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
0664 
0665     ret = hid_parse(hdev);
0666     if (ret) {
0667         hid_err(hdev, "parse failed\n");
0668         return ret;
0669     }
0670 
0671     if (id->driver_data)
0672         data->device_flags = id->driver_data;
0673 
0674     /*
0675      * Check for the RMI specific report ids. If they are misisng
0676      * simply return and let the events be processed by hid-input
0677      */
0678     if (!rmi_check_valid_report_id(hdev, HID_FEATURE_REPORT,
0679         RMI_SET_RMI_MODE_REPORT_ID, &feature_report)) {
0680         hid_dbg(hdev, "device does not have set mode feature report\n");
0681         goto start;
0682     }
0683 
0684     if (!rmi_check_valid_report_id(hdev, HID_INPUT_REPORT,
0685         RMI_ATTN_REPORT_ID, &input_report)) {
0686         hid_dbg(hdev, "device does not have attention input report\n");
0687         goto start;
0688     }
0689 
0690     data->input_report_size = hid_report_len(input_report);
0691 
0692     if (!rmi_check_valid_report_id(hdev, HID_OUTPUT_REPORT,
0693         RMI_WRITE_REPORT_ID, &output_report)) {
0694         hid_dbg(hdev,
0695             "device does not have rmi write output report\n");
0696         goto start;
0697     }
0698 
0699     data->output_report_size = hid_report_len(output_report);
0700 
0701     data->device_flags |= RMI_DEVICE;
0702     alloc_size = data->output_report_size + data->input_report_size;
0703 
0704     data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL);
0705     if (!data->writeReport) {
0706         hid_err(hdev, "failed to allocate buffer for HID reports\n");
0707         return -ENOMEM;
0708     }
0709 
0710     data->readReport = data->writeReport + data->output_report_size;
0711 
0712     init_waitqueue_head(&data->wait);
0713 
0714     mutex_init(&data->page_mutex);
0715 
0716     ret = rmi_setup_irq_domain(hdev);
0717     if (ret) {
0718         hid_err(hdev, "failed to allocate IRQ domain\n");
0719         return ret;
0720     }
0721 
0722     if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)
0723         rmi_hid_pdata.gpio_data.disable = true;
0724 
0725     data->xport.dev = hdev->dev.parent;
0726     data->xport.pdata = rmi_hid_pdata;
0727     data->xport.pdata.irq = data->rmi_irq;
0728     data->xport.proto_name = "hid";
0729     data->xport.ops = &hid_rmi_ops;
0730 
0731 start:
0732     ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
0733     if (ret) {
0734         hid_err(hdev, "hw start failed\n");
0735         return ret;
0736     }
0737 
0738     return 0;
0739 }
0740 
0741 static void rmi_remove(struct hid_device *hdev)
0742 {
0743     struct rmi_data *hdata = hid_get_drvdata(hdev);
0744 
0745     if ((hdata->device_flags & RMI_DEVICE)
0746         && test_bit(RMI_STARTED, &hdata->flags)) {
0747         clear_bit(RMI_STARTED, &hdata->flags);
0748         cancel_work_sync(&hdata->reset_work);
0749         rmi_unregister_transport_device(&hdata->xport);
0750     }
0751 
0752     hid_hw_stop(hdev);
0753 }
0754 
0755 static const struct hid_device_id rmi_id[] = {
0756     { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14),
0757         .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS },
0758     { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
0759     { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_REZEL) },
0760     { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_ACER_SWITCH5),
0761         .driver_data = RMI_DEVICE_OUTPUT_SET_REPORT },
0762     { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) },
0763     { }
0764 };
0765 MODULE_DEVICE_TABLE(hid, rmi_id);
0766 
0767 static struct hid_driver rmi_driver = {
0768     .name = "hid-rmi",
0769     .id_table       = rmi_id,
0770     .probe          = rmi_probe,
0771     .remove         = rmi_remove,
0772     .event          = rmi_event,
0773     .raw_event      = rmi_raw_event,
0774     .report         = rmi_report,
0775     .input_mapping      = rmi_input_mapping,
0776     .input_configured   = rmi_input_configured,
0777 #ifdef CONFIG_PM
0778     .suspend        = rmi_suspend,
0779     .resume         = rmi_post_resume,
0780     .reset_resume       = rmi_post_resume,
0781 #endif
0782 };
0783 
0784 module_hid_driver(rmi_driver);
0785 
0786 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com>");
0787 MODULE_DESCRIPTION("RMI HID driver");
0788 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!