/linux-4.4.14/drivers/hid/ |
H A D | Makefile | 4 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 D | hid-tivo.c | 5 * 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 D | hid-penmount.c | 6 * 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 D | hid-lg4ff.h | 5 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 D | hid-lg4ff.c | 29 #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 D | hid-kensington.c | 16 #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 D | hid-emsff.c | 24 #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 D | hid-betopff.c | 32 #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 D | hid-sjoy.c | 6 * 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 D | hid-elecom.c | 5 * (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 D | hid-zpff.c | 24 #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 D | hid-lcpower.c | 5 * 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 D | hid-xinmo.c | 5 * -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 D | hid-gaff.c | 32 #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 D | hid-input.c | 32 #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 D | hid-appleir.c | 27 #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 D | hid-axff.c | 32 #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 D | uhid.c | 17 #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 D | hid-gyration.c | 20 #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 D | hid-petalynx.c | 19 #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 D | hid-lgff.c | 2 * 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 D | hid-lg2ff.c | 26 #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 D | hid-belkin.c | 19 #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 D | hid-cherry.c | 19 #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 D | hid-ezkey.c | 20 #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 D | hid-monterey.c | 19 #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 D | hid-sunplus.c | 19 #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 D | hid-pl.c | 41 #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 D | hid-tmff.c | 30 #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 D | hid-aureal.c | 15 #include <linux/hid.h> 18 #include "hid-ids.h" 34 MODULE_DEVICE_TABLE(hid, aureal_devices);
|
H A D | hid-generic.c | 25 #include <linux/hid.h> 31 MODULE_DEVICE_TABLE(hid, hid_table); 34 .name = "hid-generic",
|
H A D | hid-lg3ff.c | 25 #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 D | hid-primax.c | 20 #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 D | hid-topseed.c | 5 * 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 D | hid-holtekff.c | 26 #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 D | hidraw.c | 5 * 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 D | hid-chicony.c | 21 #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 D | hid-roccat.c | 18 * 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 D | hid-steelseries.c | 15 #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 D | hid-core.c | 34 #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 D | hid-a4tech.c | 20 #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 D | hid-gfrm.c | 14 #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 D | hid-twinhan.c | 4 * 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 D | hid-microsoft.c | 20 #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 D | hid-speedlink.c | 17 #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 D | hid-keytouch.c | 15 #include <linux/hid.h> 18 #include "hid-ids.h" 45 MODULE_DEVICE_TABLE(hid, keytouch_devices);
|
H A D | hid-ortek.c | 22 #include <linux/hid.h> 25 #include "hid-ids.h" 46 MODULE_DEVICE_TABLE(hid, ortek_devices);
|
H A D | hid-multitouch.c | 9 * 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 D | hid-dr.c | 32 #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 D | hid-cypress.c | 19 #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 D | hid-icade.c | 16 #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 D | hid-plantronics.c | 15 #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 D | hid-samsung.c | 15 * 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 D | hid-roccat-lua.c | 21 #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 D | hid-roccat-savu.c | 20 #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 D | hid-zydacron.c | 15 #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 D | hid-holtek-mouse.c | 15 #include <linux/hid.h> 19 #include "hid-ids.h" 83 MODULE_DEVICE_TABLE(hid, holtek_mouse_devices);
|
H A D | hid-hyperv.c | 20 #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 D | hid-holtek-kbd.c | 14 #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 D | hid-roccat-konepure.c | 21 #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 D | hid-roccat-ryos.c | 17 #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 D | hid-apple.c | 21 #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 D | hid-gembird.c | 16 #include <linux/hid.h> 19 #include "hid-ids.h" 105 MODULE_DEVICE_TABLE(hid, gembird_devices);
|
H A D | hid-logitech-dj.c | 26 #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 D | hid-picolcd_cir.c | 20 #include <linux/hid.h> 21 #include <linux/hid-debug.h> 23 #include "hid-ids.h" 40 #include "hid-picolcd.h"
|
H A D | hid-picolcd_leds.c | 20 #include <linux/hid.h> 21 #include <linux/hid-debug.h> 23 #include "hid-ids.h" 39 #include "hid-picolcd.h"
|
H A D | hid-saitek.c | 7 * (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 D | hid-picolcd_lcd.c | 20 #include <linux/hid.h> 25 #include "hid-picolcd.h"
|
H A D | hid-lenovo.c | 21 #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 D | hid-sensor-hub.c | 20 #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 D | hid-lg.c | 20 #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 D | hid-roccat-arvo.c | 21 #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 D | hid-roccat-isku.c | 21 #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 D | hid-corsair.c | 17 #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 D | hid-picolcd_backlight.c | 20 #include <linux/hid.h> 25 #include "hid-picolcd.h"
|
H A D | hid-roccat-common.c | 14 #include <linux/hid.h> 17 #include "hid-roccat-common.h"
|
H A D | hid-ntrig.c | 17 #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 D | hid-roccat-koneplus.c | 22 #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 D | hid-roccat-kovaplus.c | 20 #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 D | hid-roccat-pyra.c | 22 #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 D | hid-debug.c | 39 #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 D | hid-roccat-pyra.h | 89 /* hid audio controls */
|
H A D | hid-elo.c | 11 #include <linux/hid.h> 17 #include "hid-ids.h" 273 MODULE_DEVICE_TABLE(hid, elo_devices);
|
H A D | hid-gt683r.c | 19 #include <linux/hid.h> 24 #include "hid-ids.h" 256 hid_err(hdev, "hid parsing failed\n"); gt683r_led_probe()
|
H A D | hid-rmi.c | 14 #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 D | hid-thingm.c | 12 #include <linux/hid.h> 19 #include "hid-ids.h" 300 MODULE_DEVICE_TABLE(hid, thingm_table);
|
H A D | hid-prodikeys.c | 25 #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 D | hid-roccat-kone.c | 30 #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 D | hid-picolcd_core.c | 20 #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 D | hid-logitech-hidpp.c | 18 #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 D | hid-magicmouse.c | 18 #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 D | hid-wiimote-debug.c | 18 #include "hid-wiimote.h"
|
H A D | wacom_wac.h | 13 #include <linux/hid.h>
|
H A D | wacom_wac.c | 1511 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 D | hid-kye.c | 17 #include <linux/hid.h> 20 #include "hid-ids.h" 602 MODULE_DEVICE_TABLE(hid, kye_devices);
|
H A D | hid-sensor-custom.c | 2 * 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 D | hid-picolcd_fb.c | 20 #include <linux/hid.h> 26 #include "hid-picolcd.h"
|
H A D | hid-cp2112.c | 2 * 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 D | hid-uclogic.c | 16 #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 D | hid-wiimote.h | 18 #include <linux/hid.h>
|
H A D | wacom.h | 92 #include <linux/hid.h>
|
H A D | hid-sony.c | 30 #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 D | hid-wiimote-core.c | 15 #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 D | wacom_sys.c | 122 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 D | hid-picolcd_debugfs.c | 20 #include <linux/hid.h> 21 #include <linux/hid-debug.h> 30 #include "hid-picolcd.h"
|
H A D | hid-waltop.c | 15 #include <linux/hid.h> 18 #include "hid-ids.h" 774 MODULE_DEVICE_TABLE(hid, waltop_devices);
|
H A D | hid-wiimote-modules.c | 37 #include <linux/hid.h> 40 #include "hid-wiimote.h"
|
/linux-4.4.14/drivers/iio/common/hid-sensors/ |
H A D | Makefile | 5 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 D | hid-sensor-trigger.c | 26 #include <linux/hid-sensor-hub.h> 30 #include "hid-sensor-trigger.h"
|
H A D | hid-sensor-attributes.c | 25 #include <linux/hid-sensor-hub.h>
|
/linux-4.4.14/drivers/hid/usbhid/ |
H A D | Makefile | 5 usbhid-y := hid-core.o hid-quirks.o 7 usbhid-$(CONFIG_HID_PID) += hid-pidff.o
|
H A D | hid-core.c | 35 #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 D | hiddev.c | 34 #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 D | hid-pidff.c | 31 #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 D | usbhid.h | 36 /* 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 D | usbmouse.c | 32 #include <linux/hid.h> 36 #include "../hid-ids.h"
|
H A D | hid-quirks.c | 18 #include <linux/hid.h> 22 #include "../hid-ids.h"
|
H A D | usbkbd.c | 34 #include <linux/hid.h>
|
/linux-4.4.14/samples/hidraw/ |
H A D | Makefile | 5 hostprogs-y := hid-example 12 all: hid-example
|
/linux-4.4.14/include/linux/ |
H A D | hiddev.h | 41 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 D | hid-roccat.h | 15 #include <linux/hid.h> 22 int roccat_connect(struct class *klass, struct hid_device *hid,
|
H A D | hidraw.h | 24 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 D | hid.h | 38 #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 D | hid-sensor-hub.h | 22 #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 D | i2c-hid.c | 36 #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 D | Makefile | 9 obj-$(CONFIG_HID_SENSOR_MAGNETOMETER_3D) += hid-sensor-magn-3d.o
|
H A D | hid-sensor-magn-3d.c | 26 #include <linux/hid-sensor-hub.h> 32 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
/linux-4.4.14/drivers/iio/pressure/ |
H A D | Makefile | 7 obj-$(CONFIG_HID_SENSOR_PRESS) += hid-sensor-press.o
|
H A D | hid-sensor-press.c | 25 #include <linux/hid-sensor-hub.h> 31 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
/linux-4.4.14/net/bluetooth/hidp/ |
H A D | core.c | 88 } 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 D | hidp.h | 27 #include <linux/hid.h> 163 struct hid_device *hid; member in struct:hidp_session
|
/linux-4.4.14/drivers/mmc/host/ |
H A D | sdhci-acpi.c | 177 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 D | Makefile | 10 obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o
|
H A D | hid-sensor-accel-3d.c | 26 #include <linux/hid-sensor-hub.h> 32 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
/linux-4.4.14/drivers/iio/gyro/ |
H A D | Makefile | 15 obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
|
H A D | hid-sensor-gyro-3d.c | 26 #include <linux/hid-sensor-hub.h> 32 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
/linux-4.4.14/drivers/platform/x86/ |
H A D | xo15-ebook.c | 92 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 D | surfacepro3_button.c | 146 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 D | thinkpad_acpi.c | 260 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 D | Makefile | 19 g_hid-y := hid.o
|
H A D | hid.c | 2 * hid.c -- HID Composite driver 150 n->fi = usb_get_function_instance("hid"); hid_bind()
|
/linux-4.4.14/drivers/scsi/snic/ |
H A D | snic_ctl.c | 131 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 D | snic_res.c | 61 GET_CONFIG(hid); snic_get_vnic_config() 114 SNIC_INFO("vNIC hid = %d\n", c->hid); snic_get_vnic_config()
|
H A D | snic_fwint.h | 101 __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 D | vnic_snic.h | 52 u8 hid; member in struct:vnic_snic_config
|
H A D | snic_disc.c | 59 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 D | snic_scsi.c | 211 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 D | snic.h | 241 u32 hid; /* u16 hid | u16 vnic id */ member in struct:snic_fw_info
|
/linux-4.4.14/drivers/macintosh/ |
H A D | adbhid.c | 756 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 D | ioapic.c | 68 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 D | button.c | 347 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 D | device_sysfs.c | 130 * 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 D | sleep.c | 385 const char *hid = acpi_device_hid(device); find_powerf_dev() local 387 return !strcmp(hid, ACPI_BUTTON_HID_POWERF); find_powerf_dev()
|
H A D | scan.c | 1149 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 D | u_hid.h | 4 * Utility definitions for the hid function
|
H A D | f_hid.c | 14 #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 D | i2c-hid.h | 18 * struct i2chid_platform_data - used by hid over i2c implementation.
|
/linux-4.4.14/arch/powerpc/kvm/ |
H A D | book3s_emulate.c | 400 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 D | book3s_64_mmu.c | 653 return (to_book3s(vcpu)->hid[5] & 0x80); kvmppc_mmu_book3s_64_is_dcbz32()
|
/linux-4.4.14/drivers/acpi/acpica/ |
H A D | utids.c | 73 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 D | nsxfname.c | 280 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 D | evrgnini.c | 352 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 D | nsxfeval.c | 656 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 D | acstruct.h | 150 const char *hid; member in struct:acpi_get_devices_info
|
H A D | acutils.h | 703 const struct ah_device_id *acpi_ah_match_hardware_id(char *hid);
|
/linux-4.4.14/include/uapi/linux/ |
H A D | hidraw.h | 18 #include <linux/hid.h>
|
H A D | uhid.h | 24 #include <linux/hid.h>
|
H A D | hiddev.h | 37 unsigned hid; member in struct:hiddev_event
|
/linux-4.4.14/drivers/usb/serial/ |
H A D | cypress_m8.h | 61 * These are sent / read at byte 0 of the input/output hid reports.
|
H A D | cypress_m8.c | 23 /* Thanks to cypress for providing references for the hid reports. */
|
/linux-4.4.14/drivers/xen/ |
H A D | xen-acpi-cpuhotplug.c | 319 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 D | hid-sensor-als.c | 26 #include <linux/hid-sensor-hub.h> 32 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
H A D | hid-sensor-prox.c | 25 #include <linux/hid-sensor-hub.h> 31 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
/linux-4.4.14/drivers/iio/orientation/ |
H A D | hid-sensor-rotation.c | 21 #include <linux/hid-sensor-hub.h> 27 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
H A D | hid-sensor-incl-3d.c | 26 #include <linux/hid-sensor-hub.h> 32 #include "../common/hid-sensors/hid-sensor-trigger.h"
|
/linux-4.4.14/drivers/rtc/ |
H A D | rtc-hid-sensor-time.c | 22 #include <linux/hid-sensor-hub.h> 291 "hid-sensor-time", &hid_time_rtc_ops, hid_time_probe()
|
H A D | Makefile | 69 obj-$(CONFIG_RTC_DRV_HID_SENSOR_TIME) += rtc-hid-sensor-time.o
|
/linux-4.4.14/sound/pci/asihpi/ |
H A D | hpios.h | 80 /* Conflict?: H is already used by a number of drivers hid, bluetooth hci,
|
/linux-4.4.14/drivers/media/radio/si470x/ |
H A D | radio-si470x-common.c | 43 * - blacklisted si470x in hid-quirks.c 96 * - blacklisted KWorld radio in hid-core.c and hid-ids.h
|
H A D | radio-si470x-usb.c | 38 #include <linux/hid.h>
|
/linux-4.4.14/drivers/char/tpm/ |
H A D | tpm_tis.c | 106 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 D | atmel_mxt_ts.c | 2463 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 D | elants_i2c.c | 7 * This code is partly based on hid-multitouch.c: 14 * This code is partly based on i2c-hid.c:
|
H A D | sur40.c | 12 * and from the generic hid-multitouch driver,
|
H A D | usbtouchscreen.c | 56 #include <linux/hid.h>
|
/linux-4.4.14/drivers/nfc/st-nci/ |
H A D | se.c | 218 * - 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 D | core.c | 172 * - source hid (1byte) st21nfca_hci_load_session() 174 * - destination hid (1byte) st21nfca_hci_load_session()
|
/linux-4.4.14/drivers/usb/misc/ |
H A D | idmouse.c | 344 /* check if we have gotten the data or the hid interface */ idmouse_probe()
|
H A D | yurex.c | 20 #include <linux/hid.h>
|
/linux-4.4.14/drivers/media/radio/ |
H A D | radio-keene.c | 319 * the Logitech AudioHub Speaker, but it should ignore the hid. usb_keene_probe()
|
H A D | radio-raremono.c | 24 #include <linux/hid.h>
|
H A D | radio-mr800.c | 39 * in usbhid/hid-quirks.c
|
/linux-4.4.14/samples/uhid/ |
H A D | uhid-example.c | 107 * This information can be verified by reading /sys/kernel/debug/hid/<dev>/rdesc
|
/linux-4.4.14/arch/powerpc/include/asm/ |
H A D | kvm_book3s.h | 81 u64 hid[6]; member in struct:kvmppc_vcpu_book3s
|
/linux-4.4.14/scripts/mod/ |
H A D | file2alias.c | 374 /* 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 D | synaptics_usb.c | 16 * drivers/hid/usbhid/usbmouse.c by Vojtech Pavlik
|
H A D | bcm5974.c | 41 #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 D | sst.h | 516 struct sst_platform_info *sst_get_acpi_driver_data(const char *hid);
|
/linux-4.4.14/drivers/watchdog/ |
H A D | pcwd_usb.c | 44 #include <linux/hid.h> /* For HID_REQ_SET_REPORT & HID_DT_REPORT */
|
/linux-4.4.14/drivers/input/tablet/ |
H A D | gtco.c | 892 "Can't retrieve exta USB descriptor to get hid report descriptor length\n"); gtco_probe()
|