usb: raw-gadget: support stalling/halting/wedging endpoints

Raw Gadget is currently unable to stall/halt/wedge gadget endpoints,
which is required for proper emulation of certain USB classes.

This patch adds a few more ioctls:

- USB_RAW_IOCTL_EP0_STALL allows to stall control endpoint #0 when
  there's a pending setup request for it.
- USB_RAW_IOCTL_SET/CLEAR_HALT/WEDGE allow to set/clear halt/wedge status
  on non-control non-isochronous endpoints.

Fixes: f2c2e717642c ("usb: gadget: add raw-gadget interface")
Signed-off-by: Andrey Konovalov <andreyknvl@google.com>
Signed-off-by: Felipe Balbi <balbi@kernel.org>

diff --git a/Documentation/usb/raw-gadget.rst b/Documentation/usb/raw-gadget.rst
index 4af8b1f15574f2410a67917d946f88601329d8df..3b3d78e850b2ccfbb20af673f02b5e90c9533d9a 100644 (file)
--- a/Documentation/usb/raw-gadget.rst
+++ b/Documentation/usb/raw-gadget.rst
@@ -52,8 +52,6 @@ The typical usage of Raw Gadget looks like:
 Potential future improvements
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-- Implement ioctl's for setting/clearing halt status on endpoints.
-
 - Reporting more events (suspend, resume, etc.) through
   USB_RAW_IOCTL_EVENT_FETCH.
 

diff --git a/drivers/usb/gadget/legacy/raw_gadget.c b/drivers/usb/gadget/legacy/raw_gadget.c
index 775f22184aafe5e4a1d0f2b0ffe98a157cc1a91a..d73ba77014c832cfacb9aeded96eb0e44ac312d3 100644 (file)
--- a/drivers/usb/gadget/legacy/raw_gadget.c
+++ b/drivers/usb/gadget/legacy/raw_gadget.c
@@ -204,7 +204,7 @@ static void dev_free(struct kref *kref)
        }
        raw_event_queue_destroy(&dev->queue);
        for (i = 0; i < dev->eps_num; i++) {
-               if (dev->eps[i].state != STATE_EP_ENABLED)
+               if (dev->eps[i].state == STATE_EP_DISABLED)
                        continue;
                usb_ep_disable(dev->eps[i].ep);
                usb_ep_free_request(dev->eps[i].ep, dev->eps[i].req);
@@ -704,6 +704,50 @@ free:
        return ret;
 }
 
