openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

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 <benjamin.tissoires@gmail.com>
Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
Benjamin Tissoires 2013-02-25 11:31:47 +01:00 committed by Jiri Kosina
parent d881427253
commit b7966a4d7b
8 changed files with 18 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/hid/Kconfig
View File

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

4
drivers/hid/hid-ntrig.c
View File

@ -119,7 +119,7 @@ static inline int ntrig_get_mode(struct hid_device *hdev)
return -EINVAL; return -EINVAL;
hid_hw_request(hdev, report, HID_REQ_GET_REPORT); hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
usbhid_wait_io(hdev); hid_hw_wait(hdev);
return (int)report->field[0]->value[0]; return (int)report->field[0]->value[0];
} }
@ -937,7 +937,7 @@ static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
if (report) { if (report) {
/* Let the device settle to ensure the wakeup message gets /* Let the device settle to ensure the wakeup message gets
* through */ * through */
usbhid_wait_io(hdev); hid_hw_wait(hdev);
hid_hw_request(hdev, report, HID_REQ_GET_REPORT); hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
/* /*

5
drivers/hid/hid-picolcd_fb.c
View File

@ -19,7 +19,6 @@
#include <linux/hid.h> #include <linux/hid.h>
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include "usbhid/usbhid.h"
#include <linux/fb.h> #include <linux/fb.h>
#include <linux/module.h> #include <linux/module.h>
@ -269,7 +268,7 @@ static void picolcd_fb_update(struct fb_info *info)
mutex_unlock(&info->lock); mutex_unlock(&info->lock);
if (!data) if (!data)
return; return;
usbhid_wait_io(data->hdev); hid_hw_wait(data->hdev);
mutex_lock(&info->lock); mutex_lock(&info->lock);
n = 0; n = 0;
} }
@ -287,7 +286,7 @@ static void picolcd_fb_update(struct fb_info *info)
spin_unlock_irqrestore(&fbdata->lock, flags); spin_unlock_irqrestore(&fbdata->lock, flags);
mutex_unlock(&info->lock); mutex_unlock(&info->lock);
if (data) if (data)
usbhid_wait_io(data->hdev); hid_hw_wait(data->hdev);
return; return;
} }
out: out:

5
drivers/hid/hid-sensor-hub.c
View File

@ -18,7 +18,6 @@
*/ */
#include <linux/device.h> #include <linux/device.h>
#include <linux/hid.h> #include <linux/hid.h>
#include "usbhid/usbhid.h"
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/mfd/core.h> #include <linux/mfd/core.h>
@ -204,7 +203,7 @@ int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
} }
hid_set_field(report->field[field_index], 0, value); hid_set_field(report->field[field_index], 0, value);
hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT); hid_hw_request(hsdev->hdev, report, HID_REQ_SET_REPORT);
usbhid_wait_io(hsdev->hdev); hid_hw_wait(hsdev->hdev);
done_proc: done_proc:
mutex_unlock(&data->mutex); mutex_unlock(&data->mutex);
@ -227,7 +226,7 @@ int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
goto done_proc; goto done_proc;
} }
hid_hw_request(hsdev->hdev, report, HID_REQ_GET_REPORT); 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]; *value = report->field[field_index]->value[0];
done_proc: done_proc:

3
drivers/hid/usbhid/hid-core.c
View File

@ -705,7 +705,7 @@ static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, un
return 0; 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; struct usbhid_device *usbhid = hid->driver_data;
@ -719,7 +719,6 @@ int usbhid_wait_io(struct hid_device *hid)
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(usbhid_wait_io);
static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle) static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)
{ {

16
drivers/hid/usbhid/hid-pidff.c
View File

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

4
drivers/hid/usbhid/hiddev.c
View File

@ -706,7 +706,7 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
break; break;
hid_hw_request(hid, report, HID_REQ_GET_REPORT); hid_hw_request(hid, report, HID_REQ_GET_REPORT);
usbhid_wait_io(hid); hid_hw_wait(hid);
r = 0; r = 0;
break; break;
@ -725,7 +725,7 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
break; break;
hid_hw_request(hid, report, HID_REQ_SET_REPORT); hid_hw_request(hid, report, HID_REQ_SET_REPORT);
usbhid_wait_io(hid); hid_hw_wait(hid);
r = 0; r = 0;
break; break;

1
drivers/hid/usbhid/usbhid.h
View File

@ -34,7 +34,6 @@
#include <linux/input.h> #include <linux/input.h>
/* API provided by hid-core.c for USB HID drivers */ /* 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); void usbhid_close(struct hid_device *hid);
int usbhid_open(struct hid_device *hid); int usbhid_open(struct hid_device *hid);
void usbhid_init_reports(struct hid_device *hid); void usbhid_init_reports(struct hid_device *hid);