* ok
         */
        result =
-           usb_get_status(hw->usb, USB_RECIP_ENDPOINT, hw->endp_in, &status);
+           usb_get_std_status(hw->usb, USB_RECIP_ENDPOINT, hw->endp_in, &status);
        if (result < 0) {
                netdev_err(hw->wlandev->netdev, "Cannot get bulk in endpoint status.\n");
                goto done;
                netdev_err(hw->wlandev->netdev, "Failed to reset bulk in endpoint.\n");
 
        result =
-           usb_get_status(hw->usb, USB_RECIP_ENDPOINT, hw->endp_out, &status);
+           usb_get_std_status(hw->usb, USB_RECIP_ENDPOINT, hw->endp_out, &status);
        if (result < 0) {
                netdev_err(hw->wlandev->netdev, "Cannot get bulk out endpoint status.\n");
                goto done;
 
                        int err;
                        u16 devstat;
 
-                       err = usb_get_status(udev, USB_RECIP_DEVICE, 0,
-                                            &devstat);
+                       err = usb_get_std_status(udev, USB_RECIP_DEVICE, 0,
+                                                &devstat);
                        if (err) {
                                dev_err(&udev->dev,
                                        "Failed to suspend device, error %d\n",
 
        /* power budgeting mostly matters with bus-powered hubs,
         * and battery-powered root hubs (may provide just 8 mA).
         */
-       ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
+       ret = usb_get_std_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
        if (ret) {
                message = "can't get hub status";
                goto fail;
         */
        if (status == 0) {
                devstatus = 0;
-               status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
+               status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
 
                /* If a normal resume failed, try doing a reset-resume */
                if (status && !udev->reset_resume && udev->persist_enabled) {
                        if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
                                status = usb_disable_remote_wakeup(udev);
                } else {
-                       status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
+                       status = usb_get_std_status(udev, USB_RECIP_INTERFACE, 0,
                                        &devstatus);
                        if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
                                        | USB_INTRF_STAT_FUNC_RW))
                                && udev->bus_mA <= unit_load) {
                        u16     devstat;
 
-                       status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
+                       status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0,
                                        &devstat);
                        if (status) {
                                dev_dbg(&udev->dev, "get status %d ?\n", status);
 
        /* FIXME fetch strings from at least the device descriptor */
 
        /* [9.4.5] get_status always works */
-       retval = usb_get_status(udev, USB_RECIP_DEVICE, 0, dev->buf);
+       retval = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, dev->buf);
        if (retval) {
                dev_err(&iface->dev, "get dev status --> %d\n", retval);
                return retval;
         * the device's remote wakeup feature ... if we can, test that here
         */
 
-       retval = usb_get_status(udev, USB_RECIP_INTERFACE,
+       retval = usb_get_std_status(udev, USB_RECIP_INTERFACE,
                        iface->altsetting[0].desc.bInterfaceNumber, dev->buf);
        if (retval) {
                dev_err(&iface->dev, "get interface status --> %d\n", retval);
        u16     status;
 
        /* shouldn't look or act halted */
-       retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
+       retval = usb_get_std_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
        if (retval < 0) {
                ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n",
                                ep, retval);
        u16     status;
 
        /* should look and act halted */
-       retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
+       retval = usb_get_std_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
        if (retval < 0) {
                ERROR(tdev, "ep %02x couldn't get halt status, %d\n",
                                ep, retval);
 
        unsigned char descindex, void *buf, int size);
 extern int usb_get_status(struct usb_device *dev,
        int recip, int target, void *data);
+
+static inline int usb_get_std_status(struct usb_device *dev,
+       int recip, int target, void *data)
+{
+       return usb_get_status(dev, recip, target, data);
+}
+
 extern int usb_string(struct usb_device *dev, int index,
        char *buf, size_t size);