+static int raw_ioctl_ep0_stall(struct raw_dev *dev, unsigned long value)
+{
+       int ret = 0;
+       unsigned long flags;
+
+       if (value)
+               return -EINVAL;
+       spin_lock_irqsave(&dev->lock, flags);
+       if (dev->state != STATE_DEV_RUNNING) {
+               dev_dbg(dev->dev, "fail, device is not running\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+       if (!dev->gadget) {
+               dev_dbg(dev->dev, "fail, gadget is not bound\n");
+               ret = -EBUSY;
+               goto out_unlock;
+       }
+       if (dev->ep0_urb_queued) {
+               dev_dbg(&dev->gadget->dev, "fail, urb already queued\n");
+               ret = -EBUSY;
+               goto out_unlock;
+       }
+       if (!dev->ep0_in_pending && !dev->ep0_out_pending) {
+               dev_dbg(&dev->gadget->dev, "fail, no request pending\n");
+               ret = -EBUSY;
+               goto out_unlock;
+       }
+
+       ret = usb_ep_set_halt(dev->gadget->ep0);
+       if (ret < 0)
+               dev_err(&dev->gadget->dev,
+                               "fail, usb_ep_set_halt returned %d\n", ret);
+
+       if (dev->ep0_in_pending)
+               dev->ep0_in_pending = false;
+       else
+               dev->ep0_out_pending = false;
+
+out_unlock:
+       spin_unlock_irqrestore(&dev->lock, flags);
+       return ret;
+}
+
 static int raw_ioctl_ep_enable(struct raw_dev *dev, unsigned long value)
 {
        int ret = 0, i;
@@ -798,7 +842,7 @@ static int raw_ioctl_ep_disable(struct raw_dev *dev, unsigned long value)
                ret = -EBUSY;
                goto out_unlock;
        }
-       if (dev->eps[i].state != STATE_EP_ENABLED) {
+       if (dev->eps[i].state == STATE_EP_DISABLED) {
                dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
                ret = -EINVAL;
                goto out_unlock;
@@ -832,6 +876,74 @@ out_unlock:
        return ret;
 }
 
+static int raw_ioctl_ep_set_clear_halt_wedge(struct raw_dev *dev,
+               unsigned long value, bool set, bool halt)
+{
+       int ret = 0, i = value;
+       unsigned long flags;
+
+       spin_lock_irqsave(&dev->lock, flags);
+       if (dev->state != STATE_DEV_RUNNING) {
+               dev_dbg(dev->dev, "fail, device is not running\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+       if (!dev->gadget) {
+               dev_dbg(dev->dev, "fail, gadget is not bound\n");
+               ret = -EBUSY;
+               goto out_unlock;
+       }
+       if (i < 0 || i >= dev->eps_num) {
+               dev_dbg(dev->dev, "fail, invalid endpoint\n");
+               ret = -EBUSY;
+               goto out_unlock;
+       }
+       if (dev->eps[i].state == STATE_EP_DISABLED) {
+               dev_dbg(&dev->gadget->dev, "fail, endpoint is not enabled\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+       if (dev->eps[i].disabling) {
+               dev_dbg(&dev->gadget->dev,
+                               "fail, disable is in progress\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+       if (dev->eps[i].urb_queued) {
+               dev_dbg(&dev->gadget->dev,
+                               "fail, waiting for urb completion\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+       if (usb_endpoint_xfer_isoc(dev->eps[i].ep->desc)) {
+               dev_dbg(&dev->gadget->dev,
+                               "fail, can't halt/wedge ISO endpoint\n");
+               ret = -EINVAL;
+               goto out_unlock;
+       }
+
+       if (set && halt) {
+               ret = usb_ep_set_halt(dev->eps[i].ep);
+               if (ret < 0)
+                       dev_err(&dev->gadget->dev,
+                               "fail, usb_ep_set_halt returned %d\n", ret);
+       } else if (!set && halt) {
+               ret = usb_ep_clear_halt(dev->eps[i].ep);
+               if (ret < 0)
+                       dev_err(&dev->gadget->dev,
+                               "fail, usb_ep_clear_halt returned %d\n", ret);
+       } else if (set && !halt) {
+               ret = usb_ep_set_wedge(dev->eps[i].ep);
+               if (ret < 0)
+                       dev_err(&dev->gadget->dev,
+                               "fail, usb_ep_set_wedge returned %d\n", ret);
+       }
+
+out_unlock:
+       spin_unlock_irqrestore(&dev->lock, flags);
+       return ret;
+}
+
 static void gadget_ep_complete(struct usb_ep *ep, struct usb_request *req)
 {
        struct raw_ep *r_ep = (struct raw_ep *)ep->driver_data;
@@ -1128,6 +1240,21 @@ static long raw_ioctl(struct file *fd, unsigned int cmd, unsigned long value)
        case USB_RAW_IOCTL_EPS_INFO:
                ret = raw_ioctl_eps_info(dev, value);
                break;
+       case USB_RAW_IOCTL_EP0_STALL:
+               ret = raw_ioctl_ep0_stall(dev, value);
+               break;
+       case USB_RAW_IOCTL_EP_SET_HALT:
+               ret = raw_ioctl_ep_set_clear_halt_wedge(
+                                       dev, value, true, true);
+               break;
+       case USB_RAW_IOCTL_EP_CLEAR_HALT:
+               ret = raw_ioctl_ep_set_clear_halt_wedge(
+                                       dev, value, false, true);
+               break;
+       case USB_RAW_IOCTL_EP_SET_WEDGE:
+               ret = raw_ioctl_ep_set_clear_halt_wedge(
+                                       dev, value, true, false);
+               break;
        default:
                ret = -EINVAL;
        }

diff --git a/include/uapi/linux/usb/raw_gadget.h b/include/uapi/linux/usb/raw_gadget.h
index c89f6341229c2ddc8034df78f28b6f79713f01cf..0be685272eb180074999aaf13bfdebd302903765 100644 (file)
--- a/include/uapi/linux/usb/raw_gadget.h
+++ b/include/uapi/linux/usb/raw_gadget.h
@@ -231,4 +231,19 @@ struct usb_raw_eps_info {
  */
 #define USB_RAW_IOCTL_EPS_INFO         _IOR('U', 11, struct usb_raw_eps_info)
 
+/*
+ * Stalls a pending control request on endpoint 0.
+ * Returns 0 on success or negative error code on failure.
+ */
+#define USB_RAW_IOCTL_EP0_STALL                _IO('U', 12)
+
+/*
+ * Sets or clears halt or wedge status of the endpoint.
+ * Accepts endpoint handle as an argument.
+ * Returns 0 on success or negative error code on failure.
+ */
+#define USB_RAW_IOCTL_EP_SET_HALT      _IOW('U', 13, __u32)
+#define USB_RAW_IOCTL_EP_CLEAR_HALT    _IOW('U', 14, __u32)
+#define USB_RAW_IOCTL_EP_SET_WEDGE     _IOW('U', 15, __u32)
+
 #endif /* _UAPI__LINUX_USB_RAW_GADGET_H */