4 files changed, 75 insertions, 51 deletions

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 8e0c4bf94ebc..effcd3d6f5cf 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -639,7 +639,7 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
         }
 }
 
-void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
+static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
 {
         struct usbhid_device *usbhid = hid->driver_data;
         unsigned long flags;
@@ -648,7 +648,6 @@ void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, uns
         __usbhid_submit_report(hid, report, dir);
         spin_unlock_irqrestore(&usbhid->lock, flags);
 }
-EXPORT_SYMBOL_GPL(usbhid_submit_report);
 
 /* Workqueue routine to send requests to change LEDs */
 static void hid_led(struct work_struct *work)
@@ -706,7 +705,7 @@ static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, un
         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;
 
@@ -720,7 +719,6 @@ int usbhid_wait_io(struct hid_device *hid)
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(usbhid_wait_io);
 
 static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)
 {
@@ -1243,6 +1241,32 @@ static int usbhid_power(struct hid_device *hid, int lvl)
         return r;
 }
 
+static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype)
+{
+        switch (reqtype) {
+        case HID_REQ_GET_REPORT:
+                usbhid_submit_report(hid, rep, USB_DIR_IN);
+                break;
+        case HID_REQ_SET_REPORT:
+                usbhid_submit_report(hid, rep, USB_DIR_OUT);
+                break;
+        }
+}
+
+static int usbhid_idle(struct hid_device *hid, int report, int idle,
+                int reqtype)
+{
+        struct usb_device *dev = hid_to_usb_dev(hid);
+        struct usb_interface *intf = to_usb_interface(hid->dev.parent);
+        struct usb_host_interface *interface = intf->cur_altsetting;
+        int ifnum = interface->desc.bInterfaceNumber;
+
+        if (reqtype != HID_REQ_SET_IDLE)
+                return -EINVAL;
+
+        return hid_set_idle(dev, ifnum, report, idle);
+}
+
 static struct hid_ll_driver usb_hid_driver = {
         .parse = usbhid_parse,
         .start = usbhid_start,
@@ -1251,6 +1275,9 @@ static struct hid_ll_driver usb_hid_driver = {
         .close = usbhid_close,
         .power = usbhid_power,
         .hidinput_input_event = usb_hidinput_input_event,
+        .request = usbhid_request,
+        .wait = usbhid_wait_io,
+        .idle = usbhid_idle,
 };
 
 static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id)
diff --git a/drivers/hid/usbhid/hid-pidff.c b/drivers/hid/usbhid/hid-pidff.c
index f91c136821f7..10b616702780 100644
--- a/drivers/hid/usbhid/hid-pidff.c
+++ b/drivers/hid/usbhid/hid-pidff.c
@@ -263,8 +263,8 @@ static void pidff_set_envelope_report(struct pidff_device *pidff,
                 envelope->attack_level,
                 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);
 
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
+                        HID_REQ_SET_REPORT);
 }
 
 /*
@@ -290,8 +290,8 @@ static void pidff_set_constant_force_report(struct pidff_device *pidff,
         pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],
                          effect->u.constant.level);
 
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONSTANT],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONSTANT],
+                        HID_REQ_SET_REPORT);
 }
 
 /*
@@ -325,8 +325,8 @@ static void pidff_set_effect_report(struct pidff_device *pidff,
                                 pidff->effect_direction);
         pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;
 
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
+                        HID_REQ_SET_REPORT);
 }
 
 /*
@@ -357,8 +357,8 @@ static void pidff_set_periodic_report(struct pidff_device *pidff,
         pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);
         pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;
 
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_PERIODIC],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_SET_PERIODIC],
+                        HID_REQ_SET_REPORT);
 
 }
 
@@ -399,8 +399,8 @@ static void pidff_set_condition_report(struct pidff_device *pidff,
                           effect->u.condition[i].left_saturation);
                 pidff_set(&pidff->set_condition[PID_DEAD_BAND],
                           effect->u.condition[i].deadband);
-                usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION],
-                                  USB_DIR_OUT);
+                hid_hw_request(pidff->hid, pidff->reports[PID_SET_CONDITION],
+                                HID_REQ_SET_REPORT);
         }
 }
 
@@ -440,8 +440,8 @@ static void pidff_set_ramp_force_report(struct pidff_device *pidff,
                          effect->u.ramp.start_level);
         pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],
                          effect->u.ramp.end_level);
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_RAMP],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_SET_RAMP],
+                        HID_REQ_SET_REPORT);
 }
 
 /*
@@ -465,19 +465,19 @@ static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)
         int j;
 
         pidff->create_new_effect_type->value[0] = efnum;
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
+                        HID_REQ_SET_REPORT);
         hid_dbg(pidff->hid, "create_new_effect sent, type: %d\n", efnum);
 
         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");
-                usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
-                                  USB_DIR_IN);
-                usbhid_wait_io(pidff->hid);
+                hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
+                                HID_REQ_GET_REPORT);
+                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",
@@ -513,8 +513,8 @@ static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)
                 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;
         }
 
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
+                        HID_REQ_SET_REPORT);
 }
 
 /**
@@ -535,8 +535,8 @@ static int pidff_playback(struct input_dev *dev, int effect_id, int value)
 static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)
 {
         pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_FREE],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_BLOCK_FREE],
+                        HID_REQ_SET_REPORT);
 }
 
 /*
@@ -551,7 +551,7 @@ static int pidff_erase_effect(struct input_dev *dev, int effect_id)
                 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);
 
@@ -718,8 +718,8 @@ static void pidff_set_gain(struct input_dev *dev, u16 gain)
         struct pidff_device *pidff = dev->ff->private;
 
         pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
+                        HID_REQ_SET_REPORT);
 }
 
 static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)
@@ -744,8 +744,8 @@ static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)
         pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;
         pidff->set_effect[PID_START_DELAY].value[0] = 0;
 
-        usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],
-                          USB_DIR_OUT);
+        hid_hw_request(pidff->hid, pidff->reports[PID_SET_EFFECT],
+                        HID_REQ_SET_REPORT);
 }
 
 /*
@@ -1158,19 +1158,19 @@ static void pidff_reset(struct pidff_device *pidff)
 
         pidff->device_control->value[0] = pidff->control_id[PID_RESET];
         /* We reset twice as sometimes hid_wait_io isn't waiting long enough */
