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 (laurent.pinchart@ideasonboard.com)
   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 /* ------------------------------------------------------------------------
  75  * Structures
  76  */
  77 struct uvc_request {
  78         struct usb_request *req;
  79         u8 *req_buffer;
  80         struct uvc_video *video;
  81         struct sg_table sgt;
  82         u8 header[UVCG_REQUEST_HEADER_LEN];
  83         struct uvc_buffer *last_buf;
  84         struct list_head list;
  85 };
  86
  87 struct uvc_video {
  88         struct uvc_device *uvc;
  89         struct usb_ep *ep;
  90
  91         struct work_struct pump;
  92         struct workqueue_struct *async_wq;
  93
  94         /* Frame parameters */
  95         u8 bpp;
  96         u32 fcc;
  97         unsigned int width;
  98         unsigned int height;
  99         unsigned int imagesize;
 100         struct mutex mutex;     /* protects frame parameters */
 101
 102         unsigned int uvc_num_requests;
 103
 104         /* Requests */
 105         bool is_enabled; /* tracks whether video stream is enabled */
 106         unsigned int req_size;
 107         struct list_head ureqs; /* all uvc_requests allocated by uvc_video */
 108
 109         /* USB requests that the video pump thread can encode into */
 110         struct list_head req_free;
 111
 112         /*
 113          * USB requests video pump thread has already encoded into. These are
 114          * ready to be queued to the endpoint.
 115          */
 116         struct list_head req_ready;
 117         spinlock_t req_lock;
 118
 119         unsigned int req_int_count;
 120
 121         void (*encode) (struct usb_request *req, struct uvc_video *video,
 122                         struct uvc_buffer *buf);
 123
 124         /* Context data used by the completion handler */
 125         __u32 payload_size;
 126         __u32 max_payload_size;
 127
 128         struct uvc_video_queue queue;
 129         unsigned int fid;
 130 };
 131
 132 enum uvc_state {
 133         UVC_STATE_DISCONNECTED,
 134         UVC_STATE_CONNECTED,
 135         UVC_STATE_STREAMING,
 136 };
 137
 138 struct uvc_device {
 139         struct video_device vdev;
 140         struct v4l2_device v4l2_dev;
 141         enum uvc_state state;
 142         struct usb_function func;
 143         struct uvc_video video;
 144         bool func_connected;
 145         wait_queue_head_t func_connected_queue;
 146
 147         struct uvcg_streaming_header *header;
 148
 149         /* Descriptors */
 150         struct {
 151                 const struct uvc_descriptor_header * const *fs_control;
 152                 const struct uvc_descriptor_header * const *ss_control;
 153                 const struct uvc_descriptor_header * const *fs_streaming;
 154                 const struct uvc_descriptor_header * const *hs_streaming;
 155                 const struct uvc_descriptor_header * const *ss_streaming;
 156                 struct list_head *extension_units;
 157         } desc;
 158
 159         unsigned int control_intf;
 160         struct usb_ep *interrupt_ep;
 161         struct usb_request *control_req;
 162         void *control_buf;
 163         bool enable_interrupt_ep;
 164
 165         unsigned int streaming_intf;
 166
 167         /* Events */
 168         unsigned int event_length;
 169         unsigned int event_setup_out : 1;
 170 };
 171
 172 static inline struct uvc_device *to_uvc(struct usb_function *f)
 173 {
 174         return container_of(f, struct uvc_device, func);
 175 }
 176
 177 struct uvc_file_handle {
 178         struct v4l2_fh vfh;
 179         struct uvc_video *device;
 180         bool is_uvc_app_handle;
 181 };
 182
 183 #define to_uvc_file_handle(handle) \
 184         container_of(handle, struct uvc_file_handle, vfh)
 185
 186 /* ------------------------------------------------------------------------
 187  * Functions
 188  */
 189
 190 extern void uvc_function_setup_continue(struct uvc_device *uvc, int disable_ep);
 191 extern void uvc_function_connect(struct uvc_device *uvc);
 192 extern void uvc_function_disconnect(struct uvc_device *uvc);
 193
 194 #endif /* _UVC_GADGET_H_ */