hid               108 arch/powerpc/include/asm/kvm_book3s.h 	u64 hid[6];
hid               663 arch/powerpc/kvm/book3s_64_mmu.c 	return (to_book3s(vcpu)->hid[5] & 0x80);
hid               716 arch/powerpc/kvm/book3s_emulate.c 		to_book3s(vcpu)->hid[0] = spr_val;
hid               719 arch/powerpc/kvm/book3s_emulate.c 		to_book3s(vcpu)->hid[1] = spr_val;
hid               722 arch/powerpc/kvm/book3s_emulate.c 		to_book3s(vcpu)->hid[2] = spr_val;
hid               725 arch/powerpc/kvm/book3s_emulate.c 		to_book3s(vcpu)->hid[2] = spr_val;
hid               750 arch/powerpc/kvm/book3s_emulate.c 		to_book3s(vcpu)->hid[4] = spr_val;
hid               753 arch/powerpc/kvm/book3s_emulate.c 		to_book3s(vcpu)->hid[5] = spr_val;
hid               899 arch/powerpc/kvm/book3s_emulate.c 		*spr_val = to_book3s(vcpu)->hid[0];
hid               902 arch/powerpc/kvm/book3s_emulate.c 		*spr_val = to_book3s(vcpu)->hid[1];
hid               906 arch/powerpc/kvm/book3s_emulate.c 		*spr_val = to_book3s(vcpu)->hid[2];
hid               910 arch/powerpc/kvm/book3s_emulate.c 		*spr_val = to_book3s(vcpu)->hid[4];
hid               913 arch/powerpc/kvm/book3s_emulate.c 		*spr_val = to_book3s(vcpu)->hid[5];
hid                48 drivers/acpi/ac.c 	const char *hid;
hid               441 drivers/acpi/ac.c 			if (acpi_dev_present(acpi_ac_blacklist[i].hid, "1",
hid               444 drivers/acpi/ac.c 					acpi_ac_blacklist[i].hid);
hid               530 drivers/acpi/acpi_lpss.c 	const char *hid;
hid               542 drivers/acpi/acpi_lpss.c 	return hid_uid_match(adev, id->hid, id->uid);
hid               545 drivers/acpi/acpi_lpss.c static struct device *acpi_lpss_find_device(const char *hid, const char *uid)
hid               550 drivers/acpi/acpi_lpss.c 		.hid = hid,
hid               119 drivers/acpi/acpica/acstruct.h 	const char *hid;
hid               729 drivers/acpi/acpica/acutils.h const struct ah_device_id *acpi_ah_match_hardware_id(char *hid);
hid               315 drivers/acpi/acpica/evrgnini.c 	struct acpi_pnp_device_id *hid;
hid               322 drivers/acpi/acpica/evrgnini.c 	status = acpi_ut_execute_HID(node, &hid);
hid               327 drivers/acpi/acpica/evrgnini.c 	match = acpi_ut_is_pci_root_bridge(hid->string);
hid               328 drivers/acpi/acpica/evrgnini.c 	ACPI_FREE(hid);
hid               643 drivers/acpi/acpica/nsxfeval.c 	struct acpi_pnp_device_id *hid;
hid               678 drivers/acpi/acpica/nsxfeval.c 	if (info->hid != NULL) {
hid               679 drivers/acpi/acpica/nsxfeval.c 		status = acpi_ut_execute_HID(node, &hid);
hid               686 drivers/acpi/acpica/nsxfeval.c 		no_match = strcmp(hid->string, info->hid);
hid               687 drivers/acpi/acpica/nsxfeval.c 		ACPI_FREE(hid);
hid               705 drivers/acpi/acpica/nsxfeval.c 				if (strcmp(cid->ids[i].string, info->hid) == 0) {
hid               790 drivers/acpi/acpica/nsxfeval.c 	info.hid = HID;
hid               232 drivers/acpi/acpica/nsxfname.c 	struct acpi_pnp_device_id *hid = NULL;
hid               288 drivers/acpi/acpica/nsxfname.c 		status = acpi_ut_execute_HID(node, &hid);
hid               290 drivers/acpi/acpica/nsxfname.c 			info_size += hid->length;
hid               395 drivers/acpi/acpica/nsxfname.c 	if (hid) {
hid               397 drivers/acpi/acpica/nsxfname.c 							hid, next_id_string);
hid               399 drivers/acpi/acpica/nsxfname.c 		if (acpi_ut_is_pci_root_bridge(hid->string)) {
hid               444 drivers/acpi/acpica/nsxfname.c 	if (hid) {
hid               445 drivers/acpi/acpica/nsxfname.c 		ACPI_FREE(hid);
hid                39 drivers/acpi/acpica/utids.c 	struct acpi_pnp_device_id *hid;
hid                62 drivers/acpi/acpica/utids.c 	hid =
hid                65 drivers/acpi/acpica/utids.c 	if (!hid) {
hid                72 drivers/acpi/acpica/utids.c 	hid->string =
hid                73 drivers/acpi/acpica/utids.c 	    ACPI_ADD_PTR(char, hid, sizeof(struct acpi_pnp_device_id));
hid                78 drivers/acpi/acpica/utids.c 		acpi_ex_eisa_id_to_string(hid->string, obj_desc->integer.value);
hid                80 drivers/acpi/acpica/utids.c 		strcpy(hid->string, obj_desc->string.pointer);
hid                83 drivers/acpi/acpica/utids.c 	hid->length = length;
hid                84 drivers/acpi/acpica/utids.c 	*return_id = hid;
hid               493 drivers/acpi/button.c 	const char *hid = acpi_device_hid(device);
hid               497 drivers/acpi/button.c 	if (!strcmp(hid, ACPI_BUTTON_HID_LID) && dmi_check_system(lid_blacklst))
hid               515 drivers/acpi/button.c 	if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
hid               516 drivers/acpi/button.c 	    !strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
hid               521 drivers/acpi/button.c 	} else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
hid               522 drivers/acpi/button.c 		   !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
hid               527 drivers/acpi/button.c 	} else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
hid               534 drivers/acpi/button.c 		printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
hid               543 drivers/acpi/button.c 	snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
hid               407 drivers/acpi/device_sysfs.c static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
hid                71 drivers/acpi/ioapic.c 	char *hid = NULL;
hid                80 drivers/acpi/ioapic.c 			hid = info->hardware_id.string;
hid                81 drivers/acpi/ioapic.c 		if (hid) {
hid                82 drivers/acpi/ioapic.c 			if (strcmp(hid, "ACPI0009") == 0) {
hid                85 drivers/acpi/ioapic.c 			} else if (strcmp(hid, "ACPI000A") == 0) {
hid              1171 drivers/acpi/scan.c 	struct acpi_hardware_id *hid;
hid              1176 drivers/acpi/scan.c 	hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
hid              1177 drivers/acpi/scan.c 	return hid->id;
hid               710 drivers/acpi/utils.c bool acpi_dev_found(const char *hid)
hid               717 drivers/acpi/utils.c 		if (!strcmp(acpi_device_bus_id->bus_id, hid)) {
hid               728 drivers/acpi/utils.c 	struct acpi_device_id hid[2];
hid               740 drivers/acpi/utils.c 	if (acpi_match_device_ids(adev, match->hid))
hid               777 drivers/acpi/utils.c bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)
hid               782 drivers/acpi/utils.c 	strlcpy(match.hid[0].id, hid, sizeof(match.hid[0].id));
hid               806 drivers/acpi/utils.c acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv)
hid               811 drivers/acpi/utils.c 	strlcpy(match.hid[0].id, hid, sizeof(match.hid[0].id));
hid                34 drivers/acpi/x86/utils.c 	struct acpi_device_id hid[2];
hid                42 drivers/acpi/x86/utils.c #define ENTRY(hid, uid, cpu_models, dmi...) {				\
hid                43 drivers/acpi/x86/utils.c 	{ { hid, }, {} },						\
hid               118 drivers/acpi/x86/utils.c 		if (acpi_match_device_ids(adev, always_present_ids[i].hid))
hid               453 drivers/bus/hisi_lpc.c 	const char *hid;
hid               488 drivers/bus/hisi_lpc.c 		const char *hid = acpi_device_hid(child);
hid               505 drivers/bus/hisi_lpc.c 				.hid = "IPI0001",
hid               510 drivers/bus/hisi_lpc.c 				.hid = "HISI1031",
hid               528 drivers/bus/hisi_lpc.c 			if (!strcmp(cell->hid, hid)) {
hid               537 drivers/bus/hisi_lpc.c 				 hid);
hid                93 drivers/char/tpm/tpm_crb.c 	const char *hid;
hid               385 drivers/char/tpm/tpm_crb.c 	    (!strcmp(priv->hid, "MSFT0101")))
hid               642 drivers/char/tpm/tpm_crb.c 	priv->hid = acpi_device_hid(device);
hid                67 drivers/char/tpm/tpm_tis.c static int has_hid(struct acpi_device *dev, const char *hid)
hid                72 drivers/char/tpm/tpm_tis.c 		if (!strcmp(hid, id->id))
hid               271 drivers/char/tpm/tpm_tis.c module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
hid               273 drivers/char/tpm/tpm_tis.c MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
hid                16 drivers/firmware/efi/dev-path-parser.c 	struct acpi_device_id hid[2];
hid                25 drivers/firmware/efi/dev-path-parser.c 	if (acpi_match_device_ids(adev, hid_uid.hid))
hid                43 drivers/firmware/efi/dev-path-parser.c 	sprintf(hid_uid.hid[0].id, "%c%c%c%04X",
hid                44 drivers/firmware/efi/dev-path-parser.c 		'A' + ((node->acpi.hid >> 10) & 0x1f) - 1,
hid                45 drivers/firmware/efi/dev-path-parser.c 		'A' + ((node->acpi.hid >>  5) & 0x1f) - 1,
hid                46 drivers/firmware/efi/dev-path-parser.c 		'A' + ((node->acpi.hid >>  0) & 0x1f) - 1,
hid                47 drivers/firmware/efi/dev-path-parser.c 			node->acpi.hid >> 16);
hid                41 drivers/hid/hid-a4tech.c 	    usage->hid == A4_WHEEL_ORIENTATION) {
hid                67 drivers/hid/hid-a4tech.c 	if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007)
hid                90 drivers/hid/hid-a4tech.c 		if (usage->hid == A4_WHEEL_ORIENTATION) {
hid                99 drivers/hid/hid-a4tech.c 	if ((a4->quirks & A4_2WHEEL_MOUSE_HACK_7) && usage->hid == 0x00090007) {
hid               152 drivers/hid/hid-a4tech.c MODULE_DEVICE_TABLE(hid, a4_devices);
hid                25 drivers/hid/hid-accutouch.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
hid                37 drivers/hid/hid-accutouch.c MODULE_DEVICE_TABLE(hid, accutouch_devices);
hid               661 drivers/hid/hid-alps.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               663 drivers/hid/hid-alps.c 	return hid_hw_open(hid);
hid               668 drivers/hid/hid-alps.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               670 drivers/hid/hid-alps.c 	hid_hw_close(hid);
hid               835 drivers/hid/hid-alps.c MODULE_DEVICE_TABLE(hid, alps_id);
hid               178 drivers/hid/hid-apple.c static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
hid               181 drivers/hid/hid-apple.c 	struct apple_sc *asc = hid_get_drvdata(hid);
hid               193 drivers/hid/hid-apple.c 		if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI &&
hid               194 drivers/hid/hid-apple.c 				hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS)
hid               196 drivers/hid/hid-apple.c 		else if (hid->product < 0x21d || hid->product >= 0x300)
hid               256 drivers/hid/hid-apple.c 		if (hid->country == HID_COUNTRY_INTERNATIONAL_ISO) {
hid               342 drivers/hid/hid-apple.c 	if (usage->hid == (HID_UP_CUSTOM | 0x0003) ||
hid               343 drivers/hid/hid-apple.c 			usage->hid == (HID_UP_MSVENDOR | 0x0003) ||
hid               344 drivers/hid/hid-apple.c 			usage->hid == (HID_UP_HPVENDOR2 | 0x0003)) {
hid               363 drivers/hid/hid-apple.c 		if (usage->hid == HID_GD_Z)
hid               578 drivers/hid/hid-apple.c MODULE_DEVICE_TABLE(hid, apple_devices);
hid               109 drivers/hid/hid-appleir.c 	struct hid_device *hid;
hid               151 drivers/hid/hid-appleir.c static void key_up(struct hid_device *hid, struct appleir *appleir, int key)
hid               157 drivers/hid/hid-appleir.c static void key_down(struct hid_device *hid, struct appleir *appleir, int key)
hid               171 drivers/hid/hid-appleir.c 	struct hid_device *hid = appleir->hid;
hid               176 drivers/hid/hid-appleir.c 		key_up(hid, appleir, appleir->current_key);
hid               182 drivers/hid/hid-appleir.c static int appleir_raw_event(struct hid_device *hid, struct hid_report *report,
hid               185 drivers/hid/hid-appleir.c 	struct appleir *appleir = hid_get_drvdata(hid);
hid               203 drivers/hid/hid-appleir.c 			key_up(hid, appleir, appleir->current_key);
hid               214 drivers/hid/hid-appleir.c 			key_down(hid, appleir, appleir->current_key);
hid               232 drivers/hid/hid-appleir.c 		key_down(hid, appleir, appleir->current_key);
hid               251 drivers/hid/hid-appleir.c static int appleir_input_configured(struct hid_device *hid,
hid               255 drivers/hid/hid-appleir.c 	struct appleir *appleir = hid_get_drvdata(hid);
hid               274 drivers/hid/hid-appleir.c static int appleir_input_mapping(struct hid_device *hid,
hid               281 drivers/hid/hid-appleir.c static int appleir_probe(struct hid_device *hid, const struct hid_device_id *id)
hid               292 drivers/hid/hid-appleir.c 	appleir->hid = hid;
hid               295 drivers/hid/hid-appleir.c 	hid->quirks |= HID_QUIRK_HIDINPUT_FORCE;
hid               300 drivers/hid/hid-appleir.c 	hid_set_drvdata(hid, appleir);
hid               302 drivers/hid/hid-appleir.c 	ret = hid_parse(hid);
hid               304 drivers/hid/hid-appleir.c 		hid_err(hid, "parse failed\n");
hid               308 drivers/hid/hid-appleir.c 	ret = hid_hw_start(hid, HID_CONNECT_DEFAULT | HID_CONNECT_HIDDEV_FORCE);
hid               310 drivers/hid/hid-appleir.c 		hid_err(hid, "hw start failed\n");
hid               321 drivers/hid/hid-appleir.c static void appleir_remove(struct hid_device *hid)
hid               323 drivers/hid/hid-appleir.c 	struct appleir *appleir = hid_get_drvdata(hid);
hid               324 drivers/hid/hid-appleir.c 	hid_hw_stop(hid);
hid               337 drivers/hid/hid-appleir.c MODULE_DEVICE_TABLE(hid, appleir_devices);
hid               263 drivers/hid/hid-asus.c 	if ((usage->hid & HID_USAGE_PAGE) == 0xff310000 &&
hid               264 drivers/hid/hid-asus.c 	    (usage->hid & HID_USAGE) != 0x00 &&
hid               265 drivers/hid/hid-asus.c 	    (usage->hid & HID_USAGE) != 0xff && !usage->type) {
hid               267 drivers/hid/hid-asus.c 			 usage->hid & HID_USAGE);
hid               682 drivers/hid/hid-asus.c 		    usage->hid == (HID_UP_GENDEVCTRLS | 0x0024) ||
hid               683 drivers/hid/hid-asus.c 		    usage->hid == (HID_UP_GENDEVCTRLS | 0x0025) ||
hid               684 drivers/hid/hid-asus.c 		    usage->hid == (HID_UP_GENDEVCTRLS | 0x0026))
hid               691 drivers/hid/hid-asus.c 		    usage->hid != (HID_UP_BUTTON | 1))
hid               696 drivers/hid/hid-asus.c 	if ((usage->hid & HID_USAGE_PAGE) == 0xff310000) {
hid               698 drivers/hid/hid-asus.c 		switch (usage->hid & HID_USAGE) {
hid               743 drivers/hid/hid-asus.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) {
hid               745 drivers/hid/hid-asus.c 		switch (usage->hid & HID_USAGE) {
hid               771 drivers/hid/hid-asus.c 		(usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
hid               772 drivers/hid/hid-asus.c 		switch (usage->hid & HID_USAGE) {
hid              1062 drivers/hid/hid-asus.c MODULE_DEVICE_TABLE(hid, asus_devices);
hid                35 drivers/hid/hid-aureal.c MODULE_DEVICE_TABLE(hid, aureal_devices);
hid                33 drivers/hid/hid-axff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                57 drivers/hid/hid-axff.c 	hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT);
hid                62 drivers/hid/hid-axff.c static int axff_init(struct hid_device *hid)
hid                67 drivers/hid/hid-axff.c 	struct list_head *report_list =&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                73 drivers/hid/hid-axff.c 	if (list_empty(&hid->inputs)) {
hid                74 drivers/hid/hid-axff.c 		hid_err(hid, "no inputs found\n");
hid                77 drivers/hid/hid-axff.c 	hidinput = list_first_entry(&hid->inputs, struct hid_input, list);
hid                81 drivers/hid/hid-axff.c 		hid_err(hid, "no output reports found\n");
hid                93 drivers/hid/hid-axff.c 	if (field_count < 4 && hid->product != 0xf705) {
hid                94 drivers/hid/hid-axff.c 		hid_err(hid, "not enough fields in the report: %d\n",
hid               110 drivers/hid/hid-axff.c 	hid_hw_request(hid, axff->report, HID_REQ_SET_REPORT);
hid               112 drivers/hid/hid-axff.c 	hid_info(hid, "Force Feedback for ACRUX game controllers by Sergei Kolzun <x0r@dv-life.ru>\n");
hid               121 drivers/hid/hid-axff.c static inline int axff_init(struct hid_device *hid)
hid               181 drivers/hid/hid-axff.c MODULE_DEVICE_TABLE(hid, ax_devices);
hid                32 drivers/hid/hid-belkin.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER ||
hid                36 drivers/hid/hid-belkin.c 	switch (usage->hid & HID_USAGE) {
hid                78 drivers/hid/hid-belkin.c MODULE_DEVICE_TABLE(hid, belkin_devices);
hid                40 drivers/hid/hid-betopff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                50 drivers/hid/hid-betopff.c 	hid_hw_request(hid, betopff->report, HID_REQ_SET_REPORT);
hid                55 drivers/hid/hid-betopff.c static int betopff_init(struct hid_device *hid)
hid                60 drivers/hid/hid-betopff.c 			list_first_entry(&hid->inputs, struct hid_input, list);
hid                62 drivers/hid/hid-betopff.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                69 drivers/hid/hid-betopff.c 		hid_err(hid, "no output reports found\n");
hid                90 drivers/hid/hid-betopff.c 		hid_err(hid, "not enough fields in the report: %d\n",
hid               108 drivers/hid/hid-betopff.c 	hid_hw_request(hid, betopff->report, HID_REQ_SET_REPORT);
hid               110 drivers/hid/hid-betopff.c 	hid_info(hid, "Force feedback for betop devices by huangbo <huangbobupt@163.com>\n");
hid               148 drivers/hid/hid-betopff.c MODULE_DEVICE_TABLE(hid, betop_devices);
hid               175 drivers/hid/hid-bigbenff.c 	struct hid_device *hid;
hid               207 drivers/hid/hid-bigbenff.c 		hid_hw_request(bigben->hid, bigben->report, HID_REQ_SET_REPORT);
hid               220 drivers/hid/hid-bigbenff.c 		hid_hw_request(bigben->hid, bigben->report, HID_REQ_SET_REPORT);
hid               227 drivers/hid/hid-bigbenff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               228 drivers/hid/hid-bigbenff.c 	struct bigben_device *bigben = hid_get_drvdata(hid);
hid               233 drivers/hid/hid-bigbenff.c 		hid_err(hid, "no device data\n");
hid               258 drivers/hid/hid-bigbenff.c 	struct hid_device *hid = to_hid_device(dev);
hid               259 drivers/hid/hid-bigbenff.c 	struct bigben_device *bigben = hid_get_drvdata(hid);
hid               264 drivers/hid/hid-bigbenff.c 		hid_err(hid, "no device data\n");
hid               290 drivers/hid/hid-bigbenff.c 	struct hid_device *hid = to_hid_device(dev);
hid               291 drivers/hid/hid-bigbenff.c 	struct bigben_device *bigben = hid_get_drvdata(hid);
hid               295 drivers/hid/hid-bigbenff.c 		hid_err(hid, "no device data\n");
hid               307 drivers/hid/hid-bigbenff.c static void bigben_remove(struct hid_device *hid)
hid               309 drivers/hid/hid-bigbenff.c 	struct bigben_device *bigben = hid_get_drvdata(hid);
hid               313 drivers/hid/hid-bigbenff.c 	hid_hw_stop(hid);
hid               316 drivers/hid/hid-bigbenff.c static int bigben_probe(struct hid_device *hid,
hid               327 drivers/hid/hid-bigbenff.c 	bigben = devm_kzalloc(&hid->dev, sizeof(*bigben), GFP_KERNEL);
hid               330 drivers/hid/hid-bigbenff.c 	hid_set_drvdata(hid, bigben);
hid               331 drivers/hid/hid-bigbenff.c 	bigben->hid = hid;
hid               334 drivers/hid/hid-bigbenff.c 	error = hid_parse(hid);
hid               336 drivers/hid/hid-bigbenff.c 		hid_err(hid, "parse failed\n");
hid               340 drivers/hid/hid-bigbenff.c 	error = hid_hw_start(hid, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
hid               342 drivers/hid/hid-bigbenff.c 		hid_err(hid, "hw start failed\n");
hid               346 drivers/hid/hid-bigbenff.c 	report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid               350 drivers/hid/hid-bigbenff.c 	hidinput = list_first_entry(&hid->inputs, struct hid_input, list);
hid               360 drivers/hid/hid-bigbenff.c 	name_sz = strlen(dev_name(&hid->dev)) + strlen(":red:bigben#") + 1;
hid               364 drivers/hid/hid-bigbenff.c 			&hid->dev,
hid               375 drivers/hid/hid-bigbenff.c 			dev_name(&hid->dev), n + 1
hid               383 drivers/hid/hid-bigbenff.c 		error = devm_led_classdev_register(&hid->dev, led);
hid               396 drivers/hid/hid-bigbenff.c 	hid_info(hid, "LED and force feedback support for BigBen gamepad\n");
hid               401 drivers/hid/hid-bigbenff.c 	hid_hw_stop(hid);
hid               405 drivers/hid/hid-bigbenff.c static __u8 *bigben_report_fixup(struct hid_device *hid, __u8 *rdesc,
hid               412 drivers/hid/hid-bigbenff.c 		hid_warn(hid, "unexpected rdesc, please submit for review\n");
hid               420 drivers/hid/hid-bigbenff.c MODULE_DEVICE_TABLE(hid, bigben_devices);
hid                42 drivers/hid/hid-cherry.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
hid                45 drivers/hid/hid-cherry.c 	switch (usage->hid & HID_USAGE) {
hid                61 drivers/hid/hid-cherry.c MODULE_DEVICE_TABLE(hid, ch_devices);
hid                30 drivers/hid/hid-chicony.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
hid                34 drivers/hid/hid-chicony.c 	switch (usage->hid & HID_USAGE) {
hid                87 drivers/hid/hid-chicony.c MODULE_DEVICE_TABLE(hid, ch_devices);
hid                45 drivers/hid/hid-cmedia.c 	struct hid_device *hid;
hid                49 drivers/hid/hid-cmedia.c static void hp_ev(struct hid_device *hid, struct cmhid *cm, int value)
hid                55 drivers/hid/hid-cmedia.c static int cmhid_raw_event(struct hid_device *hid, struct hid_report *report,
hid                58 drivers/hid/hid-cmedia.c 	struct cmhid *cm = hid_get_drvdata(hid);
hid                66 drivers/hid/hid-cmedia.c 		hp_ev(hid, cm, 0);
hid                70 drivers/hid/hid-cmedia.c 		hp_ev(hid, cm, 1);
hid                78 drivers/hid/hid-cmedia.c static int cmhid_input_configured(struct hid_device *hid,
hid                82 drivers/hid/hid-cmedia.c 	struct cmhid *cm = hid_get_drvdata(hid);
hid                94 drivers/hid/hid-cmedia.c static int cmhid_input_mapping(struct hid_device *hid,
hid               101 drivers/hid/hid-cmedia.c static int cmhid_probe(struct hid_device *hid, const struct hid_device_id *id)
hid               112 drivers/hid/hid-cmedia.c 	cm->hid = hid;
hid               114 drivers/hid/hid-cmedia.c 	hid->quirks |= HID_QUIRK_HIDINPUT_FORCE;
hid               115 drivers/hid/hid-cmedia.c 	hid_set_drvdata(hid, cm);
hid               117 drivers/hid/hid-cmedia.c 	ret = hid_parse(hid);
hid               119 drivers/hid/hid-cmedia.c 		hid_err(hid, "parse failed\n");
hid               123 drivers/hid/hid-cmedia.c 	ret = hid_hw_start(hid, HID_CONNECT_DEFAULT | HID_CONNECT_HIDDEV_FORCE);
hid               125 drivers/hid/hid-cmedia.c 		hid_err(hid, "hw start failed\n");
hid               136 drivers/hid/hid-cmedia.c static void cmhid_remove(struct hid_device *hid)
hid               138 drivers/hid/hid-cmedia.c 	struct cmhid *cm = hid_get_drvdata(hid);
hid               140 drivers/hid/hid-cmedia.c 	hid_hw_stop(hid);
hid               148 drivers/hid/hid-cmedia.c MODULE_DEVICE_TABLE(hid, cmhid_devices);
hid               316 drivers/hid/hid-core.c 		field->usage[i].hid = parser->local.usage[j];
hid               703 drivers/hid/hid-core.c 	struct hid_device *hid = to_hid_device(dev);
hid               705 drivers/hid/hid-core.c 	hid_close_report(hid);
hid               706 drivers/hid/hid-core.c 	kfree(hid->dev_rdesc);
hid               707 drivers/hid/hid-core.c 	kfree(hid);
hid               779 drivers/hid/hid-core.c 	struct hid_device *hid = parser->device;
hid               782 drivers/hid/hid-core.c 		hid->group = HID_GROUP_MULTITOUCH;
hid               798 drivers/hid/hid-core.c 	struct hid_device *hid = parser->device;
hid               803 drivers/hid/hid-core.c 		hid->group = HID_GROUP_SENSOR_HUB;
hid               805 drivers/hid/hid-core.c 	if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
hid               806 drivers/hid/hid-core.c 	    hid->product == USB_DEVICE_ID_MS_POWER_COVER &&
hid               807 drivers/hid/hid-core.c 	    hid->group == HID_GROUP_MULTITOUCH)
hid               808 drivers/hid/hid-core.c 		hid->group = HID_GROUP_GENERIC;
hid               860 drivers/hid/hid-core.c static int hid_scan_report(struct hid_device *hid)
hid               864 drivers/hid/hid-core.c 	__u8 *start = hid->dev_rdesc;
hid               865 drivers/hid/hid-core.c 	__u8 *end = start + hid->dev_rsize;
hid               878 drivers/hid/hid-core.c 	parser->device = hid;
hid               879 drivers/hid/hid-core.c 	hid->group = HID_GROUP_GENERIC;
hid               893 drivers/hid/hid-core.c 	    (hid->group == HID_GROUP_MULTITOUCH))
hid               894 drivers/hid/hid-core.c 		hid->group = HID_GROUP_MULTITOUCH_WIN_8;
hid               899 drivers/hid/hid-core.c 	switch (hid->vendor) {
hid               901 drivers/hid/hid-core.c 		hid->group = HID_GROUP_WACOM;
hid               904 drivers/hid/hid-core.c 		if (hid->group == HID_GROUP_GENERIC)
hid               911 drivers/hid/hid-core.c 				hid->group = HID_GROUP_RMI;
hid               930 drivers/hid/hid-core.c int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size)
hid               932 drivers/hid/hid-core.c 	hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
hid               933 drivers/hid/hid-core.c 	if (!hid->dev_rdesc)
hid               935 drivers/hid/hid-core.c 	hid->dev_rsize = size;
hid               957 drivers/hid/hid-core.c struct hid_report *hid_validate_values(struct hid_device *hid,
hid               965 drivers/hid/hid-core.c 		hid_err(hid, "invalid HID report type %u\n", type);
hid               970 drivers/hid/hid-core.c 		hid_err(hid, "invalid HID report id %u\n", id);
hid               985 drivers/hid/hid-core.c 				hid->report_enum[type].report_list.next,
hid               988 drivers/hid/hid-core.c 		report = hid->report_enum[type].report_id_hash[id];
hid               991 drivers/hid/hid-core.c 		hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
hid               995 drivers/hid/hid-core.c 		hid_err(hid, "not enough fields in %s %u\n",
hid              1000 drivers/hid/hid-core.c 		hid_err(hid, "not enough values in %s %u field %u\n",
hid              1008 drivers/hid/hid-core.c static int hid_calculate_multiplier(struct hid_device *hid,
hid              1033 drivers/hid/hid-core.c 		hid_warn(hid,
hid              1040 drivers/hid/hid-core.c 		hid_warn(hid, "unsupported Resolution Multiplier %d\n", m);
hid              1047 drivers/hid/hid-core.c static void hid_apply_multiplier_to_field(struct hid_device *hid,
hid              1065 drivers/hid/hid-core.c 		collection = &hid->collection[usage->collection_index];
hid              1068 drivers/hid/hid-core.c 			collection = &hid->collection[collection->parent_idx];
hid              1077 drivers/hid/hid-core.c static void hid_apply_multiplier(struct hid_device *hid,
hid              1105 drivers/hid/hid-core.c 	multiplier_collection = &hid->collection[multiplier->usage->collection_index];
hid              1108 drivers/hid/hid-core.c 		multiplier_collection = &hid->collection[multiplier_collection->parent_idx];
hid              1110 drivers/hid/hid-core.c 	effective_multiplier = hid_calculate_multiplier(hid, multiplier);
hid              1112 drivers/hid/hid-core.c 	rep_enum = &hid->report_enum[HID_INPUT_REPORT];
hid              1116 drivers/hid/hid-core.c 			hid_apply_multiplier_to_field(hid, field,
hid              1146 drivers/hid/hid-core.c void hid_setup_resolution_multiplier(struct hid_device *hid)
hid              1153 drivers/hid/hid-core.c 	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
hid              1162 drivers/hid/hid-core.c 				if (usage->hid == HID_GD_RESOLUTION_MULTIPLIER)
hid              1163 drivers/hid/hid-core.c 					hid_apply_multiplier(hid,
hid              1362 drivers/hid/hid-core.c u32 hid_field_extract(const struct hid_device *hid, u8 *report,
hid              1366 drivers/hid/hid-core.c 		hid_warn_once(hid, "%s() called with n (%d) > 32! (%s)\n",
hid              1408 drivers/hid/hid-core.c static void implement(const struct hid_device *hid, u8 *report,
hid              1412 drivers/hid/hid-core.c 		hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
hid              1419 drivers/hid/hid-core.c 			hid_warn(hid,
hid              1451 drivers/hid/hid-core.c static int hid_match_report(struct hid_device *hid, struct hid_report *report)
hid              1453 drivers/hid/hid-core.c 	const struct hid_report_id *id = hid->driver->report_table;
hid              1474 drivers/hid/hid-core.c static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
hid              1476 drivers/hid/hid-core.c 	const struct hid_usage_id *id = hid->driver->usage_table;
hid              1483 drivers/hid/hid-core.c 				id->usage_hid == usage->hid) &&
hid              1492 drivers/hid/hid-core.c static void hid_process_event(struct hid_device *hid, struct hid_field *field,
hid              1495 drivers/hid/hid-core.c 	struct hid_driver *hdrv = hid->driver;
hid              1498 drivers/hid/hid-core.c 	if (!list_empty(&hid->debug_list))
hid              1499 drivers/hid/hid-core.c 		hid_dump_input(hid, usage, value);
hid              1501 drivers/hid/hid-core.c 	if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
hid              1502 drivers/hid/hid-core.c 		ret = hdrv->event(hid, field, usage, value);
hid              1505 drivers/hid/hid-core.c 				hid_err(hid, "%s's event failed with %d\n",
hid              1511 drivers/hid/hid-core.c 	if (hid->claimed & HID_CLAIMED_INPUT)
hid              1512 drivers/hid/hid-core.c 		hidinput_hid_event(hid, field, usage, value);
hid              1513 drivers/hid/hid-core.c 	if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
hid              1514 drivers/hid/hid-core.c 		hid->hiddev_hid_event(hid, field, usage, value);
hid              1523 drivers/hid/hid-core.c static void hid_input_field(struct hid_device *hid, struct hid_field *field,
hid              1541 drivers/hid/hid-core.c 			snto32(hid_field_extract(hid, data, offset + n * size,
hid              1543 drivers/hid/hid-core.c 			hid_field_extract(hid, data, offset + n * size, size);
hid              1549 drivers/hid/hid-core.c 		    field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
hid              1556 drivers/hid/hid-core.c 			hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
hid              1562 drivers/hid/hid-core.c 			&& field->usage[field->value[n] - min].hid
hid              1564 drivers/hid/hid-core.c 				hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
hid              1568 drivers/hid/hid-core.c 			&& field->usage[value[n] - min].hid
hid              1570 drivers/hid/hid-core.c 				hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
hid              1582 drivers/hid/hid-core.c static void hid_output_field(const struct hid_device *hid,
hid              1592 drivers/hid/hid-core.c 			implement(hid, data, offset + n * size, size,
hid              1595 drivers/hid/hid-core.c 			implement(hid, data, offset + n * size, size,
hid              1688 drivers/hid/hid-core.c int __hid_request(struct hid_device *hid, struct hid_report *report,
hid              1704 drivers/hid/hid-core.c 	ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
hid              1712 drivers/hid/hid-core.c 		hid_input_report(hid, report->type, buf, ret, 0);
hid              1722 drivers/hid/hid-core.c int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
hid              1725 drivers/hid/hid-core.c 	struct hid_report_enum *report_enum = hid->report_enum + type;
hid              1755 drivers/hid/hid-core.c 	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
hid              1756 drivers/hid/hid-core.c 		hid->hiddev_report_event(hid, report);
hid              1757 drivers/hid/hid-core.c 	if (hid->claimed & HID_CLAIMED_HIDRAW) {
hid              1758 drivers/hid/hid-core.c 		ret = hidraw_report_event(hid, data, size);
hid              1763 drivers/hid/hid-core.c 	if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
hid              1765 drivers/hid/hid-core.c 			hid_input_field(hid, report->field[a], cdata, interrupt);
hid              1766 drivers/hid/hid-core.c 		hdrv = hid->driver;
hid              1768 drivers/hid/hid-core.c 			hdrv->report(hid, report);
hid              1771 drivers/hid/hid-core.c 	if (hid->claimed & HID_CLAIMED_INPUT)
hid              1772 drivers/hid/hid-core.c 		hidinput_report_event(hid, report);
hid              1789 drivers/hid/hid-core.c int hid_input_report(struct hid_device *hid, int type, u8 *data, u32 size, int interrupt)
hid              1796 drivers/hid/hid-core.c 	if (!hid)
hid              1799 drivers/hid/hid-core.c 	if (down_trylock(&hid->driver_input_lock))
hid              1802 drivers/hid/hid-core.c 	if (!hid->driver) {
hid              1806 drivers/hid/hid-core.c 	report_enum = hid->report_enum + type;
hid              1807 drivers/hid/hid-core.c 	hdrv = hid->driver;
hid              1816 drivers/hid/hid-core.c 	if (!list_empty(&hid->debug_list))
hid              1817 drivers/hid/hid-core.c 		hid_dump_report(hid, type, data, size);
hid              1826 drivers/hid/hid-core.c 	if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
hid              1827 drivers/hid/hid-core.c 		ret = hdrv->raw_event(hid, report, data, size);
hid              1832 drivers/hid/hid-core.c 	ret = hid_report_raw_event(hid, type, data, size, interrupt);
hid              1835 drivers/hid/hid-core.c 	up(&hid->driver_input_lock);
hid              2554 drivers/hid/hid-core.c int hid_check_keys_pressed(struct hid_device *hid)
hid              2559 drivers/hid/hid-core.c 	if (!(hid->claimed & HID_CLAIMED_INPUT))
hid              2562 drivers/hid/hid-core.c 	list_for_each_entry(hidinput, &hid->inputs, list) {
hid               608 drivers/hid/hid-corsair.c 	switch (usage->hid & HID_USAGE) {
hid               630 drivers/hid/hid-corsair.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_KEYBOARD)
hid               633 drivers/hid/hid-corsair.c 	gkey = corsair_usage_to_gkey(usage->hid & HID_USAGE);
hid               639 drivers/hid/hid-corsair.c 	if ((usage->hid & HID_USAGE) >= CORSAIR_USAGE_SPECIAL_MIN &&
hid               640 drivers/hid/hid-corsair.c 	    (usage->hid & HID_USAGE) <= CORSAIR_USAGE_SPECIAL_MAX) {
hid               641 drivers/hid/hid-corsair.c 		switch (usage->hid & HID_USAGE) {
hid               732 drivers/hid/hid-corsair.c MODULE_DEVICE_TABLE(hid, corsair_devices);
hid               331 drivers/hid/hid-cougar.c MODULE_DEVICE_TABLE(hid, cougar_id_table);
hid               151 drivers/hid/hid-cp2112.c MODULE_DEVICE_TABLE(hid, cp2112_devices);
hid               119 drivers/hid/hid-creative-sb0540.c 	struct hid_device *hid;
hid               149 drivers/hid/hid-creative-sb0540.c static int creative_sb0540_raw_event(struct hid_device *hid,
hid               152 drivers/hid/hid-creative-sb0540.c 	struct creative_sb0540 *creative_sb0540 = hid_get_drvdata(hid);
hid               172 drivers/hid/hid-creative-sb0540.c 		hid_err(hid, "Could not get a key for main_code %llX\n",
hid               185 drivers/hid/hid-creative-sb0540.c static int creative_sb0540_input_configured(struct hid_device *hid,
hid               189 drivers/hid/hid-creative-sb0540.c 	struct creative_sb0540 *creative_sb0540 = hid_get_drvdata(hid);
hid               209 drivers/hid/hid-creative-sb0540.c static int creative_sb0540_input_mapping(struct hid_device *hid,
hid               220 drivers/hid/hid-creative-sb0540.c static int creative_sb0540_probe(struct hid_device *hid,
hid               226 drivers/hid/hid-creative-sb0540.c 	creative_sb0540 = devm_kzalloc(&hid->dev,
hid               232 drivers/hid/hid-creative-sb0540.c 	creative_sb0540->hid = hid;
hid               235 drivers/hid/hid-creative-sb0540.c 	hid->quirks |= HID_QUIRK_HIDINPUT_FORCE;
hid               237 drivers/hid/hid-creative-sb0540.c 	hid_set_drvdata(hid, creative_sb0540);
hid               239 drivers/hid/hid-creative-sb0540.c 	ret = hid_parse(hid);
hid               241 drivers/hid/hid-creative-sb0540.c 		hid_err(hid, "parse failed\n");
hid               245 drivers/hid/hid-creative-sb0540.c 	ret = hid_hw_start(hid, HID_CONNECT_DEFAULT);
hid               247 drivers/hid/hid-creative-sb0540.c 		hid_err(hid, "hw start failed\n");
hid               258 drivers/hid/hid-creative-sb0540.c MODULE_DEVICE_TABLE(hid, creative_sb0540_devices);
hid                62 drivers/hid/hid-cypress.c 	if (usage->hid == 0x00090005)
hid                77 drivers/hid/hid-cypress.c 	if (usage->hid == 0x00090005) {
hid               133 drivers/hid/hid-cypress.c MODULE_DEVICE_TABLE(hid, cp_devices);
hid               542 drivers/hid/hid-debug.c 		tab(n+2, f); hid_resolv_usage(field->usage[j].hid, f); seq_printf(f, "\n");
hid               665 drivers/hid/hid-debug.c void hid_dump_report(struct hid_device *hid, int type, u8 *data,
hid               677 drivers/hid/hid-debug.c 	report_enum = hid->report_enum + type;
hid               683 drivers/hid/hid-debug.c 	hid_debug_event(hid, buf);
hid               688 drivers/hid/hid-debug.c 		hid_debug_event(hid, buf);
hid               690 drivers/hid/hid-debug.c 	hid_debug_event(hid, "\n");
hid               700 drivers/hid/hid-debug.c 	buf = hid_resolv_usage(usage->hid, NULL);
hid              1011 drivers/hid/hid-debug.c static void hid_dump_input_mapping(struct hid_device *hid, struct seq_file *f)
hid              1018 drivers/hid/hid-debug.c 		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
hid              1022 drivers/hid/hid-debug.c 					hid_resolv_usage(usage->hid, f);
hid                34 drivers/hid/hid-dr.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                57 drivers/hid/hid-dr.c 		hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
hid                69 drivers/hid/hid-dr.c 	hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
hid                74 drivers/hid/hid-dr.c static int drff_init(struct hid_device *hid)
hid                80 drivers/hid/hid-dr.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                84 drivers/hid/hid-dr.c 	if (list_empty(&hid->inputs)) {
hid                85 drivers/hid/hid-dr.c 		hid_err(hid, "no inputs found\n");
hid                88 drivers/hid/hid-dr.c 	hidinput = list_first_entry(&hid->inputs, struct hid_input, list);
hid                92 drivers/hid/hid-dr.c 		hid_err(hid, "no output reports found\n");
hid                98 drivers/hid/hid-dr.c 		hid_err(hid, "no fields in the report\n");
hid               103 drivers/hid/hid-dr.c 		hid_err(hid, "not enough values in the field\n");
hid               127 drivers/hid/hid-dr.c 	hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
hid               129 drivers/hid/hid-dr.c 	hid_info(hid, "Force Feedback for DragonRise Inc. "
hid               135 drivers/hid/hid-dr.c static inline int drff_init(struct hid_device *hid)
hid               252 drivers/hid/hid-dr.c 	switch (usage->hid) {
hid               260 drivers/hid/hid-dr.c 			map_rel(usage->hid & 0xf);
hid               262 drivers/hid/hid-dr.c 			map_abs(usage->hid & 0xf);
hid               308 drivers/hid/hid-dr.c MODULE_DEVICE_TABLE(hid, dr_devices);
hid               530 drivers/hid/hid-elan.c MODULE_DEVICE_TABLE(hid, elan_devices);
hid                91 drivers/hid/hid-elecom.c MODULE_DEVICE_TABLE(hid, elecom_devices);
hid               278 drivers/hid/hid-elo.c MODULE_DEVICE_TABLE(hid, elo_devices);
hid                25 drivers/hid/hid-emsff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                41 drivers/hid/hid-emsff.c 	hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);
hid                46 drivers/hid/hid-emsff.c static int emsff_init(struct hid_device *hid)
hid                52 drivers/hid/hid-emsff.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                56 drivers/hid/hid-emsff.c 	if (list_empty(&hid->inputs)) {
hid                57 drivers/hid/hid-emsff.c 		hid_err(hid, "no inputs found\n");
hid                60 drivers/hid/hid-emsff.c 	hidinput = list_first_entry(&hid->inputs, struct hid_input, list);
hid                64 drivers/hid/hid-emsff.c 		hid_err(hid, "no output reports found\n");
hid                70 drivers/hid/hid-emsff.c 		hid_err(hid, "no fields in the report\n");
hid                75 drivers/hid/hid-emsff.c 		hid_err(hid, "not enough values in the field\n");
hid                99 drivers/hid/hid-emsff.c 	hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);
hid               101 drivers/hid/hid-emsff.c 	hid_info(hid, "force feedback for EMS based devices by Ignaz Forster <ignaz.forster@gmx.de>\n");
hid               138 drivers/hid/hid-emsff.c MODULE_DEVICE_TABLE(hid, ems_devices);
hid                29 drivers/hid/hid-ezkey.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
hid                32 drivers/hid/hid-ezkey.c 	switch (usage->hid & HID_USAGE) {
hid                68 drivers/hid/hid-ezkey.c MODULE_DEVICE_TABLE(hid, ez_devices);
hid                32 drivers/hid/hid-gaff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                51 drivers/hid/hid-gaff.c 	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
hid                58 drivers/hid/hid-gaff.c 	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
hid                63 drivers/hid/hid-gaff.c static int gaff_init(struct hid_device *hid)
hid                69 drivers/hid/hid-gaff.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                74 drivers/hid/hid-gaff.c 	if (list_empty(&hid->inputs)) {
hid                75 drivers/hid/hid-gaff.c 		hid_err(hid, "no inputs found\n");
hid                78 drivers/hid/hid-gaff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid                82 drivers/hid/hid-gaff.c 		hid_err(hid, "no output reports found\n");
hid                90 drivers/hid/hid-gaff.c 		hid_err(hid, "no fields in the report\n");
hid                95 drivers/hid/hid-gaff.c 		hid_err(hid, "not enough values in the field\n");
hid               116 drivers/hid/hid-gaff.c 	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
hid               121 drivers/hid/hid-gaff.c 	hid_hw_request(hid, gaff->report, HID_REQ_SET_REPORT);
hid               123 drivers/hid/hid-gaff.c 	hid_info(hid, "Force Feedback for GreenAsia 0x12 devices by Lukasz Lubojanski <lukasz@lubojanski.info>\n");
hid               163 drivers/hid/hid-gaff.c MODULE_DEVICE_TABLE(hid, ga_devices);
hid               102 drivers/hid/hid-gembird.c MODULE_DEVICE_TABLE(hid, gembird_devices);
hid                74 drivers/hid/hid-generic.c MODULE_DEVICE_TABLE(hid, hid_table);
hid                34 drivers/hid/hid-gfrm.c 		if (usage->hid == (HID_UP_CONSUMER | 0x4)) {
hid                40 drivers/hid/hid-gfrm.c 		if (usage->hid == (HID_UP_CONSUMER | 0x41)) {
hid                87 drivers/hid/hid-gfrm.c static int gfrm_input_configured(struct hid_device *hid, struct hid_input *hidinput)
hid               133 drivers/hid/hid-gfrm.c MODULE_DEVICE_TABLE(hid, gfrm_devices);
hid               358 drivers/hid/hid-google-hammer.c 	    usage->hid == WHISKERS_KBD_FOLDED) {
hid               370 drivers/hid/hid-google-hammer.c static int hammer_event(struct hid_device *hid, struct hid_field *field,
hid               375 drivers/hid/hid-google-hammer.c 	if (hid->product == USB_DEVICE_ID_GOOGLE_WHISKERS &&
hid               376 drivers/hid/hid-google-hammer.c 	    usage->hid == WHISKERS_KBD_FOLDED) {
hid               379 drivers/hid/hid-google-hammer.c 		hid_dbg(hid, "%s: base: %d, folded: %d\n", __func__,
hid               426 drivers/hid/hid-google-hammer.c 				if (field->usage[j].hid == HID_AD_BRIGHTNESS)
hid               486 drivers/hid/hid-google-hammer.c MODULE_DEVICE_TABLE(hid, hammer_devices);
hid                28 drivers/hid/hid-gyration.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
hid                32 drivers/hid/hid-gyration.c 	switch (usage->hid & HID_USAGE) {
hid                61 drivers/hid/hid-gyration.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
hid                62 drivers/hid/hid-gyration.c 			(usage->hid & 0xff) == 0x82) {
hid                80 drivers/hid/hid-gyration.c MODULE_DEVICE_TABLE(hid, gyration_devices);
hid               121 drivers/hid/hid-holtek-kbd.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               122 drivers/hid/hid-holtek-kbd.c 	struct usb_device *usb_dev = hid_to_usb_dev(hid);
hid               164 drivers/hid/hid-holtek-kbd.c MODULE_DEVICE_TABLE(hid, holtek_kbd_devices);
hid                80 drivers/hid/hid-holtek-mouse.c MODULE_DEVICE_TABLE(hid, holtek_mouse_devices);
hid                76 drivers/hid/hid-holtekff.c 			  struct hid_device *hid,
hid                87 drivers/hid/hid-holtekff.c 	hid_hw_request(hid, holtekff->field->report, HID_REQ_SET_REPORT);
hid                93 drivers/hid/hid-holtekff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               105 drivers/hid/hid-holtekff.c 		holtekff_send(holtekff, hid, stop_all6);
hid               117 drivers/hid/hid-holtekff.c 	holtekff_send(holtekff, hid, buf);
hid               118 drivers/hid/hid-holtekff.c 	holtekff_send(holtekff, hid, start_effect_1);
hid               123 drivers/hid/hid-holtekff.c static int holtekff_init(struct hid_device *hid)
hid               129 drivers/hid/hid-holtekff.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid               133 drivers/hid/hid-holtekff.c 	if (list_empty(&hid->inputs)) {
hid               134 drivers/hid/hid-holtekff.c 		hid_err(hid, "no inputs found\n");
hid               137 drivers/hid/hid-holtekff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid               141 drivers/hid/hid-holtekff.c 		hid_err(hid, "no output report found\n");
hid               148 drivers/hid/hid-holtekff.c 		hid_err(hid, "unexpected output report layout\n");
hid               161 drivers/hid/hid-holtekff.c 	holtekff_send(holtekff, hid, stop_all4);
hid               162 drivers/hid/hid-holtekff.c 	holtekff_send(holtekff, hid, stop_all6);
hid               170 drivers/hid/hid-holtekff.c 	hid_info(hid, "Force feedback for Holtek On Line Grip based devices by Anssi Hannula <anssi.hannula@iki.fi>\n");
hid               175 drivers/hid/hid-holtekff.c static inline int holtekff_init(struct hid_device *hid)
hid               208 drivers/hid/hid-holtekff.c MODULE_DEVICE_TABLE(hid, holtek_devices);
hid               395 drivers/hid/hid-hyperv.c static int mousevsc_hid_parse(struct hid_device *hid)
hid               397 drivers/hid/hid-hyperv.c 	struct hv_device *dev = hid_get_drvdata(hid);
hid               400 drivers/hid/hid-hyperv.c 	return hid_parse_report(hid, input_dev->report_desc,
hid               404 drivers/hid/hid-hyperv.c static int mousevsc_hid_open(struct hid_device *hid)
hid               409 drivers/hid/hid-hyperv.c static int mousevsc_hid_start(struct hid_device *hid)
hid               414 drivers/hid/hid-hyperv.c static void mousevsc_hid_close(struct hid_device *hid)
hid               418 drivers/hid/hid-hyperv.c static void mousevsc_hid_stop(struct hid_device *hid)
hid               422 drivers/hid/hid-hyperv.c static int mousevsc_hid_raw_request(struct hid_device *hid,
hid               177 drivers/hid/hid-icade.c 	trans = icade_find_translation(usage->hid & HID_USAGE);
hid               194 drivers/hid/hid-icade.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) {
hid               195 drivers/hid/hid-icade.c 		trans = icade_find_translation(usage->hid & HID_USAGE);
hid               226 drivers/hid/hid-icade.c MODULE_DEVICE_TABLE(hid, icade_devices);
hid                64 drivers/hid/hid-input.c 	return (usage->hid & (HID_USAGE_PAGE | HID_USAGE)) == scancode;
hid                85 drivers/hid/hid-input.c static struct hid_usage *hidinput_find_key(struct hid_device *hid,
hid                95 drivers/hid/hid-input.c 		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
hid               114 drivers/hid/hid-input.c static struct hid_usage *hidinput_locate_usage(struct hid_device *hid,
hid               122 drivers/hid/hid-input.c 		usage = hidinput_find_key(hid, match_index, ke->index, index);
hid               124 drivers/hid/hid-input.c 		usage = hidinput_find_key(hid, match_scancode, scancode, index);
hid               134 drivers/hid/hid-input.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               138 drivers/hid/hid-input.c 	usage = hidinput_locate_usage(hid, ke, &index);
hid               143 drivers/hid/hid-input.c 		scancode = usage->hid & (HID_USAGE_PAGE | HID_USAGE);
hid               156 drivers/hid/hid-input.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               159 drivers/hid/hid-input.c 	usage = hidinput_locate_usage(hid, ke, NULL);
hid               168 drivers/hid/hid-input.c 			usage->code, usage->hid);
hid               174 drivers/hid/hid-input.c 		if (hidinput_find_key(hid, match_keycode, *old_keycode, NULL))
hid               578 drivers/hid/hid-input.c 			(usage->hid & HID_USAGE_PAGE) != HID_UP_LED) {
hid               591 drivers/hid/hid-input.c 	switch (usage->hid & HID_USAGE_PAGE) {
hid               598 drivers/hid/hid-input.c 		if ((usage->hid & HID_USAGE) < 256) {
hid               599 drivers/hid/hid-input.c 			if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
hid               600 drivers/hid/hid-input.c 			map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
hid               607 drivers/hid/hid-input.c 		code = ((usage->hid - 1) & HID_USAGE);
hid               638 drivers/hid/hid-input.c 		switch (usage->hid & 0xffff) {
hid               649 drivers/hid/hid-input.c 		if ((usage->hid & 0xf0) == 0x80) {	/* SystemControl */
hid               650 drivers/hid/hid-input.c 			switch (usage->hid & 0xf) {
hid               671 drivers/hid/hid-input.c 		if ((usage->hid & 0xf0) == 0xb0) {	/* SC - Display */
hid               672 drivers/hid/hid-input.c 			switch (usage->hid & 0xf) {
hid               688 drivers/hid/hid-input.c 		if ((usage->hid & 0xf0) == 0x90) {	/* D-pad */
hid               689 drivers/hid/hid-input.c 			switch (usage->hid) {
hid               704 drivers/hid/hid-input.c 		switch (usage->hid) {
hid               709 drivers/hid/hid-input.c 				map_rel(usage->hid & 0xf);
hid               711 drivers/hid/hid-input.c 				map_abs_clear(usage->hid & 0xf);
hid               719 drivers/hid/hid-input.c 				map_abs(usage->hid & 0xf);
hid               724 drivers/hid/hid-input.c 				map_rel(usage->hid & 0xf);
hid               726 drivers/hid/hid-input.c 				map_abs(usage->hid & 0xf);
hid               753 drivers/hid/hid-input.c 		switch (usage->hid & 0xffff) {		      /* HID-Value:                   */
hid               776 drivers/hid/hid-input.c 		switch (usage->hid & 0xff) {
hid               851 drivers/hid/hid-input.c 		switch (usage->hid & HID_USAGE) {
hid               874 drivers/hid/hid-input.c 		switch (usage->hid & HID_USAGE) {
hid              1058 drivers/hid/hid-input.c 		switch (usage->hid) {
hid              1068 drivers/hid/hid-input.c 		switch (usage->hid & HID_USAGE) {
hid              1087 drivers/hid/hid-input.c 		switch (usage->hid & HID_USAGE) {
hid              1110 drivers/hid/hid-input.c 		switch (usage->hid & HID_USAGE) {
hid              1263 drivers/hid/hid-input.c void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
hid              1266 drivers/hid/hid-input.c 	unsigned *quirks = &hid->quirks;
hid              1272 drivers/hid/hid-input.c 		hidinput_update_battery(hid, value);
hid              1291 drivers/hid/hid-input.c 	if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
hid              1296 drivers/hid/hid-input.c 	if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
hid              1306 drivers/hid/hid-input.c 	if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
hid              1312 drivers/hid/hid-input.c 	if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
hid              1317 drivers/hid/hid-input.c 	if (usage->hid == (HID_UP_PID | 0x7fUL)) {
hid              1390 drivers/hid/hid-input.c 		input_event(input, EV_MSC, MSC_SCAN, usage->hid);
hid              1401 drivers/hid/hid-input.c void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
hid              1405 drivers/hid/hid-input.c 	if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
hid              1408 drivers/hid/hid-input.c 	list_for_each_entry(hidinput, &hid->inputs, list)
hid              1413 drivers/hid/hid-input.c int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
hid              1418 drivers/hid/hid-input.c 	list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
hid              1430 drivers/hid/hid-input.c struct hid_field *hidinput_get_led_field(struct hid_device *hid)
hid              1437 drivers/hid/hid-input.c 			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
hid              1450 drivers/hid/hid-input.c unsigned int hidinput_count_leds(struct hid_device *hid)
hid              1458 drivers/hid/hid-input.c 			    &hid->report_enum[HID_OUTPUT_REPORT].report_list,
hid              1474 drivers/hid/hid-input.c 	struct hid_device *hid = container_of(work, struct hid_device,
hid              1482 drivers/hid/hid-input.c 	field = hidinput_get_led_field(hid);
hid              1502 drivers/hid/hid-input.c 	if (hid->ll_driver->request)
hid              1503 drivers/hid/hid-input.c 		return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);
hid              1513 drivers/hid/hid-input.c 	ret = hid_hw_output_report(hid, buf, len);
hid              1515 drivers/hid/hid-input.c 		hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
hid              1523 drivers/hid/hid-input.c 	struct hid_device *hid = input_get_drvdata(dev);
hid              1533 drivers/hid/hid-input.c 	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
hid              1540 drivers/hid/hid-input.c 	schedule_work(&hid->led_work);
hid              1546 drivers/hid/hid-input.c 	struct hid_device *hid = input_get_drvdata(dev);
hid              1548 drivers/hid/hid-input.c 	return hid_hw_open(hid);
hid              1553 drivers/hid/hid-input.c 	struct hid_device *hid = input_get_drvdata(dev);
hid              1555 drivers/hid/hid-input.c 	hid_hw_close(hid);
hid              1558 drivers/hid/hid-input.c static bool __hidinput_change_resolution_multipliers(struct hid_device *hid,
hid              1574 drivers/hid/hid-input.c 		hid_hw_request(hid, report, HID_REQ_GET_REPORT);
hid              1575 drivers/hid/hid-input.c 		hid_hw_wait(hid);
hid              1593 drivers/hid/hid-input.c 			if (usage->hid != HID_GD_RESOLUTION_MULTIPLIER)
hid              1604 drivers/hid/hid-input.c static void hidinput_change_resolution_multipliers(struct hid_device *hid)
hid              1610 drivers/hid/hid-input.c 	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
hid              1612 drivers/hid/hid-input.c 		bool update_needed = __hidinput_change_resolution_multipliers(hid,
hid              1616 drivers/hid/hid-input.c 			ret = __hid_request(hid, rep, HID_REQ_SET_REPORT);
hid              1618 drivers/hid/hid-input.c 				__hidinput_change_resolution_multipliers(hid,
hid              1626 drivers/hid/hid-input.c 	hid_setup_resolution_multiplier(hid);
hid              1629 drivers/hid/hid-input.c static void report_features(struct hid_device *hid)
hid              1631 drivers/hid/hid-input.c 	struct hid_driver *drv = hid->driver;
hid              1637 drivers/hid/hid-input.c 	rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
hid              1648 drivers/hid/hid-input.c 				if (usage->hid == HID_DC_BATTERYSTRENGTH)
hid              1649 drivers/hid/hid-input.c 					hidinput_setup_battery(hid, HID_FEATURE_REPORT,
hid              1653 drivers/hid/hid-input.c 					drv->feature_mapping(hid, rep->field[i], usage);
hid              1658 drivers/hid/hid-input.c static struct hid_input *hidinput_allocate(struct hid_device *hid,
hid              1669 drivers/hid/hid-input.c 	if ((hid->quirks & HID_QUIRK_INPUT_PER_APP) &&
hid              1670 drivers/hid/hid-input.c 	    hid->maxapplication > 1) {
hid              1708 drivers/hid/hid-input.c 		name_len = strlen(hid->name);
hid              1711 drivers/hid/hid-input.c 		    strcmp(hid->name + name_len - suffix_len, suffix)) {
hid              1713 drivers/hid/hid-input.c 						   hid->name, suffix);
hid              1719 drivers/hid/hid-input.c 	input_set_drvdata(input_dev, hid);
hid              1726 drivers/hid/hid-input.c 	input_dev->name = hidinput->name ? hidinput->name : hid->name;
hid              1727 drivers/hid/hid-input.c 	input_dev->phys = hid->phys;
hid              1728 drivers/hid/hid-input.c 	input_dev->uniq = hid->uniq;
hid              1729 drivers/hid/hid-input.c 	input_dev->id.bustype = hid->bus;
hid              1730 drivers/hid/hid-input.c 	input_dev->id.vendor  = hid->vendor;
hid              1731 drivers/hid/hid-input.c 	input_dev->id.product = hid->product;
hid              1732 drivers/hid/hid-input.c 	input_dev->id.version = hid->version;
hid              1733 drivers/hid/hid-input.c 	input_dev->dev.parent = &hid->dev;
hid              1737 drivers/hid/hid-input.c 	list_add_tail(&hidinput->list, &hid->inputs);
hid              1746 drivers/hid/hid-input.c 	hid_err(hid, "Out of memory during hid input probe\n");
hid              1785 drivers/hid/hid-input.c static void hidinput_cleanup_hidinput(struct hid_device *hid,
hid              1797 drivers/hid/hid-input.c 			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
hid              1800 drivers/hid/hid-input.c 		list_for_each_entry(report, &hid->report_enum[k].report_list,
hid              1814 drivers/hid/hid-input.c 	struct hid_device *hid = report->device;
hid              1817 drivers/hid/hid-input.c 	list_for_each_entry(hidinput, &hid->inputs, list) {
hid              1828 drivers/hid/hid-input.c 	struct hid_device *hid = report->device;
hid              1831 drivers/hid/hid-input.c 	list_for_each_entry(hidinput, &hid->inputs, list) {
hid              1856 drivers/hid/hid-input.c int hidinput_connect(struct hid_device *hid, unsigned int force)
hid              1858 drivers/hid/hid-input.c 	struct hid_driver *drv = hid->driver;
hid              1864 drivers/hid/hid-input.c 	INIT_LIST_HEAD(&hid->inputs);
hid              1865 drivers/hid/hid-input.c 	INIT_WORK(&hid->led_work, hidinput_led_worker);
hid              1867 drivers/hid/hid-input.c 	hid->status &= ~HID_STAT_DUP_DETECTED;
hid              1870 drivers/hid/hid-input.c 		for (i = 0; i < hid->maxcollection; i++) {
hid              1871 drivers/hid/hid-input.c 			struct hid_collection *col = &hid->collection[i];
hid              1878 drivers/hid/hid-input.c 		if (i == hid->maxcollection)
hid              1882 drivers/hid/hid-input.c 	report_features(hid);
hid              1886 drivers/hid/hid-input.c 			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
hid              1889 drivers/hid/hid-input.c 		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
hid              1900 drivers/hid/hid-input.c 			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
hid              1902 drivers/hid/hid-input.c 			else if (hid->maxapplication > 1 &&
hid              1903 drivers/hid/hid-input.c 				 (hid->quirks & HID_QUIRK_INPUT_PER_APP))
hid              1907 drivers/hid/hid-input.c 				hidinput = hidinput_allocate(hid, application);
hid              1914 drivers/hid/hid-input.c 			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
hid              1922 drivers/hid/hid-input.c 	hidinput_change_resolution_multipliers(hid);
hid              1924 drivers/hid/hid-input.c 	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
hid              1926 drivers/hid/hid-input.c 		    drv->input_configured(hid, hidinput))
hid              1931 drivers/hid/hid-input.c 			hidinput_cleanup_hidinput(hid, hidinput);
hid              1940 drivers/hid/hid-input.c 	if (list_empty(&hid->inputs)) {
hid              1941 drivers/hid/hid-input.c 		hid_err(hid, "No inputs registered, leaving\n");
hid              1945 drivers/hid/hid-input.c 	if (hid->status & HID_STAT_DUP_DETECTED)
hid              1946 drivers/hid/hid-input.c 		hid_dbg(hid,
hid              1953 drivers/hid/hid-input.c 	hidinput_disconnect(hid);
hid              1959 drivers/hid/hid-input.c void hidinput_disconnect(struct hid_device *hid)
hid              1963 drivers/hid/hid-input.c 	hidinput_cleanup_battery(hid);
hid              1965 drivers/hid/hid-input.c 	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
hid              1979 drivers/hid/hid-input.c 	cancel_work_sync(&hid->led_work);
hid                29 drivers/hid/hid-ite.c 	if (usage->hid == HID_GD_RFKILL_BTN) {
hid                49 drivers/hid/hid-ite.c MODULE_DEVICE_TABLE(hid, ite_devices);
hid                26 drivers/hid/hid-jabra.c 		((usage->hid & HID_USAGE_PAGE) >= HID_UP_VENDOR_DEFINED_MIN &&
hid                27 drivers/hid/hid-jabra.c 		 (usage->hid & HID_USAGE_PAGE) <= HID_UP_VENDOR_DEFINED_MAX);
hid                30 drivers/hid/hid-jabra.c 		usage->hid,
hid                44 drivers/hid/hid-jabra.c MODULE_DEVICE_TABLE(hid, jabra_devices);
hid                24 drivers/hid/hid-kensington.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
hid                27 drivers/hid/hid-kensington.c 	switch (usage->hid & HID_USAGE) {
hid                40 drivers/hid/hid-kensington.c MODULE_DEVICE_TABLE(hid, ks_devices);
hid                42 drivers/hid/hid-keytouch.c MODULE_DEVICE_TABLE(hid, keytouch_devices);
hid               771 drivers/hid/hid-kye.c MODULE_DEVICE_TABLE(hid, kye_devices);
hid                24 drivers/hid/hid-lcpower.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
hid                27 drivers/hid/hid-lcpower.c 	switch (usage->hid & HID_USAGE) {
hid                47 drivers/hid/hid-lcpower.c MODULE_DEVICE_TABLE(hid, ts_devices);
hid               523 drivers/hid/hid-led.c MODULE_DEVICE_TABLE(hid, hidled_table);
hid                88 drivers/hid/hid-lenovo.c 	if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
hid               102 drivers/hid/hid-lenovo.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR ||
hid               103 drivers/hid/hid-lenovo.c 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) {
hid               104 drivers/hid/hid-lenovo.c 		switch (usage->hid & HID_USAGE) {
hid               140 drivers/hid/hid-lenovo.c 	if (usage->hid == HID_GD_WHEEL)
hid               142 drivers/hid/hid-lenovo.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON &&
hid               143 drivers/hid/hid-lenovo.c 			(usage->hid & HID_USAGE) == 0x003)
hid               145 drivers/hid/hid-lenovo.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
hid               146 drivers/hid/hid-lenovo.c 			(usage->hid & HID_USAGE) == 0x238)
hid               150 drivers/hid/hid-lenovo.c 	if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 ||
hid               151 drivers/hid/hid-lenovo.c 	    (usage->hid & HID_USAGE_PAGE) == 0xffa10000) {
hid               156 drivers/hid/hid-lenovo.c 		switch (usage->hid & HID_USAGE) {
hid               175 drivers/hid/hid-lenovo.c 	if (usage->hid == HID_GD_Z) {
hid               926 drivers/hid/hid-lenovo.c MODULE_DEVICE_TABLE(hid, lenovo_devices);
hid               541 drivers/hid/hid-lg.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
hid               545 drivers/hid/hid-lg.c 	switch (usage->hid & HID_USAGE) {
hid               574 drivers/hid/hid-lg.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
hid               577 drivers/hid/hid-lg.c 	switch (usage->hid & HID_USAGE) {
hid               590 drivers/hid/hid-lg.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
hid               593 drivers/hid/hid-lg.c 	switch (usage->hid & HID_USAGE) {
hid               665 drivers/hid/hid-lg.c 	unsigned int hid = usage->hid;
hid               678 drivers/hid/hid-lg.c 	if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
hid               681 drivers/hid/hid-lg.c 	hid &= HID_USAGE;
hid               686 drivers/hid/hid-lg.c 				(hid == 7 || hid == 8))
hid               690 drivers/hid/hid-lg.c 				hid < ARRAY_SIZE(e_keymap) &&
hid               691 drivers/hid/hid-lg.c 				e_keymap[hid] != 0) {
hid               693 drivers/hid/hid-lg.c 					e_keymap[hid]);
hid               942 drivers/hid/hid-lg.c MODULE_DEVICE_TABLE(hid, lg_devices);
hid                25 drivers/hid/hid-lg2ff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                45 drivers/hid/hid-lg2ff.c 	hid_hw_request(hid, lg2ff->report, HID_REQ_SET_REPORT);
hid                49 drivers/hid/hid-lg2ff.c int lg2ff_init(struct hid_device *hid)
hid                57 drivers/hid/hid-lg2ff.c 	if (list_empty(&hid->inputs)) {
hid                58 drivers/hid/hid-lg2ff.c 		hid_err(hid, "no inputs found\n");
hid                61 drivers/hid/hid-lg2ff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid                65 drivers/hid/hid-lg2ff.c 	report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7);
hid                90 drivers/hid/hid-lg2ff.c 	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid                92 drivers/hid/hid-lg2ff.c 	hid_info(hid, "Force feedback for Logitech variant 2 rumble devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
hid                51 drivers/hid/hid-lg3ff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                52 drivers/hid/hid-lg3ff.c 	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                82 drivers/hid/hid-lg3ff.c 		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid                89 drivers/hid/hid-lg3ff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                90 drivers/hid/hid-lg3ff.c 	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid               108 drivers/hid/hid-lg3ff.c 	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid               118 drivers/hid/hid-lg3ff.c int lg3ff_init(struct hid_device *hid)
hid               126 drivers/hid/hid-lg3ff.c 	if (list_empty(&hid->inputs)) {
hid               127 drivers/hid/hid-lg3ff.c 		hid_err(hid, "no inputs found\n");
hid               130 drivers/hid/hid-lg3ff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid               134 drivers/hid/hid-lg3ff.c 	if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 35))
hid               148 drivers/hid/hid-lg3ff.c 	hid_info(hid, "Force feedback for Logitech Flight System G940 by Gary Stein <LordCnidarian@gmail.com>\n");
hid                61 drivers/hid/hid-lg4ff.c static void lg4ff_set_range_dfp(struct hid_device *hid, u16 range);
hid                62 drivers/hid/hid-lg4ff.c static void lg4ff_set_range_g25(struct hid_device *hid, u16 range);
hid                79 drivers/hid/hid-lg4ff.c 	void (*set_range)(struct hid_device *hid, u16 range);
hid               103 drivers/hid/hid-lg4ff.c 	void (*set_range)(struct hid_device *hid, u16 range);
hid               300 drivers/hid/hid-lg4ff.c int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field,
hid               307 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found");
hid               408 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               415 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               417 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               423 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               446 drivers/hid/hid-lg4ff.c 			hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               459 drivers/hid/hid-lg4ff.c 		hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               470 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               477 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               479 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               485 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               501 drivers/hid/hid-lg4ff.c 		hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               532 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               543 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               550 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               557 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               559 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               565 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               579 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               584 drivers/hid/hid-lg4ff.c static void lg4ff_set_range_g25(struct hid_device *hid, u16 range)
hid               591 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               593 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               599 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               614 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               619 drivers/hid/hid-lg4ff.c static void lg4ff_set_range_dfp(struct hid_device *hid, u16 range)
hid               627 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               629 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               635 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               658 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               670 drivers/hid/hid-lg4ff.c 		hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               685 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               763 drivers/hid/hid-lg4ff.c static int lg4ff_switch_compatibility_mode(struct hid_device *hid, const struct lg4ff_compat_mode_switch *s)
hid               771 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               773 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               779 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               791 drivers/hid/hid-lg4ff.c 		hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid               794 drivers/hid/hid-lg4ff.c 	hid_hw_wait(hid);
hid               800 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid               806 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               808 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               814 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               819 drivers/hid/hid-lg4ff.c 		hid_err(hid, "NULL pointer to string\n");
hid               849 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid               857 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               859 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               865 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               899 drivers/hid/hid-lg4ff.c 		hid_info(hid, "Requested mode \"%s\" is not supported by the device\n", lbuf);
hid               910 drivers/hid/hid-lg4ff.c 		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",
hid               918 drivers/hid/hid-lg4ff.c 		hid_info(hid, "\"%s\" cannot be switched back into \"%s\" mode\n", entry->wdata.real_name, lg4ff_alternate_modes[i].name);
hid               924 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Invalid target product ID %X\n", target_product_id);
hid               928 drivers/hid/hid-lg4ff.c 	ret = lg4ff_switch_compatibility_mode(hid, s);
hid               936 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid               941 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               943 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               949 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               960 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid               965 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               967 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid               973 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid               989 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid               994 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid               996 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid              1002 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid              1015 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid              1020 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid              1022 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid              1028 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid              1038 drivers/hid/hid-lg4ff.c 		entry->wdata.set_range(hid, range);
hid              1048 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid              1053 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid              1055 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid              1061 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid              1066 drivers/hid/hid-lg4ff.c 		hid_err(hid, "NULL pointer to string\n");
hid              1082 drivers/hid/hid-lg4ff.c static void lg4ff_set_leds(struct hid_device *hid, u8 leds)
hid              1089 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid              1091 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Private driver data not found!\n");
hid              1097 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found!\n");
hid              1110 drivers/hid/hid-lg4ff.c 	hid_hw_request(hid, entry->report, HID_REQ_SET_REPORT);
hid              1118 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid              1119 drivers/hid/hid-lg4ff.c 	struct lg_drv_data *drv_data = hid_get_drvdata(hid);
hid              1124 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device data not found.");
hid              1131 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found.");
hid              1141 drivers/hid/hid-lg4ff.c 			lg4ff_set_leds(hid, entry->wdata.led_state);
hid              1144 drivers/hid/hid-lg4ff.c 			lg4ff_set_leds(hid, entry->wdata.led_state);
hid              1153 drivers/hid/hid-lg4ff.c 	struct hid_device *hid = to_hid_device(dev);
hid              1154 drivers/hid/hid-lg4ff.c 	struct lg_drv_data *drv_data = hid_get_drvdata(hid);
hid              1159 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device data not found.");
hid              1166 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Device properties not found.");
hid              1180 drivers/hid/hid-lg4ff.c static u16 lg4ff_identify_multimode_wheel(struct hid_device *hid, const u16 reported_product_id, const u16 bcdDevice)
hid              1215 drivers/hid/hid-lg4ff.c static int lg4ff_handle_multimode_wheel(struct hid_device *hid, u16 *real_product_id, const u16 bcdDevice)
hid              1217 drivers/hid/hid-lg4ff.c 	const u16 reported_product_id = hid->product;
hid              1220 drivers/hid/hid-lg4ff.c 	*real_product_id = lg4ff_identify_multimode_wheel(hid, reported_product_id, bcdDevice);
hid              1236 drivers/hid/hid-lg4ff.c 			hid_err(hid, "Invalid product id %X\n", *real_product_id);
hid              1240 drivers/hid/hid-lg4ff.c 		ret = lg4ff_switch_compatibility_mode(hid, s);
hid              1244 drivers/hid/hid-lg4ff.c 			hid_err(hid, "Unable to switch wheel mode, errno %d\n", ret);
hid              1254 drivers/hid/hid-lg4ff.c int lg4ff_init(struct hid_device *hid)
hid              1258 drivers/hid/hid-lg4ff.c 	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid              1260 drivers/hid/hid-lg4ff.c 	const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor);
hid              1269 drivers/hid/hid-lg4ff.c 	if (list_empty(&hid->inputs)) {
hid              1270 drivers/hid/hid-lg4ff.c 		hid_err(hid, "no inputs found\n");
hid              1273 drivers/hid/hid-lg4ff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid              1277 drivers/hid/hid-lg4ff.c 	if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7))
hid              1280 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid              1282 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Cannot add device, private driver data not allocated\n");
hid              1294 drivers/hid/hid-lg4ff.c 	mmode_ret = lg4ff_handle_multimode_wheel(hid, &real_product_id, bcdDevice);
hid              1302 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Unable to switch device mode during initialization, errno %d\n", mmode_ret);
hid              1309 drivers/hid/hid-lg4ff.c 		if (hid->product == lg4ff_devices[i].product_id) {
hid              1316 drivers/hid/hid-lg4ff.c 		hid_err(hid, "This device is flagged to be handled by the lg4ff module but this module does not know how to handle it. "
hid              1330 drivers/hid/hid-lg4ff.c 			hid_err(hid, "Device product ID %X is not listed as a multimode wheel", real_product_id);
hid              1366 drivers/hid/hid-lg4ff.c 	error = device_create_file(&hid->dev, &dev_attr_combine_pedals);
hid              1368 drivers/hid/hid-lg4ff.c 		hid_warn(hid, "Unable to create sysfs interface for \"combine\", errno %d\n", error);
hid              1369 drivers/hid/hid-lg4ff.c 	error = device_create_file(&hid->dev, &dev_attr_range);
hid              1371 drivers/hid/hid-lg4ff.c 		hid_warn(hid, "Unable to create sysfs interface for \"range\", errno %d\n", error);
hid              1373 drivers/hid/hid-lg4ff.c 		error = device_create_file(&hid->dev, &dev_attr_real_id);
hid              1375 drivers/hid/hid-lg4ff.c 			hid_warn(hid, "Unable to create sysfs interface for \"real_id\", errno %d\n", error);
hid              1376 drivers/hid/hid-lg4ff.c 		error = device_create_file(&hid->dev, &dev_attr_alternate_modes);
hid              1378 drivers/hid/hid-lg4ff.c 			hid_warn(hid, "Unable to create sysfs interface for \"alternate_modes\", errno %d\n", error);
hid              1385 drivers/hid/hid-lg4ff.c 		entry->wdata.set_range(hid, entry->wdata.range);
hid              1399 drivers/hid/hid-lg4ff.c 		lg4ff_set_leds(hid, 0);
hid              1401 drivers/hid/hid-lg4ff.c 		name_sz = strlen(dev_name(&hid->dev)) + 8;
hid              1406 drivers/hid/hid-lg4ff.c 				hid_err(hid, "can't allocate memory for LED %d\n", j);
hid              1411 drivers/hid/hid-lg4ff.c 			snprintf(name, name_sz, "%s::RPM%d", dev_name(&hid->dev), j+1);
hid              1419 drivers/hid/hid-lg4ff.c 			error = led_classdev_register(&hid->dev, led);
hid              1422 drivers/hid/hid-lg4ff.c 				hid_err(hid, "failed to register LED %d. Aborting.\n", j);
hid              1439 drivers/hid/hid-lg4ff.c 	hid_info(hid, "Force feedback support for Logitech Gaming Wheels\n");
hid              1448 drivers/hid/hid-lg4ff.c int lg4ff_deinit(struct hid_device *hid)
hid              1453 drivers/hid/hid-lg4ff.c 	drv_data = hid_get_drvdata(hid);
hid              1455 drivers/hid/hid-lg4ff.c 		hid_err(hid, "Error while deinitializing device, no private driver data.\n");
hid              1464 drivers/hid/hid-lg4ff.c 		device_remove_file(&hid->dev, &dev_attr_real_id);
hid              1465 drivers/hid/hid-lg4ff.c 		device_remove_file(&hid->dev, &dev_attr_alternate_modes);
hid              1468 drivers/hid/hid-lg4ff.c 	device_remove_file(&hid->dev, &dev_attr_combine_pedals);
hid              1469 drivers/hid/hid-lg4ff.c 	device_remove_file(&hid->dev, &dev_attr_range);
hid                 8 drivers/hid/hid-lg4ff.h int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field,
hid                15 drivers/hid/hid-lg4ff.h static inline int lg4ff_adjust_input_event(struct hid_device *hid, struct hid_field *field,
hid                59 drivers/hid/hid-lgff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                60 drivers/hid/hid-lgff.c 	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                78 drivers/hid/hid-lgff.c 		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid                93 drivers/hid/hid-lgff.c 		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid               101 drivers/hid/hid-lgff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               102 drivers/hid/hid-lgff.c 	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid               113 drivers/hid/hid-lgff.c 	hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid               116 drivers/hid/hid-lgff.c int lgff_init(struct hid_device* hid)
hid               124 drivers/hid/hid-lgff.c 	if (list_empty(&hid->inputs)) {
hid               125 drivers/hid/hid-lgff.c 		hid_err(hid, "no inputs found\n");
hid               128 drivers/hid/hid-lgff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid               132 drivers/hid/hid-lgff.c 	if (!hid_validate_values(hid, HID_OUTPUT_REPORT, 0, 0, 7))
hid              1218 drivers/hid/hid-logitech-dj.c static int logi_dj_ll_open(struct hid_device *hid)
hid              1220 drivers/hid/hid-logitech-dj.c 	dbg_hid("%s: %s\n", __func__, hid->phys);
hid              1225 drivers/hid/hid-logitech-dj.c static void logi_dj_ll_close(struct hid_device *hid)
hid              1227 drivers/hid/hid-logitech-dj.c 	dbg_hid("%s: %s\n", __func__, hid->phys);
hid              1243 drivers/hid/hid-logitech-dj.c static int logi_dj_ll_raw_request(struct hid_device *hid,
hid              1248 drivers/hid/hid-logitech-dj.c 	struct dj_device *djdev = hid->driver_data;
hid              1275 drivers/hid/hid-logitech-dj.c 			hid_warn(hid, "Received REPORT_TYPE_LEDS request before the keyboard interface was enumerated\n");
hid              1307 drivers/hid/hid-logitech-dj.c static int logi_dj_ll_parse(struct hid_device *hid)
hid              1309 drivers/hid/hid-logitech-dj.c 	struct dj_device *djdev = hid->driver_data;
hid              1375 drivers/hid/hid-logitech-dj.c 	retval = hid_parse_report(hid, rdesc, rsize);
hid              1381 drivers/hid/hid-logitech-dj.c static int logi_dj_ll_start(struct hid_device *hid)
hid              1387 drivers/hid/hid-logitech-dj.c static void logi_dj_ll_stop(struct hid_device *hid)
hid              1887 drivers/hid/hid-logitech-dj.c MODULE_DEVICE_TABLE(hid, logi_dj_receivers);
hid              2052 drivers/hid/hid-logitech-hidpp.c 	struct hid_device *hid = to_hid_device(dev);
hid              2053 drivers/hid/hid-logitech-hidpp.c 	struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid              2062 drivers/hid/hid-logitech-hidpp.c 	struct hid_device *hid = to_hid_device(dev);
hid              2063 drivers/hid/hid-logitech-hidpp.c 	struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid              2084 drivers/hid/hid-logitech-hidpp.c 	struct hid_device *hid = data->hidpp->hid_dev;
hid              2086 drivers/hid/hid-logitech-hidpp.c 	hid_info(hid, "Unloading HID++ force feedback.\n");
hid              2088 drivers/hid/hid-logitech-hidpp.c 	device_remove_file(&hid->dev, &dev_attr_range);
hid              2096 drivers/hid/hid-logitech-hidpp.c 	struct hid_device *hid = hidpp->hid_dev;
hid              2099 drivers/hid/hid-logitech-hidpp.c 	const struct usb_device_descriptor *udesc = &(hid_to_usb_dev(hid)->descriptor);
hid              2105 drivers/hid/hid-logitech-hidpp.c 	if (list_empty(&hid->inputs)) {
hid              2106 drivers/hid/hid-logitech-hidpp.c 		hid_err(hid, "no inputs found\n");
hid              2109 drivers/hid/hid-logitech-hidpp.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid              2113 drivers/hid/hid-logitech-hidpp.c 		hid_err(hid, "Struct input_dev not set!\n");
hid              2175 drivers/hid/hid-logitech-hidpp.c 	hid_info(hid, "Force feedback support loaded (firmware release %d).\n",
hid              3314 drivers/hid/hid-logitech-hidpp.c 	struct hid_device *hid = input_get_drvdata(dev);
hid              3316 drivers/hid/hid-logitech-hidpp.c 	return hid_hw_open(hid);
hid              3321 drivers/hid/hid-logitech-hidpp.c 	struct hid_device *hid = input_get_drvdata(dev);
hid              3323 drivers/hid/hid-logitech-hidpp.c 	hid_hw_close(hid);
hid              3814 drivers/hid/hid-logitech-hidpp.c MODULE_DEVICE_TABLE(hid, hidpp_devices);
hid                37 drivers/hid/hid-macally.c MODULE_DEVICE_TABLE(hid, macally_id_table);
hid               701 drivers/hid/hid-magicmouse.c MODULE_DEVICE_TABLE(hid, magic_mice);
hid               156 drivers/hid/hid-maltron.c MODULE_DEVICE_TABLE(hid, maltron_devices);
hid                36 drivers/hid/hid-mf.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                52 drivers/hid/hid-mf.c 	hid_hw_request(hid, mf->report, HID_REQ_SET_REPORT);
hid                57 drivers/hid/hid-mf.c static int mf_init(struct hid_device *hid)
hid                62 drivers/hid/hid-mf.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                67 drivers/hid/hid-mf.c 	struct list_head *input_ptr = &hid->inputs;
hid                79 drivers/hid/hid-mf.c 			hid_err(hid, "Invalid report, this should never happen!\n");
hid                83 drivers/hid/hid-mf.c 		if (list_is_last(input_ptr, &hid->inputs)) {
hid                84 drivers/hid/hid-mf.c 			hid_err(hid, "Missing input, this should never happen!\n");
hid               107 drivers/hid/hid-mf.c 		hid_hw_request(hid, mf->report, HID_REQ_SET_REPORT);
hid               110 drivers/hid/hid-mf.c 	hid_info(hid, "Force feedback for HJZ Mayflash game controller "
hid               116 drivers/hid/hid-mf.c static int mf_probe(struct hid_device *hid, const struct hid_device_id *id)
hid               120 drivers/hid/hid-mf.c 	dev_dbg(&hid->dev, "Mayflash HID hardware probe...\n");
hid               123 drivers/hid/hid-mf.c 	hid->quirks |= id->driver_data;
hid               125 drivers/hid/hid-mf.c 	error = hid_parse(hid);
hid               127 drivers/hid/hid-mf.c 		hid_err(hid, "HID parse failed.\n");
hid               131 drivers/hid/hid-mf.c 	error = hid_hw_start(hid, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
hid               133 drivers/hid/hid-mf.c 		hid_err(hid, "HID hw start failed\n");
hid               137 drivers/hid/hid-mf.c 	error = mf_init(hid);
hid               139 drivers/hid/hid-mf.c 		hid_err(hid, "Force feedback init failed.\n");
hid               140 drivers/hid/hid-mf.c 		hid_hw_stop(hid);
hid               158 drivers/hid/hid-mf.c MODULE_DEVICE_TABLE(hid, mf_devices);
hid                85 drivers/hid/hid-microsoft.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
hid                86 drivers/hid/hid-microsoft.c 		switch (usage->hid & HID_USAGE) {
hid               101 drivers/hid/hid-microsoft.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
hid               104 drivers/hid/hid-microsoft.c 	switch (usage->hid & HID_USAGE) {
hid               145 drivers/hid/hid-microsoft.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
hid               149 drivers/hid/hid-microsoft.c 	switch (usage->hid & HID_USAGE) {
hid               164 drivers/hid/hid-microsoft.c 	switch (usage->hid & HID_USAGE_PAGE) {
hid               171 drivers/hid/hid-microsoft.c 		switch (usage->hid) {
hid               239 drivers/hid/hid-microsoft.c 	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff00)) {
hid               247 drivers/hid/hid-microsoft.c 	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff01)) {
hid               262 drivers/hid/hid-microsoft.c 	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
hid               313 drivers/hid/hid-microsoft.c 	struct hid_device *hid = input_get_drvdata(dev);
hid               314 drivers/hid/hid-microsoft.c 	struct ms_data *ms = hid_get_drvdata(hid);
hid               456 drivers/hid/hid-microsoft.c MODULE_DEVICE_TABLE(hid, ms_devices);
hid                37 drivers/hid/hid-monterey.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
hid                40 drivers/hid/hid-monterey.c 	switch (usage->hid & HID_USAGE) {
hid                55 drivers/hid/hid-monterey.c MODULE_DEVICE_TABLE(hid, mr_devices);
hid               462 drivers/hid/hid-multitouch.c 	switch (usage->hid) {
hid               615 drivers/hid/hid-multitouch.c 			if (field->usage[n].hid == HID_DG_CONTACTID)
hid               702 drivers/hid/hid-multitouch.c 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
hid               708 drivers/hid/hid-multitouch.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
hid               714 drivers/hid/hid-multitouch.c 	switch (usage->hid & HID_USAGE_PAGE) {
hid               717 drivers/hid/hid-multitouch.c 		switch (usage->hid) {
hid               719 drivers/hid/hid-multitouch.c 			if (prev_usage && (prev_usage->hid == usage->hid)) {
hid               744 drivers/hid/hid-multitouch.c 			if (prev_usage && (prev_usage->hid == usage->hid)) {
hid               759 drivers/hid/hid-multitouch.c 		switch (usage->hid) {
hid               853 drivers/hid/hid-multitouch.c 		code = BTN_MOUSE + ((usage->hid - 1) & HID_USAGE);
hid               860 drivers/hid/hid-multitouch.c 		    (usage->hid & HID_USAGE) > 1)
hid               864 drivers/hid/hid-multitouch.c 			code = BTN_0  + ((usage->hid - 1) & HID_USAGE);
hid               967 drivers/hid/hid-multitouch.c static int mt_touch_event(struct hid_device *hid, struct hid_field *field,
hid               971 drivers/hid/hid-multitouch.c 	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
hid               972 drivers/hid/hid-multitouch.c 		hid->hiddev_hid_event(hid, field, usage, value);
hid              1104 drivers/hid/hid-multitouch.c static void mt_process_mt_event(struct hid_device *hid,
hid              1114 drivers/hid/hid-multitouch.c 	if (!usage->type || !(hid->claimed & HID_CLAIMED_INPUT))
hid              1143 drivers/hid/hid-multitouch.c static void mt_touch_report(struct hid_device *hid,
hid              1146 drivers/hid/hid-multitouch.c 	struct mt_device *td = hid_get_drvdata(hid);
hid              1206 drivers/hid/hid-multitouch.c 			mt_process_mt_event(hid, app, field,
hid              1332 drivers/hid/hid-multitouch.c 	    (usage->hid & HID_USAGE_PAGE) == HID_UP_CUSTOM) {
hid              1336 drivers/hid/hid-multitouch.c 		switch (usage->hid & HID_USAGE) {
hid              1380 drivers/hid/hid-multitouch.c static int mt_event(struct hid_device *hid, struct hid_field *field,
hid              1383 drivers/hid/hid-multitouch.c 	struct mt_device *td = hid_get_drvdata(hid);
hid              1388 drivers/hid/hid-multitouch.c 		return mt_touch_event(hid, field, usage, value);
hid              1393 drivers/hid/hid-multitouch.c static void mt_report(struct hid_device *hid, struct hid_report *report)
hid              1395 drivers/hid/hid-multitouch.c 	struct mt_device *td = hid_get_drvdata(hid);
hid              1399 drivers/hid/hid-multitouch.c 	if (!(hid->claimed & HID_CLAIMED_INPUT))
hid              1404 drivers/hid/hid-multitouch.c 		return mt_touch_report(hid, rdata);
hid              1426 drivers/hid/hid-multitouch.c 	switch (usage->hid) {
hid              1614 drivers/hid/hid-multitouch.c 	if (field->usage[0].hid != usage ||
hid              1640 drivers/hid/hid-multitouch.c static void mt_release_contacts(struct hid_device *hid)
hid              1644 drivers/hid/hid-multitouch.c 	struct mt_device *td = hid_get_drvdata(hid);
hid              1646 drivers/hid/hid-multitouch.c 	list_for_each_entry(hidinput, &hid->inputs, list) {
hid              2161 drivers/hid/hid-multitouch.c MODULE_DEVICE_TABLE(hid, mt_devices);
hid                46 drivers/hid/hid-nti.c MODULE_DEVICE_TABLE(hid, nti_devices);
hid               464 drivers/hid/hid-ntrig.c 	switch (usage->hid & HID_USAGE_PAGE) {
hid               466 drivers/hid/hid-ntrig.c 		switch (usage->hid) {
hid               515 drivers/hid/hid-ntrig.c 		switch (usage->hid) {
hid               566 drivers/hid/hid-ntrig.c static int ntrig_event (struct hid_device *hid, struct hid_field *field,
hid               569 drivers/hid/hid-ntrig.c 	struct ntrig_data *nd = hid_get_drvdata(hid);
hid               573 drivers/hid/hid-ntrig.c 	if (!(hid->claimed & HID_CLAIMED_INPUT))
hid               587 drivers/hid/hid-ntrig.c 	switch (usage->hid) {
hid               852 drivers/hid/hid-ntrig.c 	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
hid               853 drivers/hid/hid-ntrig.c 		hid->hiddev_hid_event(hid, field, usage, value);
hid               858 drivers/hid/hid-ntrig.c static int ntrig_input_configured(struct hid_device *hid,
hid              1012 drivers/hid/hid-ntrig.c MODULE_DEVICE_TABLE(hid, ntrig_devices);
hid                45 drivers/hid/hid-ortek.c MODULE_DEVICE_TABLE(hid, ortek_devices);
hid                22 drivers/hid/hid-penmount.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
hid                23 drivers/hid/hid-penmount.c 		if (((usage->hid - 1) & HID_USAGE) == 0) {
hid                38 drivers/hid/hid-penmount.c MODULE_DEVICE_TABLE(hid, penmount_devices);
hid                41 drivers/hid/hid-petalynx.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR) {
hid                42 drivers/hid/hid-petalynx.c 		switch (usage->hid & HID_USAGE) {
hid                54 drivers/hid/hid-petalynx.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
hid                55 drivers/hid/hid-petalynx.c 		switch (usage->hid & HID_USAGE) {
hid                94 drivers/hid/hid-petalynx.c MODULE_DEVICE_TABLE(hid, pl_devices);
hid               644 drivers/hid/hid-picolcd_core.c MODULE_DEVICE_TABLE(hid, picolcd_devices);
hid                50 drivers/hid/hid-pl.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                64 drivers/hid/hid-pl.c 	hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT);
hid                69 drivers/hid/hid-pl.c static int plff_init(struct hid_device *hid)
hid                75 drivers/hid/hid-pl.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                97 drivers/hid/hid-pl.c 		hid_err(hid, "no output reports found\n");
hid               101 drivers/hid/hid-pl.c 	list_for_each_entry(hidinput, &hid->inputs, list) {
hid               106 drivers/hid/hid-pl.c 			hid_err(hid, "required output report is missing\n");
hid               112 drivers/hid/hid-pl.c 			hid_err(hid, "no fields in the report\n");
hid               124 drivers/hid/hid-pl.c 			   report->field[0]->usage[0].hid ==
hid               135 drivers/hid/hid-pl.c 			if (hid->vendor == USB_VENDOR_ID_JESS2)
hid               139 drivers/hid/hid-pl.c 			hid_err(hid, "not enough fields or values\n");
hid               164 drivers/hid/hid-pl.c 		hid_hw_request(hid, plff->report, HID_REQ_SET_REPORT);
hid               167 drivers/hid/hid-pl.c 	hid_info(hid, "Force feedback for PantherLord/GreenAsia devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
hid               172 drivers/hid/hid-pl.c static inline int plff_init(struct hid_device *hid)
hid               213 drivers/hid/hid-pl.c MODULE_DEVICE_TABLE(hid, pl_devices);
hid                37 drivers/hid/hid-plantronics.c 			    (usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
hid                75 drivers/hid/hid-plantronics.c 		switch (usage->hid) {
hid                98 drivers/hid/hid-plantronics.c 		usage->hid, field->application);
hid               104 drivers/hid/hid-plantronics.c 		usage->hid, field->application, mapped_key);
hid               159 drivers/hid/hid-plantronics.c MODULE_DEVICE_TABLE(hid, plantronics_devices);
hid                17 drivers/hid/hid-primax.c static int px_raw_event(struct hid_device *hid, struct hid_report *report,
hid                47 drivers/hid/hid-primax.c 		hid_report_raw_event(hid, HID_INPUT_REPORT, data, size, 0);
hid                52 drivers/hid/hid-primax.c 		hid_info(hid, "unknown report type %d\n", report->id);
hid                63 drivers/hid/hid-primax.c MODULE_DEVICE_TABLE(hid, px_devices);
hid               767 drivers/hid/hid-prodikeys.c 	if (HID_UP_MSVENDOR == (usage->hid & HID_USAGE_PAGE) &&
hid               881 drivers/hid/hid-prodikeys.c MODULE_DEVICE_TABLE(hid, pk_devices);
hid                52 drivers/hid/hid-redragon.c MODULE_DEVICE_TABLE(hid, redragon_devices);
hid                86 drivers/hid/hid-retrode.c MODULE_DEVICE_TABLE(hid, retrode_devices);
hid               408 drivers/hid/hid-rmi.c 			if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON)
hid               411 drivers/hid/hid-rmi.c 			if ((usage->hid == HID_GD_X || usage->hid == HID_GD_Y)
hid               423 drivers/hid/hid-rmi.c static void rmi_report(struct hid_device *hid, struct hid_report *report)
hid               427 drivers/hid/hid-rmi.c 	if (!(hid->claimed & HID_CLAIMED_INPUT))
hid               555 drivers/hid/hid-rmi.c 		    ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON))
hid               767 drivers/hid/hid-rmi.c MODULE_DEVICE_TABLE(hid, rmi_id);
hid               419 drivers/hid/hid-roccat-arvo.c MODULE_DEVICE_TABLE(hid, arvo_devices);
hid               422 drivers/hid/hid-roccat-isku.c MODULE_DEVICE_TABLE(hid, isku_devices);
hid               866 drivers/hid/hid-roccat-kone.c MODULE_DEVICE_TABLE(hid, kone_devices);
hid               534 drivers/hid/hid-roccat-koneplus.c MODULE_DEVICE_TABLE(hid, koneplus_devices);
hid               193 drivers/hid/hid-roccat-konepure.c MODULE_DEVICE_TABLE(hid, konepure_devices);
hid               624 drivers/hid/hid-roccat-kovaplus.c MODULE_DEVICE_TABLE(hid, kovaplus_devices);
hid               200 drivers/hid/hid-roccat-lua.c MODULE_DEVICE_TABLE(hid, lua_devices);
hid               570 drivers/hid/hid-roccat-pyra.c MODULE_DEVICE_TABLE(hid, pyra_devices);
hid               202 drivers/hid/hid-roccat-ryos.c MODULE_DEVICE_TABLE(hid, ryos_devices);
hid               190 drivers/hid/hid-roccat-savu.c MODULE_DEVICE_TABLE(hid, savu_devices);
hid                46 drivers/hid/hid-roccat.c 	struct hid_device *hid;
hid               173 drivers/hid/hid-roccat.c 		error = hid_hw_power(device->hid, PM_HINT_FULLON);
hid               179 drivers/hid/hid-roccat.c 		error = hid_hw_open(device->hid);
hid               181 drivers/hid/hid-roccat.c 			hid_hw_power(device->hid, PM_HINT_NORMAL);
hid               226 drivers/hid/hid-roccat.c 			hid_hw_power(device->hid, PM_HINT_NORMAL);
hid               227 drivers/hid/hid-roccat.c 			hid_hw_close(device->hid);
hid               294 drivers/hid/hid-roccat.c int roccat_connect(struct class *klass, struct hid_device *hid, int report_size)
hid               320 drivers/hid/hid-roccat.c 	device->dev = device_create(klass, &hid->dev,
hid               322 drivers/hid/hid-roccat.c 			"%s%s%d", "roccat", hid->driver->name, minor);
hid               339 drivers/hid/hid-roccat.c 	device->hid = hid;
hid               368 drivers/hid/hid-roccat.c 		hid_hw_close(device->hid);
hid               193 drivers/hid/hid-saitek.c MODULE_DEVICE_TABLE(hid, saitek_devices);
hid               102 drivers/hid/hid-samsung.c 	if (1 != ifnum || HID_UP_CONSUMER != (usage->hid & HID_USAGE_PAGE))
hid               106 drivers/hid/hid-samsung.c 		usage->hid & HID_USAGE);
hid               108 drivers/hid/hid-samsung.c 	switch (usage->hid & HID_USAGE) {
hid               185 drivers/hid/hid-samsung.c MODULE_DEVICE_TABLE(hid, samsung_devices);
hid               491 drivers/hid/hid-sensor-custom.c 		sensor_field->attribute.attrib_id = field->usage[0].hid;
hid               361 drivers/hid/hid-sensor-hub.c 		if (field->usage[i].hid == usage_id)
hid               398 drivers/hid/hid-sensor-hub.c 					field->usage[0].hid ==
hid               493 drivers/hid/hid-sensor-hub.c 				report->field[i]->usage->hid,
hid               512 drivers/hid/hid-sensor-hub.c 					      report->field[i]->usage->hid ||
hid               530 drivers/hid/hid-sensor-hub.c 					report->field[i]->usage->hid, sz, ptr,
hid               753 drivers/hid/hid-sensor-hub.c MODULE_DEVICE_TABLE(hid, sensor_hub_devices);
hid                32 drivers/hid/hid-sjoy.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                46 drivers/hid/hid-sjoy.c 	hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT);
hid                51 drivers/hid/hid-sjoy.c static int sjoyff_init(struct hid_device *hid)
hid                57 drivers/hid/hid-sjoy.c 			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid                63 drivers/hid/hid-sjoy.c 		hid_err(hid, "no output reports found\n");
hid                67 drivers/hid/hid-sjoy.c 	list_for_each_entry(hidinput, &hid->inputs, list) {
hid                71 drivers/hid/hid-sjoy.c 			hid_err(hid, "required output report is missing\n");
hid                77 drivers/hid/hid-sjoy.c 			hid_err(hid, "no fields in the report\n");
hid                82 drivers/hid/hid-sjoy.c 			hid_err(hid, "not enough values in the field\n");
hid               104 drivers/hid/hid-sjoy.c 		hid_hw_request(hid, sjoyff->report, HID_REQ_SET_REPORT);
hid               107 drivers/hid/hid-sjoy.c 	hid_info(hid, "Force feedback for SmartJoy PLUS PS2/USB adapter\n");
hid               112 drivers/hid/hid-sjoy.c static inline int sjoyff_init(struct hid_device *hid)
hid               162 drivers/hid/hid-sjoy.c MODULE_DEVICE_TABLE(hid, sjoy_devices);
hid               683 drivers/hid/hid-sony.c 	unsigned int key = usage->hid & HID_USAGE;
hid               685 drivers/hid/hid-sony.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
hid               717 drivers/hid/hid-sony.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
hid               718 drivers/hid/hid-sony.c 		unsigned int key = usage->hid & HID_USAGE;
hid               729 drivers/hid/hid-sony.c 	} else if (usage->hid == HID_GD_POINTER) {
hid               737 drivers/hid/hid-sony.c 			usage->hid = HID_GD_Z;
hid               743 drivers/hid/hid-sony.c 		hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
hid               745 drivers/hid/hid-sony.c 	} else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
hid               746 drivers/hid/hid-sony.c 		unsigned int abs = usage->hid & HID_USAGE;
hid               765 drivers/hid/hid-sony.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
hid               766 drivers/hid/hid-sony.c 		unsigned int key = usage->hid & HID_USAGE;
hid               774 drivers/hid/hid-sony.c 	} else if (usage->hid == HID_GD_POINTER) {
hid               783 drivers/hid/hid-sony.c 			usage->hid = HID_GD_Z;
hid               786 drivers/hid/hid-sony.c 			usage->hid = HID_GD_RZ;
hid               792 drivers/hid/hid-sony.c 		hid_map_usage_clear(hi, usage, bit, max, EV_ABS, usage->hid & 0xf);
hid               794 drivers/hid/hid-sony.c 	} else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
hid               795 drivers/hid/hid-sony.c 		unsigned int abs = usage->hid & HID_USAGE;
hid               813 drivers/hid/hid-sony.c 	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON) {
hid               814 drivers/hid/hid-sony.c 		unsigned int key = usage->hid & HID_USAGE;
hid               822 drivers/hid/hid-sony.c 	} else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK) {
hid               823 drivers/hid/hid-sony.c 		unsigned int abs = usage->hid & HID_USAGE;
hid               826 drivers/hid/hid-sony.c 		if (usage->hid == HID_GD_HATSWITCH)
hid              1329 drivers/hid/hid-sony.c 		unsigned int key = usage->hid & HID_USAGE;
hid              1331 drivers/hid/hid-sony.c 		if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
hid              2259 drivers/hid/hid-sony.c 	struct hid_device *hid = input_get_drvdata(dev);
hid              2260 drivers/hid/hid-sony.c 	struct sony_sc *sc = hid_get_drvdata(hid);
hid              3025 drivers/hid/hid-sony.c MODULE_DEVICE_TABLE(hid, sony_devices);
hid                35 drivers/hid/hid-speedlink.c 	switch (usage->hid & HID_USAGE_PAGE) {
hid                61 drivers/hid/hid-speedlink.c MODULE_DEVICE_TABLE(hid, speedlink_devices);
hid              1135 drivers/hid/hid-steam.c MODULE_DEVICE_TABLE(hid, steam_controllers);
hid               141 drivers/hid/hid-steelseries.c 	struct hid_device *hid = to_hid_device(dev);
hid               142 drivers/hid/hid-steelseries.c 	struct steelseries_srws1_data *drv_data = hid_get_drvdata(hid);
hid               145 drivers/hid/hid-steelseries.c 		hid_err(hid, "Device data not found.");
hid               154 drivers/hid/hid-steelseries.c 	steelseries_srws1_set_leds(hid, drv_data->led_state);
hid               160 drivers/hid/hid-steelseries.c 	struct hid_device *hid = to_hid_device(dev);
hid               163 drivers/hid/hid-steelseries.c 	drv_data = hid_get_drvdata(hid);
hid               166 drivers/hid/hid-steelseries.c 		hid_err(hid, "Device data not found.");
hid               177 drivers/hid/hid-steelseries.c 	struct hid_device *hid = to_hid_device(dev);
hid               178 drivers/hid/hid-steelseries.c 	struct steelseries_srws1_data *drv_data = hid_get_drvdata(hid);
hid               182 drivers/hid/hid-steelseries.c 		hid_err(hid, "Device data not found.");
hid               193 drivers/hid/hid-steelseries.c 			steelseries_srws1_set_leds(hid, drv_data->led_state);
hid               196 drivers/hid/hid-steelseries.c 			steelseries_srws1_set_leds(hid, drv_data->led_state);
hid               205 drivers/hid/hid-steelseries.c 	struct hid_device *hid = to_hid_device(dev);
hid               209 drivers/hid/hid-steelseries.c 	drv_data = hid_get_drvdata(hid);
hid               212 drivers/hid/hid-steelseries.c 		hid_err(hid, "Device data not found.");
hid               371 drivers/hid/hid-steelseries.c MODULE_DEVICE_TABLE(hid, steelseries_srws1_devices);
hid                39 drivers/hid/hid-sunplus.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
hid                42 drivers/hid/hid-sunplus.c 	switch (usage->hid & HID_USAGE) {
hid                55 drivers/hid/hid-sunplus.c MODULE_DEVICE_TABLE(hid, sp_devices);
hid                26 drivers/hid/hid-tivo.c 	switch (usage->hid & HID_USAGE_PAGE) {
hid                28 drivers/hid/hid-tivo.c 		switch (usage->hid & HID_USAGE) {
hid                42 drivers/hid/hid-tivo.c 		switch (usage->hid & HID_USAGE) {
hid                67 drivers/hid/hid-tivo.c MODULE_DEVICE_TABLE(hid, tivo_devices);
hid                76 drivers/hid/hid-tmff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                95 drivers/hid/hid-tmff.c 		hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT);
hid               107 drivers/hid/hid-tmff.c 		if (hid->product == THRUSTMASTER_DEVICE_ID_2_IN_1_DT) {
hid               116 drivers/hid/hid-tmff.c 		hid_hw_request(hid, tmff->report, HID_REQ_SET_REPORT);
hid               122 drivers/hid/hid-tmff.c static int tmff_init(struct hid_device *hid, const signed short *ff_bits)
hid               132 drivers/hid/hid-tmff.c 	if (list_empty(&hid->inputs)) {
hid               133 drivers/hid/hid-tmff.c 		hid_err(hid, "no inputs found\n");
hid               136 drivers/hid/hid-tmff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid               144 drivers/hid/hid-tmff.c 	report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
hid               154 drivers/hid/hid-tmff.c 			switch (field->usage[0].hid) {
hid               157 drivers/hid/hid-tmff.c 					hid_warn(hid, "ignoring FF field with report_count < 2\n");
hid               163 drivers/hid/hid-tmff.c 					hid_warn(hid, "ignoring FF field with logical_maximum == logical_minimum\n");
hid               168 drivers/hid/hid-tmff.c 					hid_warn(hid, "ignoring FF field in other report\n");
hid               173 drivers/hid/hid-tmff.c 					hid_warn(hid, "ignoring duplicate FF field\n");
hid               186 drivers/hid/hid-tmff.c 				hid_warn(hid, "ignoring unknown output usage %08x\n",
hid               187 drivers/hid/hid-tmff.c 					 field->usage[0].hid);
hid               194 drivers/hid/hid-tmff.c 		hid_err(hid, "can't find FF field in output reports\n");
hid               203 drivers/hid/hid-tmff.c 	hid_info(hid, "force feedback for ThrustMaster devices by Zinx Verituse <zinx@epicsol.org>\n");
hid               211 drivers/hid/hid-tmff.c static inline int tmff_init(struct hid_device *hid, const signed short *ff_bits)
hid               263 drivers/hid/hid-tmff.c MODULE_DEVICE_TABLE(hid, tm_devices);
hid                30 drivers/hid/hid-topseed.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
hid                33 drivers/hid/hid-topseed.c 	switch (usage->hid & HID_USAGE) {
hid                72 drivers/hid/hid-topseed.c MODULE_DEVICE_TABLE(hid, ts_devices);
hid                65 drivers/hid/hid-twinhan.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_KEYBOARD)
hid                68 drivers/hid/hid-twinhan.c 	switch (usage->hid & HID_USAGE) {
hid               125 drivers/hid/hid-twinhan.c MODULE_DEVICE_TABLE(hid, twinhan_devices);
hid               361 drivers/hid/hid-u2fzero.c MODULE_DEVICE_TABLE(hid, u2fzero_table);
hid               402 drivers/hid/hid-uclogic-core.c MODULE_DEVICE_TABLE(hid, uclogic_devices);
hid               458 drivers/hid/hid-udraw-ps3.c MODULE_DEVICE_TABLE(hid, udraw_devices);
hid                96 drivers/hid/hid-viewsonic.c MODULE_DEVICE_TABLE(hid, viewsonic_devices);
hid               735 drivers/hid/hid-waltop.c MODULE_DEVICE_TABLE(hid, waltop_devices);
hid              1873 drivers/hid/hid-wiimote-core.c MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
hid                50 drivers/hid/hid-xinmo.c MODULE_DEVICE_TABLE(hid, xinmo_devices);
hid                28 drivers/hid/hid-zpff.c 	struct hid_device *hid = input_get_drvdata(dev);
hid                48 drivers/hid/hid-zpff.c 	hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);
hid                53 drivers/hid/hid-zpff.c static int zpff_init(struct hid_device *hid)
hid                61 drivers/hid/hid-zpff.c 	if (list_empty(&hid->inputs)) {
hid                62 drivers/hid/hid-zpff.c 		hid_err(hid, "no inputs found\n");
hid                65 drivers/hid/hid-zpff.c 	hidinput = list_entry(hid->inputs.next, struct hid_input, list);
hid                69 drivers/hid/hid-zpff.c 		report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, i, 1);
hid                91 drivers/hid/hid-zpff.c 	hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);
hid                93 drivers/hid/hid-zpff.c 	hid_info(hid, "force feedback for Zeroplus based devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
hid                98 drivers/hid/hid-zpff.c static inline int zpff_init(struct hid_device *hid)
hid               132 drivers/hid/hid-zpff.c MODULE_DEVICE_TABLE(hid, zp_devices);
hid                53 drivers/hid/hid-zydacron.c 	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
hid                57 drivers/hid/hid-zydacron.c 		usage->hid & HID_USAGE);
hid                59 drivers/hid/hid-zydacron.c 	switch (usage->hid & HID_USAGE) {
hid               196 drivers/hid/hid-zydacron.c MODULE_DEVICE_TABLE(hid, zc_devices);
hid               117 drivers/hid/hidraw.c 	dev = hidraw_table[minor]->hid;
hid               192 drivers/hid/hidraw.c 	dev = hidraw_table[minor]->hid;
hid               283 drivers/hid/hidraw.c 		err = hid_hw_power(dev->hid, PM_HINT_FULLON);
hid               289 drivers/hid/hidraw.c 		err = hid_hw_open(dev->hid);
hid               291 drivers/hid/hidraw.c 			hid_hw_power(dev->hid, PM_HINT_NORMAL);
hid               324 drivers/hid/hidraw.c 			hid_hw_close(hidraw->hid);
hid               338 drivers/hid/hidraw.c 			hid_hw_close(hidraw->hid);
hid               339 drivers/hid/hidraw.c 			hid_hw_power(hidraw->hid, PM_HINT_NORMAL);
hid               381 drivers/hid/hidraw.c 			if (put_user(dev->hid->rsize, (int __user *)arg))
hid               396 drivers/hid/hidraw.c 					dev->hid->rdesc,
hid               397 drivers/hid/hidraw.c 					min(dev->hid->rsize, len)))
hid               405 drivers/hid/hidraw.c 				dinfo.bustype = dev->hid->bus;
hid               406 drivers/hid/hidraw.c 				dinfo.vendor = dev->hid->vendor;
hid               407 drivers/hid/hidraw.c 				dinfo.product = dev->hid->product;
hid               414 drivers/hid/hidraw.c 				struct hid_device *hid = dev->hid;
hid               438 drivers/hid/hidraw.c 					int len = strlen(hid->name) + 1;
hid               441 drivers/hid/hidraw.c 					ret = copy_to_user(user_arg, hid->name, len) ?
hid               447 drivers/hid/hidraw.c 					int len = strlen(hid->phys) + 1;
hid               450 drivers/hid/hidraw.c 					ret = copy_to_user(user_arg, hid->phys, len) ?
hid               478 drivers/hid/hidraw.c int hidraw_report_event(struct hid_device *hid, u8 *data, int len)
hid               480 drivers/hid/hidraw.c 	struct hidraw *dev = hid->hidraw;
hid               507 drivers/hid/hidraw.c int hidraw_connect(struct hid_device *hid)
hid               536 drivers/hid/hidraw.c 	dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor),
hid               551 drivers/hid/hidraw.c 	dev->hid = hid;
hid               555 drivers/hid/hidraw.c 	hid->hidraw = dev;
hid               564 drivers/hid/hidraw.c void hidraw_disconnect(struct hid_device *hid)
hid               566 drivers/hid/hidraw.c 	struct hidraw *hidraw = hid->hidraw;
hid               140 drivers/hid/i2c-hid/i2c-hid-core.c 	struct hid_device	*hid;	/* pointer to corresponding HID dev */
hid               521 drivers/hid/i2c-hid/i2c-hid-core.c 		hid_input_report(ihid->hid, HID_INPUT_REPORT, ihid->inbuf + 2,
hid               548 drivers/hid/i2c-hid/i2c-hid-core.c static void i2c_hid_find_max_report(struct hid_device *hid, unsigned int type,
hid               556 drivers/hid/i2c-hid/i2c-hid-core.c 	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
hid               601 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_get_raw_report(struct hid_device *hid,
hid               605 drivers/hid/i2c-hid/i2c-hid-core.c 	struct i2c_client *client = hid->driver_data;
hid               637 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
hid               640 drivers/hid/i2c-hid/i2c-hid-core.c 	struct i2c_client *client = hid->driver_data;
hid               667 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_output_report(struct hid_device *hid, __u8 *buf,
hid               670 drivers/hid/i2c-hid/i2c-hid-core.c 	return i2c_hid_output_raw_report(hid, buf, count, HID_OUTPUT_REPORT,
hid               674 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
hid               680 drivers/hid/i2c-hid/i2c-hid-core.c 		return i2c_hid_get_raw_report(hid, reportnum, buf, len, rtype);
hid               684 drivers/hid/i2c-hid/i2c-hid-core.c 		return i2c_hid_output_raw_report(hid, buf, len, rtype, true);
hid               690 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_parse(struct hid_device *hid)
hid               692 drivers/hid/i2c-hid/i2c-hid-core.c 	struct i2c_client *client = hid->driver_data;
hid               737 drivers/hid/i2c-hid/i2c-hid-core.c 			hid_err(hid, "reading report descriptor failed\n");
hid               745 drivers/hid/i2c-hid/i2c-hid-core.c 	ret = hid_parse_report(hid, rdesc, rsize);
hid               757 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_start(struct hid_device *hid)
hid               759 drivers/hid/i2c-hid/i2c-hid-core.c 	struct i2c_client *client = hid->driver_data;
hid               764 drivers/hid/i2c-hid/i2c-hid-core.c 	i2c_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
hid               765 drivers/hid/i2c-hid/i2c-hid-core.c 	i2c_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
hid               766 drivers/hid/i2c-hid/i2c-hid-core.c 	i2c_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
hid               782 drivers/hid/i2c-hid/i2c-hid-core.c static void i2c_hid_stop(struct hid_device *hid)
hid               784 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->claimed = 0;
hid               787 drivers/hid/i2c-hid/i2c-hid-core.c static int i2c_hid_open(struct hid_device *hid)
hid               789 drivers/hid/i2c-hid/i2c-hid-core.c 	struct i2c_client *client = hid->driver_data;
hid               796 drivers/hid/i2c-hid/i2c-hid-core.c static void i2c_hid_close(struct hid_device *hid)
hid               798 drivers/hid/i2c-hid/i2c-hid-core.c 	struct i2c_client *client = hid->driver_data;
hid              1003 drivers/hid/i2c-hid/i2c-hid-core.c 	struct hid_device *hid;
hid              1095 drivers/hid/i2c-hid/i2c-hid-core.c 	hid = hid_allocate_device();
hid              1096 drivers/hid/i2c-hid/i2c-hid-core.c 	if (IS_ERR(hid)) {
hid              1097 drivers/hid/i2c-hid/i2c-hid-core.c 		ret = PTR_ERR(hid);
hid              1101 drivers/hid/i2c-hid/i2c-hid-core.c 	ihid->hid = hid;
hid              1103 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->driver_data = client;
hid              1104 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->ll_driver = &i2c_hid_ll_driver;
hid              1105 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->dev.parent = &client->dev;
hid              1106 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->bus = BUS_I2C;
hid              1107 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->version = le16_to_cpu(ihid->hdesc.bcdVersion);
hid              1108 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->vendor = le16_to_cpu(ihid->hdesc.wVendorID);
hid              1109 drivers/hid/i2c-hid/i2c-hid-core.c 	hid->product = le16_to_cpu(ihid->hdesc.wProductID);
hid              1111 drivers/hid/i2c-hid/i2c-hid-core.c 	snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX",
hid              1112 drivers/hid/i2c-hid/i2c-hid-core.c 		 client->name, hid->vendor, hid->product);
hid              1113 drivers/hid/i2c-hid/i2c-hid-core.c 	strlcpy(hid->phys, dev_name(&client->dev), sizeof(hid->phys));
hid              1115 drivers/hid/i2c-hid/i2c-hid-core.c 	ihid->quirks = i2c_hid_lookup_quirk(hid->vendor, hid->product);
hid              1117 drivers/hid/i2c-hid/i2c-hid-core.c 	ret = hid_add_device(hid);
hid              1127 drivers/hid/i2c-hid/i2c-hid-core.c 	hid_destroy_device(hid);
hid              1142 drivers/hid/i2c-hid/i2c-hid-core.c 	struct hid_device *hid;
hid              1144 drivers/hid/i2c-hid/i2c-hid-core.c 	hid = ihid->hid;
hid              1145 drivers/hid/i2c-hid/i2c-hid-core.c 	hid_destroy_device(hid);
hid              1171 drivers/hid/i2c-hid/i2c-hid-core.c 	struct hid_device *hid = ihid->hid;
hid              1175 drivers/hid/i2c-hid/i2c-hid-core.c 	if (hid->driver && hid->driver->suspend) {
hid              1176 drivers/hid/i2c-hid/i2c-hid-core.c 		ret = hid->driver->suspend(hid, PMSG_SUSPEND);
hid              1191 drivers/hid/i2c-hid/i2c-hid-core.c 			hid_warn(hid, "Failed to enable irq wake: %d\n",
hid              1206 drivers/hid/i2c-hid/i2c-hid-core.c 	struct hid_device *hid = ihid->hid;
hid              1213 drivers/hid/i2c-hid/i2c-hid-core.c 			hid_warn(hid, "Failed to enable supplies: %d\n", ret);
hid              1222 drivers/hid/i2c-hid/i2c-hid-core.c 			hid_warn(hid, "Failed to disable irq wake: %d\n",
hid              1244 drivers/hid/i2c-hid/i2c-hid-core.c 	if (hid->driver && hid->driver->reset_resume) {
hid              1245 drivers/hid/i2c-hid/i2c-hid-core.c 		ret = hid->driver->reset_resume(hid);
hid                73 drivers/hid/intel-ish-hid/ishtp-hid-client.c 	struct hid_device *hid = NULL;
hid               218 drivers/hid/intel-ish-hid/ishtp-hid-client.c 					hid = client_data->hid_sensor_hubs[i];
hid               219 drivers/hid/intel-ish-hid/ishtp-hid-client.c 					if (!hid)
hid               222 drivers/hid/intel-ish-hid/ishtp-hid-client.c 					hid_data = hid->driver_data;
hid               234 drivers/hid/intel-ish-hid/ishtp-hid-client.c 							(hid, report_type,
hid               239 drivers/hid/intel-ish-hid/ishtp-hid-client.c 					ishtp_hid_wakeup(hid);
hid               361 drivers/hid/intel-ish-hid/ishtp-hid-client.c void hid_ishtp_set_feature(struct hid_device *hid, char *buf, unsigned int len,
hid               364 drivers/hid/intel-ish-hid/ishtp-hid-client.c 	struct ishtp_hid_data *hid_data =  hid->driver_data;
hid               370 drivers/hid/intel-ish-hid/ishtp-hid-client.c 	hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
hid               375 drivers/hid/intel-ish-hid/ishtp-hid-client.c 				__func__, hid);
hid               382 drivers/hid/intel-ish-hid/ishtp-hid-client.c 		if (hid == client_data->hid_sensor_hubs[i]) {
hid               395 drivers/hid/intel-ish-hid/ishtp-hid-client.c 				__func__, hid);
hid               407 drivers/hid/intel-ish-hid/ishtp-hid-client.c void hid_ishtp_get_report(struct hid_device *hid, int report_id,
hid               410 drivers/hid/intel-ish-hid/ishtp-hid-client.c 	struct ishtp_hid_data *hid_data =  hid->driver_data;
hid               416 drivers/hid/intel-ish-hid/ishtp-hid-client.c 	hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
hid               420 drivers/hid/intel-ish-hid/ishtp-hid-client.c 				__func__, hid);
hid               427 drivers/hid/intel-ish-hid/ishtp-hid-client.c 		if (hid == client_data->hid_sensor_hubs[i]) {
hid               442 drivers/hid/intel-ish-hid/ishtp-hid-client.c 				__func__, hid);
hid                21 drivers/hid/intel-ish-hid/ishtp-hid.c static int ishtp_hid_parse(struct hid_device *hid)
hid                23 drivers/hid/intel-ish-hid/ishtp-hid.c 	struct ishtp_hid_data *hid_data =  hid->driver_data;
hid                27 drivers/hid/intel-ish-hid/ishtp-hid.c 	rv = hid_parse_report(hid, client_data->report_descr[hid_data->index],
hid                36 drivers/hid/intel-ish-hid/ishtp-hid.c static int ishtp_hid_start(struct hid_device *hid)
hid                41 drivers/hid/intel-ish-hid/ishtp-hid.c static void ishtp_hid_stop(struct hid_device *hid)
hid                45 drivers/hid/intel-ish-hid/ishtp-hid.c static int ishtp_hid_open(struct hid_device *hid)
hid                50 drivers/hid/intel-ish-hid/ishtp-hid.c static void ishtp_hid_close(struct hid_device *hid)
hid                54 drivers/hid/intel-ish-hid/ishtp-hid.c static int ishtp_raw_request(struct hid_device *hid, unsigned char reportnum,
hid                58 drivers/hid/intel-ish-hid/ishtp-hid.c 	struct ishtp_hid_data *hid_data =  hid->driver_data;
hid                73 drivers/hid/intel-ish-hid/ishtp-hid.c 		hid_ishtp_get_report(hid, reportnum, rtype);
hid                86 drivers/hid/intel-ish-hid/ishtp-hid.c 		hid_ishtp_set_feature(hid, ishtp_buf, ishtp_buf_len, reportnum);
hid                91 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid_hw_wait(hid);
hid               104 drivers/hid/intel-ish-hid/ishtp-hid.c static void ishtp_hid_request(struct hid_device *hid, struct hid_report *rep,
hid               107 drivers/hid/intel-ish-hid/ishtp-hid.c 	struct ishtp_hid_data *hid_data =  hid->driver_data;
hid               119 drivers/hid/intel-ish-hid/ishtp-hid.c 		hid_ishtp_get_report(hid, rep->id, rep->type);
hid               131 drivers/hid/intel-ish-hid/ishtp-hid.c 		hid_ishtp_set_feature(hid, buf, len, rep->id);
hid               145 drivers/hid/intel-ish-hid/ishtp-hid.c static int ishtp_wait_for_response(struct hid_device *hid)
hid               147 drivers/hid/intel-ish-hid/ishtp-hid.c 	struct ishtp_hid_data *hid_data =  hid->driver_data;
hid               150 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
hid               161 drivers/hid/intel-ish-hid/ishtp-hid.c 		hid_err(hid,
hid               165 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid_ishtp_trace(client_data,  "%s hid %p done\n", __func__, hid);
hid               178 drivers/hid/intel-ish-hid/ishtp-hid.c void ishtp_hid_wakeup(struct hid_device *hid)
hid               180 drivers/hid/intel-ish-hid/ishtp-hid.c 	struct ishtp_hid_data *hid_data = hid->driver_data;
hid               210 drivers/hid/intel-ish-hid/ishtp-hid.c 	struct hid_device *hid;
hid               213 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid = hid_allocate_device();
hid               214 drivers/hid/intel-ish-hid/ishtp-hid.c 	if (IS_ERR(hid)) {
hid               215 drivers/hid/intel-ish-hid/ishtp-hid.c 		rv = PTR_ERR(hid);
hid               229 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->driver_data = hid_data;
hid               231 drivers/hid/intel-ish-hid/ishtp-hid.c 	client_data->hid_sensor_hubs[cur_hid_dev] = hid;
hid               233 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->ll_driver = &ishtp_hid_ll_driver;
hid               234 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->bus = BUS_INTEL_ISHTP;
hid               235 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->dev.parent = ishtp_device(client_data->cl_device);
hid               237 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->version = le16_to_cpu(ISH_HID_VERSION);
hid               238 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->vendor = le16_to_cpu(client_data->hid_devices[cur_hid_dev].vid);
hid               239 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid->product = le16_to_cpu(client_data->hid_devices[cur_hid_dev].pid);
hid               240 drivers/hid/intel-ish-hid/ishtp-hid.c 	snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-ishtp",
hid               241 drivers/hid/intel-ish-hid/ishtp-hid.c 		hid->vendor, hid->product);
hid               243 drivers/hid/intel-ish-hid/ishtp-hid.c 	rv = hid_add_device(hid);
hid               247 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid_ishtp_trace(client_data,  "%s allocated hid %p\n", __func__, hid);
hid               254 drivers/hid/intel-ish-hid/ishtp-hid.c 	hid_destroy_device(hid);
hid               172 drivers/hid/intel-ish-hid/ishtp-hid.h void hid_ishtp_set_feature(struct hid_device *hid, char *buf, unsigned int len,
hid               174 drivers/hid/intel-ish-hid/ishtp-hid.h void hid_ishtp_get_report(struct hid_device *hid, int report_id,
hid               180 drivers/hid/intel-ish-hid/ishtp-hid.h void ishtp_hid_wakeup(struct hid_device *hid);
hid                36 drivers/hid/uhid.c 	struct hid_device *hid;
hid                62 drivers/hid/uhid.c 	ret = hid_add_device(uhid->hid);
hid                64 drivers/hid/uhid.c 		hid_err(uhid->hid, "Cannot register HID device: error %d\n", ret);
hid                66 drivers/hid/uhid.c 		hid_destroy_device(uhid->hid);
hid                67 drivers/hid/uhid.c 		uhid->hid = NULL;
hid                83 drivers/hid/uhid.c 		hid_warn(uhid->hid, "Output queue is full\n");
hid               106 drivers/hid/uhid.c static int uhid_hid_start(struct hid_device *hid)
hid               108 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               118 drivers/hid/uhid.c 	if (hid->report_enum[HID_FEATURE_REPORT].numbered)
hid               120 drivers/hid/uhid.c 	if (hid->report_enum[HID_OUTPUT_REPORT].numbered)
hid               122 drivers/hid/uhid.c 	if (hid->report_enum[HID_INPUT_REPORT].numbered)
hid               132 drivers/hid/uhid.c static void uhid_hid_stop(struct hid_device *hid)
hid               134 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               136 drivers/hid/uhid.c 	hid->claimed = 0;
hid               140 drivers/hid/uhid.c static int uhid_hid_open(struct hid_device *hid)
hid               142 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               147 drivers/hid/uhid.c static void uhid_hid_close(struct hid_device *hid)
hid               149 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               154 drivers/hid/uhid.c static int uhid_hid_parse(struct hid_device *hid)
hid               156 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               158 drivers/hid/uhid.c 	return hid_parse_report(hid, uhid->rd_data, uhid->rd_size);
hid               212 drivers/hid/uhid.c static int uhid_hid_get_report(struct hid_device *hid, unsigned char rnum,
hid               215 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               255 drivers/hid/uhid.c static int uhid_hid_set_report(struct hid_device *hid, unsigned char rnum,
hid               258 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               296 drivers/hid/uhid.c static int uhid_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
hid               318 drivers/hid/uhid.c 		return uhid_hid_get_report(hid, reportnum, buf, len, u_rtype);
hid               320 drivers/hid/uhid.c 		return uhid_hid_set_report(hid, reportnum, buf, len, u_rtype);
hid               326 drivers/hid/uhid.c static int uhid_hid_output_raw(struct hid_device *hid, __u8 *buf, size_t count,
hid               329 drivers/hid/uhid.c 	struct uhid_device *uhid = hid->driver_data;
hid               364 drivers/hid/uhid.c static int uhid_hid_output_report(struct hid_device *hid, __u8 *buf,
hid               367 drivers/hid/uhid.c 	return uhid_hid_output_raw(hid, buf, count, HID_OUTPUT_REPORT);
hid               472 drivers/hid/uhid.c 	struct hid_device *hid;
hid               491 drivers/hid/uhid.c 	hid = hid_allocate_device();
hid               492 drivers/hid/uhid.c 	if (IS_ERR(hid)) {
hid               493 drivers/hid/uhid.c 		ret = PTR_ERR(hid);
hid               498 drivers/hid/uhid.c 	len = min(sizeof(hid->name), sizeof(ev->u.create2.name)) - 1;
hid               499 drivers/hid/uhid.c 	strncpy(hid->name, ev->u.create2.name, len);
hid               500 drivers/hid/uhid.c 	len = min(sizeof(hid->phys), sizeof(ev->u.create2.phys)) - 1;
hid               501 drivers/hid/uhid.c 	strncpy(hid->phys, ev->u.create2.phys, len);
hid               502 drivers/hid/uhid.c 	len = min(sizeof(hid->uniq), sizeof(ev->u.create2.uniq)) - 1;
hid               503 drivers/hid/uhid.c 	strncpy(hid->uniq, ev->u.create2.uniq, len);
hid               505 drivers/hid/uhid.c 	hid->ll_driver = &uhid_hid_driver;
hid               506 drivers/hid/uhid.c 	hid->bus = ev->u.create2.bus;
hid               507 drivers/hid/uhid.c 	hid->vendor = ev->u.create2.vendor;
hid               508 drivers/hid/uhid.c 	hid->product = ev->u.create2.product;
hid               509 drivers/hid/uhid.c 	hid->version = ev->u.create2.version;
hid               510 drivers/hid/uhid.c 	hid->country = ev->u.create2.country;
hid               511 drivers/hid/uhid.c 	hid->driver_data = uhid;
hid               512 drivers/hid/uhid.c 	hid->dev.parent = uhid_misc.this_device;
hid               514 drivers/hid/uhid.c 	uhid->hid = hid;
hid               567 drivers/hid/uhid.c 	hid_destroy_device(uhid->hid);
hid               578 drivers/hid/uhid.c 	hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input.data,
hid               589 drivers/hid/uhid.c 	hid_input_report(uhid->hid, HID_INPUT_REPORT, ev->u.input2.data,
hid                74 drivers/hid/usbhid/hid-core.c static void hid_io_error(struct hid_device *hid);
hid                75 drivers/hid/usbhid/hid-core.c static int hid_submit_out(struct hid_device *hid);
hid                76 drivers/hid/usbhid/hid-core.c static int hid_submit_ctrl(struct hid_device *hid);
hid                80 drivers/hid/usbhid/hid-core.c static int hid_start_in(struct hid_device *hid)
hid                84 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               108 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usbhid->hid;
hid               111 drivers/hid/usbhid/hid-core.c 	if (hid_start_in(hid))
hid               112 drivers/hid/usbhid/hid-core.c 		hid_io_error(hid);
hid               120 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usbhid->hid;
hid               125 drivers/hid/usbhid/hid-core.c 		rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe);
hid               128 drivers/hid/usbhid/hid-core.c 			hid_start_in(hid);
hid               143 drivers/hid/usbhid/hid-core.c static void hid_io_error(struct hid_device *hid)
hid               146 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               192 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(usbhid->intf);
hid               196 drivers/hid/usbhid/hid-core.c 	if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) ||
hid               201 drivers/hid/usbhid/hid-core.c 		hid_dbg(hid, "Kicking head %d tail %d", usbhid->outhead, usbhid->outtail);
hid               219 drivers/hid/usbhid/hid-core.c 		if (hid_submit_out(hid)) {
hid               230 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(usbhid->intf);
hid               234 drivers/hid/usbhid/hid-core.c 	WARN_ON(hid == NULL);
hid               235 drivers/hid/usbhid/hid-core.c 	if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) ||
hid               240 drivers/hid/usbhid/hid-core.c 		hid_dbg(hid, "Kicking head %d tail %d", usbhid->ctrlhead, usbhid->ctrltail);
hid               258 drivers/hid/usbhid/hid-core.c 		if (hid_submit_ctrl(hid)) {
hid               273 drivers/hid/usbhid/hid-core.c 	struct hid_device	*hid = urb->context;
hid               274 drivers/hid/usbhid/hid-core.c 	struct usbhid_device	*usbhid = hid->driver_data;
hid               292 drivers/hid/usbhid/hid-core.c 			if (hid_check_keys_pressed(hid))
hid               315 drivers/hid/usbhid/hid-core.c 		hid_io_error(hid);
hid               326 drivers/hid/usbhid/hid-core.c 			hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n",
hid               327 drivers/hid/usbhid/hid-core.c 				hid_to_usb_dev(hid)->bus->bus_name,
hid               328 drivers/hid/usbhid/hid-core.c 				hid_to_usb_dev(hid)->devpath,
hid               330 drivers/hid/usbhid/hid-core.c 			hid_io_error(hid);
hid               335 drivers/hid/usbhid/hid-core.c static int hid_submit_out(struct hid_device *hid)
hid               339 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               346 drivers/hid/usbhid/hid-core.c 	usbhid->urbout->dev = hid_to_usb_dev(hid);
hid               358 drivers/hid/usbhid/hid-core.c 		hid_err(hid, "usb_submit_urb(out) failed: %d\n", r);
hid               365 drivers/hid/usbhid/hid-core.c static int hid_submit_ctrl(struct hid_device *hid)
hid               371 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               379 drivers/hid/usbhid/hid-core.c 		usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
hid               389 drivers/hid/usbhid/hid-core.c 		usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0);
hid               390 drivers/hid/usbhid/hid-core.c 		maxpacket = usb_maxpacket(hid_to_usb_dev(hid),
hid               401 drivers/hid/usbhid/hid-core.c 	usbhid->urbctrl->dev = hid_to_usb_dev(hid);
hid               418 drivers/hid/usbhid/hid-core.c 		hid_err(hid, "usb_submit_urb(ctrl) failed: %d\n", r);
hid               431 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = urb->context;
hid               432 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               459 drivers/hid/usbhid/hid-core.c 				hid_submit_out(hid) == 0) {
hid               478 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = urb->context;
hid               479 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               510 drivers/hid/usbhid/hid-core.c 				hid_submit_ctrl(hid) == 0) {
hid               523 drivers/hid/usbhid/hid-core.c static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *report,
hid               527 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               529 drivers/hid/usbhid/hid-core.c 	if (((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN) ||
hid               535 drivers/hid/usbhid/hid-core.c 			hid_warn(hid, "output queue full\n");
hid               541 drivers/hid/usbhid/hid-core.c 			hid_warn(hid, "output queueing failed\n");
hid               583 drivers/hid/usbhid/hid-core.c 		hid_warn(hid, "control queue full\n");
hid               590 drivers/hid/usbhid/hid-core.c 			hid_warn(hid, "control queueing failed\n");
hid               632 drivers/hid/usbhid/hid-core.c static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
hid               634 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               638 drivers/hid/usbhid/hid-core.c 	__usbhid_submit_report(hid, report, dir);
hid               642 drivers/hid/usbhid/hid-core.c static int usbhid_wait_io(struct hid_device *hid)
hid               644 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               680 drivers/hid/usbhid/hid-core.c static int usbhid_open(struct hid_device *hid)
hid               682 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               689 drivers/hid/usbhid/hid-core.c 	if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
hid               707 drivers/hid/usbhid/hid-core.c 	res = hid_start_in(hid);
hid               710 drivers/hid/usbhid/hid-core.c 			hid_io_error(hid);
hid               739 drivers/hid/usbhid/hid-core.c static void usbhid_close(struct hid_device *hid)
hid               741 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               752 drivers/hid/usbhid/hid-core.c 	if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL))
hid               756 drivers/hid/usbhid/hid-core.c 	if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) {
hid               769 drivers/hid/usbhid/hid-core.c void usbhid_init_reports(struct hid_device *hid)
hid               772 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               776 drivers/hid/usbhid/hid-core.c 	report_enum = &hid->report_enum[HID_INPUT_REPORT];
hid               778 drivers/hid/usbhid/hid-core.c 		usbhid_submit_report(hid, report, USB_DIR_IN);
hid               780 drivers/hid/usbhid/hid-core.c 	report_enum = &hid->report_enum[HID_FEATURE_REPORT];
hid               782 drivers/hid/usbhid/hid-core.c 		usbhid_submit_report(hid, report, USB_DIR_IN);
hid               785 drivers/hid/usbhid/hid-core.c 	ret = usbhid_wait_io(hid);
hid               792 drivers/hid/usbhid/hid-core.c 		ret = usbhid_wait_io(hid);
hid               796 drivers/hid/usbhid/hid-core.c 		hid_warn(hid, "timeout initializing reports\n");
hid               802 drivers/hid/usbhid/hid-core.c static int hid_find_field_early(struct hid_device *hid, unsigned int page,
hid               810 drivers/hid/usbhid/hid-core.c 	list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
hid               815 drivers/hid/usbhid/hid-core.c 				if ((usage->hid & HID_USAGE_PAGE) == page &&
hid               816 drivers/hid/usbhid/hid-core.c 				    (usage->hid & 0xFFFF) == hid_code) {
hid               826 drivers/hid/usbhid/hid-core.c static void usbhid_set_leds(struct hid_device *hid)
hid               831 drivers/hid/usbhid/hid-core.c 	if ((offset = hid_find_field_early(hid, HID_UP_LED, 0x01, &field)) != -1) {
hid               833 drivers/hid/usbhid/hid-core.c 		usbhid_submit_report(hid, field->report, USB_DIR_OUT);
hid               840 drivers/hid/usbhid/hid-core.c static void hid_find_max_report(struct hid_device *hid, unsigned int type,
hid               846 drivers/hid/usbhid/hid-core.c 	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
hid               847 drivers/hid/usbhid/hid-core.c 		size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered;
hid               853 drivers/hid/usbhid/hid-core.c static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
hid               855 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               871 drivers/hid/usbhid/hid-core.c static int usbhid_get_raw_report(struct hid_device *hid,
hid               875 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               876 drivers/hid/usbhid/hid-core.c 	struct usb_device *dev = hid_to_usb_dev(hid);
hid               905 drivers/hid/usbhid/hid-core.c static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum,
hid               908 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               909 drivers/hid/usbhid/hid-core.c 	struct usb_device *dev = hid_to_usb_dev(hid);
hid               916 drivers/hid/usbhid/hid-core.c 	    (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID))
hid               941 drivers/hid/usbhid/hid-core.c static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count)
hid               943 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               944 drivers/hid/usbhid/hid-core.c 	struct usb_device *dev = hid_to_usb_dev(hid);
hid               971 drivers/hid/usbhid/hid-core.c static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
hid               973 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               981 drivers/hid/usbhid/hid-core.c static int usbhid_parse(struct hid_device *hid)
hid               983 drivers/hid/usbhid/hid-core.c 	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
hid               994 drivers/hid/usbhid/hid-core.c 	quirks = hid_lookup_quirk(hid);
hid              1019 drivers/hid/usbhid/hid-core.c 	hid->version = le16_to_cpu(hdesc->bcdHID);
hid              1020 drivers/hid/usbhid/hid-core.c 	hid->country = hdesc->bCountryCode;
hid              1048 drivers/hid/usbhid/hid-core.c 	ret = hid_parse_report(hid, rdesc, rsize);
hid              1055 drivers/hid/usbhid/hid-core.c 	hid->quirks |= quirks;
hid              1062 drivers/hid/usbhid/hid-core.c static int usbhid_start(struct hid_device *hid)
hid              1064 drivers/hid/usbhid/hid-core.c 	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
hid              1067 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1076 drivers/hid/usbhid/hid-core.c 	hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
hid              1077 drivers/hid/usbhid/hid-core.c 	hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);
hid              1078 drivers/hid/usbhid/hid-core.c 	hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize);
hid              1083 drivers/hid/usbhid/hid-core.c 	hid_find_max_report(hid, HID_INPUT_REPORT, &insize);
hid              1088 drivers/hid/usbhid/hid-core.c 	if (hid_alloc_buffers(dev, hid)) {
hid              1105 drivers/hid/usbhid/hid-core.c 		if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
hid              1109 drivers/hid/usbhid/hid-core.c 				hid->name, endpoint->bInterval, interval);
hid              1115 drivers/hid/usbhid/hid-core.c 		switch (hid->collection->usage) {
hid              1138 drivers/hid/usbhid/hid-core.c 					 hid_irq_in, hid, interval);
hid              1148 drivers/hid/usbhid/hid-core.c 					 hid_irq_out, hid, interval);
hid              1161 drivers/hid/usbhid/hid-core.c 			     usbhid->ctrlbuf, 1, hid_ctrl, hid);
hid              1167 drivers/hid/usbhid/hid-core.c 	if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
hid              1173 drivers/hid/usbhid/hid-core.c 		ret = hid_start_in(hid);
hid              1175 drivers/hid/usbhid/hid-core.c 			dev_err(&hid->dev,
hid              1190 drivers/hid/usbhid/hid-core.c 		usbhid_set_leds(hid);
hid              1204 drivers/hid/usbhid/hid-core.c 	hid_free_buffers(dev, hid);
hid              1209 drivers/hid/usbhid/hid-core.c static void usbhid_stop(struct hid_device *hid)
hid              1211 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1216 drivers/hid/usbhid/hid-core.c 	if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
hid              1233 drivers/hid/usbhid/hid-core.c 	hid->claimed = 0;
hid              1242 drivers/hid/usbhid/hid-core.c 	hid_free_buffers(hid_to_usb_dev(hid), hid);
hid              1247 drivers/hid/usbhid/hid-core.c static int usbhid_power(struct hid_device *hid, int lvl)
hid              1249 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1265 drivers/hid/usbhid/hid-core.c static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype)
hid              1269 drivers/hid/usbhid/hid-core.c 		usbhid_submit_report(hid, rep, USB_DIR_IN);
hid              1272 drivers/hid/usbhid/hid-core.c 		usbhid_submit_report(hid, rep, USB_DIR_OUT);
hid              1277 drivers/hid/usbhid/hid-core.c static int usbhid_raw_request(struct hid_device *hid, unsigned char reportnum,
hid              1283 drivers/hid/usbhid/hid-core.c 		return usbhid_get_raw_report(hid, reportnum, buf, len, rtype);
hid              1285 drivers/hid/usbhid/hid-core.c 		return usbhid_set_raw_report(hid, reportnum, buf, len, rtype);
hid              1291 drivers/hid/usbhid/hid-core.c static int usbhid_idle(struct hid_device *hid, int report, int idle,
hid              1294 drivers/hid/usbhid/hid-core.c 	struct usb_device *dev = hid_to_usb_dev(hid);
hid              1295 drivers/hid/usbhid/hid-core.c 	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
hid              1325 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid;
hid              1341 drivers/hid/usbhid/hid-core.c 	hid = hid_allocate_device();
hid              1342 drivers/hid/usbhid/hid-core.c 	if (IS_ERR(hid))
hid              1343 drivers/hid/usbhid/hid-core.c 		return PTR_ERR(hid);
hid              1345 drivers/hid/usbhid/hid-core.c 	usb_set_intfdata(intf, hid);
hid              1346 drivers/hid/usbhid/hid-core.c 	hid->ll_driver = &usb_hid_driver;
hid              1347 drivers/hid/usbhid/hid-core.c 	hid->ff_init = hid_pidff_init;
hid              1349 drivers/hid/usbhid/hid-core.c 	hid->hiddev_connect = hiddev_connect;
hid              1350 drivers/hid/usbhid/hid-core.c 	hid->hiddev_disconnect = hiddev_disconnect;
hid              1351 drivers/hid/usbhid/hid-core.c 	hid->hiddev_hid_event = hiddev_hid_event;
hid              1352 drivers/hid/usbhid/hid-core.c 	hid->hiddev_report_event = hiddev_report_event;
hid              1354 drivers/hid/usbhid/hid-core.c 	hid->dev.parent = &intf->dev;
hid              1355 drivers/hid/usbhid/hid-core.c 	hid->bus = BUS_USB;
hid              1356 drivers/hid/usbhid/hid-core.c 	hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
hid              1357 drivers/hid/usbhid/hid-core.c 	hid->product = le16_to_cpu(dev->descriptor.idProduct);
hid              1358 drivers/hid/usbhid/hid-core.c 	hid->version = le16_to_cpu(dev->descriptor.bcdDevice);
hid              1359 drivers/hid/usbhid/hid-core.c 	hid->name[0] = 0;
hid              1362 drivers/hid/usbhid/hid-core.c 		hid->type = HID_TYPE_USBMOUSE;
hid              1364 drivers/hid/usbhid/hid-core.c 		hid->type = HID_TYPE_USBNONE;
hid              1367 drivers/hid/usbhid/hid-core.c 		strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
hid              1371 drivers/hid/usbhid/hid-core.c 			strlcat(hid->name, " ", sizeof(hid->name));
hid              1372 drivers/hid/usbhid/hid-core.c 		strlcat(hid->name, dev->product, sizeof(hid->name));
hid              1375 drivers/hid/usbhid/hid-core.c 	if (!strlen(hid->name))
hid              1376 drivers/hid/usbhid/hid-core.c 		snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
hid              1380 drivers/hid/usbhid/hid-core.c 	usb_make_path(dev, hid->phys, sizeof(hid->phys));
hid              1381 drivers/hid/usbhid/hid-core.c 	strlcat(hid->phys, "/input", sizeof(hid->phys));
hid              1382 drivers/hid/usbhid/hid-core.c 	len = strlen(hid->phys);
hid              1383 drivers/hid/usbhid/hid-core.c 	if (len < sizeof(hid->phys) - 1)
hid              1384 drivers/hid/usbhid/hid-core.c 		snprintf(hid->phys + len, sizeof(hid->phys) - len,
hid              1387 drivers/hid/usbhid/hid-core.c 	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
hid              1388 drivers/hid/usbhid/hid-core.c 		hid->uniq[0] = 0;
hid              1396 drivers/hid/usbhid/hid-core.c 	hid->driver_data = usbhid;
hid              1397 drivers/hid/usbhid/hid-core.c 	usbhid->hid = hid;
hid              1407 drivers/hid/usbhid/hid-core.c 	ret = hid_add_device(hid);
hid              1418 drivers/hid/usbhid/hid-core.c 	hid_destroy_device(hid);
hid              1424 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(intf);
hid              1427 drivers/hid/usbhid/hid-core.c 	if (WARN_ON(!hid))
hid              1430 drivers/hid/usbhid/hid-core.c 	usbhid = hid->driver_data;
hid              1434 drivers/hid/usbhid/hid-core.c 	hid_destroy_device(hid);
hid              1452 drivers/hid/usbhid/hid-core.c static void hid_restart_io(struct hid_device *hid)
hid              1454 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1471 drivers/hid/usbhid/hid-core.c 		if (hid_start_in(hid) < 0)
hid              1472 drivers/hid/usbhid/hid-core.c 			hid_io_error(hid);
hid              1486 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(intf);
hid              1487 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1501 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(intf);
hid              1502 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1512 drivers/hid/usbhid/hid-core.c 	rdesc = kmalloc(hid->dev_rsize, GFP_KERNEL);
hid              1518 drivers/hid/usbhid/hid-core.c 				HID_DT_REPORT, rdesc, hid->dev_rsize);
hid              1524 drivers/hid/usbhid/hid-core.c 	status = memcmp(rdesc, hid->dev_rdesc, hid->dev_rsize);
hid              1538 drivers/hid/usbhid/hid-core.c 	hid_restart_io(hid);
hid              1544 drivers/hid/usbhid/hid-core.c static int hid_resume_common(struct hid_device *hid, bool driver_suspended)
hid              1548 drivers/hid/usbhid/hid-core.c 	hid_restart_io(hid);
hid              1549 drivers/hid/usbhid/hid-core.c 	if (driver_suspended && hid->driver && hid->driver->resume)
hid              1550 drivers/hid/usbhid/hid-core.c 		status = hid->driver->resume(hid);
hid              1556 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(intf);
hid              1557 drivers/hid/usbhid/hid-core.c 	struct usbhid_device *usbhid = hid->driver_data;
hid              1563 drivers/hid/usbhid/hid-core.c 		ledcount = hidinput_count_leds(hid);
hid              1574 drivers/hid/usbhid/hid-core.c 			if (hid->driver && hid->driver->suspend) {
hid              1575 drivers/hid/usbhid/hid-core.c 				status = hid->driver->suspend(hid, message);
hid              1588 drivers/hid/usbhid/hid-core.c 		if (hid->driver && hid->driver->suspend)
hid              1589 drivers/hid/usbhid/hid-core.c 			status = hid->driver->suspend(hid, message);
hid              1594 drivers/hid/usbhid/hid-core.c 		if (usbhid_wait_io(hid) < 0)
hid              1610 drivers/hid/usbhid/hid-core.c 	hid_resume_common(hid, driver_suspended);
hid              1616 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata (intf);
hid              1619 drivers/hid/usbhid/hid-core.c 	status = hid_resume_common(hid, true);
hid              1626 drivers/hid/usbhid/hid-core.c 	struct hid_device *hid = usb_get_intfdata(intf);
hid              1630 drivers/hid/usbhid/hid-core.c 	if (status >= 0 && hid->driver && hid->driver->reset_resume) {
hid              1631 drivers/hid/usbhid/hid-core.c 		int ret = hid->driver->reset_resume(hid);
hid               145 drivers/hid/usbhid/hid-pidff.c 	struct hid_device *hid;
hid               250 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(pidff->hid, "attack %u => %d\n",
hid               254 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
hid               281 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT],
hid               316 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
hid               348 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC],
hid               390 drivers/hid/usbhid/hid-pidff.c 		hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION],
hid               431 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP],
hid               456 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
hid               458 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);
hid               462 drivers/hid/usbhid/hid-pidff.c 	hid_hw_wait(pidff->hid);
hid               465 drivers/hid/usbhid/hid-pidff.c 		hid_dbg(pidff->hid, "pid_block_load requested\n");
hid               466 drivers/hid/usbhid/hid-pidff.c 		hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
hid               468 drivers/hid/usbhid/hid-pidff.c 		hid_hw_wait(pidff->hid);
hid               471 drivers/hid/usbhid/hid-pidff.c 			hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",
hid               478 drivers/hid/usbhid/hid-pidff.c 			hid_dbg(pidff->hid, "not enough memory free: %d bytes\n",
hid               484 drivers/hid/usbhid/hid-pidff.c 	hid_err(pidff->hid, "pid_block_load failed 60 times\n");
hid               504 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
hid               526 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE],
hid               538 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(pidff->hid, "starting to erase %d/%d\n",
hid               542 drivers/hid/usbhid/hid-pidff.c 	hid_hw_wait(pidff->hid);
hid               603 drivers/hid/usbhid/hid-pidff.c 				hid_err(pidff->hid, "invalid waveform\n");
hid               694 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "invalid type\n");
hid               702 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(pidff->hid, "uploaded\n");
hid               715 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
hid               741 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
hid               772 drivers/hid/usbhid/hid-pidff.c 				if (report->field[i]->usage[j].hid ==
hid               812 drivers/hid/usbhid/hid-pidff.c static void pidff_find_reports(struct hid_device *hid, int report_type,
hid               819 drivers/hid/usbhid/hid-pidff.c 			    &hid->report_enum[report_type].report_list, list) {
hid               824 drivers/hid/usbhid/hid-pidff.c 			hid_dbg(hid, "found usage 0x%02x from field->logical\n",
hid               839 drivers/hid/usbhid/hid-pidff.c 		    hid->collection[i - 1].type != HID_COLLECTION_LOGICAL)
hid               841 drivers/hid/usbhid/hid-pidff.c 		ret = pidff_check_usage(hid->collection[i - 1].usage);
hid               843 drivers/hid/usbhid/hid-pidff.c 			hid_dbg(hid,
hid               860 drivers/hid/usbhid/hid-pidff.c 			hid_dbg(pidff->hid, "%d missing\n", i);
hid               903 drivers/hid/usbhid/hid-pidff.c 			if (fld->usage[j].hid == (HID_UP_PID | usagetable[i])) {
hid               922 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(pidff->hid, "finding special fields\n");
hid               943 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(pidff->hid, "search done\n");
hid               946 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "effect lists not found\n");
hid               951 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "direction field not found\n");
hid               956 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "device control field not found\n");
hid               961 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "block load status field not found\n");
hid               966 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "effect operation field not found\n");
hid               978 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "no effect types found\n");
hid               985 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid,
hid               993 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "effect operation identifiers not found\n");
hid              1010 drivers/hid/usbhid/hid-pidff.c 		if (pidff->set_effect_type->usage[pidff_type].hid !=
hid              1011 drivers/hid/usbhid/hid-pidff.c 		    pidff->create_new_effect_type->usage[pidff_type].hid) {
hid              1012 drivers/hid/usbhid/hid-pidff.c 			hid_err(pidff->hid,
hid              1068 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "unknown set_effect report layout\n");
hid              1074 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "unknown pid_block_load report layout\n");
hid              1079 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "unknown effect_operation report layout\n");
hid              1084 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "unknown pid_block_free report layout\n");
hid              1096 drivers/hid/usbhid/hid-pidff.c 			hid_warn(pidff->hid,
hid              1099 drivers/hid/usbhid/hid-pidff.c 			hid_warn(pidff->hid,
hid              1103 drivers/hid/usbhid/hid-pidff.c 			hid_warn(pidff->hid,
hid              1109 drivers/hid/usbhid/hid-pidff.c 		hid_warn(pidff->hid, "unknown constant effect layout\n");
hid              1115 drivers/hid/usbhid/hid-pidff.c 		hid_warn(pidff->hid, "unknown ramp effect layout\n");
hid              1124 drivers/hid/usbhid/hid-pidff.c 		hid_warn(pidff->hid, "unknown condition effect layout\n");
hid              1133 drivers/hid/usbhid/hid-pidff.c 		hid_warn(pidff->hid, "unknown periodic effect layout\n");
hid              1150 drivers/hid/usbhid/hid-pidff.c 	struct hid_device *hid = pidff->hid;
hid              1155 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
hid              1156 drivers/hid/usbhid/hid-pidff.c 	hid_hw_wait(hid);
hid              1157 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
hid              1158 drivers/hid/usbhid/hid-pidff.c 	hid_hw_wait(hid);
hid              1162 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
hid              1163 drivers/hid/usbhid/hid-pidff.c 	hid_hw_wait(hid);
hid              1166 drivers/hid/usbhid/hid-pidff.c 	hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT);
hid              1167 drivers/hid/usbhid/hid-pidff.c 	hid_hw_wait(hid);
hid              1172 drivers/hid/usbhid/hid-pidff.c 				hid_warn(pidff->hid,
hid              1177 drivers/hid/usbhid/hid-pidff.c 			hid_dbg(pidff->hid, "pid_pool requested again\n");
hid              1178 drivers/hid/usbhid/hid-pidff.c 			hid_hw_request(hid, pidff->reports[PID_POOL],
hid              1180 drivers/hid/usbhid/hid-pidff.c 			hid_hw_wait(hid);
hid              1203 drivers/hid/usbhid/hid-pidff.c 		hid_err(pidff->hid, "upload request failed\n");
hid              1212 drivers/hid/usbhid/hid-pidff.c 		hid_notice(pidff->hid,
hid              1226 drivers/hid/usbhid/hid-pidff.c int hid_pidff_init(struct hid_device *hid)
hid              1229 drivers/hid/usbhid/hid-pidff.c 	struct hid_input *hidinput = list_entry(hid->inputs.next,
hid              1236 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(hid, "starting pid init\n");
hid              1238 drivers/hid/usbhid/hid-pidff.c 	if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) {
hid              1239 drivers/hid/usbhid/hid-pidff.c 		hid_dbg(hid, "not a PID device, no output report\n");
hid              1247 drivers/hid/usbhid/hid-pidff.c 	pidff->hid = hid;
hid              1249 drivers/hid/usbhid/hid-pidff.c 	hid_device_io_start(hid);
hid              1251 drivers/hid/usbhid/hid-pidff.c 	pidff_find_reports(hid, HID_OUTPUT_REPORT, pidff);
hid              1252 drivers/hid/usbhid/hid-pidff.c 	pidff_find_reports(hid, HID_FEATURE_REPORT, pidff);
hid              1255 drivers/hid/usbhid/hid-pidff.c 		hid_dbg(hid, "reports not ok, aborting\n");
hid              1268 drivers/hid/usbhid/hid-pidff.c 		hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN],
hid              1280 drivers/hid/usbhid/hid-pidff.c 	hid_dbg(hid, "max effects is %d\n", max_effects);
hid              1286 drivers/hid/usbhid/hid-pidff.c 		hid_dbg(hid, "max simultaneous effects is %d\n",
hid              1290 drivers/hid/usbhid/hid-pidff.c 		hid_dbg(hid, "device memory size is %d bytes\n",
hid              1295 drivers/hid/usbhid/hid-pidff.c 		hid_notice(hid,
hid              1314 drivers/hid/usbhid/hid-pidff.c 	hid_device_io_stop(hid);
hid              1319 drivers/hid/usbhid/hid-pidff.c 	hid_device_io_stop(hid);
hid                56 drivers/hid/usbhid/hiddev.c hiddev_lookup_report(struct hid_device *hid, struct hiddev_report_info *rinfo)
hid                68 drivers/hid/usbhid/hiddev.c 	report_enum = hid->report_enum +
hid               109 drivers/hid/usbhid/hiddev.c hiddev_lookup_usage(struct hid_device *hid, struct hiddev_usage_ref *uref)
hid               120 drivers/hid/usbhid/hiddev.c 	report_enum = hid->report_enum +
hid               127 drivers/hid/usbhid/hiddev.c 				if (field->usage[j].hid == uref->usage_code) {
hid               140 drivers/hid/usbhid/hiddev.c static void hiddev_send_event(struct hid_device *hid,
hid               143 drivers/hid/usbhid/hiddev.c 	struct hiddev *hiddev = hid->hiddev;
hid               166 drivers/hid/usbhid/hiddev.c void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
hid               179 drivers/hid/usbhid/hiddev.c 	uref.usage_code = usage->hid;
hid               182 drivers/hid/usbhid/hiddev.c 	hiddev_send_event(hid, &uref);
hid               186 drivers/hid/usbhid/hiddev.c void hiddev_report_event(struct hid_device *hid, struct hid_report *report)
hid               199 drivers/hid/usbhid/hiddev.c 	hiddev_send_event(hid, &uref);
hid               228 drivers/hid/usbhid/hiddev.c 			hid_hw_close(list->hiddev->hid);
hid               229 drivers/hid/usbhid/hiddev.c 			hid_hw_power(list->hiddev->hid, PM_HINT_NORMAL);
hid               259 drivers/hid/usbhid/hiddev.c 		error = hid_hw_power(hiddev->hid, PM_HINT_FULLON);
hid               263 drivers/hid/usbhid/hiddev.c 		error = hid_hw_open(hiddev->hid);
hid               277 drivers/hid/usbhid/hiddev.c 	hid_hw_power(hiddev->hid, PM_HINT_NORMAL);
hid               290 drivers/hid/usbhid/hiddev.c 	struct hid_device *hid;
hid               298 drivers/hid/usbhid/hiddev.c 	hid = usb_get_intfdata(intf);
hid               299 drivers/hid/usbhid/hiddev.c 	hiddev = hid->hiddev;
hid               380 drivers/hid/usbhid/hiddev.c 					event.hid = list->buffer[list->tail].usage_code;
hid               429 drivers/hid/usbhid/hiddev.c 	struct hid_device *hid = hiddev->hid;
hid               454 drivers/hid/usbhid/hiddev.c 		if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
hid               468 drivers/hid/usbhid/hiddev.c 		uref->usage_code = field->usage[uref->usage_index].hid;
hid               482 drivers/hid/usbhid/hiddev.c 			field = hiddev_lookup_usage(hid, uref);
hid               488 drivers/hid/usbhid/hiddev.c 			if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
hid               564 drivers/hid/usbhid/hiddev.c 	struct hid_device *hid = hiddev->hid;
hid               565 drivers/hid/usbhid/hiddev.c 	struct usb_device *dev = hid_to_usb_dev(hid);
hid               594 drivers/hid/usbhid/hiddev.c 	struct hid_device *hid;
hid               612 drivers/hid/usbhid/hiddev.c 	hid = hiddev->hid;
hid               622 drivers/hid/usbhid/hiddev.c 		if (arg >= hid->maxapplication)
hid               625 drivers/hid/usbhid/hiddev.c 		for (i = 0; i < hid->maxcollection; i++)
hid               626 drivers/hid/usbhid/hiddev.c 			if (hid->collection[i].type ==
hid               630 drivers/hid/usbhid/hiddev.c 		if (i < hid->maxcollection)
hid               631 drivers/hid/usbhid/hiddev.c 			r = hid->collection[i].usage;
hid               636 drivers/hid/usbhid/hiddev.c 			struct usb_device *dev = hid_to_usb_dev(hid);
hid               637 drivers/hid/usbhid/hiddev.c 			struct usbhid_device *usbhid = hid->driver_data;
hid               648 drivers/hid/usbhid/hiddev.c 			dinfo.num_applications = hid->maxapplication;
hid               685 drivers/hid/usbhid/hiddev.c 		usbhid_init_reports(hid);
hid               699 drivers/hid/usbhid/hiddev.c 		report = hiddev_lookup_report(hid, &rinfo);
hid               703 drivers/hid/usbhid/hiddev.c 		hid_hw_request(hid, report, HID_REQ_GET_REPORT);
hid               704 drivers/hid/usbhid/hiddev.c 		hid_hw_wait(hid);
hid               718 drivers/hid/usbhid/hiddev.c 		report = hiddev_lookup_report(hid, &rinfo);
hid               722 drivers/hid/usbhid/hiddev.c 		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
hid               723 drivers/hid/usbhid/hiddev.c 		hid_hw_wait(hid);
hid               734 drivers/hid/usbhid/hiddev.c 		report = hiddev_lookup_report(hid, &rinfo);
hid               753 drivers/hid/usbhid/hiddev.c 		report = hiddev_lookup_report(hid, &rinfo);
hid               791 drivers/hid/usbhid/hiddev.c 			usbhid_init_reports(hid);
hid               803 drivers/hid/usbhid/hiddev.c 		if (cinfo.index >= hid->maxcollection)
hid               806 drivers/hid/usbhid/hiddev.c 						 hid->maxcollection);
hid               808 drivers/hid/usbhid/hiddev.c 		cinfo.type = hid->collection[cinfo.index].type;
hid               809 drivers/hid/usbhid/hiddev.c 		cinfo.usage = hid->collection[cinfo.index].usage;
hid               810 drivers/hid/usbhid/hiddev.c 		cinfo.level = hid->collection[cinfo.index].level;
hid               821 drivers/hid/usbhid/hiddev.c 			int len = strlen(hid->name) + 1;
hid               824 drivers/hid/usbhid/hiddev.c 			r = copy_to_user(user_arg, hid->name, len) ?
hid               830 drivers/hid/usbhid/hiddev.c 			int len = strlen(hid->phys) + 1;
hid               833 drivers/hid/usbhid/hiddev.c 			r = copy_to_user(user_arg, hid->phys, len) ?
hid               881 drivers/hid/usbhid/hiddev.c int hiddev_connect(struct hid_device *hid, unsigned int force)
hid               884 drivers/hid/usbhid/hiddev.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               889 drivers/hid/usbhid/hiddev.c 		for (i = 0; i < hid->maxcollection; i++)
hid               890 drivers/hid/usbhid/hiddev.c 			if (hid->collection[i].type ==
hid               892 drivers/hid/usbhid/hiddev.c 			    !IS_INPUT_APPLICATION(hid->collection[i].usage))
hid               895 drivers/hid/usbhid/hiddev.c 		if (i == hid->maxcollection)
hid               906 drivers/hid/usbhid/hiddev.c 	hid->hiddev = hiddev;
hid               907 drivers/hid/usbhid/hiddev.c 	hiddev->hid = hid;
hid               911 drivers/hid/usbhid/hiddev.c 		hid_err(hid, "Not able to get a minor for this device\n");
hid               912 drivers/hid/usbhid/hiddev.c 		hid->hiddev = NULL;
hid               921 drivers/hid/usbhid/hiddev.c 	hiddev->initialized = hid->quirks & HID_QUIRK_NO_INIT_REPORTS;
hid               933 drivers/hid/usbhid/hiddev.c void hiddev_disconnect(struct hid_device *hid)
hid               935 drivers/hid/usbhid/hiddev.c 	struct hiddev *hiddev = hid->hiddev;
hid               936 drivers/hid/usbhid/hiddev.c 	struct usbhid_device *usbhid = hid->driver_data;
hid               944 drivers/hid/usbhid/hiddev.c 		hid_hw_close(hiddev->hid);
hid                24 drivers/hid/usbhid/usbhid.h void usbhid_init_reports(struct hid_device *hid);
hid                57 drivers/hid/usbhid/usbhid.h 	struct hid_device *hid;						/* pointer to corresponding HID dev */
hid               108 drivers/hid/wacom_sys.c 			unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
hid               216 drivers/hid/wacom_sys.c 	unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
hid               238 drivers/hid/wacom_sys.c 	    usage->hid == 0x000D0000 &&
hid               244 drivers/hid/wacom_sys.c 		    field->usage[i-4].hid == HID_DG_TIPSWITCH &&
hid               245 drivers/hid/wacom_sys.c 		    field->usage[i-3].hid == HID_DG_BARRELSWITCH &&
hid               246 drivers/hid/wacom_sys.c 		    field->usage[i-2].hid == HID_DG_ERASER &&
hid               247 drivers/hid/wacom_sys.c 		    field->usage[i-1].hid == HID_DG_INVERT &&
hid               248 drivers/hid/wacom_sys.c 		    field->usage[i+1].hid == HID_DG_INRANGE) {
hid               249 drivers/hid/wacom_sys.c 			usage->hid = HID_DG_BARRELSWITCH2;
hid               261 drivers/hid/wacom_sys.c 	if (usage->hid == WACOM_HID_WT_SERIALNUMBER &&
hid               268 drivers/hid/wacom_sys.c 		    a->usage[0].hid == HID_DG_TOOLSERIALNUMBER &&
hid               271 drivers/hid/wacom_sys.c 		    b->usage[0].hid == 0xFF000000 &&
hid               274 drivers/hid/wacom_sys.c 			usage->hid = WACOM_HID_WD_TOOLTYPE;
hid               279 drivers/hid/wacom_sys.c 			b->usage[0].hid = WACOM_HID_WD_SERIALHI;
hid               300 drivers/hid/wacom_sys.c 	unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
hid               434 drivers/hid/wacom_sys.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              1844 drivers/hid/wacom_wac.c 	unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              1889 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              1905 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              1966 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              2073 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              2085 drivers/hid/wacom_wac.c 		if (usage->hid != WACOM_HID_WD_TOUCHRING)
hid              2197 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              2276 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              2480 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              2574 drivers/hid/wacom_wac.c 	unsigned equivalent_usage = wacom_equivalent_usage(usage->hid);
hid              2630 drivers/hid/wacom_wac.c 				wacom_equivalent_usage(usage->hid);
hid              4897 drivers/hid/wacom_wac.c MODULE_DEVICE_TABLE(hid, wacom_ids);
hid               160 drivers/hid/wacom_wac.h #define WACOM_BATTERY_USAGE(f)	(((f)->hid == HID_DG_BATTERYSTRENGTH) || \
hid               161 drivers/hid/wacom_wac.h 				 ((f)->hid == WACOM_HID_WD_BATTERY_CHARGING) || \
hid               162 drivers/hid/wacom_wac.h 				 ((f)->hid == WACOM_HID_WD_BATTERY_LEVEL))
hid              1189 drivers/i2c/busses/i2c-i801.c 	char *hid;
hid              1199 drivers/i2c/busses/i2c-i801.c 	hid = info->hardware_id.string;
hid              1200 drivers/i2c/busses/i2c-i801.c 	if (!hid)
hid              1203 drivers/i2c/busses/i2c-i801.c 	i = match_string(acpi_smo8800_ids, ARRAY_SIZE(acpi_smo8800_ids), hid);
hid               131 drivers/iommu/amd_iommu.c 	const char *hid, *uid;
hid               136 drivers/iommu/amd_iommu.c 	hid = acpi_device_hid(adev);
hid               139 drivers/iommu/amd_iommu.c 	if (!hid || !(*hid))
hid               143 drivers/iommu/amd_iommu.c 		return strcmp(hid, entry->hid);
hid               146 drivers/iommu/amd_iommu.c 		return strcmp(hid, entry->hid);
hid               148 drivers/iommu/amd_iommu.c 	return (strcmp(hid, entry->hid) || strcmp(uid, entry->uid));
hid              1043 drivers/iommu/amd_iommu_init.c static int __init add_acpi_hid_device(u8 *hid, u8 *uid, u16 *devid,
hid              1050 drivers/iommu/amd_iommu_init.c 		if (strcmp(entry->hid, hid) ||
hid              1056 drivers/iommu/amd_iommu_init.c 			hid, uid);
hid              1066 drivers/iommu/amd_iommu_init.c 	memcpy(entry->hid, hid, strlen(hid));
hid              1073 drivers/iommu/amd_iommu_init.c 		entry->hid, entry->uid, entry->root_devid);
hid              1102 drivers/iommu/amd_iommu_init.c 		ret = add_acpi_hid_device(early_acpihid_map[i].hid,
hid              1334 drivers/iommu/amd_iommu_init.c 			u8 hid[ACPIHID_HID_LEN];
hid              1344 drivers/iommu/amd_iommu_init.c 			memcpy(hid, (u8 *)(&e->ext), ACPIHID_HID_LEN - 1);
hid              1345 drivers/iommu/amd_iommu_init.c 			hid[ACPIHID_HID_LEN - 1] = '\0';
hid              1347 drivers/iommu/amd_iommu_init.c 			if (!(*hid)) {
hid              1377 drivers/iommu/amd_iommu_init.c 				    hid, uid,
hid              1384 drivers/iommu/amd_iommu_init.c 			ret = add_acpi_hid_device(hid, uid, &devid, false);
hid              3038 drivers/iommu/amd_iommu_init.c 	char *hid, *uid, *p;
hid              3049 drivers/iommu/amd_iommu_init.c 	hid = strsep(&p, ":");
hid              3052 drivers/iommu/amd_iommu_init.c 	if (!hid || !(*hid) || !uid) {
hid              3058 drivers/iommu/amd_iommu_init.c 	memcpy(early_acpihid_map[i].hid, hid, strlen(hid));
hid               618 drivers/iommu/amd_iommu_types.h 	u8 hid[ACPIHID_HID_LEN];
hid               756 drivers/macintosh/adbhid.c 	struct adbhid *hid;
hid               767 drivers/macintosh/adbhid.c 	adbhid[id] = hid = kzalloc(sizeof(struct adbhid), GFP_KERNEL);
hid               769 drivers/macintosh/adbhid.c 	if (!hid || !input_dev) {
hid               774 drivers/macintosh/adbhid.c 	sprintf(hid->phys, "adb%d:%d.%02x/input", id, default_id, original_handler_id);
hid               776 drivers/macintosh/adbhid.c 	hid->input = input_dev;
hid               777 drivers/macintosh/adbhid.c 	hid->id = default_id;
hid               778 drivers/macintosh/adbhid.c 	hid->original_handler_id = original_handler_id;
hid               779 drivers/macintosh/adbhid.c 	hid->current_handler_id = current_handler_id;
hid               780 drivers/macintosh/adbhid.c 	hid->mouse_kind = mouse_kind;
hid               781 drivers/macintosh/adbhid.c 	hid->flags = 0;
hid               782 drivers/macintosh/adbhid.c 	input_set_drvdata(input_dev, hid);
hid               783 drivers/macintosh/adbhid.c 	input_dev->name = hid->name;
hid               784 drivers/macintosh/adbhid.c 	input_dev->phys = hid->phys;
hid               792 drivers/macintosh/adbhid.c 		hid->keycode = kmalloc(sizeof(adb_to_linux_keycodes), GFP_KERNEL);
hid               793 drivers/macintosh/adbhid.c 		if (!hid->keycode) {
hid               798 drivers/macintosh/adbhid.c 		sprintf(hid->name, "ADB keyboard");
hid               800 drivers/macintosh/adbhid.c 		memcpy(hid->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
hid               820 drivers/macintosh/adbhid.c 			i = hid->keycode[10];
hid               821 drivers/macintosh/adbhid.c 			hid->keycode[10] = hid->keycode[50];
hid               822 drivers/macintosh/adbhid.c 			hid->keycode[50] = i;
hid               834 drivers/macintosh/adbhid.c 			if (hid->keycode[i])
hid               835 drivers/macintosh/adbhid.c 				set_bit(hid->keycode[i], input_dev->keybit);
hid               843 drivers/macintosh/adbhid.c 		input_dev->keycodesize = sizeof(hid->keycode[0]);
hid               847 drivers/macintosh/adbhid.c 		sprintf(hid->name, "ADB mouse");
hid               858 drivers/macintosh/adbhid.c 			sprintf(hid->name, "ADB adjustable keyboard buttons");
hid               867 drivers/macintosh/adbhid.c 			sprintf(hid->name, "ADB Powerbook buttons");
hid               882 drivers/macintosh/adbhid.c 		if (hid->name[0])
hid               892 drivers/macintosh/adbhid.c 	input_dev->keycode = hid->keycode;
hid               909 drivers/macintosh/adbhid.c 	if (hid) {
hid               910 drivers/macintosh/adbhid.c 		kfree(hid->keycode);
hid               911 drivers/macintosh/adbhid.c 		kfree(hid);
hid               328 drivers/mmc/host/sdhci-acpi.c static inline bool sdhci_acpi_no_fixup_child_power(const char *hid,
hid               332 drivers/mmc/host/sdhci-acpi.c 	       !strcmp(hid, "80860F14") &&
hid               348 drivers/mmc/host/sdhci-acpi.c static inline bool sdhci_acpi_no_fixup_child_power(const char *hid,
hid               378 drivers/mmc/host/sdhci-acpi.c static int intel_probe_slot(struct platform_device *pdev, const char *hid,
hid               385 drivers/mmc/host/sdhci-acpi.c 	if (hid && uid && !strcmp(hid, "80860F14") && !strcmp(uid, "1") &&
hid               390 drivers/mmc/host/sdhci-acpi.c 	if (hid && !strcmp(hid, "80865ACA"))
hid               476 drivers/mmc/host/sdhci-acpi.c static int qcom_probe_slot(struct platform_device *pdev, const char *hid,
hid               485 drivers/mmc/host/sdhci-acpi.c 	if (strcmp(hid, "QCOM8051"))
hid               504 drivers/mmc/host/sdhci-acpi.c 	const char *hid;
hid               510 drivers/mmc/host/sdhci-acpi.c 	hid = acpi_device_hid(adev);
hid               511 drivers/mmc/host/sdhci-acpi.c 	if (strcmp(hid, "QCOM8051"))
hid               586 drivers/mmc/host/sdhci-acpi.c 					  const char *hid, const char *uid)
hid               615 drivers/mmc/host/sdhci-acpi.c 	const char *hid;
hid               659 drivers/mmc/host/sdhci-acpi.c static const struct sdhci_acpi_slot *sdhci_acpi_get_slot(const char *hid,
hid               664 drivers/mmc/host/sdhci-acpi.c 	for (u = sdhci_acpi_uids; u->hid; u++) {
hid               665 drivers/mmc/host/sdhci-acpi.c 		if (strcmp(u->hid, hid))
hid               685 drivers/mmc/host/sdhci-acpi.c 	const char *hid;
hid               693 drivers/mmc/host/sdhci-acpi.c 	hid = acpi_device_hid(device);
hid               696 drivers/mmc/host/sdhci-acpi.c 	slot = sdhci_acpi_get_slot(hid, uid);
hid               700 drivers/mmc/host/sdhci-acpi.c 	if (!sdhci_acpi_no_fixup_child_power(hid, uid)) {
hid               750 drivers/mmc/host/sdhci-acpi.c 			err = c->slot->probe_slot(pdev, hid, uid);
hid                76 drivers/pci/pci-acpi.c int acpi_get_rc_resources(struct device *dev, const char *hid, u16 segment,
hid                84 drivers/pci/pci-acpi.c 	status = acpi_get_devices(hid, acpi_match_rc, &segment, &handle);
hid                87 drivers/pci/pci-acpi.c 			hid);
hid               589 drivers/pci/pci.h int acpi_get_rc_resources(struct device *dev, const char *hid, u16 segment,
hid                59 drivers/platform/chrome/chromeos_laptop.c 	char hid[ACPI_ID_LEN];
hid               173 drivers/platform/chrome/chromeos_laptop.c 		memcpy(acpi_ids[0].id, acpi_dev->hid, ACPI_ID_LEN);
hid               498 drivers/platform/chrome/chromeos_laptop.c 		.hid		= "ATML0000",
hid               503 drivers/platform/chrome/chromeos_laptop.c 		.hid		= "ATML0001",
hid               512 drivers/platform/chrome/chromeos_laptop.c 		.hid		= "ATML0000",
hid               517 drivers/platform/chrome/chromeos_laptop.c 		.hid		= "ATML0001",
hid               780 drivers/platform/chrome/chromeos_laptop.c 		if (acpi_dev_present(src->acpi_peripherals[i].hid, NULL, -1))
hid               796 drivers/platform/chrome/chromeos_laptop.c 		if (!acpi_dev_present(src_dev->hid, NULL, -1))
hid                85 drivers/platform/x86/intel_cht_int33fe.c 	const char *hid;
hid                91 drivers/platform/x86/intel_cht_int33fe.c 	hid = acpi_device_hid(adev);
hid                94 drivers/platform/x86/intel_cht_int33fe.c 	if (strcmp(hid, "MAX17047"))
hid               193 drivers/platform/x86/surfacepro3_button.c 	const char *hid = acpi_device_hid(device);
hid               217 drivers/platform/x86/surfacepro3_button.c 	snprintf(button->phys, sizeof(button->phys), "%s/buttons", hid);
hid               262 drivers/platform/x86/thinkpad_acpi.c 	const struct acpi_device_id *hid;
hid               736 drivers/platform/x86/thinkpad_acpi.c 		const char *hid,
hid               745 drivers/platform/x86/thinkpad_acpi.c 			name, hid ? hid : "NULL");
hid               748 drivers/platform/x86/thinkpad_acpi.c 	status = acpi_get_devices(hid, tpacpi_acpi_handle_locate_callback,
hid               838 drivers/platform/x86/thinkpad_acpi.c 	ibm->acpi->driver->ids = ibm->acpi->hid;
hid              4347 drivers/platform/x86/thinkpad_acpi.c 	.hid = ibm_htk_device_ids,
hid              9957 drivers/platform/x86/thinkpad_acpi.c 		if (ibm->acpi->hid) {
hid                88 drivers/platform/x86/xo15-ebook.c 	const char *hid = acpi_device_hid(device);
hid               107 drivers/platform/x86/xo15-ebook.c 	if (strcmp(hid, XO15_EBOOK_HID)) {
hid               108 drivers/platform/x86/xo15-ebook.c 		pr_err("Unsupported hid [%s]\n", hid);
hid               116 drivers/platform/x86/xo15-ebook.c 	snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
hid               244 drivers/scsi/snic/snic.h 	u32	hid;			/* u16 hid | u16 vnic id */
hid               129 drivers/scsi/snic/snic_ctl.c 			snic->config.hid, 0, (ulong)rqi);
hid               160 drivers/scsi/snic/snic_ctl.c 	u32 cmnd_id, hid, max_sgs;
hid               166 drivers/scsi/snic/snic_ctl.c 	snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
hid               167 drivers/scsi/snic/snic_ctl.c 	SNIC_BUG_ON(snic->config.hid != hid);
hid               180 drivers/scsi/snic/snic_ctl.c 	snic->fwinfo.hid = le32_to_cpu(exv_cmpl->hid);
hid               190 drivers/scsi/snic/snic_ctl.c 		       snic->fwinfo.hid,
hid                59 drivers/scsi/snic/snic_disc.c snic_report_tgt_init(struct snic_host_req *req, u32 hid, u8 *buf, u32 len,
hid                65 drivers/scsi/snic/snic_disc.c 	snic_io_hdr_enc(&req->hdr, SNIC_REQ_REPORT_TGTS, 0, SCSI_NO_TAG, hid,
hid               131 drivers/scsi/snic/snic_disc.c 			     snic->config.hid,
hid               399 drivers/scsi/snic/snic_disc.c 	u32 cmnd_id, hid, tgt_cnt = 0;
hid               405 drivers/scsi/snic/snic_disc.c 	snic_io_hdr_dec(&fwreq->hdr, &typ, &cmpl_stat, &cmnd_id, &hid, &ctx);
hid               101 drivers/scsi/snic/snic_fwint.h 	__le32	hid;
hid               114 drivers/scsi/snic/snic_fwint.h snic_io_hdr_enc(struct snic_io_hdr *hdr, u8 typ, u8 status, u32 id, u32 hid,
hid               120 drivers/scsi/snic/snic_fwint.h 	hdr->hid = cpu_to_le32(hid);
hid               130 drivers/scsi/snic/snic_fwint.h 		u32 *hid, ulong *ctx)
hid               134 drivers/scsi/snic/snic_fwint.h 	*hid = le32_to_cpu(hdr->hid);
hid               177 drivers/scsi/snic/snic_fwint.h 	__le32	hid;
hid                61 drivers/scsi/snic/snic_res.c 	GET_CONFIG(hid);
hid               114 drivers/scsi/snic/snic_res.c 	SNIC_INFO("vNIC hid = %d\n", c->hid);
hid               210 drivers/scsi/snic/snic_scsi.c 			snic->config.hid, /* hid */
hid               548 drivers/scsi/snic/snic_scsi.c 	u32 cmnd_id, hid;
hid               558 drivers/scsi/snic/snic_scsi.c 	snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
hid               564 drivers/scsi/snic/snic_scsi.c 		      typ, hdr_stat, cmnd_id, hid, ctx);
hid               927 drivers/scsi/snic/snic_scsi.c 	u32 hid;
hid               931 drivers/scsi/snic/snic_scsi.c 	snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
hid               934 drivers/scsi/snic/snic_scsi.c 		      __func__, typ, hdr_stat, cmnd_id, hid, ctx);
hid              1006 drivers/scsi/snic/snic_scsi.c 	u32 hid;
hid              1015 drivers/scsi/snic/snic_scsi.c 	snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
hid              1022 drivers/scsi/snic/snic_scsi.c 		      typ, hdr_stat, cmnd_id, hid, ctx);
hid              1133 drivers/scsi/snic/snic_scsi.c 	u32 cmnd_id, hid;
hid              1138 drivers/scsi/snic/snic_scsi.c 	snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
hid              1141 drivers/scsi/snic/snic_scsi.c 		      typ, hdr_stat, cmnd_id, hid, ctx);
hid              1327 drivers/scsi/snic/snic_scsi.c 		       snic->config.hid,
hid              2268 drivers/scsi/snic/snic_scsi.c 			snic->config.hid, 0, (ulong) rqi);
hid                52 drivers/scsi/snic/vnic_snic.h 	u8 hid;
hid                22 drivers/staging/greybus/hid.c 	struct hid_device		*hid;
hid               146 drivers/staging/greybus/hid.c 		hid_input_report(ghid->hid, HID_INPUT_REPORT,
hid               158 drivers/staging/greybus/hid.c static void gb_hid_find_max_report(struct hid_device *hid, unsigned int type,
hid               164 drivers/staging/greybus/hid.c 	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
hid               204 drivers/staging/greybus/hid.c 	hid_report_raw_event(ghid->hid, report->type, ghid->inbuf, size, 1);
hid               209 drivers/staging/greybus/hid.c 	struct hid_device *hid = ghid->hid;
hid               213 drivers/staging/greybus/hid.c 			    &hid->report_enum[HID_INPUT_REPORT].report_list,
hid               218 drivers/staging/greybus/hid.c 			    &hid->report_enum[HID_FEATURE_REPORT].report_list,
hid               223 drivers/staging/greybus/hid.c static int __gb_hid_get_raw_report(struct hid_device *hid,
hid               227 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               240 drivers/staging/greybus/hid.c static int __gb_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
hid               243 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               262 drivers/staging/greybus/hid.c static int gb_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
hid               268 drivers/staging/greybus/hid.c 		return __gb_hid_get_raw_report(hid, reportnum, buf, len, rtype);
hid               272 drivers/staging/greybus/hid.c 		return __gb_hid_output_raw_report(hid, buf, len, rtype);
hid               279 drivers/staging/greybus/hid.c static int gb_hid_parse(struct hid_device *hid)
hid               281 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               299 drivers/staging/greybus/hid.c 		hid_err(hid, "reading report descriptor failed\n");
hid               303 drivers/staging/greybus/hid.c 	ret = hid_parse_report(hid, rdesc, rsize);
hid               313 drivers/staging/greybus/hid.c static int gb_hid_start(struct hid_device *hid)
hid               315 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               319 drivers/staging/greybus/hid.c 	gb_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
hid               320 drivers/staging/greybus/hid.c 	gb_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
hid               321 drivers/staging/greybus/hid.c 	gb_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
hid               330 drivers/staging/greybus/hid.c 	if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
hid               336 drivers/staging/greybus/hid.c static void gb_hid_stop(struct hid_device *hid)
hid               338 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               343 drivers/staging/greybus/hid.c static int gb_hid_open(struct hid_device *hid)
hid               345 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               356 drivers/staging/greybus/hid.c static void gb_hid_close(struct hid_device *hid)
hid               358 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               370 drivers/staging/greybus/hid.c static int gb_hid_power(struct hid_device *hid, int lvl)
hid               372 drivers/staging/greybus/hid.c 	struct gb_hid *ghid = hid->driver_data;
hid               397 drivers/staging/greybus/hid.c 	struct hid_device *hid = ghid->hid;
hid               404 drivers/staging/greybus/hid.c 	hid->version = le16_to_cpu(ghid->hdesc.bcdHID);
hid               405 drivers/staging/greybus/hid.c 	hid->vendor = le16_to_cpu(ghid->hdesc.wVendorID);
hid               406 drivers/staging/greybus/hid.c 	hid->product = le16_to_cpu(ghid->hdesc.wProductID);
hid               407 drivers/staging/greybus/hid.c 	hid->country = ghid->hdesc.bCountryCode;
hid               409 drivers/staging/greybus/hid.c 	hid->driver_data = ghid;
hid               410 drivers/staging/greybus/hid.c 	hid->ll_driver = &gb_hid_ll_driver;
hid               411 drivers/staging/greybus/hid.c 	hid->dev.parent = &ghid->connection->bundle->dev;
hid               415 drivers/staging/greybus/hid.c 	snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X",
hid               417 drivers/staging/greybus/hid.c 		 hid->vendor, hid->product);
hid               427 drivers/staging/greybus/hid.c 	struct hid_device *hid;
hid               452 drivers/staging/greybus/hid.c 	hid = hid_allocate_device();
hid               453 drivers/staging/greybus/hid.c 	if (IS_ERR(hid)) {
hid               454 drivers/staging/greybus/hid.c 		ret = PTR_ERR(hid);
hid               458 drivers/staging/greybus/hid.c 	ghid->hid = hid;
hid               471 drivers/staging/greybus/hid.c 	ret = hid_add_device(hid);
hid               473 drivers/staging/greybus/hid.c 		hid_err(hid, "can't add hid device: %d\n", ret);
hid               484 drivers/staging/greybus/hid.c 	hid_destroy_device(hid);
hid               500 drivers/staging/greybus/hid.c 	hid_destroy_device(ghid->hid);
hid              1132 drivers/usb/gadget/function/f_hid.c DECLARE_USB_FUNCTION_INIT(hid, hidg_alloc_inst, hidg_alloc);
hid              2653 drivers/usb/host/xhci.h 	bool hid;
hid              2666 drivers/usb/host/xhci.h 	hid = !!(info2 & (1 << 7));
hid              2680 drivers/usb/host/xhci.h 			xhci_ep_type_string(ep_type), hid ? "HID" : "",
hid               309 drivers/xen/xen-acpi-cpuhotplug.c 	char *hid;
hid               326 drivers/xen/xen-acpi-cpuhotplug.c 	hid = info->hardware_id.string;
hid               327 drivers/xen/xen-acpi-cpuhotplug.c 	if ((hid == NULL) || strcmp(hid, ACPI_PROCESSOR_DEVICE_HID)) {
hid                78 include/acpi/acpi_bus.h bool acpi_dev_found(const char *hid);
hid                79 include/acpi/acpi_bus.h bool acpi_dev_present(const char *hid, const char *uid, s64 hrv);
hid               684 include/acpi/acpi_bus.h acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv);
hid               676 include/linux/acpi.h static inline bool acpi_dev_found(const char *hid)
hid               681 include/linux/acpi.h static inline bool acpi_dev_present(const char *hid, const char *uid, s64 hrv)
hid               687 include/linux/acpi.h acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv)
hid              1313 include/linux/efi.h 			u32 hid;
hid                19 include/linux/hid-roccat.h int roccat_connect(struct class *klass, struct hid_device *hid,
hid               430 include/linux/hid.h 	unsigned  hid;			/* hid usage code */
hid               875 include/linux/hid.h extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
hid               876 include/linux/hid.h extern int hidinput_connect(struct hid_device *hid, unsigned int force);
hid               881 include/linux/hid.h int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
hid               882 include/linux/hid.h struct hid_field *hidinput_get_led_field(struct hid_device *hid);
hid               883 include/linux/hid.h unsigned int hidinput_count_leds(struct hid_device *hid);
hid               886 include/linux/hid.h int __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
hid               892 include/linux/hid.h int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
hid               893 include/linux/hid.h struct hid_report *hid_validate_values(struct hid_device *hid,
hid               898 include/linux/hid.h void hid_setup_resolution_multiplier(struct hid_device *hid);
hid               900 include/linux/hid.h int hid_check_keys_pressed(struct hid_device *hid);
hid               901 include/linux/hid.h int hid_connect(struct hid_device *hid, unsigned int connect_mask);
hid               902 include/linux/hid.h void hid_disconnect(struct hid_device *hid);
hid               912 include/linux/hid.h __u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
hid               924 include/linux/hid.h static inline void hid_device_io_start(struct hid_device *hid) {
hid               925 include/linux/hid.h 	if (hid->io_started) {
hid               926 include/linux/hid.h 		dev_warn(&hid->dev, "io already started\n");
hid               929 include/linux/hid.h 	hid->io_started = true;
hid               930 include/linux/hid.h 	up(&hid->driver_input_lock);
hid               944 include/linux/hid.h static inline void hid_device_io_stop(struct hid_device *hid) {
hid               945 include/linux/hid.h 	if (!hid->io_started) {
hid               946 include/linux/hid.h 		dev_warn(&hid->dev, "io already stopped\n");
hid               949 include/linux/hid.h 	hid->io_started = false;
hid               950 include/linux/hid.h 	down(&hid->driver_input_lock);
hid              1143 include/linux/hid.h int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
hid              1152 include/linux/hid.h int hid_pidff_init(struct hid_device *hid);
hid              1163 include/linux/hid.h #define hid_err(hid, fmt, ...)				\
hid              1164 include/linux/hid.h 	dev_err(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1165 include/linux/hid.h #define hid_notice(hid, fmt, ...)			\
hid              1166 include/linux/hid.h 	dev_notice(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1167 include/linux/hid.h #define hid_warn(hid, fmt, ...)				\
hid              1168 include/linux/hid.h 	dev_warn(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1169 include/linux/hid.h #define hid_info(hid, fmt, ...)				\
hid              1170 include/linux/hid.h 	dev_info(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1171 include/linux/hid.h #define hid_dbg(hid, fmt, ...)				\
hid              1172 include/linux/hid.h 	dev_dbg(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1174 include/linux/hid.h #define hid_err_once(hid, fmt, ...)			\
hid              1175 include/linux/hid.h 	dev_err_once(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1176 include/linux/hid.h #define hid_notice_once(hid, fmt, ...)			\
hid              1177 include/linux/hid.h 	dev_notice_once(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1178 include/linux/hid.h #define hid_warn_once(hid, fmt, ...)			\
hid              1179 include/linux/hid.h 	dev_warn_once(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1180 include/linux/hid.h #define hid_info_once(hid, fmt, ...)			\
hid              1181 include/linux/hid.h 	dev_info_once(&(hid)->dev, fmt, ##__VA_ARGS__)
hid              1182 include/linux/hid.h #define hid_dbg_once(hid, fmt, ...)			\
hid              1183 include/linux/hid.h 	dev_dbg_once(&(hid)->dev, fmt, ##__VA_ARGS__)
hid                29 include/linux/hiddev.h 	struct hid_device *hid;
hid                41 include/linux/hiddev.h int hiddev_connect(struct hid_device *hid, unsigned int force);
hid                43 include/linux/hiddev.h void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
hid                45 include/linux/hiddev.h void hiddev_report_event(struct hid_device *hid, struct hid_report *report);
hid                47 include/linux/hiddev.h static inline int hiddev_connect(struct hid_device *hid,
hid                50 include/linux/hiddev.h static inline void hiddev_disconnect(struct hid_device *hid) { }
hid                51 include/linux/hiddev.h static inline void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
hid                53 include/linux/hiddev.h static inline void hiddev_report_event(struct hid_device *hid, struct hid_report *report) { }
hid                16 include/linux/hidraw.h 	struct hid_device *hid;
hid                46 include/linux/hidraw.h static inline int hidraw_report_event(struct hid_device *hid, u8 *data, int len) { return 0; }
hid                47 include/linux/hidraw.h static inline int hidraw_connect(struct hid_device *hid) { return -1; }
hid                48 include/linux/hidraw.h static inline void hidraw_disconnect(struct hid_device *hid) { }
hid               478 include/linux/soc/ti/ti_sci_protocol.h 	int (*handover)(const struct ti_sci_handle *handle, u8 pid, u8 hid);
hid                29 include/sound/soc-acpi.h bool snd_soc_acpi_find_package_from_hid(const u8 hid[ACPI_ID_LEN],
hid                44 include/sound/soc-acpi.h snd_soc_acpi_find_package_from_hid(const u8 hid[ACPI_ID_LEN],
hid                38 include/uapi/linux/hiddev.h 	unsigned hid;
hid                89 net/bluetooth/hidp/core.c 	} else if (session->hid) {
hid                90 net/bluetooth/hidp/core.c 		ci->vendor  = session->hid->vendor;
hid                91 net/bluetooth/hidp/core.c 		ci->product = session->hid->product;
hid                92 net/bluetooth/hidp/core.c 		ci->version = session->hid->version;
hid                93 net/bluetooth/hidp/core.c 		strlcpy(ci->name, session->hid->name, 128);
hid               233 net/bluetooth/hidp/core.c static int hidp_get_raw_report(struct hid_device *hid,
hid               238 net/bluetooth/hidp/core.c 	struct hidp_session *session = hid->driver_data;
hid               241 net/bluetooth/hidp/core.c 	int numbered_reports = hid->report_enum[report_type].numbered;
hid               318 net/bluetooth/hidp/core.c static int hidp_set_raw_report(struct hid_device *hid, unsigned char reportnum,
hid               322 net/bluetooth/hidp/core.c 	struct hidp_session *session = hid->driver_data;
hid               383 net/bluetooth/hidp/core.c static int hidp_output_report(struct hid_device *hid, __u8 *data, size_t count)
hid               385 net/bluetooth/hidp/core.c 	struct hidp_session *session = hid->driver_data;
hid               392 net/bluetooth/hidp/core.c static int hidp_raw_request(struct hid_device *hid, unsigned char reportnum,
hid               398 net/bluetooth/hidp/core.c 		return hidp_get_raw_report(hid, reportnum, buf, len, rtype);
hid               400 net/bluetooth/hidp/core.c 		return hidp_set_raw_report(hid, reportnum, buf, len, rtype);
hid               446 net/bluetooth/hidp/core.c 	hid_input_report(session->hid, type, session->input_buf, len, intr);
hid               520 net/bluetooth/hidp/core.c 		if (session->hid)
hid               603 net/bluetooth/hidp/core.c 		if (session->hid) {
hid               710 net/bluetooth/hidp/core.c static int hidp_open(struct hid_device *hid)
hid               715 net/bluetooth/hidp/core.c static void hidp_close(struct hid_device *hid)
hid               719 net/bluetooth/hidp/core.c static int hidp_parse(struct hid_device *hid)
hid               721 net/bluetooth/hidp/core.c 	struct hidp_session *session = hid->driver_data;
hid               723 net/bluetooth/hidp/core.c 	return hid_parse_report(session->hid, session->rd_data,
hid               727 net/bluetooth/hidp/core.c static int hidp_start(struct hid_device *hid)
hid               732 net/bluetooth/hidp/core.c static void hidp_stop(struct hid_device *hid)
hid               734 net/bluetooth/hidp/core.c 	struct hidp_session *session = hid->driver_data;
hid               739 net/bluetooth/hidp/core.c 	hid->claimed = 0;
hid               758 net/bluetooth/hidp/core.c 	struct hid_device *hid;
hid               767 net/bluetooth/hidp/core.c 	hid = hid_allocate_device();
hid               768 net/bluetooth/hidp/core.c 	if (IS_ERR(hid)) {
hid               769 net/bluetooth/hidp/core.c 		err = PTR_ERR(hid);
hid               773 net/bluetooth/hidp/core.c 	session->hid = hid;
hid               775 net/bluetooth/hidp/core.c 	hid->driver_data = session;
hid               777 net/bluetooth/hidp/core.c 	hid->bus     = BUS_BLUETOOTH;
hid               778 net/bluetooth/hidp/core.c 	hid->vendor  = req->vendor;
hid               779 net/bluetooth/hidp/core.c 	hid->product = req->product;
hid               780 net/bluetooth/hidp/core.c 	hid->version = req->version;
hid               781 net/bluetooth/hidp/core.c 	hid->country = req->country;
hid               783 net/bluetooth/hidp/core.c 	strscpy(hid->name, req->name, sizeof(hid->name));
hid               785 net/bluetooth/hidp/core.c 	snprintf(hid->phys, sizeof(hid->phys), "%pMR",
hid               791 net/bluetooth/hidp/core.c 	snprintf(hid->uniq, sizeof(hid->uniq), "%pMR",
hid               794 net/bluetooth/hidp/core.c 	hid->dev.parent = &session->conn->hcon->dev;
hid               795 net/bluetooth/hidp/core.c 	hid->ll_driver = &hidp_hid_driver;
hid               798 net/bluetooth/hidp/core.c 	if (hid_ignore(hid)) {
hid               799 net/bluetooth/hidp/core.c 		hid_destroy_device(session->hid);
hid               800 net/bluetooth/hidp/core.c 		session->hid = NULL;
hid               825 net/bluetooth/hidp/core.c 	if (!session->hid) {
hid               837 net/bluetooth/hidp/core.c 	if (session->hid)
hid               838 net/bluetooth/hidp/core.c 		put_device(&session->hid->dev);
hid               856 net/bluetooth/hidp/core.c 	if (session->hid) {
hid               857 net/bluetooth/hidp/core.c 		ret = hid_add_device(session->hid);
hid               860 net/bluetooth/hidp/core.c 		get_device(&session->hid->dev);
hid               874 net/bluetooth/hidp/core.c 	if (session->hid)
hid               875 net/bluetooth/hidp/core.c 		hid_destroy_device(session->hid);
hid              1049 net/bluetooth/hidp/core.c 	if (session->hid) {
hid              1050 net/bluetooth/hidp/core.c 		vendor  = session->hid->vendor;
hid              1051 net/bluetooth/hidp/core.c 		product = session->hid->product;
hid               163 net/bluetooth/hidp/hidp.h 	struct hid_device *hid;
hid               485 sound/soc/intel/atom/sst/sst.h struct sst_platform_info *sst_get_acpi_driver_data(const char *hid);
hid                76 sound/soc/soc-acpi.c bool snd_soc_acpi_find_package_from_hid(const u8 hid[ACPI_ID_LEN],
hid                81 sound/soc/soc-acpi.c 	status = acpi_get_devices(hid, snd_soc_acpi_find_package, ctx, NULL);