drivers/usb/gadget/function/uvc.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  *      uvc_gadget.h  --  USB Video Class Gadget driver
   4  *
   5  *      Copyright (C) 2009-2010
   6  *          Laurent Pinchart ([email protected])
   7  */
   8
   9 #ifndef _UVC_GADGET_H_
  10 #define _UVC_GADGET_H_
  11
  12 #include <linux/list.h>
  13 #include <linux/mutex.h>
  14 #include <linux/spinlock.h>
  15 #include <linux/usb/composite.h>
  16 #include <linux/videodev2.h>
  17 #include <linux/wait.h>
  18
  19 #include <media/v4l2-device.h>
  20 #include <media/v4l2-dev.h>
  21 #include <media/v4l2-fh.h>
  22
  23 #include "uvc_queue.h"
  24
  25 struct usb_ep;
  26 struct usb_request;
  27 struct uvc_descriptor_header;
  28 struct uvc_device;
  29
  30 /* ------------------------------------------------------------------------
  31  * Debugging, printing and logging
  32  */
  33
  34 #define UVC_TRACE_PROBE                         (1 << 0)
  35 #define UVC_TRACE_DESCR                         (1 << 1)
  36 #define UVC_TRACE_CONTROL                       (1 << 2)
  37 #define UVC_TRACE_FORMAT                        (1 << 3)
  38 #define UVC_TRACE_CAPTURE                       (1 << 4)
  39 #define UVC_TRACE_CALLS                         (1 << 5)
  40 #define UVC_TRACE_IOCTL                         (1 << 6)
  41 #define UVC_TRACE_FRAME                         (1 << 7)
  42 #define UVC_TRACE_SUSPEND                       (1 << 8)
  43 #define UVC_TRACE_STATUS                        (1 << 9)
  44
  45 #define UVC_WARN_MINMAX                         0
  46 #define UVC_WARN_PROBE_DEF                      1
  47
  48 extern unsigned int uvc_gadget_trace_param;
  49
  50 #define uvc_trace(flag, msg...) \
  51         do { \
  52                 if (uvc_gadget_trace_param & flag) \
  53                         printk(KERN_DEBUG "uvcvideo: " msg); \
  54         } while (0)
  55
  56 #define uvcg_dbg(f, fmt, args...) \
  57         dev_dbg(&(f)->config->cdev->gadget->dev, "%s: " fmt, (f)->name, ##args)
  58 #define uvcg_info(f, fmt, args...) \
  59         dev_info(&(f)->config->cdev->gadget->dev, "%s: " fmt, (f)->name, ##args)
  60 #define uvcg_warn(f, fmt, args...) \
  61         dev_warn(&(f)->config->cdev->gadget->dev, "%s: " fmt, (f)->name, ##args)
  62 #define uvcg_err(f, fmt, args...) \
  63         dev_err(&(f)->config->cdev->gadget->dev, "%s: " fmt, (f)->name, ##args)
  64
  65 /* ------------------------------------------------------------------------
  66  * Driver specific constants
  67  */
  68
  69 #define UVC_MAX_REQUEST_SIZE                    64
  70 #define UVC_MAX_EVENTS                          4
  71
  72 #define UVCG_REQUEST_HEADER_LEN                 12
  73
  74 #define UVCG_REQ_MAX_INT_COUNT                  16
  75 #define UVCG_REQ_MAX_ZERO_COUNT                 (2 * UVCG_REQ_MAX_INT_COUNT)
  76
  77 #define UVCG_STREAMING_MIN_BUFFERS              2
  78
  79 /* ------------------------------------------------------------------------
  80  * Structures
  81  */
  82 struct uvc_request {
  83         struct usb_request *req;
  84         u8 *req_buffer;
  85         struct uvc_video *video;
  86         struct sg_table sgt;
  87         u8 header[UVCG_REQUEST_HEADER_LEN];
  88         struct uvc_buffer *last_buf;
  89         struct list_head list;
  90 };
  91
  92 struct uvc_video {
  93         struct uvc_device *uvc;
  94         struct usb_ep *ep;
  95
  96         struct work_struct pump;
  97         struct workqueue_struct *async_wq;
  98
  99         struct kthread_worker   *kworker;
 100         struct kthread_work     hw_submit;
 101
 102         atomic_t queued;
 103
 104         /* Frame parameters */
 105         u8 bpp;
 106         u32 fcc;
 107         unsigned int width;
 108         unsigned int height;
 109         unsigned int imagesize;
 110         unsigned int interval;
 111         struct mutex mutex;     /* protects frame parameters */
 112
 113         unsigned int uvc_num_requests;
 114
 115         unsigned int reqs_per_frame;
 116
 117         /* Requests */
 118         bool is_enabled; /* tracks whether video stream is enabled */
 119         unsigned int req_size;
 120         struct list_head ureqs; /* all uvc_requests allocated by uvc_video */
 121
 122         /* USB requests that the video pump thread can encode into */
 123         struct list_head req_free;
 124
 125         /*
 126          * USB requests video pump thread has already encoded into. These are
 127          * ready to be queued to the endpoint.
 128          */
 129         struct list_head req_ready;
 130         spinlock_t req_lock;
 131
 132         unsigned int req_int_count;
 133
 134         void (*encode) (struct usb_request *req, struct uvc_video *video,
 135                         struct uvc_buffer *buf);
 136
 137         /* Context data used by the completion handler */
 138         __u32 payload_size;
 139         __u32 max_payload_size;
 140
 141         struct uvc_video_queue queue;
 142         unsigned int fid;
 143 };
 144
 145 enum uvc_state {
 146         UVC_STATE_DISCONNECTED,
 147         UVC_STATE_CONNECTED,
 148         UVC_STATE_STREAMING,
 149 };
 150
 151 struct uvc_device {
 152         struct video_device vdev;
 153         struct v4l2_device v4l2_dev;
 154         enum uvc_state state;
 155         struct usb_function func;
 156         struct uvc_video video;
 157         bool func_connected;
 158         wait_queue_head_t func_connected_queue;
 159
 160         struct uvcg_streaming_header *header;
 161
 162         /* Descriptors */
 163         struct {
 164                 const struct uvc_descriptor_header * const *fs_control;
 165                 const struct uvc_descriptor_header * const *ss_control;
 166                 const struct uvc_descriptor_header * const *fs_streaming;
 167                 const struct uvc_descriptor_header * const *hs_streaming;
 168                 const struct uvc_descriptor_header * const *ss_streaming;
 169                 struct list_head *extension_units;
 170         } desc;
 171
 172         unsigned int control_intf;
 173         struct usb_ep *interrupt_ep;
 174         struct usb_request *control_req;
 175         void *control_buf;
 176         bool enable_interrupt_ep;
 177
 178         unsigned int streaming_intf;
 179
 180         /* Events */
 181         unsigned int event_length;
 182         unsigned int event_setup_out : 1;
 183 };
 184
 185 static inline struct uvc_device *to_uvc(struct usb_function *f)
 186 {
 187         return container_of(f, struct uvc_device, func);
 188 }
 189
 190 struct uvc_file_handle {
 191         struct v4l2_fh vfh;
 192         struct uvc_video *device;
 193         bool is_uvc_app_handle;
 194 };
 195
 196 #define to_uvc_file_handle(handle) \
 197         container_of(handle, struct uvc_file_handle, vfh)
 198
 199 /* ------------------------------------------------------------------------
 200  * Functions
 201  */
 202
 203 extern void uvc_function_setup_continue(struct uvc_device *uvc, int disable_ep);
 204 extern void uvc_function_connect(struct uvc_device *uvc);
 205 extern void uvc_function_disconnect(struct uvc_device *uvc);
 206
 207 #endif /* _UVC_GADGET_H_ */