-        usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
-        usbhid_wait_io(hid);
-        usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
-        usbhid_wait_io(hid);
+        hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
+        hid_hw_wait(hid);
+        hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
+        hid_hw_wait(hid);
 
         pidff->device_control->value[0] =
                 pidff->control_id[PID_ENABLE_ACTUATORS];
-        usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
-        usbhid_wait_io(hid);
+        hid_hw_request(hid, pidff->reports[PID_DEVICE_CONTROL], HID_REQ_SET_REPORT);
+        hid_hw_wait(hid);
 
         /* pool report is sometimes messed up, refetch it */
-        usbhid_submit_report(hid, pidff->reports[PID_POOL], USB_DIR_IN);
-        usbhid_wait_io(hid);
+        hid_hw_request(hid, pidff->reports[PID_POOL], HID_REQ_GET_REPORT);
+        hid_hw_wait(hid);
 
         if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {
                 while (pidff->pool[PID_SIMULTANEOUS_MAX].value[0] < 2) {
@@ -1181,9 +1181,9 @@ static void pidff_reset(struct pidff_device *pidff)
                                 break;
                         }
                         hid_dbg(pidff->hid, "pid_pool requested again\n");
-                        usbhid_submit_report(hid, pidff->reports[PID_POOL],
-                                          USB_DIR_IN);
-                        usbhid_wait_io(hid);
+                        hid_hw_request(hid, pidff->reports[PID_POOL],
+                                          HID_REQ_GET_REPORT);
+                        hid_hw_wait(hid);
                 }
         }
 }
@@ -1269,8 +1269,8 @@ int hid_pidff_init(struct hid_device *hid)
 
         if (test_bit(FF_GAIN, dev->ffbit)) {
                 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);
-                usbhid_submit_report(hid, pidff->reports[PID_DEVICE_GAIN],
-                                     USB_DIR_OUT);
+                hid_hw_request(hid, pidff->reports[PID_DEVICE_GAIN],
+                                     HID_REQ_SET_REPORT);
         }
 
         error = pidff_check_autocenter(pidff, dev);
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 87bd64959a91..2f1ddca6f2e0 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -705,8 +705,8 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 if (report == NULL)
                         break;
 
-                usbhid_submit_report(hid, report, USB_DIR_IN);
-                usbhid_wait_io(hid);
+                hid_hw_request(hid, report, HID_REQ_GET_REPORT);
+                hid_hw_wait(hid);
 
                 r = 0;
                 break;
@@ -724,8 +724,8 @@ static long hiddev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 if (report == NULL)
                         break;
 
-                usbhid_submit_report(hid, report, USB_DIR_OUT);
-                usbhid_wait_io(hid);
+                hid_hw_request(hid, report, HID_REQ_SET_REPORT);
+                hid_hw_wait(hid);
 
                 r = 0;
                 break;
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index bd87a61e5303..dbb6af699135 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -34,12 +34,9 @@
 #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);
-void usbhid_submit_report
-(struct hid_device *hid, struct hid_report *report, unsigned char dir);
 int usbhid_get_power(struct hid_device *hid);
 void usbhid_put_power(struct hid_device *hid);
 struct usb_interface *usbhid_find_interface(int minor);