HID: use hid_hw_wait() instead of direct call to usbhid

This removes most of the dependencies between hid drivers and usbhid.

The patch was constructed by replacing all occurences of
usbhid_wait_io() by its hid_hw_wait() counterpart.
Then, drivers not requiring USB_HID anymore have their USB_HID
dependency cleaned in the Kconfig file.

As of today, few drivers are still requiring an explicit USB layer
dependency:
* ntrig (a patch is on its way)
* multitouch (one patch following and another on its way)
* lenovo tpkbd
* roccat
* sony

The last three are two deeply using direct calls to the usb subsystem
to be able to be cleaned right now.

Signed-off-by: Benjamin Tissoires <[e-mail]>
Reviewed-by: Mika Westerberg <[e-mail]>
Signed-off-by: Jiri Kosina <[e-mail]>

drivers/hid/Kconfig

···
 
 config HID_PICOLCD
 	tristate "PicoLCD (graphic version)"
-	depends on USB_HID
+	depends on HID
 	---help---
 	  This provides support for Minibox PicoLCD devices, currently
 	  only the graphical ones are supported.

drivers/hid/hid-ntrig.c

···
 		return -EINVAL;
 
 	hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
-	usbhid_wait_io(hdev);
+	hid_hw_wait(hdev);
 	return (int)report->field[0]->value[0];
 }
 
···
 	if (report) {
 		/* Let the device settle to ensure the wakeup message gets
 		 * through */
-		usbhid_wait_io(hdev);
+		hid_hw_wait(hdev);
 		hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
 
 		/*

drivers/hid/hid-picolcd_fb.c

···
 
 #include <linux/hid.h>
 #include <linux/vmalloc.h>
-#include "usbhid/usbhid.h"
 
 #include <linux/fb.h>
 #include <linux/module.h>
···
 				mutex_unlock(&info->lock);
 				if (!data)
 					return;
-				usbhid_wait_io(data->hdev);
+				hid_hw_wait(data->hdev);
 				mutex_lock(&info->lock);
 				n = 0;
 			}
···
 		spin_unlock_irqrestore(&fbdata->lock, flags);
 		mutex_unlock(&info->lock);
 		if (data)
-			usbhid_wait_io(data->hdev);
+			hid_hw_wait(data->hdev);
 		return;
 	}
 out:

drivers/hid/hid-sensor-hub.c

···
  */
 #include <linux/device.h>
 #include <linux/hid.h>
-#include "usbhid/usbhid.h"
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mfd/core.h>
···
 	}
 	hid_set_field(report->field[field_index], 0, value);
 	hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);
-	usbhid_wait_io(hsdev->hdev);
+	hid_hw_wait(hsdev->hdev);
 
 done_proc:
 	mutex_unlock(&data->mutex);
···
 		goto done_proc;
 	}
 	hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT);
-	usbhid_wait_io(hsdev->hdev);
+	hid_hw_wait(hsdev->hdev);
 	*value = report->field[field_index]->value[0];
 
 done_proc:

drivers/hid/usbhid/hid-core.c

···
 	return 0;
 }
 
-int usbhid_wait_io(struct hid_device *hid)
+static int usbhid_wait_io(struct hid_device *hid)
 {
 	struct usbhid_device *usbhid = hid->driver_data;
 
···
 
 	return 0;
 }
-EXPORT_SYMBOL_GPL(usbhid_wait_io);
 
 static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)
 {

drivers/hid/usbhid/hid-pidff.c

···
 
 	pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;
 	pidff->block_load_status->value[0] = 0;
-	usbhid_wait_io(pidff->hid);
+	hid_hw_wait(pidff->hid);
 
 	for (j = 0; j < 60; j++) {
 		hid_dbg(pidff->hid, "pid_block_load requested\n");
 		hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
 				HID_REQ_GET_REPORT);
-		usbhid_wait_io(pidff->hid);
+		hid_hw_wait(pidff->hid);
 		if (pidff->block_load_status->value[0] ==
 		    pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {
 			hid_dbg(pidff->hid, "device reported free memory: %d bytes\n",
···
 		effect_id, pidff->pid_id[effect_id]);
 	/* Wait for the queue to clear. We do not want a full fifo to
 	   prevent the effect removal. */
-	usbhid_wait_io(pidff->hid);
+	hid_hw_wait(pidff->hid);
 	pidff_playback_pid(pidff, pid_id, 0);
 	pidff_erase_pid(pidff, pid_id);
 
···
 	pidff->device_control->value[0] = pidff->control_id[PID_RESET];
 	/* We reset twice as sometimes hid_wait_io isn't waiting long enough */
 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
-	usbhid_wait_io(hid);
+	hid_hw_wait(hid);
 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
-	usbhid_wait_io(hid);
+	hid_hw_wait(hid);
 
 	pidff->device_control->value[0] =
 		pidff->control_id[PID_ENABLE_ACTUATORS];
 	hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
-	usbhid_wait_io(hid);
+	hid_hw_wait(hid);
 
 	/* pool report is sometimes messed up, refetch it */
 	hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT);
-	usbhid_wait_io(hid);
+	hid_hw_wait(hid);
 
 	if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {
 		while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {
···
 			hid_dbg(pidff->hid, "pid_pool requested again\n");
 			hid_hw_request(hid, pidff->reports[PID_POOL],
 					  HID_REQ_GET_REPORT);
-			usbhid_wait_io(hid);
+			hid_hw_wait(hid);
 		}
 	}
 }

drivers/hid/usbhid/hiddev.c

···
 			break;
 
 		hid_hw_request(hid, report, HID_REQ_GET_REPORT);
-		usbhid_wait_io(hid);
+		hid_hw_wait(hid);
 
 		r = 0;
 		break;
···
 			break;
 
 		hid_hw_request(hid, report, HID_REQ_SET_REPORT);
-		usbhid_wait_io(hid);
+		hid_hw_wait(hid);
 
 		r = 0;
 		break;

drivers/hid/usbhid/usbhid.h

···
 #include <linux/input.h>
 
 /*  API provided by hid-core.c for USB HID drivers */
-int usbhid_wait_io(struct hid_device* hid);
 void usbhid_close(struct hid_device *hid);
 int usbhid_open(struct hid_device *hid);
 void usbhid_init_reports(struct hid_device *hid);