Lines Matching +full:i2c +full:- +full:hid
2 * HID over I2C protocol implementation
8 * This code is partly based on "USB HID support for Linux":
11 * Copyright (c) 2000-2005 Vojtech Pavlik <[email protected]>
12 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
13 * Copyright (c) 2007-2008 Oliver Neukum
14 * Copyright (c) 2006-2010 Jiri Kosina
22 #include <linux/i2c.h>
37 #include <linux/hid.h>
43 #include "../hid-ids.h"
44 #include "i2c-hid.h"
73 #define i2c_hid_dbg(ihid, ...) dev_dbg(&(ihid)->client->dev, __VA_ARGS__)
94 struct i2c_client *client; /* i2c client */
95 struct hid_device *hid; /* pointer to corresponding HID dev */ member
96 struct i2c_hid_desc hdesc; /* the HID Descriptor */
97 __le16 wHIDDescRegister; /* location of the i2c
98 * register of the HID
100 unsigned int bufsize; /* i2c buffer size */
156 * i2c_hid_lookup_quirk: return any quirks associated with a I2C HID device
157 * @idVendor: the 16-bit vendor ID
158 * @idProduct: the 16-bit product ID
181 * Some STM-based devices need 400µs after a rising clock edge to wake in i2c_hid_probe_address()
186 ret = i2c_smbus_read_byte(ihid->client); in i2c_hid_probe_address()
189 ret = i2c_smbus_read_byte(ihid->client); in i2c_hid_probe_address()
197 struct i2c_client *client = ihid->client; in i2c_hid_xfer()
206 msgs[n].addr = client->addr; in i2c_hid_xfer()
207 msgs[n].flags = (client->flags & I2C_M_TEN) | I2C_M_DMA_SAFE; in i2c_hid_xfer()
214 msgs[n].addr = client->addr; in i2c_hid_xfer()
215 msgs[n].flags = (client->flags & I2C_M_TEN) | in i2c_hid_xfer()
222 ret = i2c_transfer(client->adapter, msgs, n); in i2c_hid_xfer()
225 return ret < 0 ? ret : -EIO; in i2c_hid_xfer()
233 guard(mutex)(&ihid->cmd_lock); in i2c_hid_read_register()
235 *(__le16 *)ihid->cmdbuf = reg; in i2c_hid_read_register()
237 return i2c_hid_xfer(ihid, ihid->cmdbuf, sizeof(__le16), buf, len); in i2c_hid_read_register()
267 guard(mutex)(&ihid->cmd_lock); in i2c_hid_get_report()
270 *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; in i2c_hid_get_report()
273 length += i2c_hid_encode_command(ihid->cmdbuf + length, in i2c_hid_get_report()
281 put_unaligned_le16(le16_to_cpu(ihid->hdesc.wDataRegister), in i2c_hid_get_report()
282 ihid->cmdbuf + length); in i2c_hid_get_report()
289 error = i2c_hid_xfer(ihid, ihid->cmdbuf, length, in i2c_hid_get_report()
290 ihid->rawbuf, recv_len + sizeof(__le16)); in i2c_hid_get_report()
292 dev_err(&ihid->client->dev, in i2c_hid_get_report()
298 ret_count = le16_to_cpup((__le16 *)ihid->rawbuf); in i2c_hid_get_report()
304 recv_len = min(recv_len, ret_count - sizeof(__le16)); in i2c_hid_get_report()
305 memcpy(recv_buf, ihid->rawbuf + sizeof(__le16), recv_len); in i2c_hid_get_report()
308 dev_err(&ihid->client->dev, in i2c_hid_get_report()
311 return -EINVAL; in i2c_hid_get_report()
336 * @ihid: the i2c hid device
341 * @do_set: true: use SET_REPORT HID command, false: send plain OUTPUT report
353 if (data_len > ihid->bufsize) in i2c_hid_set_or_send_report()
354 return -EINVAL; in i2c_hid_set_or_send_report()
356 if (!do_set && le16_to_cpu(ihid->hdesc.wMaxOutputLength) == 0) in i2c_hid_set_or_send_report()
357 return -ENOSYS; in i2c_hid_set_or_send_report()
359 guard(mutex)(&ihid->cmd_lock); in i2c_hid_set_or_send_report()
363 *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; in i2c_hid_set_or_send_report()
366 length += i2c_hid_encode_command(ihid->cmdbuf + length, in i2c_hid_set_or_send_report()
374 put_unaligned_le16(le16_to_cpu(ihid->hdesc.wDataRegister), in i2c_hid_set_or_send_report()
375 ihid->cmdbuf + length); in i2c_hid_set_or_send_report()
382 *(__le16 *)ihid->cmdbuf = ihid->hdesc.wOutputRegister; in i2c_hid_set_or_send_report()
386 length += i2c_hid_format_report(ihid->cmdbuf + length, in i2c_hid_set_or_send_report()
389 error = i2c_hid_xfer(ihid, ihid->cmdbuf, length, NULL, 0); in i2c_hid_set_or_send_report()
391 dev_err(&ihid->client->dev, in i2c_hid_set_or_send_report()
403 guard(mutex)(&ihid->cmd_lock); in i2c_hid_set_power_command()
406 *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; in i2c_hid_set_power_command()
410 length += i2c_hid_encode_command(ihid->cmdbuf + length, in i2c_hid_set_power_command()
414 return i2c_hid_xfer(ihid, ihid->cmdbuf, length, NULL, 0); in i2c_hid_set_power_command()
424 * Some STM-based devices need 400µs after a rising clock edge to wake in i2c_hid_set_power()
437 dev_err(&ihid->client->dev, in i2c_hid_set_power()
441 * The HID over I2C specification states that if a DEVICE needs time in i2c_hid_set_power()
467 lockdep_assert_held(&ihid->reset_lock); in i2c_hid_start_hwreset()
473 scoped_guard(mutex, &ihid->cmd_lock) { in i2c_hid_start_hwreset()
475 *(__le16 *)ihid->cmdbuf = ihid->hdesc.wCommandRegister; in i2c_hid_start_hwreset()
478 length += i2c_hid_encode_command(ihid->cmdbuf + length, in i2c_hid_start_hwreset()
481 set_bit(I2C_HID_RESET_PENDING, &ihid->flags); in i2c_hid_start_hwreset()
483 ret = i2c_hid_xfer(ihid, ihid->cmdbuf, length, NULL, 0); in i2c_hid_start_hwreset()
485 dev_err(&ihid->client->dev, in i2c_hid_start_hwreset()
494 clear_bit(I2C_HID_RESET_PENDING, &ihid->flags); in i2c_hid_start_hwreset()
505 if (ihid->quirks & I2C_HID_QUIRK_NO_IRQ_AFTER_RESET) { in i2c_hid_finish_hwreset()
507 clear_bit(I2C_HID_RESET_PENDING, &ihid->flags); in i2c_hid_finish_hwreset()
508 } else if (!wait_event_timeout(ihid->wait, in i2c_hid_finish_hwreset()
509 !test_bit(I2C_HID_RESET_PENDING, &ihid->flags), in i2c_hid_finish_hwreset()
511 dev_warn(&ihid->client->dev, "device did not ack reset within 1000 ms\n"); in i2c_hid_finish_hwreset()
512 clear_bit(I2C_HID_RESET_PENDING, &ihid->flags); in i2c_hid_finish_hwreset()
517 if (!(ihid->quirks & I2C_HID_QUIRK_NO_WAKEUP_AFTER_RESET)) in i2c_hid_finish_hwreset()
525 u16 size = le16_to_cpu(ihid->hdesc.wMaxInputLength); in i2c_hid_get_input()
529 if (size > ihid->bufsize) in i2c_hid_get_input()
530 size = ihid->bufsize; in i2c_hid_get_input()
532 ret = i2c_master_recv(ihid->client, ihid->inbuf, size); in i2c_hid_get_input()
537 dev_err(&ihid->client->dev, "%s: got %d data instead of %d\n", in i2c_hid_get_input()
543 ret_size = le16_to_cpup((__le16 *)ihid->inbuf); in i2c_hid_get_input()
546 if (test_and_clear_bit(I2C_HID_RESET_PENDING, &ihid->flags)) in i2c_hid_get_input()
547 wake_up(&ihid->wait); in i2c_hid_get_input()
551 if ((ihid->quirks & I2C_HID_QUIRK_BOGUS_IRQ) && ret_size == 0xffff) { in i2c_hid_get_input()
552 dev_warn_once(&ihid->client->dev, in i2c_hid_get_input()
559 if (ihid->quirks & I2C_HID_QUIRK_BAD_INPUT_SIZE) { in i2c_hid_get_input()
560 *(__le16 *)ihid->inbuf = cpu_to_le16(size); in i2c_hid_get_input()
563 dev_err(&ihid->client->dev, in i2c_hid_get_input()
570 i2c_hid_dbg(ihid, "input: %*ph\n", ret_size, ihid->inbuf); in i2c_hid_get_input()
572 if (test_bit(I2C_HID_STARTED, &ihid->flags)) { in i2c_hid_get_input()
573 if (ihid->hid->group != HID_GROUP_RMI) in i2c_hid_get_input()
574 pm_wakeup_event(&ihid->client->dev, 0); in i2c_hid_get_input()
576 hid_input_report(ihid->hid, HID_INPUT_REPORT, in i2c_hid_get_input()
577 ihid->inbuf + sizeof(__le16), in i2c_hid_get_input()
578 ret_size - sizeof(__le16), 1); in i2c_hid_get_input()
595 return ((report->size - 1) >> 3) + 1 + in i2c_hid_get_report_length()
596 report->device->report_enum[report->type].numbered + 2; in i2c_hid_get_report_length()
602 static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type, in i2c_hid_find_max_report() argument
610 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { in i2c_hid_find_max_report()
619 kfree(ihid->inbuf); in i2c_hid_free_buffers()
620 kfree(ihid->rawbuf); in i2c_hid_free_buffers()
621 kfree(ihid->cmdbuf); in i2c_hid_free_buffers()
622 ihid->inbuf = NULL; in i2c_hid_free_buffers()
623 ihid->rawbuf = NULL; in i2c_hid_free_buffers()
624 ihid->cmdbuf = NULL; in i2c_hid_free_buffers()
625 ihid->bufsize = 0; in i2c_hid_free_buffers()
643 ihid->inbuf = kzalloc(report_size, GFP_KERNEL); in i2c_hid_alloc_buffers()
644 ihid->rawbuf = kzalloc(report_size, GFP_KERNEL); in i2c_hid_alloc_buffers()
645 ihid->cmdbuf = kzalloc(cmd_len, GFP_KERNEL); in i2c_hid_alloc_buffers()
647 if (!ihid->inbuf || !ihid->rawbuf || !ihid->cmdbuf) { in i2c_hid_alloc_buffers()
649 return -ENOMEM; in i2c_hid_alloc_buffers()
652 ihid->bufsize = report_size; in i2c_hid_alloc_buffers()
657 static int i2c_hid_get_raw_report(struct hid_device *hid, in i2c_hid_get_raw_report() argument
661 struct i2c_client *client = hid->driver_data; in i2c_hid_get_raw_report()
666 return -EINVAL; in i2c_hid_get_raw_report()
676 count--; in i2c_hid_get_raw_report()
689 static int i2c_hid_output_raw_report(struct hid_device *hid, u8 report_type, in i2c_hid_output_raw_report() argument
692 struct i2c_client *client = hid->driver_data; in i2c_hid_output_raw_report()
698 return -EINVAL; in i2c_hid_output_raw_report()
700 mutex_lock(&ihid->reset_lock); in i2c_hid_output_raw_report()
711 report_id, buf + 1, count - 1, do_set); in i2c_hid_output_raw_report()
716 mutex_unlock(&ihid->reset_lock); in i2c_hid_output_raw_report()
721 static int i2c_hid_output_report(struct hid_device *hid, u8 *buf, size_t count) in i2c_hid_output_report() argument
723 return i2c_hid_output_raw_report(hid, HID_OUTPUT_REPORT, buf, count, in i2c_hid_output_report()
727 static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum, in i2c_hid_raw_request() argument
733 return i2c_hid_get_raw_report(hid, rtype, reportnum, buf, len); in i2c_hid_raw_request()
736 return -EINVAL; in i2c_hid_raw_request()
737 return i2c_hid_output_raw_report(hid, rtype, buf, len, true); in i2c_hid_raw_request()
739 return -EIO; in i2c_hid_raw_request()
743 static int i2c_hid_parse(struct hid_device *hid) in i2c_hid_parse() argument
745 struct i2c_client *client = hid->driver_data; in i2c_hid_parse()
747 struct i2c_hid_desc *hdesc = &ihid->hdesc; in i2c_hid_parse()
755 rsize = le16_to_cpu(hdesc->wReportDescLength); in i2c_hid_parse()
758 return -EINVAL; in i2c_hid_parse()
761 mutex_lock(&ihid->reset_lock); in i2c_hid_parse()
768 } while (tries-- > 0 && ret); in i2c_hid_parse()
769 mutex_unlock(&ihid->reset_lock); in i2c_hid_parse()
774 use_override = i2c_hid_get_dmi_hid_report_desc_override(client->name, in i2c_hid_parse()
779 i2c_hid_dbg(ihid, "Using a HID report descriptor override\n"); in i2c_hid_parse()
783 return -ENOMEM; in i2c_hid_parse()
785 i2c_hid_dbg(ihid, "asking HID report descriptor\n"); in i2c_hid_parse()
788 ihid->hdesc.wReportDescRegister, in i2c_hid_parse()
791 hid_err(hid, "reading report descriptor failed\n"); in i2c_hid_parse()
798 ret = hid_parse_report(hid, rdesc, rsize); in i2c_hid_parse()
809 static int i2c_hid_start(struct hid_device *hid) in i2c_hid_start() argument
811 struct i2c_client *client = hid->driver_data; in i2c_hid_start()
816 i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize); in i2c_hid_start()
817 i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize); in i2c_hid_start()
818 i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize); in i2c_hid_start()
820 if (bufsize > ihid->bufsize) { in i2c_hid_start()
821 disable_irq(client->irq); in i2c_hid_start()
825 enable_irq(client->irq); in i2c_hid_start()
834 static void i2c_hid_stop(struct hid_device *hid) in i2c_hid_stop() argument
836 hid->claimed = 0; in i2c_hid_stop()
839 static int i2c_hid_open(struct hid_device *hid) in i2c_hid_open() argument
841 struct i2c_client *client = hid->driver_data; in i2c_hid_open()
844 set_bit(I2C_HID_STARTED, &ihid->flags); in i2c_hid_open()
848 static void i2c_hid_close(struct hid_device *hid) in i2c_hid_close() argument
850 struct i2c_client *client = hid->driver_data; in i2c_hid_close()
853 clear_bit(I2C_HID_STARTED, &ihid->flags); in i2c_hid_close()
872 i2c_hid_dbg(ihid, "Requesting IRQ: %d\n", client->irq); in i2c_hid_init_irq()
874 if (!irq_get_trigger_type(client->irq)) in i2c_hid_init_irq()
877 ret = request_threaded_irq(client->irq, NULL, i2c_hid_irq, in i2c_hid_init_irq()
879 client->name, ihid); in i2c_hid_init_irq()
881 dev_warn(&client->dev, in i2c_hid_init_irq()
884 client->name, client->irq, ret); in i2c_hid_init_irq()
894 struct i2c_client *client = ihid->client; in i2c_hid_fetch_hid_descriptor()
895 struct i2c_hid_desc *hdesc = &ihid->hdesc; in i2c_hid_fetch_hid_descriptor()
899 /* i2c hid fetch using a fixed descriptor size (30 bytes) */ in i2c_hid_fetch_hid_descriptor()
900 if (i2c_hid_get_dmi_i2c_hid_desc_override(client->name)) { in i2c_hid_fetch_hid_descriptor()
901 i2c_hid_dbg(ihid, "Using a HID descriptor override\n"); in i2c_hid_fetch_hid_descriptor()
902 ihid->hdesc = in i2c_hid_fetch_hid_descriptor()
903 *i2c_hid_get_dmi_i2c_hid_desc_override(client->name); in i2c_hid_fetch_hid_descriptor()
905 i2c_hid_dbg(ihid, "Fetching the HID descriptor\n"); in i2c_hid_fetch_hid_descriptor()
907 ihid->wHIDDescRegister, in i2c_hid_fetch_hid_descriptor()
908 &ihid->hdesc, in i2c_hid_fetch_hid_descriptor()
909 sizeof(ihid->hdesc)); in i2c_hid_fetch_hid_descriptor()
911 dev_err(&ihid->client->dev, in i2c_hid_fetch_hid_descriptor()
912 "failed to fetch HID descriptor: %d\n", in i2c_hid_fetch_hid_descriptor()
914 return -ENODEV; in i2c_hid_fetch_hid_descriptor()
918 /* Validate the length of HID descriptor, the 4 first bytes: in i2c_hid_fetch_hid_descriptor()
919 * bytes 0-1 -> length in i2c_hid_fetch_hid_descriptor()
920 * bytes 2-3 -> bcdVersion (has to be 1.00) */ in i2c_hid_fetch_hid_descriptor()
922 if (le16_to_cpu(hdesc->bcdVersion) != 0x0100) { in i2c_hid_fetch_hid_descriptor()
923 dev_err(&ihid->client->dev, in i2c_hid_fetch_hid_descriptor()
924 "unexpected HID descriptor bcdVersion (0x%04hx)\n", in i2c_hid_fetch_hid_descriptor()
925 le16_to_cpu(hdesc->bcdVersion)); in i2c_hid_fetch_hid_descriptor()
926 return -ENODEV; in i2c_hid_fetch_hid_descriptor()
930 dsize = le16_to_cpu(hdesc->wHIDDescLength); in i2c_hid_fetch_hid_descriptor()
932 dev_err(&ihid->client->dev, in i2c_hid_fetch_hid_descriptor()
933 "weird size of HID descriptor (%u)\n", dsize); in i2c_hid_fetch_hid_descriptor()
934 return -ENODEV; in i2c_hid_fetch_hid_descriptor()
936 i2c_hid_dbg(ihid, "HID Descriptor: %*ph\n", dsize, &ihid->hdesc); in i2c_hid_fetch_hid_descriptor()
942 if (!ihid->ops->power_up) in i2c_hid_core_power_up()
945 return ihid->ops->power_up(ihid->ops); in i2c_hid_core_power_up()
950 if (!ihid->ops->power_down) in i2c_hid_core_power_down()
953 ihid->ops->power_down(ihid->ops); in i2c_hid_core_power_down()
958 if (!ihid->ops->shutdown_tail) in i2c_hid_core_shutdown_tail()
961 ihid->ops->shutdown_tail(ihid->ops); in i2c_hid_core_shutdown_tail()
966 struct i2c_client *client = ihid->client; in i2c_hid_core_suspend()
967 struct hid_device *hid = ihid->hid; in i2c_hid_core_suspend() local
970 ret = hid_driver_suspend(hid, PMSG_SUSPEND); in i2c_hid_core_suspend()
975 if (!(ihid->quirks & I2C_HID_QUIRK_NO_SLEEP_ON_SUSPEND)) in i2c_hid_core_suspend()
978 disable_irq(client->irq); in i2c_hid_core_suspend()
980 if (force_poweroff || !device_may_wakeup(&client->dev)) in i2c_hid_core_suspend()
988 struct i2c_client *client = ihid->client; in i2c_hid_core_resume()
989 struct hid_device *hid = ihid->hid; in i2c_hid_core_resume() local
992 if (!device_may_wakeup(&client->dev)) in i2c_hid_core_resume()
995 enable_irq(client->irq); in i2c_hid_core_resume()
1001 if (ihid->quirks & I2C_HID_QUIRK_DELAY_WAKEUP_AFTER_RESUME) in i2c_hid_core_resume()
1012 if (ihid->quirks & I2C_HID_QUIRK_RESET_ON_RESUME) { in i2c_hid_core_resume()
1013 mutex_lock(&ihid->reset_lock); in i2c_hid_core_resume()
1017 mutex_unlock(&ihid->reset_lock); in i2c_hid_core_resume()
1025 return hid_driver_reset_resume(hid); in i2c_hid_core_resume()
1029 * Check that the device exists and parse the HID descriptor.
1033 struct i2c_client *client = ihid->client; in __i2c_hid_core_probe()
1034 struct hid_device *hid = ihid->hid; in __i2c_hid_core_probe() local
1040 return -ENXIO; in __i2c_hid_core_probe()
1045 dev_err(&client->dev, in __i2c_hid_core_probe()
1046 "Failed to fetch the HID Descriptor\n"); in __i2c_hid_core_probe()
1050 hid->version = le16_to_cpu(ihid->hdesc.bcdVersion); in __i2c_hid_core_probe()
1051 hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID); in __i2c_hid_core_probe()
1052 hid->product = le16_to_cpu(ihid->hdesc.wProductID); in __i2c_hid_core_probe()
1054 hid->initial_quirks |= i2c_hid_get_dmi_quirks(hid->vendor, in __i2c_hid_core_probe()
1055 hid->product); in __i2c_hid_core_probe()
1057 snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", in __i2c_hid_core_probe()
1058 client->name, (u16)hid->vendor, (u16)hid->product); in __i2c_hid_core_probe()
1059 strscpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys)); in __i2c_hid_core_probe()
1061 ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product); in __i2c_hid_core_probe()
1068 struct i2c_client *client = ihid->client; in i2c_hid_core_register_hid()
1069 struct hid_device *hid = ihid->hid; in i2c_hid_core_register_hid() local
1072 enable_irq(client->irq); in i2c_hid_core_register_hid()
1074 ret = hid_add_device(hid); in i2c_hid_core_register_hid()
1076 if (ret != -ENODEV) in i2c_hid_core_register_hid()
1077 hid_err(client, "can't add hid device: %d\n", ret); in i2c_hid_core_register_hid()
1078 disable_irq(client->irq); in i2c_hid_core_register_hid()
1083 if (ihid->quirks & I2C_HID_QUIRK_RE_POWER_ON) in i2c_hid_core_register_hid()
1117 struct hid_device *hid = ihid->hid; in ihid_core_panel_prepare_work() local
1121 * hid->version is set on the first power up. If it's still zero then in ihid_core_panel_prepare_work()
1125 if (!hid->version) in ihid_core_panel_prepare_work()
1131 dev_warn(&ihid->client->dev, "Power on failed: %d\n", ret); in ihid_core_panel_prepare_work()
1133 WRITE_ONCE(ihid->prepare_work_finished, true); in ihid_core_panel_prepare_work()
1155 WRITE_ONCE(ihid->prepare_work_finished, false); in i2c_hid_core_panel_prepared()
1156 schedule_work(&ihid->panel_follower_prepare_work); in i2c_hid_core_panel_prepared()
1165 cancel_work_sync(&ihid->panel_follower_prepare_work); in i2c_hid_core_panel_unpreparing()
1169 if (!READ_ONCE(ihid->prepare_work_finished)) in i2c_hid_core_panel_unpreparing()
1182 struct device *dev = &ihid->client->dev; in i2c_hid_core_register_panel_follower()
1185 ihid->panel_follower.funcs = &i2c_hid_core_panel_follower_funcs; in i2c_hid_core_register_panel_follower()
1197 ret = drm_panel_add_follower(dev, &ihid->panel_follower); in i2c_hid_core_register_panel_follower()
1209 struct hid_device *hid; in i2c_hid_core_probe() local
1211 dbg_hid("HID probe called for i2c 0x%02x\n", client->addr); in i2c_hid_core_probe()
1213 if (!client->irq) { in i2c_hid_core_probe()
1214 dev_err(&client->dev, in i2c_hid_core_probe()
1215 "HID over i2c has not been provided an Int IRQ\n"); in i2c_hid_core_probe()
1216 return -EINVAL; in i2c_hid_core_probe()
1219 if (client->irq < 0) { in i2c_hid_core_probe()
1220 if (client->irq != -EPROBE_DEFER) in i2c_hid_core_probe()
1221 dev_err(&client->dev, in i2c_hid_core_probe()
1222 "HID over i2c doesn't have a valid IRQ\n"); in i2c_hid_core_probe()
1223 return client->irq; in i2c_hid_core_probe()
1226 ihid = devm_kzalloc(&client->dev, sizeof(*ihid), GFP_KERNEL); in i2c_hid_core_probe()
1228 return -ENOMEM; in i2c_hid_core_probe()
1232 ihid->ops = ops; in i2c_hid_core_probe()
1233 ihid->client = client; in i2c_hid_core_probe()
1234 ihid->wHIDDescRegister = cpu_to_le16(hid_descriptor_address); in i2c_hid_core_probe()
1235 ihid->is_panel_follower = drm_is_panel_follower(&client->dev); in i2c_hid_core_probe()
1237 init_waitqueue_head(&ihid->wait); in i2c_hid_core_probe()
1238 mutex_init(&ihid->cmd_lock); in i2c_hid_core_probe()
1239 mutex_init(&ihid->reset_lock); in i2c_hid_core_probe()
1240 INIT_WORK(&ihid->panel_follower_prepare_work, ihid_core_panel_prepare_work); in i2c_hid_core_probe()
1248 device_enable_async_suspend(&client->dev); in i2c_hid_core_probe()
1250 hid = hid_allocate_device(); in i2c_hid_core_probe()
1251 if (IS_ERR(hid)) { in i2c_hid_core_probe()
1252 ret = PTR_ERR(hid); in i2c_hid_core_probe()
1256 ihid->hid = hid; in i2c_hid_core_probe()
1258 hid->driver_data = client; in i2c_hid_core_probe()
1259 hid->ll_driver = &i2c_hid_ll_driver; in i2c_hid_core_probe()
1260 hid->dev.parent = &client->dev; in i2c_hid_core_probe()
1261 hid->bus = BUS_I2C; in i2c_hid_core_probe()
1262 hid->initial_quirks = quirks; in i2c_hid_core_probe()
1265 if (!ihid->is_panel_follower) { in i2c_hid_core_probe()
1283 if (ihid->is_panel_follower) in i2c_hid_core_probe()
1293 free_irq(client->irq, ihid); in i2c_hid_core_probe()
1295 if (!ihid->is_panel_follower) in i2c_hid_core_probe()
1298 hid_destroy_device(hid); in i2c_hid_core_probe()
1309 struct hid_device *hid; in i2c_hid_core_remove() local
1315 if (ihid->is_panel_follower) in i2c_hid_core_remove()
1316 drm_panel_remove_follower(&ihid->panel_follower); in i2c_hid_core_remove()
1320 hid = ihid->hid; in i2c_hid_core_remove()
1321 hid_destroy_device(hid); in i2c_hid_core_remove()
1323 free_irq(client->irq, ihid); in i2c_hid_core_remove()
1325 if (ihid->bufsize) in i2c_hid_core_remove()
1335 free_irq(client->irq, ihid); in i2c_hid_core_shutdown()
1346 if (ihid->is_panel_follower) in i2c_hid_core_pm_suspend()
1357 if (ihid->is_panel_follower) in i2c_hid_core_pm_resume()
1368 MODULE_DESCRIPTION("HID over I2C core driver");