Searched refs:hid (Results 1 - 200 of 202) sorted by relevance

12

/linux-4.4.14/drivers/hid/
H A DMakefile4 hid-y := hid-core.o hid-input.o
5 hid-$(CONFIG_DEBUG_FS) += hid-debug.o
7 obj-$(CONFIG_HID) += hid.o
10 obj-$(CONFIG_HID_GENERIC) += hid-generic.o
12 hid-$(CONFIG_HIDRAW) += hidraw.o
14 hid-logitech-y := hid-lg.o
15 hid-logitech-$(CONFIG_LOGITECH_FF) += hid-lgff.o
16 hid-logitech-$(CONFIG_LOGIRUMBLEPAD2_FF) += hid-lg2ff.o
17 hid-logitech-$(CONFIG_LOGIG940_FF) += hid-lg3ff.o
18 hid-logitech-$(CONFIG_LOGIWHEELS_FF) += hid-lg4ff.o
20 hid-wiimote-y := hid-wiimote-core.o hid-wiimote-modules.o
21 hid-wiimote-$(CONFIG_DEBUG_FS) += hid-wiimote-debug.o
23 obj-$(CONFIG_HID_A4TECH) += hid-a4tech.o
24 obj-$(CONFIG_HID_ACRUX) += hid-axff.o
25 obj-$(CONFIG_HID_APPLE) += hid-apple.o
26 obj-$(CONFIG_HID_APPLEIR) += hid-appleir.o
27 obj-$(CONFIG_HID_AUREAL) += hid-aureal.o
28 obj-$(CONFIG_HID_BELKIN) += hid-belkin.o
29 obj-$(CONFIG_HID_BETOP_FF) += hid-betopff.o
30 obj-$(CONFIG_HID_CHERRY) += hid-cherry.o
31 obj-$(CONFIG_HID_CHICONY) += hid-chicony.o
32 obj-$(CONFIG_HID_CORSAIR) += hid-corsair.o
33 obj-$(CONFIG_HID_CP2112) += hid-cp2112.o
34 obj-$(CONFIG_HID_CYPRESS) += hid-cypress.o
35 obj-$(CONFIG_HID_DRAGONRISE) += hid-dr.o
36 obj-$(CONFIG_HID_EMS_FF) += hid-emsff.o
37 obj-$(CONFIG_HID_ELECOM) += hid-elecom.o
38 obj-$(CONFIG_HID_ELO) += hid-elo.o
39 obj-$(CONFIG_HID_EZKEY) += hid-ezkey.o
40 obj-$(CONFIG_HID_GEMBIRD) += hid-gembird.o
41 obj-$(CONFIG_HID_GFRM) += hid-gfrm.o
42 obj-$(CONFIG_HID_GT683R) += hid-gt683r.o
43 obj-$(CONFIG_HID_GYRATION) += hid-gyration.o
44 obj-$(CONFIG_HID_HOLTEK) += hid-holtek-kbd.o
45 obj-$(CONFIG_HID_HOLTEK) += hid-holtek-mouse.o
46 obj-$(CONFIG_HID_HOLTEK) += hid-holtekff.o
47 obj-$(CONFIG_HID_HYPERV_MOUSE) += hid-hyperv.o
48 obj-$(CONFIG_HID_ICADE) += hid-icade.o
49 obj-$(CONFIG_HID_KENSINGTON) += hid-kensington.o
50 obj-$(CONFIG_HID_KEYTOUCH) += hid-keytouch.o
51 obj-$(CONFIG_HID_KYE) += hid-kye.o
52 obj-$(CONFIG_HID_LCPOWER) += hid-lcpower.o
53 obj-$(CONFIG_HID_LENOVO) += hid-lenovo.o
54 obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o
55 obj-$(CONFIG_HID_LOGITECH_DJ) += hid-logitech-dj.o
56 obj-$(CONFIG_HID_LOGITECH_HIDPP) += hid-logitech-hidpp.o
57 obj-$(CONFIG_HID_MAGICMOUSE) += hid-magicmouse.o
58 obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o
59 obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o
60 obj-$(CONFIG_HID_MULTITOUCH) += hid-multitouch.o
61 obj-$(CONFIG_HID_NTRIG) += hid-ntrig.o
62 obj-$(CONFIG_HID_ORTEK) += hid-ortek.o
63 obj-$(CONFIG_HID_PRODIKEYS) += hid-prodikeys.o
64 obj-$(CONFIG_HID_PANTHERLORD) += hid-pl.o
65 obj-$(CONFIG_HID_PENMOUNT) += hid-penmount.o
66 obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o
67 obj-$(CONFIG_HID_PICOLCD) += hid-picolcd.o
68 hid-picolcd-y += hid-picolcd_core.o
69 hid-picolcd-$(CONFIG_HID_PICOLCD_FB) += hid-picolcd_fb.o
70 hid-picolcd-$(CONFIG_HID_PICOLCD_BACKLIGHT) += hid-picolcd_backlight.o
71 hid-picolcd-$(CONFIG_HID_PICOLCD_LCD) += hid-picolcd_lcd.o
72 hid-picolcd-$(CONFIG_HID_PICOLCD_LEDS) += hid-picolcd_leds.o
73 hid-picolcd-$(CONFIG_HID_PICOLCD_CIR) += hid-picolcd_cir.o
74 hid-picolcd-$(CONFIG_DEBUG_FS) += hid-picolcd_debugfs.o
76 obj-$(CONFIG_HID_PLANTRONICS) += hid-plantronics.o
77 obj-$(CONFIG_HID_PRIMAX) += hid-primax.o
78 obj-$(CONFIG_HID_ROCCAT) += hid-roccat.o hid-roccat-common.o \
79 hid-roccat-arvo.o hid-roccat-isku.o hid-roccat-kone.o \
80 hid-roccat-koneplus.o hid-roccat-konepure.o hid-roccat-kovaplus.o \
81 hid-roccat-lua.o hid-roccat-pyra.o hid-roccat-ryos.o hid-roccat-savu.o
82 obj-$(CONFIG_HID_RMI) += hid-rmi.o
83 obj-$(CONFIG_HID_SAITEK) += hid-saitek.o
84 obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o
85 obj-$(CONFIG_HID_SMARTJOYPLUS) += hid-sjoy.o
86 obj-$(CONFIG_HID_SONY) += hid-sony.o
87 obj-$(CONFIG_HID_SPEEDLINK) += hid-speedlink.o
88 obj-$(CONFIG_HID_STEELSERIES) += hid-steelseries.o
89 obj-$(CONFIG_HID_SUNPLUS) += hid-sunplus.o
90 obj-$(CONFIG_HID_GREENASIA) += hid-gaff.o
91 obj-$(CONFIG_HID_THINGM) += hid-thingm.o
92 obj-$(CONFIG_HID_THRUSTMASTER) += hid-tmff.o
93 obj-$(CONFIG_HID_TIVO) += hid-tivo.o
94 obj-$(CONFIG_HID_TOPSEED) += hid-topseed.o
95 obj-$(CONFIG_HID_TWINHAN) += hid-twinhan.o
96 obj-$(CONFIG_HID_UCLOGIC) += hid-uclogic.o
97 obj-$(CONFIG_HID_XINMO) += hid-xinmo.o
98 obj-$(CONFIG_HID_ZEROPLUS) += hid-zpff.o
99 obj-$(CONFIG_HID_ZYDACRON) += hid-zydacron.o
103 obj-$(CONFIG_HID_WALTOP) += hid-waltop.o
104 obj-$(CONFIG_HID_WIIMOTE) += hid-wiimote.o
105 obj-$(CONFIG_HID_SENSOR_HUB) += hid-sensor-hub.o
106 obj-$(CONFIG_HID_SENSOR_CUSTOM_SENSOR) += hid-sensor-custom.o
112 obj-$(CONFIG_I2C_HID) += i2c-hid/
H A Dhid-tivo.c5 * based on the hid-topseed driver, which is in turn, based on hid-cherry...
16 #include <linux/hid.h>
19 #include "hid-ids.h"
29 switch (usage->hid & HID_USAGE_PAGE) { tivo_input_mapping()
31 switch (usage->hid & HID_USAGE) { tivo_input_mapping()
45 switch (usage->hid & HID_USAGE) { tivo_input_mapping()
59 * standard hid mappings in hid-input.c */ tivo_input_mapping()
70 MODULE_DEVICE_TABLE(hid, tivo_devices);
H A Dhid-penmount.c6 * based on hid-penmount copyrighted by
18 #include <linux/hid.h>
19 #include "hid-ids.h"
25 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { penmount_input_mapping()
37 MODULE_DEVICE_TABLE(hid, penmount_devices);
40 .name = "hid-penmount",
H A Dhid-lg4ff.h5 extern int lg4ff_no_autoswitch; /* From hid-lg.c */
7 int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field,
12 static inline int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field, lg4ff_adjust_input_event() argument
H A Dhid-lg4ff.c29 #include <linux/hid.h>
32 #include "hid-lg.h"
33 #include "hid-lg4ff.h"
34 #include "hid-ids.h"
75 static void lg4ff_set_range_dfp(struct hid_device *hid, u16 range);
76 static void lg4ff_set_range_g25(struct hid_device *hid, u16 range);
92 void (*set_range)(struct hid_device *hid, u16 range);
112 void (*set_range)(struct hid_device *hid, u16 range);
307 int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field, lg4ff_adjust_input_event() argument
314 hid_err(hid, "Device properties not found"); lg4ff_adjust_input_event()
363 struct hid_device *hid = input_get_drvdata(dev); lg4ff_play() local
370 drv_data = hid_get_drvdata(hid); lg4ff_play()
372 hid_err(hid, "Private driver data not found!\n"); lg4ff_play()
378 hid_err(hid, "Device properties not found!\n"); lg4ff_play()
401 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_play()
414 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_play()
425 struct hid_device *hid = input_get_drvdata(dev); lg4ff_set_autocenter_default() local
426 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; lg4ff_set_autocenter_default()
434 drv_data = hid_get_drvdata(hid); lg4ff_set_autocenter_default()
436 hid_err(hid, "Private driver data not found!\n"); lg4ff_set_autocenter_default()
442 hid_err(hid, "Device properties not found!\n"); lg4ff_set_autocenter_default()
458 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_autocenter_default()
489 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_autocenter_default()
500 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_autocenter_default()
507 struct hid_device *hid = input_get_drvdata(dev); lg4ff_set_autocenter_ffex() local
514 drv_data = hid_get_drvdata(hid); lg4ff_set_autocenter_ffex()
516 hid_err(hid, "Private driver data not found!\n"); lg4ff_set_autocenter_ffex()
522 hid_err(hid, "Device properties not found!\n"); lg4ff_set_autocenter_ffex()
536 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_autocenter_ffex()
541 static void lg4ff_set_range_g25(struct hid_device *hid, u16 range) lg4ff_set_range_g25() argument
548 drv_data = hid_get_drvdata(hid); lg4ff_set_range_g25()
550 hid_err(hid, "Private driver data not found!\n"); lg4ff_set_range_g25()
556 hid_err(hid, "Device properties not found!\n"); lg4ff_set_range_g25()
571 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_range_g25()
576 static void lg4ff_set_range_dfp(struct hid_device *hid, u16 range) lg4ff_set_range_dfp() argument
584 drv_data = hid_get_drvdata(hid); lg4ff_set_range_dfp()
586 hid_err(hid, "Private driver data not found!\n"); lg4ff_set_range_dfp()
592 hid_err(hid, "Device properties not found!\n"); lg4ff_set_range_dfp()
615 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_range_dfp()
627 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_range_dfp()
642 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_range_dfp()
720 static int lg4ff_switch_compatibility_mode(struct hid_device *hid, const struct lg4ff_compat_mode_switch *s) lg4ff_switch_compatibility_mode() argument
728 drv_data = hid_get_drvdata(hid); lg4ff_switch_compatibility_mode()
730 hid_err(hid, "Private driver data not found!\n"); lg4ff_switch_compatibility_mode()
736 hid_err(hid, "Device properties not found!\n"); lg4ff_switch_compatibility_mode()
748 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_switch_compatibility_mode()
751 hid_hw_wait(hid); lg4ff_switch_compatibility_mode()
757 struct hid_device *hid = to_hid_device(dev); lg4ff_alternate_modes_show() local
763 drv_data = hid_get_drvdata(hid); lg4ff_alternate_modes_show()
765 hid_err(hid, "Private driver data not found!\n"); lg4ff_alternate_modes_show()
771 hid_err(hid, "Device properties not found!\n"); lg4ff_alternate_modes_show()
776 hid_err(hid, "NULL pointer to string\n"); lg4ff_alternate_modes_show()
806 struct hid_device *hid = to_hid_device(dev); lg4ff_alternate_modes_store() local
814 drv_data = hid_get_drvdata(hid); lg4ff_alternate_modes_store()
816 hid_err(hid, "Private driver data not found!\n"); lg4ff_alternate_modes_store()
822 hid_err(hid, "Device properties not found!\n"); lg4ff_alternate_modes_store()
856 hid_info(hid, "Requested mode \"%s\" is not supported by the device\n", lbuf); lg4ff_alternate_modes_store()
867 hid_info(hid, "\"%s\" cannot be switched to \"DF-EX\" mode. Load the \"hid_logitech\" module with \"lg4ff_no_autoswitch=1\" parameter set and try again\n", lg4ff_alternate_modes_store()
875 hid_info(hid, "\"%s\" cannot be switched back into \"%s\" mode\n", entry->wdata.real_name, lg4ff_alternate_modes[i].name); lg4ff_alternate_modes_store()
881 hid_err(hid, "Invalid target product ID %X\n", target_product_id); lg4ff_alternate_modes_store()
885 ret = lg4ff_switch_compatibility_mode(hid, s); lg4ff_alternate_modes_store()
894 struct hid_device *hid = to_hid_device(dev); lg4ff_range_show() local
899 drv_data = hid_get_drvdata(hid); lg4ff_range_show()
901 hid_err(hid, "Private driver data not found!\n"); lg4ff_range_show()
907 hid_err(hid, "Device properties not found!\n"); lg4ff_range_show()
920 struct hid_device *hid = to_hid_device(dev); lg4ff_range_store() local
925 drv_data = hid_get_drvdata(hid); lg4ff_range_store()
927 hid_err(hid, "Private driver data not found!\n"); lg4ff_range_store()
933 hid_err(hid, "Device properties not found!\n"); lg4ff_range_store()
943 entry->wdata.set_range(hid, range); lg4ff_range_store()
953 struct hid_device *hid = to_hid_device(dev); lg4ff_real_id_show() local
958 drv_data = hid_get_drvdata(hid); lg4ff_real_id_show()
960 hid_err(hid, "Private driver data not found!\n"); lg4ff_real_id_show()
966 hid_err(hid, "Device properties not found!\n"); lg4ff_real_id_show()
971 hid_err(hid, "NULL pointer to string\n"); lg4ff_real_id_show()
987 static void lg4ff_set_leds(struct hid_device *hid, u8 leds) lg4ff_set_leds() argument
994 drv_data = hid_get_drvdata(hid); lg4ff_set_leds()
996 hid_err(hid, "Private driver data not found!\n"); lg4ff_set_leds()
1002 hid_err(hid, "Device properties not found!\n"); lg4ff_set_leds()
1015 hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT); lg4ff_set_leds()
1023 struct hid_device *hid = container_of(dev, struct hid_device, dev); lg4ff_led_set_brightness() local
1024 struct lg_drv_data *drv_data = hid_get_drvdata(hid); lg4ff_led_set_brightness()
1029 hid_err(hid, "Device data not found."); lg4ff_led_set_brightness()
1036 hid_err(hid, "Device properties not found."); lg4ff_led_set_brightness()
1046 lg4ff_set_leds(hid, entry->wdata.led_state); lg4ff_led_set_brightness()
1049 lg4ff_set_leds(hid, entry->wdata.led_state); lg4ff_led_set_brightness()
1058 struct hid_device *hid = container_of(dev, struct hid_device, dev); lg4ff_led_get_brightness() local
1059 struct lg_drv_data *drv_data = hid_get_drvdata(hid); lg4ff_led_get_brightness()
1064 hid_err(hid, "Device data not found."); lg4ff_led_get_brightness()
1071 hid_err(hid, "Device properties not found."); lg4ff_led_get_brightness()
1085 static u16 lg4ff_identify_multimode_wheel(struct hid_device *hid, const u16 reported_product_id, const u16 bcdDevice) lg4ff_identify_multimode_wheel() argument
1120 static int lg4ff_handle_multimode_wheel(struct hid_device *hid, u16 *real_product_id, const u16 bcdDevice) lg4ff_handle_multimode_wheel() argument
1122 const u16 reported_product_id = hid->product; lg4ff_handle_multimode_wheel()
1125 *real_product_id = lg4ff_identify_multimode_wheel(hid, reported_product_id, bcdDevice); lg4ff_handle_multimode_wheel()
1141 hid_err(hid, "Invalid product id %X\n", *real_product_id); lg4ff_handle_multimode_wheel()
1145 ret = lg4ff_switch_compatibility_mode(hid, s); lg4ff_handle_multimode_wheel()
1149 hid_err(hid, "Unable to switch wheel mode, errno %d\n", ret); lg4ff_handle_multimode_wheel()
1159 int lg4ff_init(struct hid_device *hid) lg4ff_init() argument
1161 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); lg4ff_init()
1163 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; lg4ff_init()
1165 const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor); lg4ff_init()
1175 if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7)) lg4ff_init()
1178 drv_data = hid_get_drvdata(hid); lg4ff_init()
1180 hid_err(hid, "Cannot add device, private driver data not allocated\n"); lg4ff_init()
1192 mmode_ret = lg4ff_handle_multimode_wheel(hid, &real_product_id, bcdDevice); lg4ff_init()
1200 hid_err(hid, "Unable to switch device mode during initialization, errno %d\n", mmode_ret); lg4ff_init()
1207 if (hid->product == lg4ff_devices[i].product_id) { lg4ff_init()
1214 hid_err(hid, "This device is flagged to be handled by the lg4ff module but this module does not know how to handle it. " lg4ff_init()
1228 hid_err(hid, "Device product ID %X is not listed as a multimode wheel", real_product_id); lg4ff_init()
1264 error = device_create_file(&hid->dev, &dev_attr_range); lg4ff_init()
1266 hid_warn(hid, "Unable to create sysfs interface for \"range\", errno %d\n", error); lg4ff_init()
1268 error = device_create_file(&hid->dev, &dev_attr_real_id); lg4ff_init()
1270 hid_warn(hid, "Unable to create sysfs interface for \"real_id\", errno %d\n", error); lg4ff_init()
1271 error = device_create_file(&hid->dev, &dev_attr_alternate_modes); lg4ff_init()
1273 hid_warn(hid, "Unable to create sysfs interface for \"alternate_modes\", errno %d\n", error); lg4ff_init()
1280 entry->wdata.set_range(hid, entry->wdata.range); lg4ff_init()
1294 lg4ff_set_leds(hid, 0); lg4ff_init()
1296 name_sz = strlen(dev_name(&hid->dev)) + 8; lg4ff_init()
1301 hid_err(hid, "can't allocate memory for LED %d\n", j); lg4ff_init()
1306 snprintf(name, name_sz, "%s::RPM%d", dev_name(&hid->dev), j+1); lg4ff_init()
1314 error = led_classdev_register(&hid->dev, led); lg4ff_init()
1317 hid_err(hid, "failed to register LED %d. Aborting.\n", j); lg4ff_init()
1334 hid_info(hid, "Force feedback support for Logitech Gaming Wheels\n"); lg4ff_init()
1343 int lg4ff_deinit(struct hid_device *hid) lg4ff_deinit() argument
1348 drv_data = hid_get_drvdata(hid); lg4ff_deinit()
1350 hid_err(hid, "Error while deinitializing device, no private driver data.\n"); lg4ff_deinit()
1359 device_remove_file(&hid->dev, &dev_attr_real_id); lg4ff_deinit()
1360 device_remove_file(&hid->dev, &dev_attr_alternate_modes); lg4ff_deinit()
1363 device_remove_file(&hid->dev, &dev_attr_range); lg4ff_deinit()
1381 hid_hw_stop(hid); lg4ff_deinit()
H A Dhid-kensington.c16 #include <linux/hid.h>
19 #include "hid-ids.h"
27 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR) ks_input_mapping()
30 switch (usage->hid & HID_USAGE) { ks_input_mapping()
43 MODULE_DEVICE_TABLE(hid, ks_devices);
H A Dhid-emsff.c24 #include <linux/hid.h>
28 #include "hid-ids.h"
37 struct hid_device *hid = input_get_drvdata(dev); emsff_play() local
53 hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT); emsff_play()
58 static int emsff_init(struct hid_device *hid) emsff_init() argument
62 struct hid_input *hidinput = list_first_entry(&hid->inputs, emsff_init()
65 &hid->report_enum[HID_OUTPUT_REPORT].report_list; emsff_init()
70 hid_err(hid, "no output reports found\n"); emsff_init()
76 hid_err(hid, "no fields in the report\n"); emsff_init()
81 hid_err(hid, "not enough values in the field\n"); emsff_init()
105 hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT); emsff_init()
107 hid_info(hid, "force feedback for EMS based devices by Ignaz Forster <ignaz.forster@gmx.de>\n"); emsff_init()
144 MODULE_DEVICE_TABLE(hid, ems_devices);
H A Dhid-betopff.c32 #include <linux/hid.h>
34 #include "hid-ids.h"
43 struct hid_device *hid = input_get_drvdata(dev); hid_betopff_play() local
53 hid_hw_request(hid, betopff->report, HID_REQ_SET_REPORT); hid_betopff_play()
58 static int betopff_init(struct hid_device *hid) betopff_init() argument
63 list_first_entry(&hid->inputs, struct hid_input, list); betopff_init()
65 &hid->report_enum[HID_OUTPUT_REPORT].report_list; betopff_init()
72 hid_err(hid, "no output reports found\n"); betopff_init()
93 hid_err(hid, "not enough fields in the report: %d\n", betopff_init()
111 hid_hw_request(hid, betopff->report, HID_REQ_SET_REPORT); betopff_init()
113 hid_info(hid, "Force feedback for betop devices by huangbo <huangbobupt@163.com>\n"); betopff_init()
151 MODULE_DEVICE_TABLE(hid, betop_devices);
H A Dhid-sjoy.c6 * Based of hid-pl.c and hid-gaff.c
31 #include <linux/hid.h>
33 #include "hid-ids.h"
44 struct hid_device *hid = input_get_drvdata(dev); hid_sjoyff_play() local
58 hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT); hid_sjoyff_play()
63 static int sjoyff_init(struct hid_device *hid) sjoyff_init() argument
69 &hid->report_enum[HID_OUTPUT_REPORT].report_list; sjoyff_init()
75 hid_err(hid, "no output reports found\n"); sjoyff_init()
79 list_for_each_entry(hidinput, &hid->inputs, list) { sjoyff_init()
83 hid_err(hid, "required output report is missing\n"); sjoyff_init()
89 hid_err(hid, "no fields in the report\n"); sjoyff_init()
94 hid_err(hid, "not enough values in the field\n"); sjoyff_init()
116 hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT); sjoyff_init()
119 hid_info(hid, "Force feedback for SmartJoy PLUS PS2/USB adapter\n"); sjoyff_init()
124 static inline int sjoyff_init(struct hid_device *hid) sjoyff_init() argument
174 MODULE_DEVICE_TABLE(hid, sjoy_devices);
H A Dhid-elecom.c5 * (This module is based on "hid-ortek".)
18 #include <linux/hid.h>
21 #include "hid-ids.h"
37 MODULE_DEVICE_TABLE(hid, elecom_devices);
H A Dhid-zpff.c24 #include <linux/hid.h>
29 #include "hid-ids.h"
40 struct hid_device *hid = input_get_drvdata(dev); zpff_play() local
60 hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT); zpff_play()
65 static int zpff_init(struct hid_device *hid) zpff_init() argument
69 struct hid_input *hidinput = list_entry(hid->inputs.next, zpff_init()
75 report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, i, 1); zpff_init()
97 hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT); zpff_init()
99 hid_info(hid, "force feedback for Zeroplus based devices by Anssi Hannula <anssi.hannula@gmail.com>\n"); zpff_init()
104 static inline int zpff_init(struct hid_device *hid) zpff_init() argument
138 MODULE_DEVICE_TABLE(hid, zp_devices);
H A Dhid-lcpower.c5 * based on hid-topseed module
16 #include <linux/hid.h>
19 #include "hid-ids.h"
27 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) ts_input_mapping()
30 switch (usage->hid & HID_USAGE) { ts_input_mapping()
50 MODULE_DEVICE_TABLE(hid, ts_devices);
H A Dhid-xinmo.c5 * -1). It is needed because hid-input discards out of bounds values.
6 * (This module is based on "hid-saitek" and "hid-lg".)
19 #include <linux/hid.h>
23 #include "hid-ids.h"
52 MODULE_DEVICE_TABLE(hid, xinmo_devices);
H A Dhid-gaff.c32 #include <linux/hid.h>
34 #include "hid-ids.h"
45 struct hid_device *hid = input_get_drvdata(dev); hid_gaff_play() local
64 hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT); hid_gaff_play()
71 hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT); hid_gaff_play()
76 static int gaff_init(struct hid_device *hid) gaff_init() argument
80 struct hid_input *hidinput = list_entry(hid->inputs.next, gaff_init()
83 &hid->report_enum[HID_OUTPUT_REPORT].report_list; gaff_init()
89 hid_err(hid, "no output reports found\n"); gaff_init()
97 hid_err(hid, "no fields in the report\n"); gaff_init()
102 hid_err(hid, "not enough values in the field\n"); gaff_init()
123 hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT); gaff_init()
128 hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT); gaff_init()
130 hid_info(hid, "Force Feedback for GreenAsia 0x12 devices by Lukasz Lubojanski <lukasz@lubojanski.info>\n"); gaff_init()
170 MODULE_DEVICE_TABLE(hid, ga_devices);
H A Dhid-input.c32 #include <linux/hid.h>
33 #include <linux/hid-debug.h>
35 #include "hid-ids.h"
76 return (usage->hid & (HID_USAGE_PAGE | HID_USAGE)) == scancode; match_scancode()
97 static struct hid_usage *hidinput_find_key(struct hid_device *hid, hidinput_find_key() argument
107 list_for_each_entry(report, &hid->report_enum[k].report_list, list) { hidinput_find_key()
126 static struct hid_usage *hidinput_locate_usage(struct hid_device *hid, hidinput_locate_usage() argument
134 usage = hidinput_find_key(hid, match_index, ke->index, index); hidinput_locate_usage()
136 usage = hidinput_find_key(hid, match_scancode, scancode, index); hidinput_locate_usage()
146 struct hid_device *hid = input_get_drvdata(dev); hidinput_getkeycode() local
150 usage = hidinput_locate_usage(hid, ke, &index); hidinput_getkeycode()
155 scancode = usage->hid & (HID_USAGE_PAGE | HID_USAGE); hidinput_getkeycode()
168 struct hid_device *hid = input_get_drvdata(dev); hidinput_setkeycode() local
171 usage = hidinput_locate_usage(hid, ke, NULL); hidinput_setkeycode()
180 usage->code, usage->hid); hidinput_setkeycode()
186 if (hidinput_find_key(hid, match_keycode, *old_keycode, NULL)) hidinput_setkeycode()
405 if (field->usage->hid != HID_DC_BATTERYSTRENGTH) hidinput_setup_battery()
415 psy_desc->name = kasprintf(GFP_KERNEL, "hid-%s-battery", dev->uniq); hidinput_setup_battery()
507 (usage->hid & HID_USAGE_PAGE) != HID_UP_LED) { hidinput_configure_usage()
520 switch (usage->hid & HID_USAGE_PAGE) { hidinput_configure_usage()
527 if ((usage->hid & HID_USAGE) < 256) { hidinput_configure_usage()
528 if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore; hidinput_configure_usage()
529 map_key_clear(hid_keyboard[usage->hid & HID_USAGE]); hidinput_configure_usage()
536 code = ((usage->hid - 1) & HID_USAGE); hidinput_configure_usage()
567 switch (usage->hid & 0xffff) { hidinput_configure_usage()
578 if ((usage->hid & 0xf0) == 0x80) { /* SystemControl */ hidinput_configure_usage()
579 switch (usage->hid & 0xf) { hidinput_configure_usage()
600 if ((usage->hid & 0xf0) == 0x90) { /* D-pad */ hidinput_configure_usage()
601 switch (usage->hid) { hidinput_configure_usage()
616 switch (usage->hid) { hidinput_configure_usage()
621 map_rel(usage->hid & 0xf); hidinput_configure_usage()
623 map_abs_clear(usage->hid & 0xf); hidinput_configure_usage()
628 map_rel(usage->hid & 0xf); hidinput_configure_usage()
630 map_abs(usage->hid & 0xf); hidinput_configure_usage()
648 switch (usage->hid & 0xffff) { /* HID-Value: */ hidinput_configure_usage()
666 switch (usage->hid & 0xff) { hidinput_configure_usage()
727 switch (usage->hid & HID_USAGE) { hidinput_configure_usage()
750 switch (usage->hid & HID_USAGE) { hidinput_configure_usage()
929 switch (usage->hid & HID_USAGE) { hidinput_configure_usage()
948 switch (usage->hid & HID_USAGE) { hidinput_configure_usage()
966 switch (usage->hid & HID_USAGE) { hidinput_configure_usage()
1057 void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value) hidinput_hid_event() argument
1060 unsigned *quirks = &hid->quirks; hidinput_hid_event()
1080 if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */ hidinput_hid_event()
1085 if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */ hidinput_hid_event()
1095 if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */ hidinput_hid_event()
1101 if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */ hidinput_hid_event()
1106 if (usage->hid == (HID_UP_PID | 0x7fUL)) { hidinput_hid_event()
1165 input_event(input, EV_MSC, MSC_SCAN, usage->hid); hidinput_hid_event()
1176 void hidinput_report_event(struct hid_device *hid, struct hid_report *report) hidinput_report_event() argument
1180 if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC) hidinput_report_event()
1183 list_for_each_entry(hidinput, &hid->inputs, list) hidinput_report_event()
1188 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field) hidinput_find_field() argument
1193 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) { hidinput_find_field()
1205 struct hid_field *hidinput_get_led_field(struct hid_device *hid) hidinput_get_led_field() argument
1212 &hid->report_enum[HID_OUTPUT_REPORT].report_list, hidinput_get_led_field()
1225 unsigned int hidinput_count_leds(struct hid_device *hid) hidinput_count_leds() argument
1233 &hid->report_enum[HID_OUTPUT_REPORT].report_list, hidinput_count_leds()
1249 struct hid_device *hid = container_of(work, struct hid_device, hidinput_led_worker() local
1256 field = hidinput_get_led_field(hid); hidinput_led_worker()
1276 if (hid->ll_driver->request) hidinput_led_worker()
1277 return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT); hidinput_led_worker()
1287 ret = hid_hw_output_report(hid, buf, len); hidinput_led_worker()
1289 hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT, hidinput_led_worker()
1297 struct hid_device *hid = input_get_drvdata(dev); hidinput_input_event() local
1307 if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) { hidinput_input_event()
1314 schedule_work(&hid->led_work); hidinput_input_event()
1320 struct hid_device *hid = input_get_drvdata(dev); hidinput_open() local
1322 return hid_hw_open(hid); hidinput_open()
1327 struct hid_device *hid = input_get_drvdata(dev); hidinput_close() local
1329 hid_hw_close(hid); hidinput_close()
1332 static void report_features(struct hid_device *hid) report_features() argument
1334 struct hid_driver *drv = hid->driver; report_features()
1339 rep_enum = &hid->report_enum[HID_FEATURE_REPORT]; report_features()
1348 hidinput_setup_battery(hid, HID_FEATURE_REPORT, rep->field[i]); report_features()
1351 drv->feature_mapping(hid, rep->field[i], report_features()
1357 static struct hid_input *hidinput_allocate(struct hid_device *hid) hidinput_allocate() argument
1364 hid_err(hid, "Out of memory during hid input probe\n"); hidinput_allocate()
1368 input_set_drvdata(input_dev, hid); hidinput_allocate()
1375 input_dev->name = hid->name; hidinput_allocate()
1376 input_dev->phys = hid->phys; hidinput_allocate()
1377 input_dev->uniq = hid->uniq; hidinput_allocate()
1378 input_dev->id.bustype = hid->bus; hidinput_allocate()
1379 input_dev->id.vendor = hid->vendor; hidinput_allocate()
1380 input_dev->id.product = hid->product; hidinput_allocate()
1381 input_dev->id.version = hid->version; hidinput_allocate()
1382 input_dev->dev.parent = &hid->dev; hidinput_allocate()
1384 list_add_tail(&hidinput->list, &hid->inputs); hidinput_allocate()
1424 static void hidinput_cleanup_hidinput(struct hid_device *hid, hidinput_cleanup_hidinput() argument
1435 hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS) hidinput_cleanup_hidinput()
1438 list_for_each_entry(report, &hid->report_enum[k].report_list, hidinput_cleanup_hidinput()
1456 int hidinput_connect(struct hid_device *hid, unsigned int force) hidinput_connect() argument
1458 struct hid_driver *drv = hid->driver; hidinput_connect()
1463 INIT_LIST_HEAD(&hid->inputs); hidinput_connect()
1464 INIT_WORK(&hid->led_work, hidinput_led_worker); hidinput_connect()
1467 for (i = 0; i < hid->maxcollection; i++) { hidinput_connect()
1468 struct hid_collection *col = &hid->collection[i]; hidinput_connect()
1475 if (i == hid->maxcollection) hidinput_connect()
1479 report_features(hid); hidinput_connect()
1483 hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS) hidinput_connect()
1486 list_for_each_entry(report, &hid->report_enum[k].report_list, list) { hidinput_connect()
1492 hidinput = hidinput_allocate(hid); hidinput_connect()
1502 if ((hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) && hidinput_connect()
1506 if (hid->quirks & HID_QUIRK_MULTI_INPUT) { hidinput_connect()
1514 drv->input_configured(hid, hidinput)) hidinput_connect()
1523 if (hidinput && (hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) && hidinput_connect()
1526 hidinput_cleanup_hidinput(hid, hidinput); hidinput_connect()
1530 if (list_empty(&hid->inputs)) { hidinput_connect()
1531 hid_err(hid, "No inputs registered, leaving\n"); hidinput_connect()
1537 drv->input_configured(hid, hidinput)) hidinput_connect()
1551 hidinput_disconnect(hid); hidinput_connect()
1557 void hidinput_disconnect(struct hid_device *hid) hidinput_disconnect() argument
1561 hidinput_cleanup_battery(hid); hidinput_disconnect()
1563 list_for_each_entry_safe(hidinput, next, &hid->inputs, list) { hidinput_disconnect()
1573 cancel_work_sync(&hid->led_work); hidinput_disconnect()
H A Dhid-appleir.c27 #include <linux/hid.h>
29 #include "hid-ids.h"
117 struct hid_device *hid; member in struct:appleir
159 static void key_up(struct hid_device *hid, struct appleir *appleir, int key) key_up() argument
165 static void key_down(struct hid_device *hid, struct appleir *appleir, int key) key_down() argument
179 struct hid_device *hid = appleir->hid; key_up_tick() local
184 key_up(hid, appleir, appleir->current_key); key_up_tick()
190 static int appleir_raw_event(struct hid_device *hid, struct hid_report *report, appleir_raw_event() argument
193 struct appleir *appleir = hid_get_drvdata(hid); appleir_raw_event()
211 key_up(hid, appleir, appleir->current_key); appleir_raw_event()
222 key_down(hid, appleir, appleir->current_key); appleir_raw_event()
240 key_down(hid, appleir, appleir->current_key); appleir_raw_event()
259 static int appleir_input_configured(struct hid_device *hid, appleir_input_configured() argument
263 struct appleir *appleir = hid_get_drvdata(hid); appleir_input_configured()
282 static int appleir_input_mapping(struct hid_device *hid, appleir_input_mapping() argument
289 static int appleir_probe(struct hid_device *hid, const struct hid_device_id *id) appleir_probe() argument
300 appleir->hid = hid; appleir_probe()
303 hid->quirks |= HID_QUIRK_HIDINPUT_FORCE; appleir_probe()
309 hid_set_drvdata(hid, appleir); appleir_probe()
311 ret = hid_parse(hid); appleir_probe()
313 hid_err(hid, "parse failed\n"); appleir_probe()
317 ret = hid_hw_start(hid, HID_CONNECT_DEFAULT | HID_CONNECT_HIDDEV_FORCE); appleir_probe()
319 hid_err(hid, "hw start failed\n"); appleir_probe()
330 static void appleir_remove(struct hid_device *hid) appleir_remove() argument
332 struct appleir *appleir = hid_get_drvdata(hid); appleir_remove()
333 hid_hw_stop(hid); appleir_remove()
346 MODULE_DEVICE_TABLE(hid, appleir_devices);
H A Dhid-axff.c32 #include <linux/hid.h>
35 #include "hid-ids.h"
45 struct hid_device *hid = input_get_drvdata(dev); axff_play() local
69 hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT); axff_play()
74 static int axff_init(struct hid_device *hid) axff_init() argument
78 struct hid_input *hidinput = list_first_entry(&hid->inputs, struct hid_input, list); axff_init()
79 struct list_head *report_list =&hid->report_enum[HID_OUTPUT_REPORT].report_list; axff_init()
86 hid_err(hid, "no output reports found\n"); axff_init()
98 if (field_count < 4 && hid->product != 0xf705) { axff_init()
99 hid_err(hid, "not enough fields in the report: %d\n", axff_init()
115 hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT); axff_init()
117 hid_info(hid, "Force Feedback for ACRUX game controllers by Sergei Kolzun <x0r@dv-life.ru>\n"); axff_init()
126 static inline int axff_init(struct hid_device *hid) axff_init() argument
186 MODULE_DEVICE_TABLE(hid, ax_devices);
H A Duhid.c17 #include <linux/hid.h>
38 struct hid_device *hid; member in struct:uhid_device
69 hid_warn(uhid->hid, "Output queue is full\n"); uhid_queue()
92 static int uhid_hid_start(struct hid_device *hid) uhid_hid_start() argument
94 struct uhid_device *uhid = hid->driver_data; uhid_hid_start()
104 if (hid->report_enum[HID_FEATURE_REPORT].numbered) uhid_hid_start()
106 if (hid->report_enum[HID_OUTPUT_REPORT].numbered) uhid_hid_start()
108 if (hid->report_enum[HID_INPUT_REPORT].numbered) uhid_hid_start()
118 static void uhid_hid_stop(struct hid_device *hid) uhid_hid_stop() argument
120 struct uhid_device *uhid = hid->driver_data; uhid_hid_stop()
122 hid->claimed = 0; uhid_hid_stop()
126 static int uhid_hid_open(struct hid_device *hid) uhid_hid_open() argument
128 struct uhid_device *uhid = hid->driver_data; uhid_hid_open()
133 static void uhid_hid_close(struct hid_device *hid) uhid_hid_close() argument
135 struct uhid_device *uhid = hid->driver_data; uhid_hid_close()
140 static int uhid_hid_parse(struct hid_device *hid) uhid_hid_parse() argument
142 struct uhid_device *uhid = hid->driver_data; uhid_hid_parse()
144 return hid_parse_report(hid, uhid->rd_data, uhid->rd_size); uhid_hid_parse()
198 static int uhid_hid_get_report(struct hid_device *hid, unsigned char rnum, uhid_hid_get_report() argument
201 struct uhid_device *uhid = hid->driver_data; uhid_hid_get_report()
241 static int uhid_hid_set_report(struct hid_device *hid, unsigned char rnum, uhid_hid_set_report() argument
244 struct uhid_device *uhid = hid->driver_data; uhid_hid_set_report()
282 static int uhid_hid_raw_request(struct hid_device *hid, unsigned char reportnum, uhid_hid_raw_request() argument
304 return uhid_hid_get_report(hid, reportnum, buf, len, u_rtype); uhid_hid_raw_request()
306 return uhid_hid_set_report(hid, reportnum, buf, len, u_rtype); uhid_hid_raw_request()
312 static int uhid_hid_output_raw(struct hid_device *hid, __u8 *buf, size_t count, uhid_hid_output_raw() argument
315 struct uhid_device *uhid = hid->driver_data; uhid_hid_output_raw()
350 static int uhid_hid_output_report(struct hid_device *hid, __u8 *buf, uhid_hid_output_report() argument
353 return uhid_hid_output_raw(hid, buf, count, HID_OUTPUT_REPORT); uhid_hid_output_report()
457 struct hid_device *hid; uhid_dev_create2() local
476 hid = hid_allocate_device(); uhid_dev_create2()
477 if (IS_ERR(hid)) { uhid_dev_create2()
478 ret = PTR_ERR(hid); uhid_dev_create2()
482 len = min(sizeof(hid->name), sizeof(ev->u.create2.name)) - 1; uhid_dev_create2()
483 strncpy(hid->name, ev->u.create2.name, len); uhid_dev_create2()
484 len = min(sizeof(hid->phys), sizeof(ev->u.create2.phys)) - 1; uhid_dev_create2()
485 strncpy(hid->phys, ev->u.create2.phys, len); uhid_dev_create2()
486 len = min(sizeof(hid->uniq), sizeof(ev->u.create2.uniq)) - 1; uhid_dev_create2()
487 strncpy(hid->uniq, ev->u.create2.uniq, len); uhid_dev_create2()
489 hid->ll_driver = &uhid_hid_driver; uhid_dev_create2()
490 hid->bus = ev->u.create2.bus; uhid_dev_create2()
491 hid->vendor = ev->u.create2.vendor; uhid_dev_create2()
492 hid->product = ev->u.create2.product; uhid_dev_create2()
493 hid->version = ev->u.create2.version; uhid_dev_create2()
494 hid->country = ev->u.create2.country; uhid_dev_create2()
495 hid->driver_data = uhid; uhid_dev_create2()
496 hid->dev.parent = uhid_misc.this_device; uhid_dev_create2()
498 uhid->hid = hid; uhid_dev_create2()
501 ret = hid_add_device(hid); uhid_dev_create2()
503 hid_err(hid, "Cannot register HID device\n"); uhid_dev_create2()
510 hid_destroy_device(hid); uhid_dev_create2()
511 uhid->hid = NULL; uhid_dev_create2()
553 hid_destroy_device(uhid->hid); uhid_dev_destroy()
564 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input.data, uhid_dev_input()
575 hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input2.data, uhid_dev_input2()
H A Dhid-gyration.c20 #include <linux/hid.h>
23 #include "hid-ids.h"
31 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) gyration_input_mapping()
35 switch (usage->hid & HID_USAGE) { gyration_input_mapping()
64 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK && gyration_event()
65 (usage->hid & 0xff) == 0x82) { gyration_event()
83 MODULE_DEVICE_TABLE(hid, gyration_devices);
H A Dhid-petalynx.c19 #include <linux/hid.h>
22 #include "hid-ids.h"
44 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR) { pl_input_mapping()
45 switch (usage->hid & HID_USAGE) { pl_input_mapping()
57 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) { pl_input_mapping()
58 switch (usage->hid & HID_USAGE) { pl_input_mapping()
97 MODULE_DEVICE_TABLE(hid, pl_devices);
H A Dhid-lgff.c2 * Force feedback support for hid-compliant for some of the devices from
33 #include <linux/hid.h>
35 #include "hid-lg.h"
71 struct hid_device *hid = input_get_drvdata(dev); hid_lgff_play() local
72 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; hid_lgff_play()
90 hid_hw_request(hid, report, HID_REQ_SET_REPORT); hid_lgff_play()
105 hid_hw_request(hid, report, HID_REQ_SET_REPORT); hid_lgff_play()
113 struct hid_device *hid = input_get_drvdata(dev); hid_lgff_set_autocenter() local
114 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; hid_lgff_set_autocenter()
125 hid_hw_request(hid, report, HID_REQ_SET_REPORT); hid_lgff_set_autocenter()
128 int lgff_init(struct hid_device* hid) lgff_init() argument
130 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); lgff_init()
137 if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7)) lgff_init()
H A Dhid-lg2ff.c26 #include <linux/hid.h>
28 #include "hid-lg.h"
37 struct hid_device *hid = input_get_drvdata(dev); play_effect() local
57 hid_hw_request(hid, lg2ff->report, HID_REQ_SET_REPORT); play_effect()
61 int lg2ff_init(struct hid_device *hid) lg2ff_init() argument
65 struct hid_input *hidinput = list_entry(hid->inputs.next, lg2ff_init()
71 report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7); lg2ff_init()
96 hid_hw_request(hid, report, HID_REQ_SET_REPORT); lg2ff_init()
98 hid_info(hid, "Force feedback for Logitech variant 2 rumble devices by Anssi Hannula <anssi.hannula@gmail.com>\n"); lg2ff_init()
H A Dhid-belkin.c19 #include <linux/hid.h>
22 #include "hid-ids.h"
35 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER || belkin_input_mapping()
39 switch (usage->hid & HID_USAGE) { belkin_input_mapping()
81 MODULE_DEVICE_TABLE(hid, belkin_devices);
H A Dhid-cherry.c19 #include <linux/hid.h>
22 #include "hid-ids.h"
45 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) ch_input_mapping()
48 switch (usage->hid & HID_USAGE) { ch_input_mapping()
64 MODULE_DEVICE_TABLE(hid, ch_devices);
H A Dhid-ezkey.c20 #include <linux/hid.h>
23 #include "hid-ids.h"
32 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) ez_input_mapping()
35 switch (usage->hid & HID_USAGE) { ez_input_mapping()
71 MODULE_DEVICE_TABLE(hid, ez_devices);
H A Dhid-monterey.c19 #include <linux/hid.h>
22 #include "hid-ids.h"
40 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) mr_input_mapping()
43 switch (usage->hid & HID_USAGE) { mr_input_mapping()
58 MODULE_DEVICE_TABLE(hid, mr_devices);
H A Dhid-sunplus.c19 #include <linux/hid.h>
22 #include "hid-ids.h"
42 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) sp_input_mapping()
45 switch (usage->hid & HID_USAGE) { sp_input_mapping()
58 MODULE_DEVICE_TABLE(hid, sp_devices);
H A Dhid-pl.c41 #define debug(format, arg...) pr_debug("hid-plff: " format "\n" , ## arg)
46 #include <linux/hid.h>
48 #include "hid-ids.h"
62 struct hid_device *hid = input_get_drvdata(dev); hid_plff_play() local
76 hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT); hid_plff_play()
81 static int plff_init(struct hid_device *hid) plff_init() argument
87 &hid->report_enum[HID_OUTPUT_REPORT].report_list; plff_init()
105 Zeroplus (hid-zpff) devices. plff_init()
109 hid_err(hid, "no output reports found\n"); plff_init()
113 list_for_each_entry(hidinput, &hid->inputs, list) { plff_init()
118 hid_err(hid, "required output report is missing\n"); plff_init()
124 hid_err(hid, "no fields in the report\n"); plff_init()
136 report->field[0]->usage[0].hid == plff_init()
147 if (hid->vendor == USB_VENDOR_ID_JESS2) plff_init()
151 hid_err(hid, "not enough fields or values\n"); plff_init()
176 hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT); plff_init()
179 hid_info(hid, "Force feedback for PantherLord/GreenAsia devices by Anssi Hannula <anssi.hannula@gmail.com>\n"); plff_init()
184 static inline int plff_init(struct hid_device *hid) plff_init() argument
225 MODULE_DEVICE_TABLE(hid, pl_devices);
H A Dhid-tmff.c30 #include <linux/hid.h>
35 #include "hid-ids.h"
86 struct hid_device *hid = input_get_drvdata(dev); tmff_play() local
104 hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT); tmff_play()
118 hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT); tmff_play()
124 static int tmff_init(struct hid_device *hid, const signed short *ff_bits) tmff_init() argument
129 struct hid_input *hidinput = list_entry(hid->inputs.next, tmff_init()
140 report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; list_for_each_entry()
150 switch (field->usage[0].hid) { list_for_each_entry()
153 hid_warn(hid, "ignoring FF field with report_count < 2\n"); list_for_each_entry()
159 hid_warn(hid, "ignoring FF field with logical_maximum == logical_minimum\n"); list_for_each_entry()
164 hid_warn(hid, "ignoring FF field in other report\n"); list_for_each_entry()
169 hid_warn(hid, "ignoring duplicate FF field\n"); list_for_each_entry()
182 hid_warn(hid, "ignoring unknown output usage %08x\n", list_for_each_entry()
183 field->usage[0].hid); list_for_each_entry()
190 hid_err(hid, "can't find FF field in output reports\n");
199 hid_info(hid, "force feedback for ThrustMaster devices by Zinx Verituse <zinx@epicsol.org>\n");
207 static inline int tmff_init(struct hid_device *hid, const signed short *ff_bits) tmff_init() argument
255 MODULE_DEVICE_TABLE(hid, tm_devices);
H A Dhid-aureal.c15 #include <linux/hid.h>
18 #include "hid-ids.h"
34 MODULE_DEVICE_TABLE(hid, aureal_devices);
H A Dhid-generic.c25 #include <linux/hid.h>
31 MODULE_DEVICE_TABLE(hid, hid_table);
34 .name = "hid-generic",
H A Dhid-lg3ff.c25 #include <linux/hid.h>
27 #include "hid-lg.h"
63 struct hid_device *hid = input_get_drvdata(dev); hid_lg3ff_play() local
64 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; hid_lg3ff_play()
94 hid_hw_request(hid, report, HID_REQ_SET_REPORT); hid_lg3ff_play()
101 struct hid_device *hid = input_get_drvdata(dev); hid_lg3ff_set_autocenter() local
102 struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; hid_lg3ff_set_autocenter()
120 hid_hw_request(hid, report, HID_REQ_SET_REPORT); hid_lg3ff_set_autocenter()
130 int lg3ff_init(struct hid_device *hid) lg3ff_init() argument
132 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); lg3ff_init()
139 if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 35)) lg3ff_init()
153 hid_info(hid, "Force feedback for Logitech Flight System G940 by Gary Stein <LordCnidarian@gmail.com>\n"); lg3ff_init()
H A Dhid-primax.c20 #include <linux/hid.h>
23 #include "hid-ids.h"
25 static int px_raw_event(struct hid_device *hid, struct hid_report *report, px_raw_event() argument
55 hid_report_raw_event(hid, HID_INPUT_REPORT, data, size, 0); px_raw_event()
60 hid_info(hid, "unknown report type %d\n", report->id); px_raw_event()
71 MODULE_DEVICE_TABLE(hid, px_devices);
H A Dhid-topseed.c5 * based on hid-cherry driver
22 #include <linux/hid.h>
25 #include "hid-ids.h"
33 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) ts_input_mapping()
36 switch (usage->hid & HID_USAGE) { ts_input_mapping()
72 MODULE_DEVICE_TABLE(hid, ts_devices);
H A Dhid-holtekff.c26 #include <linux/hid.h>
31 #include "hid-ids.h"
92 struct hid_device *hid, holtekff_send()
103 hid_hw_request(hid, holtekff->field->report, HID_REQ_SET_REPORT); holtekff_send()
109 struct hid_device *hid = input_get_drvdata(dev); holtekff_play() local
121 holtekff_send(holtekff, hid, stop_all6); holtekff_play()
133 holtekff_send(holtekff, hid, buf); holtekff_play()
134 holtekff_send(holtekff, hid, start_effect_1); holtekff_play()
139 static int holtekff_init(struct hid_device *hid) holtekff_init() argument
143 struct hid_input *hidinput = list_entry(hid->inputs.next, holtekff_init()
146 &hid->report_enum[HID_OUTPUT_REPORT].report_list; holtekff_init()
151 hid_err(hid, "no output report found\n"); holtekff_init()
158 hid_err(hid, "unexpected output report layout\n"); holtekff_init()
171 holtekff_send(holtekff, hid, stop_all4); holtekff_init()
172 holtekff_send(holtekff, hid, stop_all6); holtekff_init()
180 hid_info(hid, "Force feedback for Holtek On Line Grip based devices by Anssi Hannula <anssi.hannula@iki.fi>\n"); holtekff_init()
185 static inline int holtekff_init(struct hid_device *hid) holtekff_init() argument
218 MODULE_DEVICE_TABLE(hid, holtek_devices);
91 holtekff_send(struct holtekff_device *holtekff, struct hid_device *hid, const u8 data[HOLTEKFF_MSG_LENGTH]) holtekff_send() argument
H A Dhidraw.c5 * hid events at all (no parsing, no lookups). This lets applications
6 * to work on raw hid events as they want to, and avoids a need to
34 #include <linux/hid.h>
124 dev = hidraw_table[minor]->hid; hidraw_send_report()
200 dev = hidraw_table[minor]->hid; hidraw_get_report()
290 err = hid_hw_power(dev->hid, PM_HINT_FULLON); hidraw_open()
296 err = hid_hw_open(dev->hid); hidraw_open()
298 hid_hw_power(dev->hid, PM_HINT_NORMAL); hidraw_open()
331 hid_hw_close(hidraw->hid); drop_ref()
345 hid_hw_power(hidraw->hid, PM_HINT_NORMAL); drop_ref()
346 hid_hw_close(hidraw->hid); drop_ref()
388 if (put_user(dev->hid->rsize, (int __user *)arg)) hidraw_ioctl()
403 dev->hid->rdesc, hidraw_ioctl()
404 min(dev->hid->rsize, len))) hidraw_ioctl()
412 dinfo.bustype = dev->hid->bus; hidraw_ioctl()
413 dinfo.vendor = dev->hid->vendor; hidraw_ioctl()
414 dinfo.product = dev->hid->product; hidraw_ioctl()
421 struct hid_device *hid = dev->hid; hidraw_ioctl() local
445 int len = strlen(hid->name) + 1; hidraw_ioctl()
448 ret = copy_to_user(user_arg, hid->name, len) ? hidraw_ioctl()
454 int len = strlen(hid->phys) + 1; hidraw_ioctl()
457 ret = copy_to_user(user_arg, hid->phys, len) ? hidraw_ioctl()
485 int hidraw_report_event(struct hid_device *hid, u8 *data, int len) hidraw_report_event() argument
487 struct hidraw *dev = hid->hidraw; hidraw_report_event()
514 int hidraw_connect(struct hid_device *hid) hidraw_connect() argument
543 dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor), hidraw_connect()
558 dev->hid = hid; hidraw_connect()
562 hid->hidraw = dev; hidraw_connect()
571 void hidraw_disconnect(struct hid_device *hid) hidraw_disconnect() argument
573 struct hidraw *hidraw = hid->hidraw; hidraw_disconnect()
H A Dhid-chicony.c21 #include <linux/hid.h>
25 #include "hid-ids.h"
33 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR) ch_input_mapping()
37 switch (usage->hid & HID_USAGE) { ch_input_mapping()
91 MODULE_DEVICE_TABLE(hid, ch_devices);
H A Dhid-roccat.c18 * not stored in device. The information in these events depends on hid device
19 * implementation and contains data that is not available in a single hid event
29 #include <linux/hid-roccat.h>
49 struct hid_device *hid; member in struct:roccat_device
176 error = hid_hw_power(device->hid, PM_HINT_FULLON); roccat_open()
182 error = hid_hw_open(device->hid); roccat_open()
184 hid_hw_power(device->hid, PM_HINT_NORMAL); roccat_open()
229 hid_hw_power(device->hid, PM_HINT_NORMAL); roccat_release()
230 hid_hw_close(device->hid); roccat_release()
291 * @hid: the hid device the char device should be connected to.
297 int roccat_connect(struct class *klass, struct hid_device *hid, int report_size) roccat_connect() argument
323 device->dev = device_create(klass, &hid->dev, roccat_connect()
325 "%s%s%d", "roccat", hid->driver->name, minor); roccat_connect()
342 device->hid = hid; roccat_connect()
351 /* roccat_disconnect() - remove char device from hid device
371 hid_hw_close(device->hid); roccat_disconnect()
H A Dhid-steelseries.c15 #include <linux/hid.h>
18 #include "hid-ids.h"
144 struct hid_device *hid = container_of(dev, struct hid_device, dev); steelseries_srws1_led_all_set_brightness() local
145 struct steelseries_srws1_data *drv_data = hid_get_drvdata(hid); steelseries_srws1_led_all_set_brightness()
148 hid_err(hid, "Device data not found."); steelseries_srws1_led_all_set_brightness()
157 steelseries_srws1_set_leds(hid, drv_data->led_state); steelseries_srws1_led_all_set_brightness()
163 struct hid_device *hid = container_of(dev, struct hid_device, dev); steelseries_srws1_led_all_get_brightness() local
166 drv_data = hid_get_drvdata(hid); steelseries_srws1_led_all_get_brightness()
169 hid_err(hid, "Device data not found."); steelseries_srws1_led_all_get_brightness()
180 struct hid_device *hid = container_of(dev, struct hid_device, dev); steelseries_srws1_led_set_brightness() local
181 struct steelseries_srws1_data *drv_data = hid_get_drvdata(hid); steelseries_srws1_led_set_brightness()
185 hid_err(hid, "Device data not found."); steelseries_srws1_led_set_brightness()
196 steelseries_srws1_set_leds(hid, drv_data->led_state); steelseries_srws1_led_set_brightness()
199 steelseries_srws1_set_leds(hid, drv_data->led_state); steelseries_srws1_led_set_brightness()
208 struct hid_device *hid = container_of(dev, struct hid_device, dev); steelseries_srws1_led_get_brightness() local
212 drv_data = hid_get_drvdata(hid); steelseries_srws1_led_get_brightness()
215 hid_err(hid, "Device data not found."); steelseries_srws1_led_get_brightness()
374 MODULE_DEVICE_TABLE(hid, steelseries_srws1_devices);
H A Dhid-core.c34 #include <linux/hid.h>
36 #include <linux/hid-debug.h>
39 #include "hid-ids.h"
270 field->usage[i].hid = parser->local.usage[j]; hid_add_field()
628 struct hid_device *hid = container_of(dev, struct hid_device, dev); hid_device_release() local
630 hid_close_report(hid); hid_device_release()
631 kfree(hid->dev_rdesc); hid_device_release()
632 kfree(hid); hid_device_release()
704 struct hid_device *hid = parser->device; hid_scan_input_usage() local
707 hid->group = HID_GROUP_MULTITOUCH; hid_scan_input_usage()
719 struct hid_device *hid = parser->device; hid_scan_collection() local
724 hid->group = HID_GROUP_SENSOR_HUB; hid_scan_collection()
726 if (hid->vendor == USB_VENDOR_ID_MICROSOFT && hid_scan_collection()
727 (hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3 || hid_scan_collection()
728 hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2 || hid_scan_collection()
729 hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP || hid_scan_collection()
730 hid->product == USB_DEVICE_ID_MS_TYPE_COVER_3 || hid_scan_collection()
731 hid->product == USB_DEVICE_ID_MS_POWER_COVER) && hid_scan_collection()
732 hid->group == HID_GROUP_MULTITOUCH) hid_scan_collection()
733 hid->group = HID_GROUP_GENERIC; hid_scan_collection()
758 /* ignore constant inputs, they will be ignored by hid-input */ hid_scan_main()
783 static int hid_scan_report(struct hid_device *hid) hid_scan_report() argument
787 __u8 *start = hid->dev_rdesc; hid_scan_report()
788 __u8 *end = start + hid->dev_rsize; hid_scan_report()
801 parser->device = hid; hid_scan_report()
802 hid->group = HID_GROUP_GENERIC; hid_scan_report()
806 * be robust against hid errors. Those errors will be raised by hid_scan_report()
816 (hid->group == HID_GROUP_MULTITOUCH)) hid_scan_report()
817 hid->group = HID_GROUP_MULTITOUCH_WIN_8; hid_scan_report()
822 switch (hid->vendor) { hid_scan_report()
824 hid->group = HID_GROUP_WACOM; hid_scan_report()
827 if (hid->group == HID_GROUP_GENERIC) hid_scan_report()
831 * hid-rmi should take care of them, hid_scan_report()
832 * not hid-generic hid_scan_report()
834 hid->group = HID_GROUP_RMI; hid_scan_report()
845 * @device: hid device
852 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size) hid_parse_report() argument
854 hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL); hid_parse_report()
855 if (!hid->dev_rdesc) hid_parse_report()
857 hid->dev_rsize = size; hid_parse_report()
870 * @device: hid device
879 struct hid_report *hid_validate_values(struct hid_device *hid, hid_validate_values() argument
887 hid_err(hid, "invalid HID report type %u\n", type); hid_validate_values()
892 hid_err(hid, "invalid HID report id %u\n", id); hid_validate_values()
907 hid->report_enum[type].report_list.next, hid_validate_values()
910 report = hid->report_enum[type].report_id_hash[id]; hid_validate_values()
913 hid_err(hid, "missing %s %u\n", hid_report_names[type], id); hid_validate_values()
917 hid_err(hid, "not enough fields in %s %u\n", hid_validate_values()
922 hid_err(hid, "not enough values in %s %u field %u\n", hid_validate_values()
933 * @device: hid device
1083 * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
1086 __u32 hid_field_extract(const struct hid_device *hid, __u8 *report, hid_field_extract() argument
1092 hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n", hid_field_extract()
1111 static void implement(const struct hid_device *hid, __u8 *report, implement() argument
1118 hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n", implement()
1122 hid_warn(hid, "%s() called with too large value %d! (%s)\n", implement()
1152 * @hid: hid device
1155 * compare hid->driver->report_table->report_type to report->type
1157 static int hid_match_report(struct hid_device *hid, struct hid_report *report) hid_match_report() argument
1159 const struct hid_report_id *id = hid->driver->report_table; hid_match_report()
1174 * @hid: hid device
1177 * compare hid->driver->usage_table->usage_{type,code} to
1180 static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage) hid_match_usage() argument
1182 const struct hid_usage_id *id = hid->driver->usage_table; hid_match_usage()
1189 id->usage_hid == usage->hid) && hid_match_usage()
1198 static void hid_process_event(struct hid_device *hid, struct hid_field *field, hid_process_event() argument
1201 struct hid_driver *hdrv = hid->driver; hid_process_event()
1204 if (!list_empty(&hid->debug_list)) hid_process_event()
1205 hid_dump_input(hid, usage, value); hid_process_event()
1207 if (hdrv && hdrv->event && hid_match_usage(hid, usage)) { hid_process_event()
1208 ret = hdrv->event(hid, field, usage, value); hid_process_event()
1211 hid_err(hid, "%s's event failed with %d\n", hid_process_event()
1217 if (hid->claimed & HID_CLAIMED_INPUT) hid_process_event()
1218 hidinput_hid_event(hid, field, usage, value); hid_process_event()
1219 if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event) hid_process_event()
1220 hid->hiddev_hid_event(hid, field, usage, value); hid_process_event()
1229 static void hid_input_field(struct hid_device *hid, struct hid_field *field, hid_input_field() argument
1247 snto32(hid_field_extract(hid, data, offset + n * size, hid_input_field()
1249 hid_field_extract(hid, data, offset + n * size, size); hid_input_field()
1254 field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1) hid_input_field()
1261 hid_process_event(hid, field, &field->usage[n], value[n], interrupt); hid_input_field()
1266 && field->usage[field->value[n] - min].hid hid_input_field()
1268 hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt); hid_input_field()
1271 && field->usage[value[n] - min].hid hid_input_field()
1273 hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt); hid_input_field()
1285 static void hid_output_field(const struct hid_device *hid, hid_output_field() argument
1295 implement(hid, data, offset + n * size, size, hid_output_field()
1298 implement(hid, data, offset + n * size, size, hid_output_field()
1389 * DO NOT USE in hid drivers directly, but through hid_hw_request instead.
1391 void __hid_request(struct hid_device *hid, struct hid_report *report, __hid_request() argument
1407 ret = hid->ll_driver->raw_request(hid, report->id, buf, len, __hid_request()
1415 hid_input_report(hid, report->type, buf, ret, 0); __hid_request()
1422 int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size, hid_report_raw_event() argument
1425 struct hid_report_enum *report_enum = hid->report_enum + type; hid_report_raw_event()
1453 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event) hid_report_raw_event()
1454 hid->hiddev_report_event(hid, report); hid_report_raw_event()
1455 if (hid->claimed & HID_CLAIMED_HIDRAW) { hid_report_raw_event()
1456 ret = hidraw_report_event(hid, data, size); hid_report_raw_event()
1461 if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) { hid_report_raw_event()
1463 hid_input_field(hid, report->field[a], cdata, interrupt); hid_report_raw_event()
1464 hdrv = hid->driver; hid_report_raw_event()
1466 hdrv->report(hid, report); hid_report_raw_event()
1469 if (hid->claimed & HID_CLAIMED_INPUT) hid_report_raw_event()
1470 hidinput_report_event(hid, report); hid_report_raw_event()
1479 * @hid: hid device
1487 int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt) hid_input_report() argument
1494 if (!hid) hid_input_report()
1497 if (down_trylock(&hid->driver_input_lock)) hid_input_report()
1500 if (!hid->driver) { hid_input_report()
1504 report_enum = hid->report_enum + type; hid_input_report()
1505 hdrv = hid->driver; hid_input_report()
1514 if (!list_empty(&hid->debug_list)) hid_input_report()
1515 hid_dump_report(hid, type, data, size); hid_input_report()
1524 if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) { hid_input_report()
1525 ret = hdrv->raw_event(hid, report, data, size); hid_input_report()
1530 ret = hid_report_raw_event(hid, type, data, size, interrupt); hid_input_report()
1533 up(&hid->driver_input_lock); hid_input_report()
1724 * Please note that for multitouch devices (driven by hid-multitouch driver),
1730 * physical is found inside a usage page of type sensor, hid-sensor-hub will be
2074 * Adds a new dynamic hid device ID to this driver,
2229 len = snprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n", modalias_show()
2259 if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X", hid_uevent()
2267 .name = "hid",
2445 * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
2531 * the Logitech AudioHub Speaker, but it should ignore the hid. hid_ignore()
2567 * ignore the hid. Check the name, bus, product and ignore hid_ignore()
2645 * hid_allocate_device - allocate new hid device descriptor
2647 * Allocate and initialize hid device, so that hid_destroy_device might be
2693 * @hdev: hid device
2738 int hid_check_keys_pressed(struct hid_device *hid) hid_check_keys_pressed() argument
2743 if (!(hid->claimed & HID_CLAIMED_INPUT)) hid_check_keys_pressed()
2746 list_for_each_entry(hidinput, &hid->inputs, list) { hid_check_keys_pressed()
2767 pr_err("can't register hid bus\n"); hid_init()
H A Dhid-a4tech.c20 #include <linux/hid.h>
24 #include "hid-ids.h"
44 if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007) a4_input_mapped()
68 if (usage->hid == 0x000100b8) { a4_event()
75 if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007) { a4_event()
127 MODULE_DEVICE_TABLE(hid, a4_devices);
H A Dhid-gfrm.c14 #include <linux/hid.h>
18 #include "hid-ids.h"
38 if (usage->hid == (HID_UP_CONSUMER | 0x4)) { gfrm_input_mapping()
44 if (usage->hid == (HID_UP_CONSUMER | 0x41)) { gfrm_input_mapping()
91 static int gfrm_input_configured(struct hid_device *hid, struct hid_input *hidinput) gfrm_input_configured() argument
143 MODULE_DEVICE_TABLE(hid, gfrm_devices);
H A Dhid-twinhan.c4 * Based on hid-gyration.c
17 #include <linux/hid.h>
20 #include "hid-ids.h"
67 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_KEYBOARD) twinhan_input_mapping()
70 switch (usage->hid & HID_USAGE) { twinhan_input_mapping()
127 MODULE_DEVICE_TABLE(hid, twinhan_devices);
H A Dhid-microsoft.c20 #include <linux/hid.h>
23 #include "hid-ids.h"
65 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) { ms_ergonomy_kb_quirk()
66 switch (usage->hid & HID_USAGE) { ms_ergonomy_kb_quirk()
81 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR) ms_ergonomy_kb_quirk()
84 switch (usage->hid & HID_USAGE) { ms_ergonomy_kb_quirk()
100 * standard hid keyboard report, as send by interface 0 ms_ergonomy_kb_quirk()
125 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR) ms_presenter_8k_quirk()
129 switch (usage->hid & HID_USAGE) { ms_presenter_8k_quirk()
185 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff00)) { ms_event()
193 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff01)) { ms_event()
208 if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) { ms_event()
294 MODULE_DEVICE_TABLE(hid, ms_devices);
H A Dhid-speedlink.c17 #include <linux/hid.h>
20 #include "hid-ids.h"
38 switch (usage->hid & HID_USAGE_PAGE) { speedlink_input_mapping()
64 MODULE_DEVICE_TABLE(hid, speedlink_devices);
H A Dhid-keytouch.c15 #include <linux/hid.h>
18 #include "hid-ids.h"
45 MODULE_DEVICE_TABLE(hid, keytouch_devices);
H A Dhid-ortek.c22 #include <linux/hid.h>
25 #include "hid-ids.h"
46 MODULE_DEVICE_TABLE(hid, ortek_devices);
H A Dhid-multitouch.c9 * This code is partly based on hid-egalax.c:
15 * This code is partly based on hid-3m-pct.c:
31 * This driver is regularly tested thanks to the tool hid-test[1].
32 * This tool relies on hid-replay[2] and a database of hid devices[3].
36 * [1] https://github.com/bentiss/hid-test
37 * [2] https://github.com/bentiss/hid-replay
38 * [3] https://github.com/bentiss/hid-devices
42 #include <linux/hid.h>
54 #include "hid-ids.h"
352 switch (usage->hid) { mt_feature_mapping()
425 f->usages[f->length++] = usage->hid; mt_store_field()
444 (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) { mt_touch_input_mapping()
450 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) mt_touch_input_mapping()
456 switch (usage->hid & HID_USAGE_PAGE) { mt_touch_input_mapping()
459 switch (usage->hid) { mt_touch_input_mapping()
461 if (prev_usage && (prev_usage->hid == usage->hid)) { mt_touch_input_mapping()
476 if (prev_usage && (prev_usage->hid == usage->hid)) { mt_touch_input_mapping()
494 switch (usage->hid) { mt_touch_input_mapping()
560 /* let hid-input decide for the others */ mt_touch_input_mapping()
564 code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE); mt_touch_input_mapping()
668 static int mt_touch_event(struct hid_device *hid, struct hid_field *field, mt_touch_event() argument
672 if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event) mt_touch_event()
673 hid->hiddev_hid_event(hid, field, usage, value); mt_touch_event()
678 static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field, mt_process_mt_event() argument
681 struct mt_device *td = hid_get_drvdata(hid); mt_process_mt_event()
685 if (hid->claimed & HID_CLAIMED_INPUT) { mt_process_mt_event()
686 switch (usage->hid) { mt_process_mt_event()
741 if (usage->hid == td->last_slot_field) mt_process_mt_event()
748 static void mt_touch_report(struct hid_device *hid, struct hid_report *report) mt_touch_report() argument
750 struct mt_device *td = hid_get_drvdata(hid); mt_touch_report()
774 mt_process_mt_event(hid, field, &field->usage[n], mt_touch_report()
854 /* let hid-core decide for the others */ mt_input_mapping()
873 /* let hid-core decide for the others */ mt_input_mapped()
877 static int mt_event(struct hid_device *hid, struct hid_field *field, mt_event() argument
880 struct mt_device *td = hid_get_drvdata(hid); mt_event()
883 return mt_touch_event(hid, field, usage, value); mt_event()
888 static void mt_report(struct hid_device *hid, struct hid_report *report) mt_report() argument
890 struct mt_device *td = hid_get_drvdata(hid); mt_report()
893 if (!(hid->claimed & HID_CLAIMED_INPUT)) mt_report()
897 return mt_touch_report(hid, report); mt_report()
1470 MODULE_DEVICE_TABLE(hid, mt_devices);
1478 .name = "hid-multitouch",
H A Dhid-dr.c32 #include <linux/hid.h>
35 #include "hid-ids.h"
46 struct hid_device *hid = input_get_drvdata(dev); drff_play() local
69 hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT); drff_play()
81 hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT); drff_play()
86 static int drff_init(struct hid_device *hid) drff_init() argument
90 struct hid_input *hidinput = list_first_entry(&hid->inputs, drff_init()
93 &hid->report_enum[HID_OUTPUT_REPORT].report_list; drff_init()
98 hid_err(hid, "no output reports found\n"); drff_init()
104 hid_err(hid, "no fields in the report\n"); drff_init()
109 hid_err(hid, "not enough values in the field\n"); drff_init()
133 hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT); drff_init()
135 hid_info(hid, "Force Feedback for DragonRise Inc. " drff_init()
141 static inline int drff_init(struct hid_device *hid) drff_init() argument
348 MODULE_DEVICE_TABLE(hid, dr_devices);
H A Dhid-cypress.c19 #include <linux/hid.h>
23 #include "hid-ids.h"
62 if (usage->hid == 0x00090005) cp_input_mapped()
77 if (usage->hid == 0x00090005) { cp_event()
133 MODULE_DEVICE_TABLE(hid, cp_devices);
H A Dhid-icade.c16 #include <linux/hid.h>
19 #include "hid-ids.h"
51 * < copy of hid_keyboard[] from hid-input.c >
180 trans = icade_find_translation(usage->hid & HID_USAGE); icade_event()
197 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) { icade_input_mapping()
198 trans = icade_find_translation(usage->hid & HID_USAGE); icade_input_mapping()
229 MODULE_DEVICE_TABLE(hid, icade_devices);
H A Dhid-plantronics.c15 #include "hid-ids.h"
17 #include <linux/hid.h>
40 (usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
74 switch (usage->hid) { plantronics_input_mapping()
97 usage->hid, field->application); plantronics_input_mapping()
103 usage->hid, field->application, mapped_key); plantronics_input_mapping()
158 MODULE_DEVICE_TABLE(hid, plantronics_devices);
H A Dhid-samsung.c15 * various hid report fixups for different variants.
32 #include <linux/hid.h>
35 #include "hid-ids.h"
107 if (1 != ifnum || HID_UP_CONSUMER != (usage->hid & HID_USAGE_PAGE)) samsung_kbd_mouse_input_mapping()
111 usage->hid & HID_USAGE); samsung_kbd_mouse_input_mapping()
113 switch (usage->hid & HID_USAGE) { samsung_kbd_mouse_input_mapping()
190 MODULE_DEVICE_TABLE(hid, samsung_devices);
H A Dhid-roccat-lua.c21 #include <linux/hid.h>
24 #include <linux/hid-roccat.h>
25 #include "hid-ids.h"
26 #include "hid-roccat-common.h"
27 #include "hid-roccat-lua.h"
203 MODULE_DEVICE_TABLE(hid, lua_devices);
H A Dhid-roccat-savu.c20 #include <linux/hid.h>
23 #include <linux/hid-roccat.h>
24 #include "hid-ids.h"
25 #include "hid-roccat-common.h"
26 #include "hid-roccat-savu.h"
193 MODULE_DEVICE_TABLE(hid, savu_devices);
H A Dhid-zydacron.c15 #include <linux/hid.h>
18 #include "hid-ids.h"
56 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) zc_input_mapping()
60 usage->hid & HID_USAGE); zc_input_mapping()
62 switch (usage->hid & HID_USAGE) { zc_input_mapping()
199 MODULE_DEVICE_TABLE(hid, zc_devices);
H A Dhid-holtek-mouse.c15 #include <linux/hid.h>
19 #include "hid-ids.h"
83 MODULE_DEVICE_TABLE(hid, holtek_mouse_devices);
H A Dhid-hyperv.c20 #include <linux/hid.h>
295 * hid desc and report desc mousevsc_on_receive()
316 pr_err("unsupported hid msg type - type %d len %d", mousevsc_on_receive()
430 * We should have gotten the device attr, hid desc and report mousevsc_connect_to_vsp()
439 static int mousevsc_hid_parse(struct hid_device *hid) mousevsc_hid_parse() argument
441 struct hv_device *dev = hid_get_drvdata(hid); mousevsc_hid_parse()
444 return hid_parse_report(hid, input_dev->report_desc, mousevsc_hid_parse()
448 static int mousevsc_hid_open(struct hid_device *hid) mousevsc_hid_open() argument
453 static int mousevsc_hid_start(struct hid_device *hid) mousevsc_hid_start() argument
458 static void mousevsc_hid_close(struct hid_device *hid) mousevsc_hid_close() argument
462 static void mousevsc_hid_stop(struct hid_device *hid) mousevsc_hid_stop() argument
466 static int mousevsc_hid_raw_request(struct hid_device *hid, mousevsc_hid_raw_request() argument
H A Dhid-holtek-kbd.c14 #include <linux/hid.h>
18 #include "hid-ids.h"
124 struct hid_device *hid = input_get_drvdata(dev); holtek_kbd_input_event() local
125 struct usb_device *usb_dev = hid_to_usb_dev(hid); holtek_kbd_input_event()
162 MODULE_DEVICE_TABLE(hid, holtek_kbd_devices);
H A Dhid-roccat-konepure.c21 #include <linux/hid.h>
24 #include <linux/hid-roccat.h>
25 #include "hid-ids.h"
26 #include "hid-roccat-common.h"
196 MODULE_DEVICE_TABLE(hid, konepure_devices);
H A Dhid-roccat-ryos.c17 #include <linux/hid.h>
20 #include <linux/hid-roccat.h>
21 #include "hid-ids.h"
22 #include "hid-roccat-common.h"
205 MODULE_DEVICE_TABLE(hid, ryos_devices);
H A Dhid-apple.c21 #include <linux/hid.h>
25 #include "hid-ids.h"
180 static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input, hidinput_apple_event() argument
183 struct apple_sc *asc = hid_get_drvdata(hid); hidinput_apple_event()
195 if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI && hidinput_apple_event()
196 hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) hidinput_apple_event()
198 else if (hid->product < 0x21d || hid->product >= 0x300) hidinput_apple_event()
336 if (usage->hid == (HID_UP_CUSTOM | 0x0003)) { apple_input_mapping()
344 /* we want the hid layer to go through standard path (set and ignore) */ apple_input_mapping()
355 if (usage->hid == HID_GD_Z) apple_input_mapped()
569 MODULE_DEVICE_TABLE(hid, apple_devices);
H A Dhid-gembird.c16 #include <linux/hid.h>
19 #include "hid-ids.h"
105 MODULE_DEVICE_TABLE(hid, gembird_devices);
H A Dhid-logitech-dj.c26 #include <linux/hid.h>
31 #include "hid-ids.h"
305 /* Maximum size of all defined hid reports in bytes (including report id) */
317 /* Number of possible hid report types that can be created by this driver.
320 * than the hid report created from those RF reports. In the future
324 * to hid report id 0x01, this is standard keyboard. Same thing applies to mice
326 * has to have the same report id as its corresponding hid report, so an
498 * hid-core discards all packets coming from a device while probe() is delayedwork_callback()
683 static int logi_dj_ll_open(struct hid_device *hid) logi_dj_ll_open() argument
685 dbg_hid("%s:%s\n", __func__, hid->phys); logi_dj_ll_open()
690 static void logi_dj_ll_close(struct hid_device *hid) logi_dj_ll_close() argument
692 dbg_hid("%s:%s\n", __func__, hid->phys); logi_dj_ll_close()
698 static int logi_dj_ll_raw_request(struct hid_device *hid, logi_dj_ll_raw_request() argument
703 struct dj_device *djdev = hid->driver_data; logi_dj_ll_raw_request()
751 static int logi_dj_ll_parse(struct hid_device *hid) logi_dj_ll_parse() argument
753 struct dj_device *djdev = hid->driver_data; logi_dj_ll_parse()
804 retval = hid_parse_report(hid, rdesc, rsize); logi_dj_ll_parse()
810 static int logi_dj_ll_start(struct hid_device *hid) logi_dj_ll_start() argument
816 static void logi_dj_ll_stop(struct hid_device *hid) logi_dj_ll_stop() argument
844 * processing by the work queue. We return 1 to hid-core as no further logi_dj_dj_event()
850 * layer. Return 1 to hid-core as no further processing is required. logi_dj_dj_event()
853 * case we forward it to the correct hid device (via hid_input_report() logi_dj_dj_event()
854 * ) and return 1 so hid-core does not anything else with it. logi_dj_dj_event()
924 * data to the corresponding child dj device and return 0 to hid-core logi_dj_hidpp_event()
1030 * subsequently call to the hid/hid-core to parse the fetched logi_dj_probe()
1156 MODULE_DEVICE_TABLE(hid, logi_dj_receivers);
H A Dhid-picolcd_cir.c20 #include <linux/hid.h>
21 #include <linux/hid-debug.h>
23 #include "hid-ids.h"
40 #include "hid-picolcd.h"
H A Dhid-picolcd_leds.c20 #include <linux/hid.h>
21 #include <linux/hid-debug.h>
23 #include "hid-ids.h"
39 #include "hid-picolcd.h"
H A Dhid-saitek.c7 * (This module is based on "hid-ortek".)
25 #include <linux/hid.h>
29 #include "hid-ids.h"
193 MODULE_DEVICE_TABLE(hid, saitek_devices);
H A Dhid-picolcd_lcd.c20 #include <linux/hid.h>
25 #include "hid-picolcd.h"
H A Dhid-lenovo.c21 #include <linux/hid.h>
25 #include "hid-ids.h"
80 if (usage->hid == (HID_UP_BUTTON | 0x0010)) { lenovo_input_mapping_tpkbd()
94 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR || lenovo_input_mapping_cptkbd()
95 (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) { lenovo_input_mapping_cptkbd()
96 switch (usage->hid & HID_USAGE) { lenovo_input_mapping_cptkbd()
132 if (usage->hid == HID_GD_WHEEL) lenovo_input_mapping_cptkbd()
134 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON && lenovo_input_mapping_cptkbd()
135 (usage->hid & HID_USAGE) == 0x003) lenovo_input_mapping_cptkbd()
137 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER && lenovo_input_mapping_cptkbd()
138 (usage->hid & HID_USAGE) == 0x238) lenovo_input_mapping_cptkbd()
142 if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 || lenovo_input_mapping_cptkbd()
143 (usage->hid & HID_USAGE_PAGE) == 0xffa10000) { lenovo_input_mapping_cptkbd()
148 switch (usage->hid & HID_USAGE) { lenovo_input_mapping_cptkbd()
879 MODULE_DEVICE_TABLE(hid, lenovo_devices);
H A Dhid-sensor-hub.c20 #include <linux/hid.h>
25 #include <linux/hid-sensor-ids.h>
26 #include <linux/hid-sensor-hub.h>
27 #include "hid-ids.h"
33 * @hsdev: Stored hid instance for current hub device.
350 if (field->usage[i].hid == usage_id) hid_sensor_get_usage_index()
387 field->usage[0].hid == sensor_hub_input_get_attribute_info()
480 hid_dbg(hdev, "%d collection_index:%x hid:%x sz:%x\n", sensor_hub_raw_event()
482 report->field[i]->usage->hid, sensor_hub_raw_event()
501 report->field[i]->usage->hid || sensor_hub_raw_event()
519 report->field[i]->usage->hid, sz, ptr, sensor_hub_raw_event()
541 hid_err(hsdev->hdev, "failed to open hid device\n"); sensor_hub_device_open()
801 MODULE_DEVICE_TABLE(hid, sensor_hub_devices);
804 .name = "hid-sensor-hub",
H A Dhid-lg.c20 #include <linux/hid.h>
28 #include "hid-ids.h"
29 #include "hid-lg.h"
30 #include "hid-lg4ff.h"
444 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) lg_ultrax_remote_mapping()
448 switch (usage->hid & HID_USAGE) { lg_ultrax_remote_mapping()
477 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) lg_dinovo_mapping()
480 switch (usage->hid & HID_USAGE) { lg_dinovo_mapping()
493 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER) lg_wireless_mapping()
496 switch (usage->hid & HID_USAGE) { lg_wireless_mapping()
568 unsigned int hid = usage->hid; lg_input_mapping() local
581 if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON) lg_input_mapping()
584 hid &= HID_USAGE; lg_input_mapping()
589 (hid == 7 || hid == 8)) lg_input_mapping()
593 hid < ARRAY_SIZE(e_keymap) && lg_input_mapping()
594 e_keymap[hid] != 0) { lg_input_mapping()
596 e_keymap[hid]); lg_input_mapping()
824 MODULE_DEVICE_TABLE(hid, lg_devices);
H A Dhid-roccat-arvo.c21 #include <linux/hid.h>
24 #include <linux/hid-roccat.h>
25 #include "hid-ids.h"
26 #include "hid-roccat-common.h"
27 #include "hid-roccat-arvo.h"
424 MODULE_DEVICE_TABLE(hid, arvo_devices);
H A Dhid-roccat-isku.c21 #include <linux/hid.h>
24 #include <linux/hid-roccat.h>
25 #include "hid-ids.h"
26 #include "hid-roccat-common.h"
27 #include "hid-roccat-isku.h"
427 MODULE_DEVICE_TABLE(hid, isku_devices);
H A Dhid-corsair.c17 #include <linux/hid.h>
22 #include "hid-ids.h"
576 switch (usage->hid & HID_USAGE) { corsair_event()
598 gkey = corsair_usage_to_gkey(usage->hid & HID_USAGE); corsair_input_mapping()
604 if ((usage->hid & HID_USAGE) >= CORSAIR_USAGE_SPECIAL_MIN && corsair_input_mapping()
605 (usage->hid & HID_USAGE) <= CORSAIR_USAGE_SPECIAL_MAX) { corsair_input_mapping()
606 switch (usage->hid & HID_USAGE) { corsair_input_mapping()
647 MODULE_DEVICE_TABLE(hid, corsair_devices);
H A Dhid-picolcd_backlight.c20 #include <linux/hid.h>
25 #include "hid-picolcd.h"
H A Dhid-roccat-common.c14 #include <linux/hid.h>
17 #include "hid-roccat-common.h"
H A Dhid-ntrig.c17 #include <linux/hid.h>
23 #include "hid-ids.h"
468 switch (usage->hid & HID_USAGE_PAGE) { ntrig_input_mapping()
470 switch (usage->hid) { ntrig_input_mapping()
519 switch (usage->hid) { ntrig_input_mapping()
570 static int ntrig_event (struct hid_device *hid, struct hid_field *field, ntrig_event() argument
573 struct ntrig_data *nd = hid_get_drvdata(hid); ntrig_event()
577 if (!(hid->claimed & HID_CLAIMED_INPUT)) ntrig_event()
591 switch (usage->hid) { ntrig_event()
856 if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event) ntrig_event()
857 hid->hiddev_hid_event(hid, field, usage, value); ntrig_event()
862 static int ntrig_input_configured(struct hid_device *hid, ntrig_input_configured() argument
1014 MODULE_DEVICE_TABLE(hid, ntrig_devices);
H A Dhid-roccat-koneplus.c22 #include <linux/hid.h>
25 #include <linux/hid-roccat.h>
26 #include "hid-ids.h"
27 #include "hid-roccat-common.h"
28 #include "hid-roccat-koneplus.h"
541 MODULE_DEVICE_TABLE(hid, koneplus_devices);
H A Dhid-roccat-kovaplus.c20 #include <linux/hid.h>
23 #include <linux/hid-roccat.h>
24 #include "hid-ids.h"
25 #include "hid-roccat-common.h"
26 #include "hid-roccat-kovaplus.h"
629 MODULE_DEVICE_TABLE(hid, kovaplus_devices);
H A Dhid-roccat-pyra.c22 #include <linux/hid.h>
25 #include <linux/hid-roccat.h>
26 #include "hid-ids.h"
27 #include "hid-roccat-common.h"
28 #include "hid-roccat-pyra.h"
578 MODULE_DEVICE_TABLE(hid, pyra_devices);
H A Dhid-debug.c39 #include <linux/hid.h>
40 #include <linux/hid-debug.h>
551 tab(n+2, f); hid_resolv_usage(field->usage[j].hid, f); seq_printf(f, "\n"); hid_dump_field()
679 void hid_dump_report(struct hid_device *hid, int type, u8 *data, hid_dump_report() argument
691 report_enum = hid->report_enum + type; hid_dump_report()
697 hid_debug_event(hid, buf); hid_dump_report()
702 hid_debug_event(hid, buf); hid_dump_report()
704 hid_debug_event(hid, "\n"); hid_dump_report()
714 buf = hid_resolv_usage(usage->hid, NULL); hid_dump_input()
1026 static void hid_dump_input_mapping(struct hid_device *hid, struct seq_file *f) hid_dump_input_mapping() argument
1033 list_for_each_entry(report, &hid->report_enum[k].report_list, list) { hid_dump_input_mapping()
1037 hid_resolv_usage(usage->hid, f); hid_dump_input_mapping()
1244 hid_debug_root = debugfs_create_dir("hid", NULL); hid_debug_init()
H A Dhid-roccat-pyra.h89 /* hid audio controls */
H A Dhid-elo.c11 #include <linux/hid.h>
17 #include "hid-ids.h"
273 MODULE_DEVICE_TABLE(hid, elo_devices);
H A Dhid-gt683r.c19 #include <linux/hid.h>
24 #include "hid-ids.h"
256 hid_err(hdev, "hid parsing failed\n"); gt683r_led_probe()
H A Dhid-rmi.c14 #include <linux/hid.h>
22 #include "hid-ids.h"
72 * struct rmi_data - stores information for hid communication
210 dev_err(&hdev->dev, "failed to write hid report (%d)\n", ret); rmi_write_report()
557 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) rmi_event()
560 if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y) rmi_event()
1193 /* Allow incoming hid reports */ rmi_input_configured()
1264 ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)) rmi_input_mapping()
1321 * simply return and let the events be processed by hid-input rmi_probe()
1397 MODULE_DEVICE_TABLE(hid, rmi_id);
1400 .name = "hid-rmi",
H A Dhid-thingm.c12 #include <linux/hid.h>
19 #include "hid-ids.h"
300 MODULE_DEVICE_TABLE(hid, thingm_table);
H A Dhid-prodikeys.c25 #include <linux/hid.h>
29 #include "hid-ids.h"
33 pr_debug("hid-prodikeys: " format "\n" , ## arg)
35 pr_err("hid-prodikeys: " format "\n" , ## arg)
764 if (HID_UP_MSVENDOR == (usage->hid & HID_USAGE_PAGE) && pk_input_mapping()
827 hid_err(hdev, "hid parse failed\n"); pk_probe()
878 MODULE_DEVICE_TABLE(hid, pk_devices);
H A Dhid-roccat-kone.c30 #include <linux/hid.h>
33 #include <linux/hid-roccat.h>
34 #include "hid-ids.h"
35 #include "hid-roccat-common.h"
36 #include "hid-roccat-kone.h"
686 * Since IGNORE_MOUSE quirk moved to hid-apple, there is no way to bind only to
872 MODULE_DEVICE_TABLE(hid, kone_devices);
H A Dhid-picolcd_core.c20 #include <linux/hid.h>
21 #include <linux/hid-debug.h>
23 #include "hid-ids.h"
32 #include "hid-picolcd.h"
665 MODULE_DEVICE_TABLE(hid, picolcd_devices);
668 .name = "hid-picolcd",
H A Dhid-logitech-hidpp.c18 #include <linux/hid.h>
25 #include "hid-ids.h"
67 * bluetooth. The message lengths are defined by the hid vendor specific report
355 /* hid-logitech-dj is in charge of setting the right device index */ hidpp_get_unifying_name()
1322 * We return 1 to hid-core to avoid forwarding the hidpp_raw_hidpp_event()
1352 hid_err(hdev, "received hid++ report of bad size (%d)", hidpp_raw_event()
1360 hid_err(hdev, "received hid++ report of bad size (%d)", hidpp_raw_event()
1406 struct hid_device *hid = input_get_drvdata(dev); hidpp_input_open() local
1408 return hid_hw_open(hid); hidpp_input_open()
1413 struct hid_device *hid = input_get_drvdata(dev); hidpp_input_close() local
1415 hid_hw_close(hid); hidpp_input_close()
1654 MODULE_DEVICE_TABLE(hid, hidpp_devices);
H A Dhid-magicmouse.c18 #include <linux/hid.h>
23 #include "hid-ids.h"
514 hid_err(hdev, "magicmouse hid parse failed\n"); magicmouse_probe()
575 MODULE_DEVICE_TABLE(hid, magic_mice);
H A Dhid-wiimote-debug.c18 #include "hid-wiimote.h"
H A Dwacom_wac.h13 #include <linux/hid.h>
H A Dwacom_wac.c1511 switch (usage->hid) { wacom_wac_pen_usage_mapping()
1552 switch (usage->hid) { wacom_wac_pen_event()
1617 switch (usage->hid) { wacom_wac_finger_usage_mapping()
1619 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1627 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1636 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1642 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1645 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1648 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1651 features->last_slot_field = usage->hid; wacom_wac_finger_usage_mapping()
1706 switch (usage->hid) { wacom_wac_finger_event()
1729 if (usage->hid == wacom_wac->features.last_slot_field) wacom_wac_finger_event()
1756 if (field->usage[j].hid == HID_DG_CONTACTCOUNT) { wacom_wac_finger_pre_report()
1810 /* currently, only direct devices have proper hid report descriptors */ wacom_wac_usage_mapping()
3632 MODULE_DEVICE_TABLE(hid, wacom_ids);
H A Dhid-kye.c17 #include <linux/hid.h>
20 #include "hid-ids.h"
602 MODULE_DEVICE_TABLE(hid, kye_devices);
H A Dhid-sensor-custom.c2 * hid-sensor-custom.c
25 #include <linux/hid-sensor-hub.h>
503 sensor_field->attribute.attrib_id = field->usage[0].hid; hid_sensor_custom_add_field()
H A Dhid-picolcd_fb.c20 #include <linux/hid.h>
26 #include "hid-picolcd.h"
H A Dhid-cp2112.c2 * hid-cp2112.c - Silicon Labs HID USB to SMBus master bridge
28 #include <linux/hid.h>
33 #include "hid-ids.h"
151 MODULE_DEVICE_TABLE(hid, cp2112_devices);
H A Dhid-uclogic.c16 #include <linux/hid.h>
22 #include "hid-ids.h"
730 /* let hid-core decide what to do */ uclogic_input_mapping()
965 MODULE_DEVICE_TABLE(hid, uclogic_devices);
H A Dhid-wiimote.h18 #include <linux/hid.h>
H A Dwacom.h92 #include <linux/hid.h>
H A Dhid-sony.c30 #include <linux/hid.h>
40 #include "hid-ids.h"
1084 unsigned int key = usage->hid & HID_USAGE; ps3remote_mapping()
1086 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) ps3remote_mapping()
1318 unsigned int key = usage->hid & HID_USAGE; sony_mapping()
1320 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON) sony_mapping()
1343 /* Let hid-core decide for the others */ sony_mapping()
1946 struct hid_device *hid = input_get_drvdata(dev); sony_play_effect() local
1947 struct sony_sc *sc = hid_get_drvdata(hid); sony_play_effect()
2463 MODULE_DEVICE_TABLE(hid, sony_devices);
H A Dhid-wiimote-core.c15 #include <linux/hid.h>
20 #include "hid-ids.h"
21 #include "hid-wiimote.h"
90 * send out the buffer to the hid device. wiimote_queue()
1862 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
H A Dwacom_sys.c122 switch (usage->hid) { wacom_feature_mapping()
220 switch (usage->hid) { wacom_usage_mapping()
1705 /* hid-core sets this quirk for the boot interface */ wacom_probe()
1746 * Bamboo Pad has a generic hid handling for the Pen, and we switch it wacom_probe()
1760 /* set the default size in case we do not get them from hid */ wacom_probe()
H A Dhid-picolcd_debugfs.c20 #include <linux/hid.h>
21 #include <linux/hid-debug.h>
30 #include "hid-picolcd.h"
H A Dhid-waltop.c15 #include <linux/hid.h>
18 #include "hid-ids.h"
774 MODULE_DEVICE_TABLE(hid, waltop_devices);
H A Dhid-wiimote-modules.c37 #include <linux/hid.h>
40 #include "hid-wiimote.h"
/linux-4.4.14/drivers/iio/common/hid-sensors/
H A DMakefile5 obj-$(CONFIG_HID_SENSOR_IIO_COMMON) += hid-sensor-iio-common.o
6 obj-$(CONFIG_HID_SENSOR_IIO_TRIGGER) += hid-sensor-trigger.o
7 hid-sensor-iio-common-y := hid-sensor-attributes.o
H A Dhid-sensor-trigger.c26 #include <linux/hid-sensor-hub.h>
30 #include "hid-sensor-trigger.h"
H A Dhid-sensor-attributes.c25 #include <linux/hid-sensor-hub.h>
/linux-4.4.14/drivers/hid/usbhid/
H A DMakefile5 usbhid-y := hid-core.o hid-quirks.o
7 usbhid-$(CONFIG_HID_PID) += hid-pidff.o
H A Dhid-core.c35 #include <linux/hid.h>
37 #include <linux/hid-debug.h>
72 static void hid_io_error(struct hid_device *hid);
73 static int hid_submit_out(struct hid_device *hid);
74 static int hid_submit_ctrl(struct hid_device *hid);
78 static int hid_start_in(struct hid_device *hid) hid_start_in() argument
82 struct usbhid_device *usbhid = hid->driver_data; hid_start_in()
85 if ((hid->open > 0 || hid->quirks & HID_QUIRK_ALWAYS_POLL) && hid_start_in()
105 struct hid_device *hid = (struct hid_device *) _hid; hid_retry_timeout() local
106 struct usbhid_device *usbhid = hid->driver_data; hid_retry_timeout()
109 if (hid_start_in(hid)) hid_retry_timeout()
110 hid_io_error(hid); hid_retry_timeout()
118 struct hid_device *hid = usbhid->hid; hid_reset() local
123 rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe); hid_reset()
126 hid_start_in(hid); hid_reset()
141 static void hid_io_error(struct hid_device *hid) hid_io_error() argument
144 struct usbhid_device *usbhid = hid->driver_data; hid_io_error()
190 struct hid_device *hid = usb_get_intfdata(usbhid->intf); usbhid_restart_out_queue() local
194 if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) || usbhid_restart_out_queue()
199 hid_dbg(hid, "Kicking head %d tail %d", usbhid->outhead, usbhid->outtail); usbhid_restart_out_queue()
217 if (hid_submit_out(hid)) { usbhid_restart_out_queue()
228 struct hid_device *hid = usb_get_intfdata(usbhid->intf); usbhid_restart_ctrl_queue() local
232 WARN_ON(hid == NULL); usbhid_restart_ctrl_queue()
233 if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) || usbhid_restart_ctrl_queue()
238 hid_dbg(hid, "Kicking head %d tail %d", usbhid->ctrlhead, usbhid->ctrltail); usbhid_restart_ctrl_queue()
256 if (hid_submit_ctrl(hid)) { usbhid_restart_ctrl_queue()
271 struct hid_device *hid = urb->context; hid_irq_in() local
272 struct usbhid_device *usbhid = hid->driver_data; hid_irq_in()
279 if ((hid->quirks & HID_QUIRK_ALWAYS_POLL) && !hid->open) hid_irq_in()
290 if (hid_check_keys_pressed(hid)) hid_irq_in()
313 hid_io_error(hid); hid_irq_in()
324 hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n", hid_irq_in()
325 hid_to_usb_dev(hid)->bus->bus_name, hid_irq_in()
326 hid_to_usb_dev(hid)->devpath, hid_irq_in()
328 hid_io_error(hid); hid_irq_in()
333 static int hid_submit_out(struct hid_device *hid) hid_submit_out() argument
337 struct usbhid_device *usbhid = hid->driver_data; hid_submit_out()
344 usbhid->urbout->dev = hid_to_usb_dev(hid); hid_submit_out()
356 hid_err(hid, "usb_submit_urb(out) failed: %d\n", r); hid_submit_out()
363 static int hid_submit_ctrl(struct hid_device *hid) hid_submit_ctrl() argument
369 struct usbhid_device *usbhid = hid->driver_data; hid_submit_ctrl()
377 usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0); hid_submit_ctrl()
387 usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0); hid_submit_ctrl()
388 maxpacket = usb_maxpacket(hid_to_usb_dev(hid), hid_submit_ctrl()
399 usbhid->urbctrl->dev = hid_to_usb_dev(hid); hid_submit_ctrl()
416 hid_err(hid, "usb_submit_urb(ctrl) failed: %d\n", r); hid_submit_ctrl()
429 struct hid_device *hid = urb->context; hid_irq_out() local
430 struct usbhid_device *usbhid = hid->driver_data; hid_irq_out()
457 hid_submit_out(hid) == 0) { hid_irq_out()
476 struct hid_device *hid = urb->context; hid_ctrl() local
477 struct usbhid_device *usbhid = hid->driver_data; hid_ctrl()
507 hid_submit_ctrl(hid) == 0) { hid_ctrl()
520 static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *report, __usbhid_submit_report() argument
524 struct usbhid_device *usbhid = hid->driver_data; __usbhid_submit_report()
526 if (((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN) || __usbhid_submit_report()
532 hid_warn(hid, "output queue full\n"); __usbhid_submit_report()
538 hid_warn(hid, "output queueing failed\n"); __usbhid_submit_report()
580 hid_warn(hid, "control queue full\n"); __usbhid_submit_report()
587 hid_warn(hid, "control queueing failed\n"); __usbhid_submit_report()
629 static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir) usbhid_submit_report() argument
631 struct usbhid_device *usbhid = hid->driver_data; usbhid_submit_report()
635 __usbhid_submit_report(hid, report, dir); usbhid_submit_report()
639 static int usbhid_wait_io(struct hid_device *hid) usbhid_wait_io() argument
641 struct usbhid_device *usbhid = hid->driver_data; usbhid_wait_io()
677 int usbhid_open(struct hid_device *hid) usbhid_open() argument
679 struct usbhid_device *usbhid = hid->driver_data; usbhid_open()
683 if (!hid->open++) { usbhid_open()
687 hid->open--; usbhid_open()
693 res = hid_start_in(hid); usbhid_open()
696 hid_io_error(hid); usbhid_open()
700 hid->open--; usbhid_open()
711 * to go through hid. usbhid_open()
713 if (res == 0 && !(hid->quirks & HID_QUIRK_ALWAYS_POLL)) usbhid_open()
722 void usbhid_close(struct hid_device *hid) usbhid_close() argument
724 struct usbhid_device *usbhid = hid->driver_data; usbhid_close()
728 /* protecting hid->open to make sure we don't restart usbhid_close()
733 if (!--hid->open) { usbhid_close()
736 if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) { usbhid_close()
750 void usbhid_init_reports(struct hid_device *hid) usbhid_init_reports() argument
753 struct usbhid_device *usbhid = hid->driver_data; usbhid_init_reports()
757 if (!(hid->quirks & HID_QUIRK_NO_INIT_INPUT_REPORTS)) { usbhid_init_reports()
758 report_enum = &hid->report_enum[HID_INPUT_REPORT]; usbhid_init_reports()
760 usbhid_submit_report(hid, report, USB_DIR_IN); usbhid_init_reports()
763 report_enum = &hid->report_enum[HID_FEATURE_REPORT]; usbhid_init_reports()
765 usbhid_submit_report(hid, report, USB_DIR_IN); usbhid_init_reports()
768 ret = usbhid_wait_io(hid); usbhid_init_reports()
775 ret = usbhid_wait_io(hid); usbhid_init_reports()
779 hid_warn(hid, "timeout initializing reports\n"); usbhid_init_reports()
785 static int hid_find_field_early(struct hid_device *hid, unsigned int page, hid_find_field_early() argument
793 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) { hid_find_field_early()
798 if ((usage->hid & HID_USAGE_PAGE) == page && hid_find_field_early()
799 (usage->hid & 0xFFFF) == hid_code) { hid_find_field_early()
809 static void usbhid_set_leds(struct hid_device *hid) usbhid_set_leds() argument
814 if ((offset = hid_find_field_early(hid, HID_UP_LED, 0x01, &field)) != -1) { usbhid_set_leds()
816 usbhid_submit_report(hid, field->report, USB_DIR_OUT); usbhid_set_leds()
823 static void hid_find_max_report(struct hid_device *hid, unsigned int type, hid_find_max_report() argument
829 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { hid_find_max_report()
830 size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered; hid_find_max_report()
836 static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid) hid_alloc_buffers() argument
838 struct usbhid_device *usbhid = hid->driver_data; hid_alloc_buffers()
854 static int usbhid_get_raw_report(struct hid_device *hid, usbhid_get_raw_report() argument
858 struct usbhid_device *usbhid = hid->driver_data; usbhid_get_raw_report()
859 struct usb_device *dev = hid_to_usb_dev(hid); usbhid_get_raw_report()
888 static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum, usbhid_set_raw_report() argument
891 struct usbhid_device *usbhid = hid->driver_data; usbhid_set_raw_report()
892 struct usb_device *dev = hid_to_usb_dev(hid); usbhid_set_raw_report()
899 (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID)) usbhid_set_raw_report()
924 static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count) usbhid_output_report() argument
926 struct usbhid_device *usbhid = hid->driver_data; usbhid_output_report()
927 struct usb_device *dev = hid_to_usb_dev(hid); usbhid_output_report()
954 static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid) hid_free_buffers() argument
956 struct usbhid_device *usbhid = hid->driver_data; hid_free_buffers()
964 static int usbhid_parse(struct hid_device *hid) usbhid_parse() argument
966 struct usb_interface *intf = to_usb_interface(hid->dev.parent); usbhid_parse()
996 hid->version = le16_to_cpu(hdesc->bcdHID); usbhid_parse()
997 hid->country = hdesc->bCountryCode; usbhid_parse()
1023 ret = hid_parse_report(hid, rdesc, rsize); usbhid_parse()
1030 hid->quirks |= quirks; usbhid_parse()
1037 static int usbhid_start(struct hid_device *hid) usbhid_start() argument
1039 struct usb_interface *intf = to_usb_interface(hid->dev.parent); usbhid_start()
1042 struct usbhid_device *usbhid = hid->driver_data; usbhid_start()
1049 hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize); usbhid_start()
1050 hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize); usbhid_start()
1051 hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize); usbhid_start()
1056 hid_find_max_report(hid, HID_INPUT_REPORT, &insize); usbhid_start()
1061 if (hid_alloc_buffers(dev, hid)) { usbhid_start()
1078 if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL && usbhid_start()
1082 hid->name, endpoint->bInterval, interval); usbhid_start()
1086 if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0) usbhid_start()
1097 hid_irq_in, hid, interval); usbhid_start()
1107 hid_irq_out, hid, interval); usbhid_start()
1120 usbhid->ctrlbuf, 1, hid_ctrl, hid); usbhid_start()
1124 if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS)) usbhid_start()
1125 usbhid_init_reports(hid); usbhid_start()
1129 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) { usbhid_start()
1134 ret = hid_start_in(hid); usbhid_start()
1136 dev_err(&hid->dev, usbhid_start()
1151 usbhid_set_leds(hid); usbhid_start()
1163 hid_free_buffers(dev, hid); usbhid_start()
1167 static void usbhid_stop(struct hid_device *hid) usbhid_stop() argument
1169 struct usbhid_device *usbhid = hid->driver_data; usbhid_stop()
1174 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) usbhid_stop()
1187 hid->claimed = 0; usbhid_stop()
1196 hid_free_buffers(hid_to_usb_dev(hid), hid); usbhid_stop() local
1199 static int usbhid_power(struct hid_device *hid, int lvl) usbhid_power() argument
1205 r = usbhid_get_power(hid); usbhid_power()
1208 usbhid_put_power(hid); usbhid_power()
1214 static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype) usbhid_request() argument
1218 usbhid_submit_report(hid, rep, USB_DIR_IN); usbhid_request()
1221 usbhid_submit_report(hid, rep, USB_DIR_OUT); usbhid_request()
1226 static int usbhid_raw_request(struct hid_device *hid, unsigned char reportnum, usbhid_raw_request() argument
1232 return usbhid_get_raw_report(hid, reportnum, buf, len, rtype); usbhid_raw_request()
1234 return usbhid_set_raw_report(hid, reportnum, buf, len, rtype); usbhid_raw_request()
1240 static int usbhid_idle(struct hid_device *hid, int report, int idle, usbhid_idle() argument
1243 struct usb_device *dev = hid_to_usb_dev(hid); usbhid_idle()
1244 struct usb_interface *intf = to_usb_interface(hid->dev.parent); usbhid_idle()
1273 struct hid_device *hid; usbhid_probe() local
1289 hid = hid_allocate_device(); usbhid_probe()
1290 if (IS_ERR(hid)) usbhid_probe()
1291 return PTR_ERR(hid); usbhid_probe()
1293 usb_set_intfdata(intf, hid); usbhid_probe()
1294 hid->ll_driver = &usb_hid_driver; usbhid_probe()
1295 hid->ff_init = hid_pidff_init; usbhid_probe()
1297 hid->hiddev_connect = hiddev_connect; usbhid_probe()
1298 hid->hiddev_disconnect = hiddev_disconnect; usbhid_probe()
1299 hid->hiddev_hid_event = hiddev_hid_event; usbhid_probe()
1300 hid->hiddev_report_event = hiddev_report_event; usbhid_probe()
1302 hid->dev.parent = &intf->dev; usbhid_probe()
1303 hid->bus = BUS_USB; usbhid_probe()
1304 hid->vendor = le16_to_cpu(dev->descriptor.idVendor); usbhid_probe()
1305 hid->product = le16_to_cpu(dev->descriptor.idProduct); usbhid_probe()
1306 hid->name[0] = 0; usbhid_probe()
1307 hid->quirks = usbhid_lookup_quirk(hid->vendor, hid->product); usbhid_probe()
1310 hid->type = HID_TYPE_USBMOUSE; usbhid_probe()
1312 hid->type = HID_TYPE_USBNONE; usbhid_probe()
1315 strlcpy(hid->name, dev->manufacturer, sizeof(hid->name)); usbhid_probe()
1319 strlcat(hid->name, " ", sizeof(hid->name)); usbhid_probe()
1320 strlcat(hid->name, dev->product, sizeof(hid->name)); usbhid_probe()
1323 if (!strlen(hid->name)) usbhid_probe()
1324 snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x", usbhid_probe()
1328 usb_make_path(dev, hid->phys, sizeof(hid->phys)); usbhid_probe()
1329 strlcat(hid->phys, "/input", sizeof(hid->phys)); usbhid_probe()
1330 len = strlen(hid->phys); usbhid_probe()
1331 if (len < sizeof(hid->phys) - 1) usbhid_probe()
1332 snprintf(hid->phys + len, sizeof(hid->phys) - len, usbhid_probe()
1335 if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0) usbhid_probe()
1336 hid->uniq[0] = 0; usbhid_probe()
1344 hid->driver_data = usbhid; usbhid_probe()
1345 usbhid->hid = hid; usbhid_probe()
1351 setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid); usbhid_probe()
1354 ret = hid_add_device(hid); usbhid_probe()
1357 hid_err(intf, "can't add hid device: %d\n", ret); usbhid_probe()
1365 hid_destroy_device(hid); usbhid_probe()
1371 struct hid_device *hid = usb_get_intfdata(intf); usbhid_disconnect() local
1374 if (WARN_ON(!hid)) usbhid_disconnect()
1377 usbhid = hid->driver_data; usbhid_disconnect()
1381 hid_destroy_device(hid); usbhid_disconnect()
1399 static void hid_restart_io(struct hid_device *hid) hid_restart_io() argument
1401 struct usbhid_device *usbhid = hid->driver_data; hid_restart_io()
1418 if (hid_start_in(hid) < 0) hid_restart_io()
1419 hid_io_error(hid); hid_restart_io()
1433 struct hid_device *hid = usb_get_intfdata(intf); hid_pre_reset() local
1434 struct usbhid_device *usbhid = hid->driver_data; hid_pre_reset()
1448 struct hid_device *hid = usb_get_intfdata(intf); hid_post_reset() local
1449 struct usbhid_device *usbhid = hid->driver_data; hid_post_reset()
1459 rdesc = kmalloc(hid->dev_rsize, GFP_KERNEL); hid_post_reset()
1466 HID_DT_REPORT, rdesc, hid->dev_rsize); hid_post_reset()
1472 status = memcmp(rdesc, hid->dev_rdesc, hid->dev_rsize); hid_post_reset()
1486 hid_restart_io(hid); hid_post_reset()
1491 int usbhid_get_power(struct hid_device *hid) usbhid_get_power() argument
1493 struct usbhid_device *usbhid = hid->driver_data; usbhid_get_power()
1498 void usbhid_put_power(struct hid_device *hid) usbhid_put_power() argument
1500 struct usbhid_device *usbhid = hid->driver_data; usbhid_put_power()
1507 static int hid_resume_common(struct hid_device *hid, bool driver_suspended) hid_resume_common() argument
1511 hid_restart_io(hid); hid_resume_common()
1512 if (driver_suspended && hid->driver && hid->driver->resume) hid_resume_common()
1513 status = hid->driver->resume(hid); hid_resume_common()
1519 struct hid_device *hid = usb_get_intfdata(intf); hid_suspend() local
1520 struct usbhid_device *usbhid = hid->driver_data; hid_suspend()
1526 ledcount = hidinput_count_leds(hid); hid_suspend()
1537 if (hid->driver && hid->driver->suspend) { hid_suspend()
1538 status = hid->driver->suspend(hid, message); hid_suspend()
1551 if (hid->driver && hid->driver->suspend) hid_suspend()
1552 status = hid->driver->suspend(hid, message); hid_suspend()
1557 if (usbhid_wait_io(hid) < 0) hid_suspend()
1573 hid_resume_common(hid, driver_suspended); hid_suspend()
1579 struct hid_device *hid = usb_get_intfdata (intf); hid_resume() local
1582 status = hid_resume_common(hid, true); hid_resume()
1589 struct hid_device *hid = usb_get_intfdata(intf); hid_reset_resume() local
1593 if (status >= 0 && hid->driver && hid->driver->reset_resume) { hid_reset_resume()
1594 int ret = hid->driver->reset_resume(hid); hid_reset_resume()
H A Dhiddev.c34 #include <linux/hid.h>
54 struct hid_device *hid; member in struct:hiddev
77 hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo) hiddev_lookup_report() argument
89 report_enum = hid->report_enum + hiddev_lookup_report()
130 hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref) hiddev_lookup_usage() argument
141 report_enum = hid->report_enum + hiddev_lookup_usage()
148 if (field->usage[j].hid == uref->usage_code) { hiddev_lookup_usage()
161 static void hiddev_send_event(struct hid_device *hid, hiddev_send_event() argument
164 struct hiddev *hiddev = hid->hiddev; hiddev_send_event()
184 * This is where hid.c calls into hiddev to pass an event that occurred over
187 void hiddev_hid_event(struct hid_device *hid, struct hid_field *field, hiddev_hid_event() argument
200 uref.usage_code = usage->hid; hiddev_hid_event()
203 hiddev_send_event(hid, &uref); hiddev_hid_event()
207 void hiddev_report_event(struct hid_device *hid, struct hid_report *report) hiddev_report_event() argument
220 hiddev_send_event(hid, &uref); hiddev_report_event()
249 usbhid_close(list->hiddev->hid); hiddev_release()
250 usbhid_put_power(list->hiddev->hid); hiddev_release()
272 struct hid_device *hid; hiddev_open() local
279 hid = usb_get_intfdata(intf); hiddev_open()
280 hiddev = hid->hiddev; hiddev_open()
294 res = usbhid_open(hiddev->hid); hiddev_open()
312 struct hid_device *hid = hiddev->hid; hiddev_open() local
313 res = usbhid_get_power(hid); hiddev_open()
318 usbhid_open(hid); hiddev_open()
402 event.hid = list->buffer[list->tail].usage_code; hiddev_read()
451 struct hid_device *hid = hiddev->hid; hiddev_ioctl_usage() local
476 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) hiddev_ioctl_usage()
486 uref->usage_code = field->usage[uref->usage_index].hid; hiddev_ioctl_usage()
500 field = hiddev_lookup_usage(hid, uref); hiddev_ioctl_usage()
506 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) hiddev_ioctl_usage()
570 struct hid_device *hid = hiddev->hid; hiddev_ioctl_string() local
571 struct usb_device *dev = hid_to_usb_dev(hid); hiddev_ioctl_string()
600 struct hid_device *hid; hiddev_ioctl() local
618 hid = hiddev->hid; hiddev_ioctl()
628 if (arg >= hid->maxapplication) hiddev_ioctl()
631 for (i = 0; i < hid->maxcollection; i++) hiddev_ioctl()
632 if (hid->collection[i].type == hiddev_ioctl()
636 if (i < hid->maxcollection) hiddev_ioctl()
637 r = hid->collection[i].usage; hiddev_ioctl()
642 struct usb_device *dev = hid_to_usb_dev(hid); hiddev_ioctl()
643 struct usbhid_device *usbhid = hid->driver_data; hiddev_ioctl()
654 dinfo.num_applications = hid->maxapplication; hiddev_ioctl()
691 usbhid_init_reports(hid); hiddev_ioctl()
704 report = hiddev_lookup_report(hid, &rinfo); hiddev_ioctl()
708 hid_hw_request(hid, report, HID_REQ_GET_REPORT); hiddev_ioctl()
709 hid_hw_wait(hid); hiddev_ioctl()
723 report = hiddev_lookup_report(hid, &rinfo); hiddev_ioctl()
727 hid_hw_request(hid, report, HID_REQ_SET_REPORT); hiddev_ioctl()
728 hid_hw_wait(hid); hiddev_ioctl()
739 report = hiddev_lookup_report(hid, &rinfo); hiddev_ioctl()
758 report = hiddev_lookup_report(hid, &rinfo); hiddev_ioctl()
802 if (cinfo.index >= hid->maxcollection) hiddev_ioctl()
805 cinfo.type = hid->collection[cinfo.index].type; hiddev_ioctl()
806 cinfo.usage = hid->collection[cinfo.index].usage; hiddev_ioctl()
807 cinfo.level = hid->collection[cinfo.index].level; hiddev_ioctl()
818 int len = strlen(hid->name) + 1; hiddev_ioctl()
821 r = copy_to_user(user_arg, hid->name, len) ? hiddev_ioctl()
827 int len = strlen(hid->phys) + 1; hiddev_ioctl()
830 r = copy_to_user(user_arg, hid->phys, len) ? hiddev_ioctl()
876 * This is where hid.c calls us to connect a hid device to the hiddev driver
878 int hiddev_connect(struct hid_device *hid, unsigned int force) hiddev_connect() argument
881 struct usbhid_device *usbhid = hid->driver_data; hiddev_connect()
886 for (i = 0; i < hid->maxcollection; i++) hiddev_connect()
887 if (hid->collection[i].type == hiddev_connect()
889 !IS_INPUT_APPLICATION(hid->collection[i].usage)) hiddev_connect()
892 if (i == hid->maxcollection) hiddev_connect()
903 hid->hiddev = hiddev; hiddev_connect()
904 hiddev->hid = hid; hiddev_connect()
908 hid_err(hid, "Not able to get a minor for this device\n"); hiddev_connect()
909 hid->hiddev = NULL; hiddev_connect()
917 * This is where hid.c calls us to disconnect a hiddev device from the
918 * corresponding hid device (usually because the usb device has disconnected)
921 void hiddev_disconnect(struct hid_device *hid) hiddev_disconnect() argument
923 struct hiddev *hiddev = hid->hiddev; hiddev_disconnect()
924 struct usbhid_device *usbhid = hid->driver_data; hiddev_disconnect()
933 usbhid_close(hiddev->hid); hiddev_disconnect()
H A Dhid-pidff.c31 #include <linux/hid.h>
157 struct hid_device *hid; member in struct:pidff_device
262 hid_dbg(pidff->hid, "attack %u => %d\n", pidff_set_envelope_report()
266 hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE], pidff_set_envelope_report()
293 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT], pidff_set_constant_force_report()
328 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT], pidff_set_effect_report()
360 hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC], pidff_set_periodic_report()
402 hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION], pidff_set_condition_report()
443 hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP], pidff_set_ramp_force_report()
468 hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT], pidff_request_effect_upload()
470 hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum); pidff_request_effect_upload()
474 hid_hw_wait(pidff->hid); pidff_request_effect_upload()
477 hid_dbg(pidff->hid, "pid_block_load requested\n"); pidff_request_effect_upload()
478 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD], pidff_request_effect_upload()
480 hid_hw_wait(pidff->hid); pidff_request_effect_upload()
483 hid_dbg(pidff->hid, "device reported free memory: %d bytes\n", pidff_request_effect_upload()
490 hid_dbg(pidff->hid, "not enough memory free: %d bytes\n", pidff_request_effect_upload()
496 hid_err(pidff->hid, "pid_block_load failed 60 times\n"); pidff_request_effect_upload()
516 hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION], pidff_playback_pid()
538 hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE], pidff_erase_pid()
550 hid_dbg(pidff->hid, "starting to erase %d/%d\n", pidff_erase_effect()
554 hid_hw_wait(pidff->hid); pidff_erase_effect()
615 hid_err(pidff->hid, "invalid waveform\n"); pidff_upload_effect()
706 hid_err(pidff->hid, "invalid type\n"); pidff_upload_effect()
714 hid_dbg(pidff->hid, "uploaded\n"); pidff_upload_effect()
727 hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN], pidff_set_gain()
753 hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT], pidff_autocenter()
784 if (report->field[i]->usage[j].hid == pidff_find_fields()
824 static void pidff_find_reports(struct hid_device *hid, int report_type, pidff_find_reports() argument
831 &hid->report_enum[report_type].report_list, list) { pidff_find_reports()
836 hid_dbg(hid, "found usage 0x%02x from field->logical\n", pidff_find_reports()
851 hid->collection[i - 1].type != HID_COLLECTION_LOGICAL) pidff_find_reports()
853 ret = pidff_check_usage(hid->collection[i - 1].usage); pidff_find_reports()
855 hid_dbg(hid, pidff_find_reports()
872 hid_dbg(pidff->hid, "%d missing\n", i); pidff_reports_ok()
915 if (fld->usage[j].hid == (HID_UP_PID | usagetable[i])) { pidff_find_special_keys()
934 hid_dbg(pidff->hid, "finding special fields\n"); pidff_find_special_fields()
955 hid_dbg(pidff->hid, "search done\n"); pidff_find_special_fields()
958 hid_err(pidff->hid, "effect lists not found\n"); pidff_find_special_fields()
963 hid_err(pidff->hid, "direction field not found\n"); pidff_find_special_fields()
968 hid_err(pidff->hid, "device control field not found\n"); pidff_find_special_fields()
973 hid_err(pidff->hid, "block load status field not found\n"); pidff_find_special_fields()
978 hid_err(pidff->hid, "effect operation field not found\n"); pidff_find_special_fields()
990 hid_err(pidff->hid, "no effect types found\n"); pidff_find_special_fields()
997 hid_err(pidff->hid, pidff_find_special_fields()
1005 hid_err(pidff->hid, "effect operation identifiers not found\n"); pidff_find_special_fields()
1022 if (pidff->set_effect_type->usage[pidff_type].hid != pidff_find_effects()
1023 pidff->create_new_effect_type->usage[pidff_type].hid) { pidff_find_effects()
1024 hid_err(pidff->hid, pidff_find_effects()
1080 hid_err(pidff->hid, "unknown set_effect report layout\n"); pidff_init_fields()
1086 hid_err(pidff->hid, "unknown pid_block_load report layout\n"); pidff_init_fields()
1091 hid_err(pidff->hid, "unknown effect_operation report layout\n"); pidff_init_fields()
1096 hid_err(pidff->hid, "unknown pid_block_free report layout\n"); pidff_init_fields()
1108 hid_warn(pidff->hid, pidff_init_fields()
1111 hid_warn(pidff->hid, pidff_init_fields()
1115 hid_warn(pidff->hid, pidff_init_fields()
1121 hid_warn(pidff->hid, "unknown constant effect layout\n"); pidff_init_fields()
1127 hid_warn(pidff->hid, "unknown ramp effect layout\n"); pidff_init_fields()
1136 hid_warn(pidff->hid, "unknown condition effect layout\n"); pidff_init_fields()
1145 hid_warn(pidff->hid, "unknown periodic effect layout\n"); pidff_init_fields()
1162 struct hid_device *hid = pidff->hid; pidff_reset() local
1167 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); pidff_reset()
1168 hid_hw_wait(hid); pidff_reset()
1169 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); pidff_reset()
1170 hid_hw_wait(hid); pidff_reset()
1174 hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT); pidff_reset()
1175 hid_hw_wait(hid); pidff_reset()
1178 hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT); pidff_reset()
1179 hid_hw_wait(hid); pidff_reset()
1184 hid_warn(pidff->hid, pidff_reset()
1189 hid_dbg(pidff->hid, "pid_pool requested again\n"); pidff_reset()
1190 hid_hw_request(hid, pidff->reports[PID_POOL], pidff_reset()
1192 hid_hw_wait(hid); pidff_reset()
1215 hid_err(pidff->hid, "upload request failed\n"); pidff_check_autocenter()
1224 hid_notice(pidff->hid, pidff_check_autocenter()
1238 int hid_pidff_init(struct hid_device *hid) hid_pidff_init() argument
1241 struct hid_input *hidinput = list_entry(hid->inputs.next, hid_pidff_init()
1248 hid_dbg(hid, "starting pid init\n"); hid_pidff_init()
1250 if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) { hid_pidff_init()
1251 hid_dbg(hid, "not a PID device, no output report\n"); hid_pidff_init()
1259 pidff->hid = hid; hid_pidff_init()
1261 hid_device_io_start(hid); hid_pidff_init()
1263 pidff_find_reports(hid, HID_OUTPUT_REPORT, pidff); hid_pidff_init()
1264 pidff_find_reports(hid, HID_FEATURE_REPORT, pidff); hid_pidff_init()
1267 hid_dbg(hid, "reports not ok, aborting\n"); hid_pidff_init()
1280 hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN], hid_pidff_init()
1292 hid_dbg(hid, "max effects is %d\n", max_effects); hid_pidff_init()
1298 hid_dbg(hid, "max simultaneous effects is %d\n", hid_pidff_init()
1302 hid_dbg(hid, "device memory size is %d bytes\n", hid_pidff_init()
1307 hid_notice(hid, hid_pidff_init()
1326 hid_device_io_stop(hid); hid_pidff_init()
1331 hid_device_io_stop(hid); hid_pidff_init()
H A Dusbhid.h36 /* API provided by hid-core.c for USB HID drivers */
37 void usbhid_close(struct hid_device *hid);
38 int usbhid_open(struct hid_device *hid);
39 void usbhid_init_reports(struct hid_device *hid);
40 int usbhid_get_power(struct hid_device *hid);
41 void usbhid_put_power(struct hid_device *hid);
63 struct hid_device *hid; /* pointer to corresponding HID dev */ member in struct:usbhid_device
H A Dusbmouse.c32 #include <linux/hid.h>
36 #include "../hid-ids.h"
H A Dhid-quirks.c18 #include <linux/hid.h>
22 #include "../hid-ids.h"
H A Dusbkbd.c34 #include <linux/hid.h>
/linux-4.4.14/samples/hidraw/
H A DMakefile5 hostprogs-y := hid-example
12 all: hid-example
/linux-4.4.14/include/linux/
H A Dhiddev.h41 int hiddev_connect(struct hid_device *hid, unsigned int force);
43 void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
45 void hiddev_report_event(struct hid_device *hid, struct hid_report *report);
47 static inline int hiddev_connect(struct hid_device *hid, hiddev_connect() argument
50 static inline void hiddev_disconnect(struct hid_device *hid) { } hiddev_hid_event() argument
51 static inline void hiddev_hid_event(struct hid_device *hid, struct hid_field *field, hiddev_hid_event() argument
53 static inline void hiddev_report_event(struct hid_device *hid, struct hid_report *report) { } argument
H A Dhid-roccat.h15 #include <linux/hid.h>
22 int roccat_connect(struct class *klass, struct hid_device *hid,
H A Dhidraw.h24 struct hid_device *hid; member in struct:hidraw
54 static inline int hidraw_report_event(struct hid_device *hid, u8 *data, int len) { return 0; } hidraw_connect() argument
55 static inline int hidraw_connect(struct hid_device *hid) { return -1; } hidraw_disconnect() argument
56 static inline void hidraw_disconnect(struct hid_device *hid) { } argument
H A Dhid.h38 #include <uapi/linux/hid.h>
394 unsigned hid; /* hid usage code */ member in struct:hid_usage
791 extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
792 extern int hidinput_connect(struct hid_device *hid, unsigned int force);
797 int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
798 struct hid_field *hidinput_get_led_field(struct hid_device *hid);
799 unsigned int hidinput_count_leds(struct hid_device *hid);
802 void __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
806 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
807 struct hid_report *hid_validate_values(struct hid_device *hid,
812 int hid_check_keys_pressed(struct hid_device *hid);
813 int hid_connect(struct hid_device *hid, unsigned int connect_mask);
814 void hid_disconnect(struct hid_device *hid);
818 __u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
824 * @hid - the device
830 static inline void hid_device_io_start(struct hid_device *hid) { hid_device_io_start() argument
831 if (hid->io_started) { hid_device_io_start()
832 dev_warn(&hid->dev, "io already started"); hid_device_io_start()
835 hid->io_started = true; hid_device_io_start()
836 up(&hid->driver_input_lock); hid_device_io_start()
842 * @hid - the device
850 static inline void hid_device_io_stop(struct hid_device *hid) { hid_device_io_stop() argument
851 if (!hid->io_started) { hid_device_io_stop()
852 dev_warn(&hid->dev, "io already stopped"); hid_device_io_stop()
855 hid->io_started = false; hid_device_io_stop()
856 down(&hid->driver_input_lock); hid_device_io_stop()
915 * @hdev: hid device
919 * device before passing it to hid layer for real parsing.
929 * @hdev: hid device
951 * @hdev: hid device
965 * @hdev: hid device
979 * @hdev: hid device
993 * @hdev: hid device
1009 * @hdev: hid device
1011 * @reqtype: hid request type
1025 * @hdev: hid device
1050 * @hdev: hid device
1071 * @hdev: hid device
1074 * @reqtype: hid request type
1088 * @hdev: hid device
1107 int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
1116 int hid_pidff_init(struct hid_device *hid);
1127 #define hid_printk(level, hid, fmt, arg...) \
1128 dev_printk(level, &(hid)->dev, fmt, ##arg)
1129 #define hid_emerg(hid, fmt, arg...) \
1130 dev_emerg(&(hid)->dev, fmt, ##arg)
1131 #define hid_crit(hid, fmt, arg...) \
1132 dev_crit(&(hid)->dev, fmt, ##arg)
1133 #define hid_alert(hid, fmt, arg...) \
1134 dev_alert(&(hid)->dev, fmt, ##arg)
1135 #define hid_err(hid, fmt, arg...) \
1136 dev_err(&(hid)->dev, fmt, ##arg)
1137 #define hid_notice(hid, fmt, arg...) \
1138 dev_notice(&(hid)->dev, fmt, ##arg)
1139 #define hid_warn(hid, fmt, arg...) \
1140 dev_warn(&(hid)->dev, fmt, ##arg)
1141 #define hid_info(hid, fmt, arg...) \
1142 dev_info(&(hid)->dev, fmt, ##arg)
1143 #define hid_dbg(hid, fmt, arg...) \
1144 dev_dbg(&(hid)->dev, fmt, ##arg)
H A Dhid-sensor-hub.h22 #include <linux/hid.h>
23 #include <linux/hid-sensor-ids.h>
71 * @hdev: Stores the hid instance.
115 * Used to open hid device for sensor hub.
123 * Used to clode hid device for sensor hub.
225 /* hid-sensor-attributes */
227 /* Common hid sensor iio structure */
241 /* Convert from hid unit expo to regular exponent */ hid_sensor_convert_exponent()
/linux-4.4.14/drivers/hid/i2c-hid/
H A Di2c-hid.c36 #include <linux/hid.h>
42 #include <linux/i2c/i2c-hid.h>
131 struct hid_device *hid; /* pointer to corresponding HID dev */ member in struct:i2c_hid
415 hid_input_report(ihid->hid, HID_INPUT_REPORT, ihid->inbuf + 2, i2c_hid_get_input()
442 struct hid_device *hid = report->device; i2c_hid_init_report() local
443 struct i2c_client *client = hid->driver_data; i2c_hid_init_report()
463 /* hid->driver_lock is held as we are in probe function, i2c_hid_init_report()
466 hid_report_raw_event(hid, report->type, buffer + 2, size - 2, 1); i2c_hid_init_report()
472 static void i2c_hid_init_reports(struct hid_device *hid) i2c_hid_init_reports() argument
475 struct i2c_client *client = hid->driver_data; i2c_hid_init_reports()
491 &hid->report_enum[HID_FEATURE_REPORT].report_list, list) i2c_hid_init_reports()
502 static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type, i2c_hid_find_max_report() argument
510 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { i2c_hid_find_max_report()
554 static int i2c_hid_get_raw_report(struct hid_device *hid, i2c_hid_get_raw_report() argument
558 struct i2c_client *client = hid->driver_data; i2c_hid_get_raw_report()
590 static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf, i2c_hid_output_raw_report() argument
593 struct i2c_client *client = hid->driver_data; i2c_hid_output_raw_report()
615 static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf, i2c_hid_output_report() argument
618 return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT, i2c_hid_output_report()
622 static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum, i2c_hid_raw_request() argument
628 return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype); i2c_hid_raw_request()
632 return i2c_hid_output_raw_report(hid, buf, len, rtype, true); i2c_hid_raw_request()
638 static int i2c_hid_parse(struct hid_device *hid) i2c_hid_parse() argument
640 struct i2c_client *client = hid->driver_data; i2c_hid_parse()
676 hid_err(hid, "reading report descriptor failed\n"); i2c_hid_parse()
683 ret = hid_parse_report(hid, rdesc, rsize); i2c_hid_parse()
693 static int i2c_hid_start(struct hid_device *hid) i2c_hid_start() argument
695 struct i2c_client *client = hid->driver_data; i2c_hid_start()
700 i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize); i2c_hid_start()
701 i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize); i2c_hid_start()
702 i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize); i2c_hid_start()
713 if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS)) i2c_hid_start()
714 i2c_hid_init_reports(hid); i2c_hid_start()
719 static void i2c_hid_stop(struct hid_device *hid) i2c_hid_stop() argument
721 hid->claimed = 0; i2c_hid_stop()
724 static int i2c_hid_open(struct hid_device *hid) i2c_hid_open() argument
726 struct i2c_client *client = hid->driver_data; i2c_hid_open()
731 if (!hid->open++) { i2c_hid_open()
734 hid->open--; i2c_hid_open()
744 static void i2c_hid_close(struct hid_device *hid) i2c_hid_close() argument
746 struct i2c_client *client = hid->driver_data; i2c_hid_close()
749 /* protecting hid->open to make sure we don't restart i2c_hid_close()
754 if (!--hid->open) { i2c_hid_close()
763 static int i2c_hid_power(struct hid_device *hid, int lvl) i2c_hid_power() argument
765 struct i2c_client *client = hid->driver_data; i2c_hid_power()
821 /* i2c hid fetch using a fixed descriptor size (30 bytes) */ i2c_hid_fetch_hid_descriptor()
914 ret = of_property_read_u32(dev->of_node, "hid-descr-addr", &val); i2c_hid_of_probe()
930 { .compatible = "hid-over-i2c" },
947 struct hid_device *hid; i2c_hid_probe() local
1017 hid = hid_allocate_device(); i2c_hid_probe()
1018 if (IS_ERR(hid)) { i2c_hid_probe()
1019 ret = PTR_ERR(hid); i2c_hid_probe()
1023 ihid->hid = hid; i2c_hid_probe()
1025 hid->driver_data = client; i2c_hid_probe()
1026 hid->ll_driver = &i2c_hid_ll_driver; i2c_hid_probe()
1027 hid->dev.parent = &client->dev; i2c_hid_probe()
1028 hid->bus = BUS_I2C; i2c_hid_probe()
1029 hid->version = le16_to_cpu(ihid->hdesc.bcdVersion); i2c_hid_probe()
1030 hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID); i2c_hid_probe()
1031 hid->product = le16_to_cpu(ihid->hdesc.wProductID); i2c_hid_probe()
1033 snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX", i2c_hid_probe()
1034 client->name, hid->vendor, hid->product); i2c_hid_probe()
1035 strlcpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys)); i2c_hid_probe()
1037 ret = hid_add_device(hid); i2c_hid_probe()
1040 hid_err(client, "can't add hid device: %d\n", ret); i2c_hid_probe()
1048 hid_destroy_device(hid); i2c_hid_probe()
1069 struct hid_device *hid; i2c_hid_remove() local
1076 hid = ihid->hid; i2c_hid_remove()
1077 hid_destroy_device(hid); i2c_hid_remove()
1099 struct hid_device *hid = ihid->hid; i2c_hid_suspend() local
1103 if (hid->driver && hid->driver->suspend) i2c_hid_suspend()
1104 ret = hid->driver->suspend(hid, PMSG_SUSPEND); i2c_hid_suspend()
1112 hid_warn(hid, "Failed to enable irq wake: %d\n", i2c_hid_suspend()
1127 struct hid_device *hid = ihid->hid; i2c_hid_resume() local
1140 hid_warn(hid, "Failed to disable irq wake: %d\n", i2c_hid_resume()
1144 if (hid->driver && hid->driver->reset_resume) { i2c_hid_resume()
1145 ret = hid->driver->reset_resume(hid); i2c_hid_resume()
1182 { "hid", 0 },
/linux-4.4.14/drivers/iio/magnetometer/
H A DMakefile9 obj-$(CONFIG_HID_SENSOR_MAGNETOMETER_3D) += hid-sensor-magn-3d.o
H A Dhid-sensor-magn-3d.c26 #include <linux/hid-sensor-hub.h>
32 #include "../common/hid-sensors/hid-sensor-trigger.h"
/linux-4.4.14/drivers/iio/pressure/
H A DMakefile7 obj-$(CONFIG_HID_SENSOR_PRESS) += hid-sensor-press.o
H A Dhid-sensor-press.c25 #include <linux/hid-sensor-hub.h>
31 #include "../common/hid-sensors/hid-sensor-trigger.h"
/linux-4.4.14/net/bluetooth/hidp/
H A Dcore.c88 } else if (session->hid) { hidp_copy_session()
89 ci->vendor = session->hid->vendor; hidp_copy_session()
90 ci->product = session->hid->product; hidp_copy_session()
91 ci->version = session->hid->version; hidp_copy_session()
92 strlcpy(ci->name, session->hid->name, 128); hidp_copy_session()
227 static int hidp_get_raw_report(struct hid_device *hid, hidp_get_raw_report() argument
232 struct hidp_session *session = hid->driver_data; hidp_get_raw_report()
235 int numbered_reports = hid->report_enum[report_type].numbered; hidp_get_raw_report()
312 static int hidp_set_raw_report(struct hid_device *hid, unsigned char reportnum, hidp_set_raw_report() argument
316 struct hidp_session *session = hid->driver_data; hidp_set_raw_report()
377 static int hidp_output_report(struct hid_device *hid, __u8 *data, size_t count) hidp_output_report() argument
379 struct hidp_session *session = hid->driver_data; hidp_output_report()
386 static int hidp_raw_request(struct hid_device *hid, unsigned char reportnum, hidp_raw_request() argument
392 return hidp_get_raw_report(hid, reportnum, buf, len, rtype); hidp_raw_request()
394 return hidp_set_raw_report(hid, reportnum, buf, len, rtype); hidp_raw_request()
440 hid_input_report(session->hid, type, session->input_buf, len, intr); hidp_process_report()
514 if (session->hid) hidp_process_data()
597 if (session->hid) { hidp_recv_intr_frame()
704 static int hidp_open(struct hid_device *hid) hidp_open() argument
709 static void hidp_close(struct hid_device *hid) hidp_close() argument
713 static int hidp_parse(struct hid_device *hid) hidp_parse() argument
715 struct hidp_session *session = hid->driver_data; hidp_parse()
717 return hid_parse_report(session->hid, session->rd_data, hidp_parse()
721 static int hidp_start(struct hid_device *hid) hidp_start() argument
726 static void hidp_stop(struct hid_device *hid) hidp_stop() argument
728 struct hidp_session *session = hid->driver_data; hidp_stop()
733 hid->claimed = 0; hidp_stop()
746 /* This function sets up the hid device. It does not add it
751 struct hid_device *hid; hidp_setup_hid() local
760 hid = hid_allocate_device(); hidp_setup_hid()
761 if (IS_ERR(hid)) { hidp_setup_hid()
762 err = PTR_ERR(hid); hidp_setup_hid()
766 session->hid = hid; hidp_setup_hid()
768 hid->driver_data = session; hidp_setup_hid()
770 hid->bus = BUS_BLUETOOTH; hidp_setup_hid()
771 hid->vendor = req->vendor; hidp_setup_hid()
772 hid->product = req->product; hidp_setup_hid()
773 hid->version = req->version; hidp_setup_hid()
774 hid->country = req->country; hidp_setup_hid()
776 strncpy(hid->name, req->name, sizeof(req->name) - 1); hidp_setup_hid()
778 snprintf(hid->phys, sizeof(hid->phys), "%pMR", hidp_setup_hid()
784 snprintf(hid->uniq, sizeof(hid->uniq), "%pMR", hidp_setup_hid()
787 hid->dev.parent = &session->conn->hcon->dev; hidp_setup_hid()
788 hid->ll_driver = &hidp_hid_driver; hidp_setup_hid()
790 /* True if device is blacklisted in drivers/hid/hid-core.c */ hidp_setup_hid()
791 if (hid_ignore(hid)) { hidp_setup_hid()
792 hid_destroy_device(session->hid); hidp_setup_hid()
793 session->hid = NULL; hidp_setup_hid()
818 if (!session->hid) { hidp_session_dev_init()
830 if (session->hid) hidp_session_dev_destroy()
831 put_device(&session->hid->dev); hidp_session_dev_destroy()
849 if (session->hid) { hidp_session_dev_add()
850 ret = hid_add_device(session->hid); hidp_session_dev_add()
853 get_device(&session->hid->dev); hidp_session_dev_add()
867 if (session->hid) hidp_session_dev_del()
868 hid_destroy_device(session->hid); hidp_session_dev_del()
1043 if (session->hid) { hidp_session_start_sync()
1044 vendor = session->hid->vendor; hidp_session_start_sync()
1045 product = session->hid->product; hidp_session_start_sync()
H A Dhidp.h27 #include <linux/hid.h>
163 struct hid_device *hid; member in struct:hidp_session
/linux-4.4.14/drivers/mmc/host/
H A Dsdhci-acpi.c177 const char *hid, const char *uid) sdhci_acpi_emmc_probe_slot()
189 if (hid && uid && !strcmp(hid, "80860F14") && !strcmp(uid, "1") && sdhci_acpi_emmc_probe_slot()
198 const char *hid, const char *uid) sdhci_acpi_sdio_probe_slot()
214 const char *hid, const char *uid) sdhci_acpi_sd_probe_slot()
226 if (hid && !strcmp(hid, "80865ACA")) sdhci_acpi_sd_probe_slot()
268 const char *hid; member in struct:sdhci_acpi_uid_slot
305 static const struct sdhci_acpi_slot *sdhci_acpi_get_slot(const char *hid, sdhci_acpi_get_slot() argument
310 for (u = sdhci_acpi_uids; u->hid; u++) { sdhci_acpi_get_slot()
311 if (strcmp(u->hid, hid)) sdhci_acpi_get_slot()
330 const char *hid; sdhci_acpi_probe() local
340 hid = acpi_device_hid(device); sdhci_acpi_probe()
360 c->slot = sdhci_acpi_get_slot(hid, uid); sdhci_acpi_probe()
379 err = c->slot->probe_slot(pdev, hid, uid); sdhci_acpi_probe()
176 sdhci_acpi_emmc_probe_slot(struct platform_device *pdev, const char *hid, const char *uid) sdhci_acpi_emmc_probe_slot() argument
197 sdhci_acpi_sdio_probe_slot(struct platform_device *pdev, const char *hid, const char *uid) sdhci_acpi_sdio_probe_slot() argument
213 sdhci_acpi_sd_probe_slot(struct platform_device *pdev, const char *hid, const char *uid) sdhci_acpi_sd_probe_slot() argument
/linux-4.4.14/drivers/iio/accel/
H A DMakefile10 obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o
H A Dhid-sensor-accel-3d.c26 #include <linux/hid-sensor-hub.h>
32 #include "../common/hid-sensors/hid-sensor-trigger.h"
/linux-4.4.14/drivers/iio/gyro/
H A DMakefile15 obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
H A Dhid-sensor-gyro-3d.c26 #include <linux/hid-sensor-hub.h>
32 #include "../common/hid-sensors/hid-sensor-trigger.h"
/linux-4.4.14/drivers/platform/x86/
H A Dxo15-ebook.c92 const char *hid = acpi_device_hid(device); ebook_switch_add() local
111 if (strcmp(hid, XO15_EBOOK_HID)) { ebook_switch_add()
112 pr_err("Unsupported hid [%s]\n", hid); ebook_switch_add()
120 snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid); ebook_switch_add()
H A Dsurfacepro3_button.c146 const char *hid = acpi_device_hid(device); surface_button_add() local
167 snprintf(button->phys, sizeof(button->phys), "%s/buttons", hid); surface_button_add()
H A Dthinkpad_acpi.c260 const struct acpi_device_id *hid; member in struct:tp_acpi_drv_struct
715 const char *hid, tpacpi_acpi_handle_locate()
724 name, hid ? hid : "NULL"); tpacpi_acpi_handle_locate()
727 status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback, tpacpi_acpi_handle_locate()
817 ibm->acpi->driver->ids = ibm->acpi->hid; register_tpacpi_subdriver()
4110 .hid = ibm_htk_device_ids,
8944 if (ibm->acpi->hid) { ibm_init()
714 tpacpi_acpi_handle_locate(const char *name, const char *hid, acpi_handle *handle) tpacpi_acpi_handle_locate() argument
/linux-4.4.14/drivers/usb/gadget/legacy/
H A DMakefile19 g_hid-y := hid.o
H A Dhid.c2 * hid.c -- HID Composite driver
150 n->fi = usb_get_function_instance("hid"); hid_bind()
/linux-4.4.14/drivers/scsi/snic/
H A Dsnic_ctl.c131 snic->config.hid, 0, (ulong)rqi); snic_queue_exch_ver_req()
162 u32 cmnd_id, hid, max_sgs; snic_io_exch_ver_cmpl_handler() local
168 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); snic_io_exch_ver_cmpl_handler()
169 SNIC_BUG_ON(snic->config.hid != hid); snic_io_exch_ver_cmpl_handler()
182 snic->fwinfo.hid = le32_to_cpu(exv_cmpl->hid); snic_io_exch_ver_cmpl_handler()
190 "vers %u hid %u max_concur_ios %u max_sgs_per_cmd %u max_io_sz %u max_tgts %u fw tmo %u\n", snic_io_exch_ver_cmpl_handler()
192 snic->fwinfo.hid, snic_io_exch_ver_cmpl_handler()
H A Dsnic_res.c61 GET_CONFIG(hid); snic_get_vnic_config()
114 SNIC_INFO("vNIC hid = %d\n", c->hid); snic_get_vnic_config()
H A Dsnic_fwint.h101 __le32 hid; member in struct:snic_io_hdr
114 snic_io_hdr_enc(struct snic_io_hdr *hdr, u8 typ, u8 status, u32 id, u32 hid, snic_io_hdr_enc() argument
120 hdr->hid = cpu_to_le32(hid); snic_io_hdr_enc()
130 u32 *hid, ulong *ctx) snic_io_hdr_dec()
134 *hid = le32_to_cpu(hdr->hid); snic_io_hdr_dec()
177 __le32 hid; member in struct:snic_exch_ver_rsp
129 snic_io_hdr_dec(struct snic_io_hdr *hdr, u8 *typ, u8 *stat, u32 *cmnd_id, u32 *hid, ulong *ctx) snic_io_hdr_dec() argument
H A Dvnic_snic.h52 u8 hid; member in struct:vnic_snic_config
H A Dsnic_disc.c59 snic_report_tgt_init(struct snic_host_req *req, u32 hid, u8 *buf, u32 len, snic_report_tgt_init() argument
65 snic_io_hdr_enc(&req->hdr, SNIC_REQ_REPORT_TGTS, 0, SCSI_NO_TAG, hid, snic_report_tgt_init()
131 snic->config.hid, snic_queue_report_tgt_req()
398 u32 cmnd_id, hid, tgt_cnt = 0; snic_report_tgt_cmpl_handler() local
404 snic_io_hdr_dec(&fwreq->hdr, &typ, &cmpl_stat, &cmnd_id, &hid, &ctx); snic_report_tgt_cmpl_handler()
H A Dsnic_scsi.c211 snic->config.hid, /* hid */ snic_queue_icmnd_req()
548 u32 cmnd_id, hid; snic_icmnd_cmpl_handler() local
558 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); snic_icmnd_cmpl_handler()
563 "Icmnd_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,i ctx = %lx\n", snic_icmnd_cmpl_handler()
564 typ, hdr_stat, cmnd_id, hid, ctx); snic_icmnd_cmpl_handler()
916 u32 hid; snic_itmf_cmpl_handler() local
920 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); snic_itmf_cmpl_handler()
922 "Itmf_cmpl: %s: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,ctx = %lx\n", snic_itmf_cmpl_handler()
923 __func__, typ, hdr_stat, cmnd_id, hid, ctx); snic_itmf_cmpl_handler()
995 u32 hid; snic_hba_reset_cmpl_handler() local
1007 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); snic_hba_reset_cmpl_handler()
1009 "reset_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n", snic_hba_reset_cmpl_handler()
1010 typ, hdr_stat, cmnd_id, hid, ctx); snic_hba_reset_cmpl_handler()
1114 u32 cmnd_id, hid; snic_aen_handler() local
1119 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); snic_aen_handler()
1121 "aen: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n", snic_aen_handler()
1122 typ, hdr_stat, cmnd_id, hid, ctx); snic_aen_handler()
1308 snic->config.hid, snic_queue_itmf_req()
2237 snic->config.hid, 0, (ulong) rqi); snic_issue_hba_reset()
H A Dsnic.h241 u32 hid; /* u16 hid | u16 vnic id */ member in struct:snic_fw_info
/linux-4.4.14/drivers/macintosh/
H A Dadbhid.c756 struct adbhid *hid; adbhid_input_register() local
766 adbhid[id] = hid = kzalloc(sizeof(struct adbhid), GFP_KERNEL); adbhid_input_register()
768 if (!hid || !input_dev) { adbhid_input_register()
773 sprintf(hid->phys, "adb%d:%d.%02x/input", id, default_id, original_handler_id); adbhid_input_register()
775 hid->input = input_dev; adbhid_input_register()
776 hid->id = default_id; adbhid_input_register()
777 hid->original_handler_id = original_handler_id; adbhid_input_register()
778 hid->current_handler_id = current_handler_id; adbhid_input_register()
779 hid->mouse_kind = mouse_kind; adbhid_input_register()
780 hid->flags = 0; adbhid_input_register()
781 input_set_drvdata(input_dev, hid); adbhid_input_register()
782 input_dev->name = hid->name; adbhid_input_register()
783 input_dev->phys = hid->phys; adbhid_input_register()
791 hid->keycode = kmalloc(sizeof(adb_to_linux_keycodes), GFP_KERNEL); adbhid_input_register()
792 if (!hid->keycode) { adbhid_input_register()
797 sprintf(hid->name, "ADB keyboard"); adbhid_input_register()
799 memcpy(hid->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes)); adbhid_input_register()
820 i = hid->keycode[10]; adbhid_input_register()
821 hid->keycode[10] = hid->keycode[50]; adbhid_input_register()
822 hid->keycode[50] = i; adbhid_input_register()
833 if (hid->keycode[i]) adbhid_input_register()
834 set_bit(hid->keycode[i], input_dev->keybit); adbhid_input_register()
842 input_dev->keycodesize = sizeof(hid->keycode[0]); adbhid_input_register()
846 sprintf(hid->name, "ADB mouse"); adbhid_input_register()
857 sprintf(hid->name, "ADB adjustable keyboard buttons"); adbhid_input_register()
866 sprintf(hid->name, "ADB Powerbook buttons"); adbhid_input_register()
881 if (hid->name[0]) adbhid_input_register()
891 input_dev->keycode = hid->keycode; adbhid_input_register()
908 if (hid) { adbhid_input_register()
909 kfree(hid->keycode); adbhid_input_register()
910 kfree(hid); adbhid_input_register()
/linux-4.4.14/drivers/acpi/
H A Dioapic.c68 char *hid = NULL; acpi_is_ioapic() local
77 hid = info->hardware_id.string; acpi_is_ioapic()
78 if (hid) { acpi_is_ioapic()
79 if (strcmp(hid, "ACPI0009") == 0) { acpi_is_ioapic()
82 } else if (strcmp(hid, "ACPI000A") == 0) { acpi_is_ioapic()
H A Dbutton.c347 const char *hid = acpi_device_hid(device); acpi_button_add() local
366 if (!strcmp(hid, ACPI_BUTTON_HID_POWER) || acpi_button_add()
367 !strcmp(hid, ACPI_BUTTON_HID_POWERF)) { acpi_button_add()
372 } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) || acpi_button_add()
373 !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) { acpi_button_add()
378 } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) { acpi_button_add()
384 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid); acpi_button_add()
393 snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid); acpi_button_add()
H A Ddevice_sysfs.c130 * create_pnp_modalias - Create hid/cid(s) string for modalias and uevent
135 * Creates hid/cid(s) string needed for modalias and uevent
136 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
282 * hid:IBM0001 and cid:ACPI0001 you get: "acpi:IBM0001:ACPI0001".
327 * hid:IBM0001 and cid:ACPI0001 you get: "acpi:IBM0001:ACPI0001".
405 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
H A Dsleep.c385 const char *hid = acpi_device_hid(device); find_powerf_dev() local
387 return !strcmp(hid, ACPI_BUTTON_HID_POWERF); find_powerf_dev()
H A Dscan.c1149 struct acpi_hardware_id *hid; acpi_device_hid() local
1154 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list); acpi_device_hid()
1155 return hid->id; acpi_device_hid()
/linux-4.4.14/drivers/usb/gadget/function/
H A Du_hid.h4 * Utility definitions for the hid function
H A Df_hid.c14 #include <linux/hid.h>
952 hidg->func.name = "hid"; hidg_alloc()
966 DECLARE_USB_FUNCTION_INIT(hid, hidg_alloc_inst, hidg_alloc);
/linux-4.4.14/include/linux/i2c/
H A Di2c-hid.h18 * struct i2chid_platform_data - used by hid over i2c implementation.
/linux-4.4.14/arch/powerpc/kvm/
H A Dbook3s_emulate.c400 to_book3s(vcpu)->hid[0] = spr_val; kvmppc_core_emulate_mtspr_pr()
403 to_book3s(vcpu)->hid[1] = spr_val; kvmppc_core_emulate_mtspr_pr()
406 to_book3s(vcpu)->hid[2] = spr_val; kvmppc_core_emulate_mtspr_pr()
409 to_book3s(vcpu)->hid[2] = spr_val; kvmppc_core_emulate_mtspr_pr()
434 to_book3s(vcpu)->hid[4] = spr_val; kvmppc_core_emulate_mtspr_pr()
437 to_book3s(vcpu)->hid[5] = spr_val; kvmppc_core_emulate_mtspr_pr()
549 *spr_val = to_book3s(vcpu)->hid[0]; kvmppc_core_emulate_mfspr_pr()
552 *spr_val = to_book3s(vcpu)->hid[1]; kvmppc_core_emulate_mfspr_pr()
556 *spr_val = to_book3s(vcpu)->hid[2]; kvmppc_core_emulate_mfspr_pr()
560 *spr_val = to_book3s(vcpu)->hid[4]; kvmppc_core_emulate_mfspr_pr()
563 *spr_val = to_book3s(vcpu)->hid[5]; kvmppc_core_emulate_mfspr_pr()
H A Dbook3s_64_mmu.c653 return (to_book3s(vcpu)->hid[5] & 0x80); kvmppc_mmu_book3s_64_is_dcbz32()
/linux-4.4.14/drivers/acpi/acpica/
H A Dutids.c73 struct acpi_pnp_device_id *hid; acpi_ut_execute_HID() local
96 hid = acpi_ut_execute_HID()
99 if (!hid) { acpi_ut_execute_HID()
106 hid->string = acpi_ut_execute_HID()
107 ACPI_ADD_PTR(char, hid, sizeof(struct acpi_pnp_device_id)); acpi_ut_execute_HID()
112 acpi_ex_eisa_id_to_string(hid->string, obj_desc->integer.value); acpi_ut_execute_HID()
114 strcpy(hid->string, obj_desc->string.pointer); acpi_ut_execute_HID()
117 hid->length = length; acpi_ut_execute_HID()
118 *return_id = hid; acpi_ut_execute_HID()
H A Dnsxfname.c280 struct acpi_pnp_device_id *hid = NULL; acpi_get_object_info() local
337 status = acpi_ut_execute_HID(node, &hid); acpi_get_object_info()
339 info_size += hid->length; acpi_get_object_info()
465 if (hid) { acpi_get_object_info()
467 hid, next_id_string); acpi_get_object_info()
469 if (acpi_ut_is_pci_root_bridge(hid->string)) { acpi_get_object_info()
519 if (hid) { acpi_get_object_info()
520 ACPI_FREE(hid); acpi_get_object_info()
H A Devrgnini.c352 struct acpi_pnp_device_id *hid; acpi_ev_is_pci_root_bridge() local
359 status = acpi_ut_execute_HID(node, &hid); acpi_ev_is_pci_root_bridge()
364 match = acpi_ut_is_pci_root_bridge(hid->string); acpi_ev_is_pci_root_bridge()
365 ACPI_FREE(hid); acpi_ev_is_pci_root_bridge()
H A Dnsxfeval.c656 struct acpi_pnp_device_id *hid; acpi_ns_get_device_callback() local
691 if (info->hid != NULL) { acpi_ns_get_device_callback()
692 status = acpi_ut_execute_HID(node, &hid); acpi_ns_get_device_callback()
699 no_match = strcmp(hid->string, info->hid); acpi_ns_get_device_callback()
700 ACPI_FREE(hid); acpi_ns_get_device_callback()
718 if (strcmp(cid->ids[i].string, info->hid) == 0) { acpi_ns_get_device_callback()
803 info.hid = HID; acpi_get_devices()
H A Dacstruct.h150 const char *hid; member in struct:acpi_get_devices_info
H A Dacutils.h703 const struct ah_device_id *acpi_ah_match_hardware_id(char *hid);
/linux-4.4.14/include/uapi/linux/
H A Dhidraw.h18 #include <linux/hid.h>
H A Duhid.h24 #include <linux/hid.h>
H A Dhiddev.h37 unsigned hid; member in struct:hiddev_event
/linux-4.4.14/drivers/usb/serial/
H A Dcypress_m8.h61 * These are sent / read at byte 0 of the input/output hid reports.
H A Dcypress_m8.c23 /* Thanks to cypress for providing references for the hid reports. */
/linux-4.4.14/drivers/xen/
H A Dxen-acpi-cpuhotplug.c319 char *hid; is_processor_device() local
336 hid = info->hardware_id.string; is_processor_device()
337 if ((hid == NULL) || strcmp(hid, ACPI_PROCESSOR_DEVICE_HID)) { is_processor_device()
/linux-4.4.14/drivers/iio/light/
H A Dhid-sensor-als.c26 #include <linux/hid-sensor-hub.h>
32 #include "../common/hid-sensors/hid-sensor-trigger.h"
H A Dhid-sensor-prox.c25 #include <linux/hid-sensor-hub.h>
31 #include "../common/hid-sensors/hid-sensor-trigger.h"
/linux-4.4.14/drivers/iio/orientation/
H A Dhid-sensor-rotation.c21 #include <linux/hid-sensor-hub.h>
27 #include "../common/hid-sensors/hid-sensor-trigger.h"
H A Dhid-sensor-incl-3d.c26 #include <linux/hid-sensor-hub.h>
32 #include "../common/hid-sensors/hid-sensor-trigger.h"
/linux-4.4.14/drivers/rtc/
H A Drtc-hid-sensor-time.c22 #include <linux/hid-sensor-hub.h>
291 "hid-sensor-time", &hid_time_rtc_ops, hid_time_probe()
H A DMakefile69 obj-$(CONFIG_RTC_DRV_HID_SENSOR_TIME) += rtc-hid-sensor-time.o
/linux-4.4.14/sound/pci/asihpi/
H A Dhpios.h80 /* Conflict?: H is already used by a number of drivers hid, bluetooth hci,
/linux-4.4.14/drivers/media/radio/si470x/
H A Dradio-si470x-common.c43 * - blacklisted si470x in hid-quirks.c
96 * - blacklisted KWorld radio in hid-core.c and hid-ids.h
H A Dradio-si470x-usb.c38 #include <linux/hid.h>
/linux-4.4.14/drivers/char/tpm/
H A Dtpm_tis.c106 static int has_hid(struct acpi_device *dev, const char *hid) has_hid() argument
111 if (!strcmp(hid, id->id)) has_hid()
994 module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
996 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
/linux-4.4.14/drivers/input/touchscreen/
H A Datmel_mxt_ts.c2463 const char *hid; member in struct:mxt_acpi_platform_data
2477 .hid = "ATML0000",
2485 .hid = "ATML0001",
2502 .hid = "ATML0000",
2510 .hid = "ATML0001",
2567 while (acpi_pdata->hid) { mxt_parse_acpi()
2568 if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid)) mxt_parse_acpi()
H A Delants_i2c.c7 * This code is partly based on hid-multitouch.c:
14 * This code is partly based on i2c-hid.c:
H A Dsur40.c12 * and from the generic hid-multitouch driver,
H A Dusbtouchscreen.c56 #include <linux/hid.h>
/linux-4.4.14/drivers/nfc/st-nci/
H A Dse.c218 * - source hid (1byte) st_nci_hci_load_session()
220 * - destination hid (1byte) st_nci_hci_load_session()
/linux-4.4.14/drivers/nfc/st21nfca/
H A Dcore.c172 * - source hid (1byte) st21nfca_hci_load_session()
174 * - destination hid (1byte) st21nfca_hci_load_session()
/linux-4.4.14/drivers/usb/misc/
H A Didmouse.c344 /* check if we have gotten the data or the hid interface */ idmouse_probe()
H A Dyurex.c20 #include <linux/hid.h>
/linux-4.4.14/drivers/media/radio/
H A Dradio-keene.c319 * the Logitech AudioHub Speaker, but it should ignore the hid. usb_keene_probe()
H A Dradio-raremono.c24 #include <linux/hid.h>
H A Dradio-mr800.c39 * in usbhid/hid-quirks.c
/linux-4.4.14/samples/uhid/
H A Duhid-example.c107 * This information can be verified by reading /sys/kernel/debug/hid/<dev>/rdesc
/linux-4.4.14/arch/powerpc/include/asm/
H A Dkvm_book3s.h81 u64 hid[6]; member in struct:kvmppc_vcpu_book3s
/linux-4.4.14/scripts/mod/
H A Dfile2alias.c374 /* Looks like: hid:bNvNpN */ do_hid_entry()
383 sprintf(alias, "hid:"); do_hid_entry()
391 ADD_TO_DEVTABLE("hid", hid_device_id, do_hid_entry);
/linux-4.4.14/drivers/input/mouse/
H A Dsynaptics_usb.c16 * drivers/hid/usbhid/usbmouse.c by Vojtech Pavlik
H A Dbcm5974.c41 #include <linux/hid.h>
788 * probe. However, the hid module may also alter the state of the
/linux-4.4.14/sound/soc/intel/atom/sst/
H A Dsst.h516 struct sst_platform_info *sst_get_acpi_driver_data(const char *hid);
/linux-4.4.14/drivers/watchdog/
H A Dpcwd_usb.c44 #include <linux/hid.h> /* For HID_REQ_SET_REPORT & HID_DT_REPORT */
/linux-4.4.14/drivers/input/tablet/
H A Dgtco.c892 "Can't retrieve exta USB descriptor to get hid report descriptor length\n"); gtco_probe()

Completed in 3214 milliseconds

12