drivers/media/usb/s2255/s2255drv.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  s2255drv.c - a driver for the Sensoray 2255 USB video capture device
   4  *
   5  *   Copyright (C) 2007-2014 by Sensoray Company Inc.
   6  *                              Dean Anderson
   7  *
   8  * Some video buffer code based on vivi driver:
   9  *
  10  * Sensoray 2255 device supports 4 simultaneous channels.
  11  * The channels are not "crossbar" inputs, they are physically
  12  * attached to separate video decoders.
  13  *
  14  * Because of USB2.0 bandwidth limitations. There is only a
  15  * certain amount of data which may be transferred at one time.
  16  *
  17  * Example maximum bandwidth utilization:
  18  *
  19  * -full size, color mode YUYV or YUV422P: 2 channels at once
  20  * -full or half size Grey scale: all 4 channels at once
  21  * -half size, color mode YUYV or YUV422P: all 4 channels at once
  22  * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
  23  *  at once.
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/firmware.h>
  28 #include <linux/kernel.h>
  29 #include <linux/mutex.h>
  30 #include <linux/slab.h>
  31 #include <linux/videodev2.h>
  32 #include <linux/mm.h>
  33 #include <linux/vmalloc.h>
  34 #include <linux/usb.h>
  35 #include <media/videobuf2-v4l2.h>
  36 #include <media/videobuf2-vmalloc.h>
  37 #include <media/v4l2-common.h>
  38 #include <media/v4l2-device.h>
  39 #include <media/v4l2-ioctl.h>
  40 #include <media/v4l2-ctrls.h>
  41 #include <media/v4l2-event.h>
  42
  43 #define S2255_VERSION           "1.25.1"
  44 #define FIRMWARE_FILE_NAME "f2255usb.bin"
  45
  46 /* default JPEG quality */
  47 #define S2255_DEF_JPEG_QUAL     50
  48 /* vendor request in */
  49 #define S2255_VR_IN             0
  50 /* vendor request out */
  51 #define S2255_VR_OUT            1
  52 /* firmware query */
  53 #define S2255_VR_FW             0x30
  54 /* USB endpoint number for configuring the device */
  55 #define S2255_CONFIG_EP         2
  56 /* maximum time for DSP to start responding after last FW word loaded(ms) */
  57 #define S2255_DSP_BOOTTIME      800
  58 /* maximum time to wait for firmware to load (ms) */
  59 #define S2255_LOAD_TIMEOUT      (5000 + S2255_DSP_BOOTTIME)
  60 #define S2255_MIN_BUFS          2
  61 #define S2255_SETMODE_TIMEOUT   500
  62 #define S2255_VIDSTATUS_TIMEOUT 350
  63 #define S2255_MARKER_FRAME      cpu_to_le32(0x2255DA4AL)
  64 #define S2255_MARKER_RESPONSE   cpu_to_le32(0x2255ACACL)
  65 #define S2255_RESPONSE_SETMODE  cpu_to_le32(0x01)
  66 #define S2255_RESPONSE_FW       cpu_to_le32(0x10)
  67 #define S2255_RESPONSE_STATUS   cpu_to_le32(0x20)
  68 #define S2255_USB_XFER_SIZE     (16 * 1024)
  69 #define MAX_CHANNELS            4
  70 #define SYS_FRAMES              4
  71 /* maximum size is PAL full size plus room for the marker header(s) */
  72 #define SYS_FRAMES_MAXSIZE      (720*288*2*2 + 4096)
  73 #define DEF_USB_BLOCK           S2255_USB_XFER_SIZE
  74 #define LINE_SZ_4CIFS_NTSC      640
  75 #define LINE_SZ_2CIFS_NTSC      640
  76 #define LINE_SZ_1CIFS_NTSC      320
  77 #define LINE_SZ_4CIFS_PAL       704
  78 #define LINE_SZ_2CIFS_PAL       704
  79 #define LINE_SZ_1CIFS_PAL       352
  80 #define NUM_LINES_4CIFS_NTSC    240
  81 #define NUM_LINES_2CIFS_NTSC    240
  82 #define NUM_LINES_1CIFS_NTSC    240
  83 #define NUM_LINES_4CIFS_PAL     288
  84 #define NUM_LINES_2CIFS_PAL     288
  85 #define NUM_LINES_1CIFS_PAL     288
  86 #define LINE_SZ_DEF             640
  87 #define NUM_LINES_DEF           240
  88
  89
  90 /* predefined settings */
  91 #define FORMAT_NTSC     1
  92 #define FORMAT_PAL      2
  93
  94 #define SCALE_4CIFS     1       /* 640x480(NTSC) or 704x576(PAL) */
  95 #define SCALE_2CIFS     2       /* 640x240(NTSC) or 704x288(PAL) */
  96 #define SCALE_1CIFS     3       /* 320x240(NTSC) or 352x288(PAL) */
  97 /* SCALE_4CIFSI is the 2 fields interpolated into one */
  98 #define SCALE_4CIFSI    4       /* 640x480(NTSC) or 704x576(PAL) high quality */
  99
 100 #define COLOR_YUVPL     1       /* YUV planar */
 101 #define COLOR_YUVPK     2       /* YUV packed */
 102 #define COLOR_Y8        4       /* monochrome */
 103 #define COLOR_JPG       5       /* JPEG */
 104
 105 #define MASK_COLOR       0x000000ff
 106 #define MASK_JPG_QUALITY 0x0000ff00
 107 #define MASK_INPUT_TYPE  0x000f0000
 108 /* frame decimation. */
 109 #define FDEC_1          1       /* capture every frame. default */
 110 #define FDEC_2          2       /* capture every 2nd frame */
 111 #define FDEC_3          3       /* capture every 3rd frame */
 112 #define FDEC_5          5       /* capture every 5th frame */
 113
 114 /*-------------------------------------------------------
 115  * Default mode parameters.
 116  *-------------------------------------------------------*/
 117 #define DEF_SCALE       SCALE_4CIFS
 118 #define DEF_COLOR       COLOR_YUVPL
 119 #define DEF_FDEC        FDEC_1
 120 #define DEF_BRIGHT      0
 121 #define DEF_CONTRAST    0x5c
 122 #define DEF_SATURATION  0x80
 123 #define DEF_HUE         0
 124
 125 /* usb config commands */
 126 #define IN_DATA_TOKEN   cpu_to_le32(0x2255c0de)
 127 #define CMD_2255        0xc2255000
 128 #define CMD_SET_MODE    cpu_to_le32((CMD_2255 | 0x10))
 129 #define CMD_START       cpu_to_le32((CMD_2255 | 0x20))
 130 #define CMD_STOP        cpu_to_le32((CMD_2255 | 0x30))
 131 #define CMD_STATUS      cpu_to_le32((CMD_2255 | 0x40))
 132
 133 struct s2255_mode {
 134         u32 format;     /* input video format (NTSC, PAL) */
 135         u32 scale;      /* output video scale */
 136         u32 color;      /* output video color format */
 137         u32 fdec;       /* frame decimation */
 138         u32 bright;     /* brightness */
 139         u32 contrast;   /* contrast */
 140         u32 saturation; /* saturation */
 141         u32 hue;        /* hue (NTSC only)*/
 142         u32 single;     /* capture 1 frame at a time (!=0), continuously (==0)*/
 143         u32 usb_block;  /* block size. should be 4096 of DEF_USB_BLOCK */
 144         u32 restart;    /* if DSP requires restart */
 145 };
 146
 147
 148 #define S2255_READ_IDLE         0
 149 #define S2255_READ_FRAME        1
 150
 151 /* frame structure */
 152 struct s2255_framei {
 153         unsigned long size;
 154         unsigned long ulState;  /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
 155         void *lpvbits;          /* image data */
 156         unsigned long cur_size; /* current data copied to it */
 157 };
 158
 159 /* image buffer structure */
 160 struct s2255_bufferi {
 161         unsigned long dwFrames;                 /* number of frames in buffer */
 162         struct s2255_framei frame[SYS_FRAMES];  /* array of FRAME structures */
 163 };
 164
 165 #define DEF_MODEI_NTSC_CONT     {FORMAT_NTSC, DEF_SCALE, DEF_COLOR,     \
 166                         DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
 167                         DEF_HUE, 0, DEF_USB_BLOCK, 0}
 168
 169 /* for firmware loading, fw_state */
 170 #define S2255_FW_NOTLOADED      0
 171 #define S2255_FW_LOADED_DSPWAIT 1
 172 #define S2255_FW_SUCCESS        2
 173 #define S2255_FW_FAILED         3
 174 #define S2255_FW_DISCONNECTING  4
 175 #define S2255_FW_MARKER         cpu_to_le32(0x22552f2f)
 176 /* 2255 read states */
 177 #define S2255_READ_IDLE         0
 178 #define S2255_READ_FRAME        1
 179 struct s2255_fw {
 180         int                   fw_loaded;
 181         int                   fw_size;
 182         struct urb            *fw_urb;
 183         atomic_t              fw_state;
 184         void                  *pfw_data;
 185         wait_queue_head_t     wait_fw;
 186         const struct firmware *fw;
 187 };
 188
 189 struct s2255_pipeinfo {
 190         u32 max_transfer_size;
 191         u32 cur_transfer_size;
 192         u8 *transfer_buffer;
 193         u32 state;
 194         void *stream_urb;
 195         void *dev;      /* back pointer to s2255_dev struct*/
 196         u32 err_count;
 197         u32 idx;
 198 };
 199
 200 struct s2255_fmt; /*forward declaration */
 201 struct s2255_dev;
 202
 203 /* 2255 video channel */
 204 struct s2255_vc {
 205         struct s2255_dev        *dev;
 206         struct video_device     vdev;
 207         struct v4l2_ctrl_handler hdl;
 208         struct v4l2_ctrl        *jpegqual_ctrl;
 209         int                     resources;
 210         struct list_head        buf_list;
 211         struct s2255_bufferi    buffer;
 212         struct s2255_mode       mode;
 213         v4l2_std_id             std;
 214         /* jpeg compression */
 215         unsigned                jpegqual;
 216         /* capture parameters (for high quality mode full size) */
 217         struct v4l2_captureparm cap_parm;
 218         int                     cur_frame;
 219         int                     last_frame;
 220         /* allocated image size */
 221         unsigned long           req_image_size;
 222         /* received packet size */
 223         unsigned long           pkt_size;
 224         int                     bad_payload;
 225         unsigned long           frame_count;
 226         /* if JPEG image */
 227         int                     jpg_size;
 228         /* if channel configured to default state */
 229         int                     configured;
 230         wait_queue_head_t       wait_setmode;
 231         int                     setmode_ready;
 232         /* video status items */
 233         int                     vidstatus;
 234         wait_queue_head_t       wait_vidstatus;
 235         int                     vidstatus_ready;
 236         unsigned int            width;
 237         unsigned int            height;
 238         enum v4l2_field         field;
 239         const struct s2255_fmt  *fmt;
 240         int idx; /* channel number on device, 0-3 */
 241         struct vb2_queue vb_vidq;
 242         struct mutex vb_lock; /* streaming lock */
 243         spinlock_t qlock;
 244 };
 245
 246
 247 struct s2255_dev {
 248         struct s2255_vc         vc[MAX_CHANNELS];
 249         struct v4l2_device      v4l2_dev;
 250         atomic_t                num_channels;
 251         int                     frames;
 252         struct mutex            lock;   /* channels[].vdev.lock */
 253         struct mutex            cmdlock; /* protects cmdbuf */
 254         struct usb_device       *udev;
 255         struct usb_interface    *interface;
 256         u8                      read_endpoint;
 257         struct timer_list       timer;
 258         struct s2255_fw *fw_data;
 259         struct s2255_pipeinfo   pipe;
 260         u32                     cc;     /* current channel */
 261         int                     frame_ready;
 262         int                     chn_ready;
 263         /* dsp firmware version (f2255usb.bin) */
 264         int                     dsp_fw_ver;
 265         u16                     pid; /* product id */
 266 #define S2255_CMDBUF_SIZE 512
 267         __le32                  *cmdbuf;
 268 };
 269
 270 static inline struct s2255_dev *to_s2255_dev(struct v4l2_device *v4l2_dev)
 271 {
 272         return container_of(v4l2_dev, struct s2255_dev, v4l2_dev);
 273 }
 274
 275 struct s2255_fmt {
 276         u32 fourcc;
 277         int depth;
 278 };
 279
 280 /* buffer for one video frame */
 281 struct s2255_buffer {
 282         /* common v4l buffer stuff -- must be first */
 283         struct vb2_v4l2_buffer vb;
 284         struct list_head list;
 285 };
 286
 287
 288 /* current cypress EEPROM firmware version */
 289 #define S2255_CUR_USB_FWVER     ((3 << 8) | 12)
 290 /* current DSP FW version */
 291 #define S2255_CUR_DSP_FWVER     10104
 292 /* Need DSP version 5+ for video status feature */
 293 #define S2255_MIN_DSP_STATUS      5
 294 #define S2255_MIN_DSP_COLORFILTER 8
 295 #define S2255_NORMS             (V4L2_STD_ALL)
 296
 297 /* private V4L2 controls */
 298
 299 /*
 300  * The following chart displays how COLORFILTER should be set
 301  *  =========================================================
 302  *  =     fourcc              =     COLORFILTER             =
 303  *  =                         ===============================
 304  *  =                         =   0             =    1      =
 305  *  =========================================================
 306  *  =  V4L2_PIX_FMT_GREY(Y8)  = monochrome from = monochrome=
 307  *  =                         = s-video or      = composite =
 308  *  =                         = B/W camera      = input     =
 309  *  =========================================================
 310  *  =    other                = color, svideo   = color,    =
 311  *  =                         =                 = composite =
 312  *  =========================================================
 313  *
 314  * Notes:
 315  *   channels 0-3 on 2255 are composite
 316  *   channels 0-1 on 2257 are composite, 2-3 are s-video
 317  * If COLORFILTER is 0 with a composite color camera connected,
 318  * the output will appear monochrome but hatching
 319  * will occur.
 320  * COLORFILTER is different from "color killer" and "color effects"
 321  * for reasons above.
 322  */
 323 #define S2255_V4L2_YC_ON  1
 324 #define S2255_V4L2_YC_OFF 0
 325 #define V4L2_CID_S2255_COLORFILTER (V4L2_CID_USER_S2255_BASE + 0)
 326
 327 /* frame prefix size (sent once every frame) */
 328 #define PREFIX_SIZE             512
 329
 330 /* Channels on box are in reverse order */
 331 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
 332
 333 static int debug;
 334
 335 static int s2255_start_readpipe(struct s2255_dev *dev);
 336 static void s2255_stop_readpipe(struct s2255_dev *dev);
 337 static int s2255_start_acquire(struct s2255_vc *vc);
 338 static int s2255_stop_acquire(struct s2255_vc *vc);
 339 static void s2255_fillbuff(struct s2255_vc *vc, struct s2255_buffer *buf,
 340                            int jpgsize);
 341 static int s2255_set_mode(struct s2255_vc *vc, struct s2255_mode *mode);
 342 static int s2255_board_shutdown(struct s2255_dev *dev);
 343 static void s2255_fwload_start(struct s2255_dev *dev);
 344 static void s2255_destroy(struct s2255_dev *dev);
 345 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
 346                              u16 index, u16 value, void *buf,
 347                              s32 buf_len, int bOut);
 348
 349 /* dev_err macro with driver name */
 350 #define S2255_DRIVER_NAME "s2255"
 351 #define s2255_dev_err(dev, fmt, arg...)                                 \
 352                 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
 353
 354 #define dprintk(dev, level, fmt, arg...) \
 355         v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
 356
 357 static struct usb_driver s2255_driver;
 358
 359 /* start video number */
 360 static int video_nr = -1;       /* /dev/videoN, -1 for autodetect */
 361
 362 /* Enable jpeg capture. */
 363 static int jpeg_enable = 1;
 364
 365 module_param(debug, int, 0644);
 366 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
 367 module_param(video_nr, int, 0644);
 368 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
 369 module_param(jpeg_enable, int, 0644);
 370 MODULE_PARM_DESC(jpeg_enable, "Jpeg enable(1-on 0-off) default 1");
 371
 372 /* USB device table */
 373 #define USB_SENSORAY_VID        0x1943
 374 static const struct usb_device_id s2255_table[] = {
 375         {USB_DEVICE(USB_SENSORAY_VID, 0x2255)},
 376         {USB_DEVICE(USB_SENSORAY_VID, 0x2257)}, /*same family as 2255*/
 377         { }                     /* Terminating entry */
 378 };
 379 MODULE_DEVICE_TABLE(usb, s2255_table);
 380
 381 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
 382
 383 /* image formats.  */
 384 /* JPEG formats must be defined last to support jpeg_enable parameter */
 385 static const struct s2255_fmt formats[] = {
 386         {
 387                 .fourcc = V4L2_PIX_FMT_YUYV,
 388                 .depth = 16
 389
 390         }, {
 391                 .fourcc = V4L2_PIX_FMT_UYVY,
 392                 .depth = 16
 393         }, {
 394                 .fourcc = V4L2_PIX_FMT_YUV422P,
 395                 .depth = 16
 396
 397         }, {
 398                 .fourcc = V4L2_PIX_FMT_GREY,
 399                 .depth = 8
 400         }, {
 401                 .fourcc = V4L2_PIX_FMT_JPEG,
 402                 .depth = 24
 403         }, {
 404                 .fourcc = V4L2_PIX_FMT_MJPEG,
 405                 .depth = 24
 406         }
 407 };
 408
 409 static int norm_maxw(struct s2255_vc *vc)
 410 {
 411         return (vc->std & V4L2_STD_525_60) ?
 412             LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
 413 }
 414
 415 static int norm_maxh(struct s2255_vc *vc)
 416 {
 417         return (vc->std & V4L2_STD_525_60) ?
 418             (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
 419 }
 420
 421 static int norm_minw(struct s2255_vc *vc)
 422 {
 423         return (vc->std & V4L2_STD_525_60) ?
 424             LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
 425 }
 426
 427 static int norm_minh(struct s2255_vc *vc)
 428 {
 429         return (vc->std & V4L2_STD_525_60) ?
 430             (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
 431 }
 432
 433
 434 /*
 435  * TODO: fixme: move YUV reordering to hardware
 436  * converts 2255 planar format to yuyv or uyvy
 437  */
 438 static void planar422p_to_yuv_packed(const unsigned char *in,
 439                                      unsigned char *out,
 440                                      int width, int height,
 441                                      int fmt)
 442 {
 443         unsigned char *pY;
 444         unsigned char *pCb;
 445         unsigned char *pCr;
 446         unsigned long size = height * width;
 447         unsigned int i;
 448         pY = (unsigned char *)in;
 449         pCr = (unsigned char *)in + height * width;
 450         pCb = (unsigned char *)in + height * width + (height * width / 2);
 451         for (i = 0; i < size * 2; i += 4) {
 452                 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
 453                 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
 454                 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
 455                 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
 456         }
 457         return;
 458 }
 459
 460 static void s2255_reset_dsppower(struct s2255_dev *dev)
 461 {
 462         s2255_vendor_req(dev, 0x40, 0x0000, 0x0001, NULL, 0, 1);
 463         msleep(50);
 464         s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
 465         msleep(600);
 466         s2255_vendor_req(dev, 0x10, 0x0000, 0x0000, NULL, 0, 1);
 467         return;
 468 }
 469
 470 /* kickstarts the firmware loading. from probe
 471  */
 472 static void s2255_timer(struct timer_list *t)
 473 {
 474         struct s2255_dev *dev = from_timer(dev, t, timer);
 475         struct s2255_fw *data = dev->fw_data;
 476         if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
 477                 pr_err("s2255: can't submit urb\n");
 478                 atomic_set(&data->fw_state, S2255_FW_FAILED);
 479                 /* wake up anything waiting for the firmware */
 480                 wake_up(&data->wait_fw);
 481                 return;
 482         }
 483 }
 484
 485
 486 /* this loads the firmware asynchronously.
 487    Originally this was done synchronously in probe.
 488    But it is better to load it asynchronously here than block
 489    inside the probe function. Blocking inside probe affects boot time.
 490    FW loading is triggered by the timer in the probe function
 491 */
 492 static void s2255_fwchunk_complete(struct urb *urb)
 493 {
 494         struct s2255_fw *data = urb->context;
 495         struct usb_device *udev = urb->dev;
 496         int len;
 497         if (urb->status) {
 498                 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
 499                 atomic_set(&data->fw_state, S2255_FW_FAILED);
 500                 /* wake up anything waiting for the firmware */
 501                 wake_up(&data->wait_fw);
 502                 return;
 503         }
 504         if (data->fw_urb == NULL) {
 505                 s2255_dev_err(&udev->dev, "disconnected\n");
 506                 atomic_set(&data->fw_state, S2255_FW_FAILED);
 507                 /* wake up anything waiting for the firmware */
 508                 wake_up(&data->wait_fw);
 509                 return;
 510         }
 511 #define CHUNK_SIZE 512
 512         /* all USB transfers must be done with continuous kernel memory.
 513            can't allocate more than 128k in current linux kernel, so
 514            upload the firmware in chunks
 515          */
 516         if (data->fw_loaded < data->fw_size) {
 517                 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
 518                     data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
 519
 520                 if (len < CHUNK_SIZE)
 521                         memset(data->pfw_data, 0, CHUNK_SIZE);
 522
 523                 memcpy(data->pfw_data,
 524                        (char *) data->fw->data + data->fw_loaded, len);
 525
 526                 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
 527                                   data->pfw_data, CHUNK_SIZE,
 528                                   s2255_fwchunk_complete, data);
 529                 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
 530                         dev_err(&udev->dev, "failed submit URB\n");
 531                         atomic_set(&data->fw_state, S2255_FW_FAILED);
 532                         /* wake up anything waiting for the firmware */
 533                         wake_up(&data->wait_fw);
 534                         return;
 535                 }
 536                 data->fw_loaded += len;
 537         } else
 538                 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
 539         return;
 540
 541 }
 542
 543 static void s2255_got_frame(struct s2255_vc *vc, int jpgsize)
 544 {
 545         struct s2255_buffer *buf;
 546         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
 547         unsigned long flags = 0;
 548
 549         spin_lock_irqsave(&vc->qlock, flags);
 550         if (list_empty(&vc->buf_list)) {
 551                 dprintk(dev, 1, "No active queue to serve\n");
 552                 spin_unlock_irqrestore(&vc->qlock, flags);
 553                 return;
 554         }
 555         buf = list_entry(vc->buf_list.next,
 556                          struct s2255_buffer, list);
 557         list_del(&buf->list);
 558         buf->vb.vb2_buf.timestamp = ktime_get_ns();
 559         buf->vb.field = vc->field;
 560         buf->vb.sequence = vc->frame_count;
 561         spin_unlock_irqrestore(&vc->qlock, flags);
 562
 563         s2255_fillbuff(vc, buf, jpgsize);
 564         /* tell v4l buffer was filled */
 565         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 566         dprintk(dev, 2, "%s: [buf] [%p]\n", __func__, buf);
 567 }
 568
 569 static const struct s2255_fmt *format_by_fourcc(int fourcc)
 570 {
 571         unsigned int i;
 572         for (i = 0; i < ARRAY_SIZE(formats); i++) {
 573                 if (-1 == formats[i].fourcc)
 574                         continue;
 575                 if (!jpeg_enable && ((formats[i].fourcc == V4L2_PIX_FMT_JPEG) ||
 576                                      (formats[i].fourcc == V4L2_PIX_FMT_MJPEG)))
 577                         continue;
 578                 if (formats[i].fourcc == fourcc)
 579                         return formats + i;
 580         }
 581         return NULL;
 582 }
 583
 584 /* video buffer vmalloc implementation based partly on VIVI driver which is
 585  *          Copyright (c) 2006 by
 586  *                  Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
 587  *                  Ted Walther <ted--a.t--enumera.com>
 588  *                  John Sokol <sokol--a.t--videotechnology.com>
 589  *                  http://v4l.videotechnology.com/
 590  *
 591  */
 592 static void s2255_fillbuff(struct s2255_vc *vc,
 593                            struct s2255_buffer *buf, int jpgsize)
 594 {
 595         int pos = 0;
 596         const char *tmpbuf;
 597         char *vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
 598         unsigned long last_frame;
 599         struct s2255_dev *dev = vc->dev;
 600
 601         if (!vbuf)
 602                 return;
 603         last_frame = vc->last_frame;
 604         if (last_frame != -1) {
 605                 tmpbuf =
 606                     (const char *)vc->buffer.frame[last_frame].lpvbits;
 607                 switch (vc->fmt->fourcc) {
 608                 case V4L2_PIX_FMT_YUYV:
 609                 case V4L2_PIX_FMT_UYVY:
 610                         planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
 611                                                  vbuf, vc->width,
 612                                                  vc->height,
 613                                                  vc->fmt->fourcc);
 614                         break;
 615                 case V4L2_PIX_FMT_GREY:
 616                         memcpy(vbuf, tmpbuf, vc->width * vc->height);
 617                         break;
 618                 case V4L2_PIX_FMT_JPEG:
 619                 case V4L2_PIX_FMT_MJPEG:
 620                         vb2_set_plane_payload(&buf->vb.vb2_buf, 0, jpgsize);
 621                         memcpy(vbuf, tmpbuf, jpgsize);
 622                         break;
 623                 case V4L2_PIX_FMT_YUV422P:
 624                         memcpy(vbuf, tmpbuf,
 625                                vc->width * vc->height * 2);
 626                         break;
 627                 default:
 628                         pr_info("s2255: unknown format?\n");
 629                 }
 630                 vc->last_frame = -1;
 631         } else {
 632                 pr_err("s2255: =======no frame\n");
 633                 return;
 634         }
 635         dprintk(dev, 2, "s2255fill at : Buffer %p size= %d\n",
 636                 vbuf, pos);
 637 }
 638
 639
 640 /* ------------------------------------------------------------------
 641    Videobuf operations
 642    ------------------------------------------------------------------*/
 643
 644 static int queue_setup(struct vb2_queue *vq,
 645                        unsigned int *nbuffers, unsigned int *nplanes,
 646                        unsigned int sizes[], struct device *alloc_devs[])
 647 {
 648         struct s2255_vc *vc = vb2_get_drv_priv(vq);
 649         if (*nbuffers < S2255_MIN_BUFS)
 650                 *nbuffers = S2255_MIN_BUFS;
 651         *nplanes = 1;
 652         sizes[0] = vc->width * vc->height * (vc->fmt->depth >> 3);
 653         return 0;
 654 }
 655
 656 static int buffer_prepare(struct vb2_buffer *vb)
 657 {
 658         struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
 659         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 660         struct s2255_buffer *buf = container_of(vbuf, struct s2255_buffer, vb);
 661         int w = vc->width;
 662         int h = vc->height;
 663         unsigned long size;
 664
 665         dprintk(vc->dev, 4, "%s\n", __func__);
 666         if (vc->fmt == NULL)
 667                 return -EINVAL;
 668
 669         if ((w < norm_minw(vc)) ||
 670             (w > norm_maxw(vc)) ||
 671             (h < norm_minh(vc)) ||
 672             (h > norm_maxh(vc))) {
 673                 dprintk(vc->dev, 4, "invalid buffer prepare\n");
 674                 return -EINVAL;
 675         }
 676         size = w * h * (vc->fmt->depth >> 3);
 677         if (vb2_plane_size(vb, 0) < size) {
 678                 dprintk(vc->dev, 4, "invalid buffer prepare\n");
 679                 return -EINVAL;
 680         }
 681
 682         vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
 683         return 0;
 684 }
 685
 686 static void buffer_queue(struct vb2_buffer *vb)
 687 {
 688         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 689         struct s2255_buffer *buf = container_of(vbuf, struct s2255_buffer, vb);
 690         struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
 691         unsigned long flags = 0;
 692         dprintk(vc->dev, 1, "%s\n", __func__);
 693         spin_lock_irqsave(&vc->qlock, flags);
 694         list_add_tail(&buf->list, &vc->buf_list);
 695         spin_unlock_irqrestore(&vc->qlock, flags);
 696 }
 697
 698 static int start_streaming(struct vb2_queue *vq, unsigned int count);
 699 static void stop_streaming(struct vb2_queue *vq);
 700
 701 static const struct vb2_ops s2255_video_qops = {
 702         .queue_setup = queue_setup,
 703         .buf_prepare = buffer_prepare,
 704         .buf_queue = buffer_queue,
 705         .start_streaming = start_streaming,
 706         .stop_streaming = stop_streaming,
 707         .wait_prepare = vb2_ops_wait_prepare,
 708         .wait_finish = vb2_ops_wait_finish,
 709 };
 710
 711 static int vidioc_querycap(struct file *file, void *priv,
 712                            struct v4l2_capability *cap)
 713 {
 714         struct s2255_vc *vc = video_drvdata(file);
 715         struct s2255_dev *dev = vc->dev;
 716
 717         strscpy(cap->driver, "s2255", sizeof(cap->driver));
 718         strscpy(cap->card, "s2255", sizeof(cap->card));
 719         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 720         return 0;
 721 }
 722
 723 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
 724                                struct v4l2_fmtdesc *f)
 725 {
 726         int index = f->index;
 727
 728         if (index >= ARRAY_SIZE(formats))
 729                 return -EINVAL;
 730         if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
 731                         (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
 732                 return -EINVAL;
 733         f->pixelformat = formats[index].fourcc;
 734         return 0;
 735 }
 736
 737 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 738                             struct v4l2_format *f)
 739 {
 740         struct s2255_vc *vc = video_drvdata(file);
 741         int is_ntsc = vc->std & V4L2_STD_525_60;
 742
 743         f->fmt.pix.width = vc->width;
 744         f->fmt.pix.height = vc->height;
 745         if (f->fmt.pix.height >=
 746             (is_ntsc ? NUM_LINES_1CIFS_NTSC : NUM_LINES_1CIFS_PAL) * 2)
 747                 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
 748         else
 749                 f->fmt.pix.field = V4L2_FIELD_TOP;
 750         f->fmt.pix.pixelformat = vc->fmt->fourcc;
 751         f->fmt.pix.bytesperline = f->fmt.pix.width * (vc->fmt->depth >> 3);
 752         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 753         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 754         return 0;
 755 }
 756
 757 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 758                               struct v4l2_format *f)
 759 {
 760         const struct s2255_fmt *fmt;
 761         enum v4l2_field field;
 762         struct s2255_vc *vc = video_drvdata(file);
 763         int is_ntsc = vc->std & V4L2_STD_525_60;
 764
 765         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 766
 767         if (fmt == NULL)
 768                 return -EINVAL;
 769
 770         field = f->fmt.pix.field;
 771
 772         dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
 773                 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
 774         if (is_ntsc) {
 775                 /* NTSC */
 776                 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
 777                         f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
 778                         field = V4L2_FIELD_INTERLACED;
 779                 } else {
 780                         f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
 781                         field = V4L2_FIELD_TOP;
 782                 }
 783                 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
 784                         f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
 785                 else
 786                         f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
 787         } else {
 788                 /* PAL */
 789                 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
 790                         f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
 791                         field = V4L2_FIELD_INTERLACED;
 792                 } else {
 793                         f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
 794                         field = V4L2_FIELD_TOP;
 795                 }
 796                 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL)
 797                         f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
 798                 else
 799                         f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
 800         }
 801         f->fmt.pix.field = field;
 802         f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
 803         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 804         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 805         dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__,
 806                 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
 807         return 0;
 808 }
 809
 810 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 811                             struct v4l2_format *f)
 812 {
 813         struct s2255_vc *vc = video_drvdata(file);
 814         const struct s2255_fmt *fmt;
 815         struct vb2_queue *q = &vc->vb_vidq;
 816         struct s2255_mode mode;
 817         int ret;
 818
 819         ret = vidioc_try_fmt_vid_cap(file, vc, f);
 820
 821         if (ret < 0)
 822                 return ret;
 823
 824         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 825
 826         if (fmt == NULL)
 827                 return -EINVAL;
 828
 829         if (vb2_is_busy(q)) {
 830                 dprintk(vc->dev, 1, "queue busy\n");
 831                 return -EBUSY;
 832         }
 833
 834         mode = vc->mode;
 835         vc->fmt = fmt;
 836         vc->width = f->fmt.pix.width;
 837         vc->height = f->fmt.pix.height;
 838         vc->field = f->fmt.pix.field;
 839         if (vc->width > norm_minw(vc)) {
 840                 if (vc->height > norm_minh(vc)) {
 841                         if (vc->cap_parm.capturemode &
 842                             V4L2_MODE_HIGHQUALITY)
 843                                 mode.scale = SCALE_4CIFSI;
 844                         else
 845                                 mode.scale = SCALE_4CIFS;
 846                 } else
 847                         mode.scale = SCALE_2CIFS;
 848
 849         } else {
 850                 mode.scale = SCALE_1CIFS;
 851         }
 852         /* color mode */
 853         switch (vc->fmt->fourcc) {
 854         case V4L2_PIX_FMT_GREY:
 855                 mode.color &= ~MASK_COLOR;
 856                 mode.color |= COLOR_Y8;
 857                 break;
 858         case V4L2_PIX_FMT_JPEG:
 859         case V4L2_PIX_FMT_MJPEG:
 860                 mode.color &= ~MASK_COLOR;
 861                 mode.color |= COLOR_JPG;
 862                 mode.color |= (vc->jpegqual << 8);
 863                 break;
 864         case V4L2_PIX_FMT_YUV422P:
 865                 mode.color &= ~MASK_COLOR;
 866                 mode.color |= COLOR_YUVPL;
 867                 break;
 868         case V4L2_PIX_FMT_YUYV:
 869         case V4L2_PIX_FMT_UYVY:
 870         default:
 871                 mode.color &= ~MASK_COLOR;
 872                 mode.color |= COLOR_YUVPK;
 873                 break;
 874         }
 875         if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR))
 876                 mode.restart = 1;
 877         else if (mode.scale != vc->mode.scale)
 878                 mode.restart = 1;
 879         else if (mode.format != vc->mode.format)
 880                 mode.restart = 1;
 881         vc->mode = mode;
 882         (void) s2255_set_mode(vc, &mode);
 883         return 0;
 884 }
 885
 886
 887 /* write to the configuration pipe, synchronously */
 888 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
 889                               int size)
 890 {
 891         int pipe;
 892         int done;
 893         long retval = -1;
 894         if (udev) {
 895                 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
 896                 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
 897         }
 898         return retval;
 899 }
 900
 901 static u32 get_transfer_size(struct s2255_mode *mode)
 902 {
 903         int linesPerFrame = LINE_SZ_DEF;
 904         int pixelsPerLine = NUM_LINES_DEF;
 905         u32 outImageSize;
 906         u32 usbInSize;
 907         unsigned int mask_mult;
 908
 909         if (mode == NULL)
 910                 return 0;
 911
 912         if (mode->format == FORMAT_NTSC) {
 913                 switch (mode->scale) {
 914                 case SCALE_4CIFS:
 915                 case SCALE_4CIFSI:
 916                         linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
 917                         pixelsPerLine = LINE_SZ_4CIFS_NTSC;
 918                         break;
 919                 case SCALE_2CIFS:
 920                         linesPerFrame = NUM_LINES_2CIFS_NTSC;
 921                         pixelsPerLine = LINE_SZ_2CIFS_NTSC;
 922                         break;
 923                 case SCALE_1CIFS:
 924                         linesPerFrame = NUM_LINES_1CIFS_NTSC;
 925                         pixelsPerLine = LINE_SZ_1CIFS_NTSC;
 926                         break;
 927                 default:
 928                         break;
 929                 }
 930         } else if (mode->format == FORMAT_PAL) {
 931                 switch (mode->scale) {
 932                 case SCALE_4CIFS:
 933                 case SCALE_4CIFSI:
 934                         linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
 935                         pixelsPerLine = LINE_SZ_4CIFS_PAL;
 936                         break;
 937                 case SCALE_2CIFS:
 938                         linesPerFrame = NUM_LINES_2CIFS_PAL;
 939                         pixelsPerLine = LINE_SZ_2CIFS_PAL;
 940                         break;
 941                 case SCALE_1CIFS:
 942                         linesPerFrame = NUM_LINES_1CIFS_PAL;
 943                         pixelsPerLine = LINE_SZ_1CIFS_PAL;
 944                         break;
 945                 default:
 946                         break;
 947                 }
 948         }
 949         outImageSize = linesPerFrame * pixelsPerLine;
 950         if ((mode->color & MASK_COLOR) != COLOR_Y8) {
 951                 /* 2 bytes/pixel if not monochrome */
 952                 outImageSize *= 2;
 953         }
 954
 955         /* total bytes to send including prefix and 4K padding;
 956            must be a multiple of USB_READ_SIZE */
 957         usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
 958         mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
 959         /* if size not a multiple of USB_READ_SIZE */
 960         if (usbInSize & ~mask_mult)
 961                 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
 962         return usbInSize;
 963 }
 964
 965 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
 966 {
 967         struct device *dev = &sdev->udev->dev;
 968         dev_info(dev, "------------------------------------------------\n");
 969         dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
 970         dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
 971         dev_info(dev, "bright: 0x%x\n", mode->bright);
 972         dev_info(dev, "------------------------------------------------\n");
 973 }
 974
 975 /*
 976  * set mode is the function which controls the DSP.
 977  * the restart parameter in struct s2255_mode should be set whenever
 978  * the image size could change via color format, video system or image
 979  * size.
 980  * When the restart parameter is set, we sleep for ONE frame to allow the
 981  * DSP time to get the new frame
 982  */
 983 static int s2255_set_mode(struct s2255_vc *vc,
 984                           struct s2255_mode *mode)
 985 {
 986         int res;
 987         unsigned long chn_rev;
 988         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
 989         int i;
 990         __le32 *buffer = dev->cmdbuf;
 991
 992         mutex_lock(&dev->cmdlock);
 993         chn_rev = G_chnmap[vc->idx];
 994         dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
 995         /* if JPEG, set the quality */
 996         if ((mode->color & MASK_COLOR) == COLOR_JPG) {
 997                 mode->color &= ~MASK_COLOR;
 998                 mode->color |= COLOR_JPG;
 999                 mode->color &= ~MASK_JPG_QUALITY;
1000                 mode->color |= (vc->jpegqual << 8);
1001         }
1002         /* save the mode */
1003         vc->mode = *mode;
1004         vc->req_image_size = get_transfer_size(mode);
1005         dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
1006         /* set the mode */
1007         buffer[0] = IN_DATA_TOKEN;
1008         buffer[1] = (__le32) cpu_to_le32(chn_rev);
1009         buffer[2] = CMD_SET_MODE;
1010         for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++)
1011                 buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]);
1012         vc->setmode_ready = 0;
1013         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1014         if (debug)
1015                 s2255_print_cfg(dev, mode);
1016         /* wait at least 3 frames before continuing */
1017         if (mode->restart) {
1018                 wait_event_timeout(vc->wait_setmode,
1019                                    (vc->setmode_ready != 0),
1020                                    msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1021                 if (vc->setmode_ready != 1) {
1022                         dprintk(dev, 0, "s2255: no set mode response\n");
1023                         res = -EFAULT;
1024                 }
1025         }
1026         /* clear the restart flag */
1027         vc->mode.restart = 0;
1028         dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
1029         mutex_unlock(&dev->cmdlock);
1030         return res;
1031 }
1032
1033 static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus)
1034 {
1035         int res;
1036         u32 chn_rev;
1037         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1038         __le32 *buffer = dev->cmdbuf;
1039
1040         mutex_lock(&dev->cmdlock);
1041         chn_rev = G_chnmap[vc->idx];
1042         dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
1043         /* form the get vid status command */
1044         buffer[0] = IN_DATA_TOKEN;
1045         buffer[1] = (__le32) cpu_to_le32(chn_rev);
1046         buffer[2] = CMD_STATUS;
1047         *pstatus = 0;
1048         vc->vidstatus_ready = 0;
1049         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1050         wait_event_timeout(vc->wait_vidstatus,
1051                            (vc->vidstatus_ready != 0),
1052                            msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1053         if (vc->vidstatus_ready != 1) {
1054                 dprintk(dev, 0, "s2255: no vidstatus response\n");
1055                 res = -EFAULT;
1056         }
1057         *pstatus = vc->vidstatus;
1058         dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
1059         mutex_unlock(&dev->cmdlock);
1060         return res;
1061 }
1062
1063 static int start_streaming(struct vb2_queue *vq, unsigned int count)
1064 {
1065         struct s2255_vc *vc = vb2_get_drv_priv(vq);
1066         int j;
1067
1068         vc->last_frame = -1;
1069         vc->bad_payload = 0;
1070         vc->cur_frame = 0;
1071         vc->frame_count = 0;
1072         for (j = 0; j < SYS_FRAMES; j++) {
1073                 vc->buffer.frame[j].ulState = S2255_READ_IDLE;
1074                 vc->buffer.frame[j].cur_size = 0;
1075         }
1076         return s2255_start_acquire(vc);
1077 }
1078
1079 /* abort streaming and wait for last buffer */
1080 static void stop_streaming(struct vb2_queue *vq)
1081 {
1082         struct s2255_vc *vc = vb2_get_drv_priv(vq);
1083         struct s2255_buffer *buf, *node;
1084         unsigned long flags;
1085         (void) s2255_stop_acquire(vc);
1086         spin_lock_irqsave(&vc->qlock, flags);
1087         list_for_each_entry_safe(buf, node, &vc->buf_list, list) {
1088                 list_del(&buf->list);
1089                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1090                 dprintk(vc->dev, 2, "[%p/%d] done\n",
1091                         buf, buf->vb.vb2_buf.index);
1092         }
1093         spin_unlock_irqrestore(&vc->qlock, flags);
1094 }
1095
1096 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id i)
1097 {
1098         struct s2255_vc *vc = video_drvdata(file);
1099         struct s2255_mode mode;
1100         struct vb2_queue *q = &vc->vb_vidq;
1101
1102         /*
1103          * Changing the standard implies a format change, which is not allowed
1104          * while buffers for use with streaming have already been allocated.
1105          */
1106         if (vb2_is_busy(q))
1107                 return -EBUSY;
1108
1109         mode = vc->mode;
1110         if (i & V4L2_STD_525_60) {
1111                 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
1112                 /* if changing format, reset frame decimation/intervals */
1113                 if (mode.format != FORMAT_NTSC) {
1114                         mode.restart = 1;
1115                         mode.format = FORMAT_NTSC;
1116                         mode.fdec = FDEC_1;
1117                         vc->width = LINE_SZ_4CIFS_NTSC;
1118                         vc->height = NUM_LINES_4CIFS_NTSC * 2;
1119                 }
1120         } else if (i & V4L2_STD_625_50) {
1121                 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
1122                 if (mode.format != FORMAT_PAL) {
1123                         mode.restart = 1;
1124                         mode.format = FORMAT_PAL;
1125                         mode.fdec = FDEC_1;
1126                         vc->width = LINE_SZ_4CIFS_PAL;
1127                         vc->height = NUM_LINES_4CIFS_PAL * 2;
1128                 }
1129         } else
1130                 return -EINVAL;
1131         vc->std = i;
1132         if (mode.restart)
1133                 s2255_set_mode(vc, &mode);
1134         return 0;
1135 }
1136
1137 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i)
1138 {
1139         struct s2255_vc *vc = video_drvdata(file);
1140
1141         *i = vc->std;
1142         return 0;
1143 }
1144
1145 /* Sensoray 2255 is a multiple channel capture device.
1146    It does not have a "crossbar" of inputs.
1147    We use one V4L device per channel. The user must
1148    be aware that certain combinations are not allowed.
1149    For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1150    at once in color(you can do full fps on 4 channels with greyscale.
1151 */
1152 static int vidioc_enum_input(struct file *file, void *priv,
1153                              struct v4l2_input *inp)
1154 {
1155         struct s2255_vc *vc = video_drvdata(file);
1156         struct s2255_dev *dev = vc->dev;
1157         u32 status = 0;
1158
1159         if (inp->index != 0)
1160                 return -EINVAL;
1161         inp->type = V4L2_INPUT_TYPE_CAMERA;
1162         inp->std = S2255_NORMS;
1163         inp->status = 0;
1164         if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1165                 int rc;
1166                 rc = s2255_cmd_status(vc, &status);
1167                 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
1168                         rc, status);
1169                 if (rc == 0)
1170                         inp->status =  (status & 0x01) ? 0
1171                                 : V4L2_IN_ST_NO_SIGNAL;
1172         }
1173         switch (dev->pid) {
1174         case 0x2255:
1175         default:
1176                 strscpy(inp->name, "Composite", sizeof(inp->name));
1177                 break;
1178         case 0x2257:
1179                 strscpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video",
1180                         sizeof(inp->name));
1181                 break;
1182         }
1183         return 0;
1184 }
1185
1186 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1187 {
1188         *i = 0;
1189         return 0;
1190 }
1191 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1192 {
1193         if (i > 0)
1194                 return -EINVAL;
1195         return 0;
1196 }
1197
1198 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
1199 {
1200         struct s2255_vc *vc =
1201                 container_of(ctrl->handler, struct s2255_vc, hdl);
1202         struct s2255_mode mode;
1203         mode = vc->mode;
1204         /* update the mode to the corresponding value */
1205         switch (ctrl->id) {
1206         case V4L2_CID_BRIGHTNESS:
1207                 mode.bright = ctrl->val;
1208                 break;
1209         case V4L2_CID_CONTRAST:
1210                 mode.contrast = ctrl->val;
1211                 break;
1212         case V4L2_CID_HUE:
1213                 mode.hue = ctrl->val;
1214                 break;
1215         case V4L2_CID_SATURATION:
1216                 mode.saturation = ctrl->val;
1217                 break;
1218         case V4L2_CID_S2255_COLORFILTER:
1219                 mode.color &= ~MASK_INPUT_TYPE;
1220                 mode.color |= !ctrl->val << 16;
1221                 break;
1222         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1223                 vc->jpegqual = ctrl->val;
1224                 return 0;
1225         default:
1226                 return -EINVAL;
1227         }
1228         mode.restart = 0;
1229         /* set mode here.  Note: stream does not need restarted.
1230            some V4L programs restart stream unnecessarily
1231            after a s_crtl.
1232         */
1233         s2255_set_mode(vc, &mode);
1234         return 0;
1235 }
1236
1237 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1238                          struct v4l2_jpegcompression *jc)
1239 {
1240         struct s2255_vc *vc = video_drvdata(file);
1241
1242         memset(jc, 0, sizeof(*jc));
1243         jc->quality = vc->jpegqual;
1244         dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1245         return 0;
1246 }
1247
1248 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1249                          const struct v4l2_jpegcompression *jc)
1250 {
1251         struct s2255_vc *vc = video_drvdata(file);
1252
1253         if (jc->quality < 0 || jc->quality > 100)
1254                 return -EINVAL;
1255         v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality);
1256         dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1257         return 0;
1258 }
1259
1260 static int vidioc_g_parm(struct file *file, void *priv,
1261                          struct v4l2_streamparm *sp)
1262 {
1263         __u32 def_num, def_dem;
1264         struct s2255_vc *vc = video_drvdata(file);
1265
1266         if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1267                 return -EINVAL;
1268         sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1269         sp->parm.capture.capturemode = vc->cap_parm.capturemode;
1270         sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1271         def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1272         def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1273         sp->parm.capture.timeperframe.denominator = def_dem;
1274         switch (vc->mode.fdec) {
1275         default:
1276         case FDEC_1:
1277                 sp->parm.capture.timeperframe.numerator = def_num;
1278                 break;
1279         case FDEC_2:
1280                 sp->parm.capture.timeperframe.numerator = def_num * 2;
1281                 break;
1282         case FDEC_3:
1283                 sp->parm.capture.timeperframe.numerator = def_num * 3;
1284                 break;
1285         case FDEC_5:
1286                 sp->parm.capture.timeperframe.numerator = def_num * 5;
1287                 break;
1288         }
1289         dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
1290                 __func__,
1291                 sp->parm.capture.capturemode,
1292                 sp->parm.capture.timeperframe.numerator,
1293                 sp->parm.capture.timeperframe.denominator);
1294         return 0;
1295 }
1296
1297 static int vidioc_s_parm(struct file *file, void *priv,
1298                          struct v4l2_streamparm *sp)
1299 {
1300         struct s2255_vc *vc = video_drvdata(file);
1301         struct s2255_mode mode;
1302         int fdec = FDEC_1;
1303         __u32 def_num, def_dem;
1304         if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1305                 return -EINVAL;
1306         mode = vc->mode;
1307         /* high quality capture mode requires a stream restart */
1308         if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode)
1309             && vb2_is_streaming(&vc->vb_vidq))
1310                 return -EBUSY;
1311         def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1312         def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1313         if (def_dem != sp->parm.capture.timeperframe.denominator)
1314                 sp->parm.capture.timeperframe.numerator = def_num;
1315         else if (sp->parm.capture.timeperframe.numerator <= def_num)
1316                 sp->parm.capture.timeperframe.numerator = def_num;
1317         else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1318                 sp->parm.capture.timeperframe.numerator = def_num * 2;
1319                 fdec = FDEC_2;
1320         } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1321                 sp->parm.capture.timeperframe.numerator = def_num * 3;
1322                 fdec = FDEC_3;
1323         } else {
1324                 sp->parm.capture.timeperframe.numerator = def_num * 5;
1325                 fdec = FDEC_5;
1326         }
1327         mode.fdec = fdec;
1328         sp->parm.capture.timeperframe.denominator = def_dem;
1329         sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1330         s2255_set_mode(vc, &mode);
1331         dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1332                 __func__,
1333                 sp->parm.capture.capturemode,
1334                 sp->parm.capture.timeperframe.numerator,
1335                 sp->parm.capture.timeperframe.denominator, fdec);
1336         return 0;
1337 }
1338
1339 #define NUM_SIZE_ENUMS 3
1340 static const struct v4l2_frmsize_discrete ntsc_sizes[] = {
1341         { 640, 480 },
1342         { 640, 240 },
1343         { 320, 240 },
1344 };
1345 static const struct v4l2_frmsize_discrete pal_sizes[] = {
1346         { 704, 576 },
1347         { 704, 288 },
1348         { 352, 288 },
1349 };
1350
1351 static int vidioc_enum_framesizes(struct file *file, void *priv,
1352                             struct v4l2_frmsizeenum *fe)
1353 {
1354         struct s2255_vc *vc = video_drvdata(file);
1355         int is_ntsc = vc->std & V4L2_STD_525_60;
1356         const struct s2255_fmt *fmt;
1357
1358         if (fe->index >= NUM_SIZE_ENUMS)
1359                 return -EINVAL;
1360
1361         fmt = format_by_fourcc(fe->pixel_format);
1362         if (fmt == NULL)
1363                 return -EINVAL;
1364         fe->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1365         fe->discrete = is_ntsc ?  ntsc_sizes[fe->index] : pal_sizes[fe->index];
1366         return 0;
1367 }
1368
1369 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1370                             struct v4l2_frmivalenum *fe)
1371 {
1372         struct s2255_vc *vc = video_drvdata(file);
1373         const struct s2255_fmt *fmt;
1374         const struct v4l2_frmsize_discrete *sizes;
1375         int is_ntsc = vc->std & V4L2_STD_525_60;
1376 #define NUM_FRAME_ENUMS 4
1377         int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1378         int i;
1379
1380         if (fe->index >= NUM_FRAME_ENUMS)
1381                 return -EINVAL;
1382
1383         fmt = format_by_fourcc(fe->pixel_format);
1384         if (fmt == NULL)
1385                 return -EINVAL;
1386
1387         sizes = is_ntsc ? ntsc_sizes : pal_sizes;
1388         for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++)
1389                 if (fe->width == sizes->width &&
1390                     fe->height == sizes->height)
1391                         break;
1392         if (i == NUM_SIZE_ENUMS)
1393                 return -EINVAL;
1394
1395         fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1396         fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1397         fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1398         dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
1399                 fe->discrete.numerator,
1400                 fe->discrete.denominator);
1401         return 0;
1402 }
1403
1404 static int s2255_open(struct file *file)
1405 {
1406         struct s2255_vc *vc = video_drvdata(file);
1407         struct s2255_dev *dev = vc->dev;
1408         int state;
1409         int rc = 0;
1410
1411         rc = v4l2_fh_open(file);
1412         if (rc != 0)
1413                 return rc;
1414
1415         dprintk(dev, 1, "s2255: %s\n", __func__);
1416         state = atomic_read(&dev->fw_data->fw_state);
1417         switch (state) {
1418         case S2255_FW_DISCONNECTING:
1419                 return -ENODEV;
1420         case S2255_FW_FAILED:
1421                 s2255_dev_err(&dev->udev->dev,
1422                         "firmware load failed. retrying.\n");
1423                 s2255_fwload_start(dev);
1424                 wait_event_timeout(dev->fw_data->wait_fw,
1425                                    ((atomic_read(&dev->fw_data->fw_state)
1426                                      == S2255_FW_SUCCESS) ||
1427                                     (atomic_read(&dev->fw_data->fw_state)
1428                                      == S2255_FW_DISCONNECTING)),
1429                                    msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1430                 /* state may have changed, re-read */
1431                 state = atomic_read(&dev->fw_data->fw_state);
1432                 break;
1433         case S2255_FW_NOTLOADED:
1434         case S2255_FW_LOADED_DSPWAIT:
1435                 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1436                    driver loaded and then device immediately opened */
1437                 pr_info("%s waiting for firmware load\n", __func__);
1438                 wait_event_timeout(dev->fw_data->wait_fw,
1439                                    ((atomic_read(&dev->fw_data->fw_state)
1440                                      == S2255_FW_SUCCESS) ||
1441                                     (atomic_read(&dev->fw_data->fw_state)
1442                                      == S2255_FW_DISCONNECTING)),
1443                                    msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1444                 /* state may have changed, re-read */
1445                 state = atomic_read(&dev->fw_data->fw_state);
1446                 break;
1447         case S2255_FW_SUCCESS:
1448         default:
1449                 break;
1450         }
1451         /* state may have changed in above switch statement */
1452         switch (state) {
1453         case S2255_FW_SUCCESS:
1454                 break;
1455         case S2255_FW_FAILED:
1456                 pr_info("2255 firmware load failed.\n");
1457                 return -ENODEV;
1458         case S2255_FW_DISCONNECTING:
1459                 pr_info("%s: disconnecting\n", __func__);
1460                 return -ENODEV;
1461         case S2255_FW_LOADED_DSPWAIT:
1462         case S2255_FW_NOTLOADED:
1463                 pr_info("%s: firmware not loaded, please retry\n",
1464                         __func__);
1465                 /*
1466                  * Timeout on firmware load means device unusable.
1467                  * Set firmware failure state.
1468                  * On next s2255_open the firmware will be reloaded.
1469                  */
1470                 atomic_set(&dev->fw_data->fw_state,
1471                            S2255_FW_FAILED);
1472                 return -EAGAIN;
1473         default:
1474                 pr_info("%s: unknown state\n", __func__);
1475                 return -EFAULT;
1476         }
1477         if (!vc->configured) {
1478                 /* configure channel to default state */
1479                 vc->fmt = &formats[0];
1480                 s2255_set_mode(vc, &vc->mode);
1481                 vc->configured = 1;
1482         }
1483         return 0;
1484 }
1485
1486 static void s2255_destroy(struct s2255_dev *dev)
1487 {
1488         dprintk(dev, 1, "%s", __func__);
1489         /* board shutdown stops the read pipe if it is running */
1490         s2255_board_shutdown(dev);
1491         /* make sure firmware still not trying to load */
1492         del_timer_sync(&dev->timer);  /* only started in .probe and .open */
1493         if (dev->fw_data->fw_urb) {
1494                 usb_kill_urb(dev->fw_data->fw_urb);
1495                 usb_free_urb(dev->fw_data->fw_urb);
1496                 dev->fw_data->fw_urb = NULL;
1497         }
1498         release_firmware(dev->fw_data->fw);
1499         kfree(dev->fw_data->pfw_data);
1500         kfree(dev->fw_data);
1501         /* reset the DSP so firmware can be reloaded next time */
1502         s2255_reset_dsppower(dev);
1503         mutex_destroy(&dev->lock);
1504         usb_put_dev(dev->udev);
1505         v4l2_device_unregister(&dev->v4l2_dev);
1506         kfree(dev->cmdbuf);
1507         kfree(dev);
1508 }
1509
1510 static const struct v4l2_file_operations s2255_fops_v4l = {
1511         .owner = THIS_MODULE,
1512         .open = s2255_open,
1513         .release = vb2_fop_release,
1514         .poll = vb2_fop_poll,
1515         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1516         .mmap = vb2_fop_mmap,
1517         .read = vb2_fop_read,
1518 };
1519
1520 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1521         .vidioc_querycap = vidioc_querycap,
1522         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1523         .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1524         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1525         .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1526         .vidioc_reqbufs = vb2_ioctl_reqbufs,
1527         .vidioc_querybuf = vb2_ioctl_querybuf,
1528         .vidioc_qbuf = vb2_ioctl_qbuf,
1529         .vidioc_dqbuf = vb2_ioctl_dqbuf,
1530         .vidioc_s_std = vidioc_s_std,
1531         .vidioc_g_std = vidioc_g_std,
1532         .vidioc_enum_input = vidioc_enum_input,
1533         .vidioc_g_input = vidioc_g_input,
1534         .vidioc_s_input = vidioc_s_input,
1535         .vidioc_streamon = vb2_ioctl_streamon,
1536         .vidioc_streamoff = vb2_ioctl_streamoff,
1537         .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1538         .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1539         .vidioc_s_parm = vidioc_s_parm,
1540         .vidioc_g_parm = vidioc_g_parm,
1541         .vidioc_enum_framesizes = vidioc_enum_framesizes,
1542         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1543         .vidioc_log_status  = v4l2_ctrl_log_status,
1544         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1545         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1546 };
1547
1548 static void s2255_video_device_release(struct video_device *vdev)
1549 {
1550         struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1551         struct s2255_vc *vc =
1552                 container_of(vdev, struct s2255_vc, vdev);
1553
1554         dprintk(dev, 4, "%s, chnls: %d\n", __func__,
1555                 atomic_read(&dev->num_channels));
1556
1557         v4l2_ctrl_handler_free(&vc->hdl);
1558
1559         if (atomic_dec_and_test(&dev->num_channels))
1560                 s2255_destroy(dev);
1561         return;
1562 }
1563
1564 static const struct video_device template = {
1565         .name = "s2255v",
1566         .fops = &s2255_fops_v4l,
1567         .ioctl_ops = &s2255_ioctl_ops,
1568         .release = s2255_video_device_release,
1569         .tvnorms = S2255_NORMS,
1570 };
1571
1572 static const struct v4l2_ctrl_ops s2255_ctrl_ops = {
1573         .s_ctrl = s2255_s_ctrl,
1574 };
1575
1576 static const struct v4l2_ctrl_config color_filter_ctrl = {
1577         .ops = &s2255_ctrl_ops,
1578         .name = "Color Filter",
1579         .id = V4L2_CID_S2255_COLORFILTER,
1580         .type = V4L2_CTRL_TYPE_BOOLEAN,
1581         .max = 1,
1582         .step = 1,
1583         .def = 1,
1584 };
1585
1586 static int s2255_probe_v4l(struct s2255_dev *dev)
1587 {
1588         int ret;
1589         int i;
1590         int cur_nr = video_nr;
1591         struct s2255_vc *vc;
1592         struct vb2_queue *q;
1593
1594         ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1595         if (ret)
1596                 return ret;
1597         /* initialize all video 4 linux */
1598         /* register 4 video devices */
1599         for (i = 0; i < MAX_CHANNELS; i++) {
1600                 vc = &dev->vc[i];
1601                 INIT_LIST_HEAD(&vc->buf_list);
1602
1603                 v4l2_ctrl_handler_init(&vc->hdl, 6);
1604                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1605                                 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
1606                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1607                                 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
1608                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1609                                 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
1610                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1611                                 V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
1612                 vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl,
1613                                 &s2255_ctrl_ops,
1614                                 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1615                                 0, 100, 1, S2255_DEF_JPEG_QUAL);
1616                 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1617                     (dev->pid != 0x2257 || vc->idx <= 1))
1618                         v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl,
1619                                              NULL);
1620                 if (vc->hdl.error) {
1621                         ret = vc->hdl.error;
1622                         v4l2_ctrl_handler_free(&vc->hdl);
1623                         dev_err(&dev->udev->dev, "couldn't register control\n");
1624                         break;
1625                 }
1626                 q = &vc->vb_vidq;
1627                 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1628                 q->io_modes = VB2_MMAP | VB2_READ | VB2_USERPTR;
1629                 q->drv_priv = vc;
1630                 q->lock = &vc->vb_lock;
1631                 q->buf_struct_size = sizeof(struct s2255_buffer);
1632                 q->mem_ops = &vb2_vmalloc_memops;
1633                 q->ops = &s2255_video_qops;
1634                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1635                 ret = vb2_queue_init(q);
1636                 if (ret != 0) {
1637                         dev_err(&dev->udev->dev,
1638                                 "%s vb2_queue_init 0x%x\n", __func__, ret);
1639                         break;
1640                 }
1641                 /* register video devices */
1642                 vc->vdev = template;
1643                 vc->vdev.queue = q;
1644                 vc->vdev.ctrl_handler = &vc->hdl;
1645                 vc->vdev.lock = &dev->lock;
1646                 vc->vdev.v4l2_dev = &dev->v4l2_dev;
1647                 vc->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
1648                                        V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1649                 video_set_drvdata(&vc->vdev, vc);
1650                 if (video_nr == -1)
1651                         ret = video_register_device(&vc->vdev,
1652                                                     VFL_TYPE_GRABBER,
1653                                                     video_nr);
1654                 else
1655                         ret = video_register_device(&vc->vdev,
1656                                                     VFL_TYPE_GRABBER,
1657                                                     cur_nr + i);
1658
1659                 if (ret) {
1660                         dev_err(&dev->udev->dev,
1661                                 "failed to register video device!\n");
1662                         break;
1663                 }
1664                 atomic_inc(&dev->num_channels);
1665                 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1666                           video_device_node_name(&vc->vdev));
1667
1668         }
1669         pr_info("Sensoray 2255 V4L driver Revision: %s\n",
1670                 S2255_VERSION);
1671         /* if no channels registered, return error and probe will fail*/
1672         if (atomic_read(&dev->num_channels) == 0) {
1673                 v4l2_device_unregister(&dev->v4l2_dev);
1674                 return ret;
1675         }
1676         if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1677                 pr_warn("s2255: Not all channels available.\n");
1678         return 0;
1679 }
1680
1681 /* this function moves the usb stream read pipe data
1682  * into the system buffers.
1683  * returns 0 on success, EAGAIN if more data to process( call this
1684  * function again).
1685  *
1686  * Received frame structure:
1687  * bytes 0-3:  marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1688  * bytes 4-7:  channel: 0-3
1689  * bytes 8-11: payload size:  size of the frame
1690  * bytes 12-payloadsize+12:  frame data
1691  */
1692 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1693 {
1694         char *pdest;
1695         u32 offset = 0;
1696         int bframe = 0;
1697         char *psrc;
1698         unsigned long copy_size;
1699         unsigned long size;
1700         s32 idx = -1;
1701         struct s2255_framei *frm;
1702         unsigned char *pdata;
1703         struct s2255_vc *vc;
1704         dprintk(dev, 100, "buffer to user\n");
1705         vc = &dev->vc[dev->cc];
1706         idx = vc->cur_frame;
1707         frm = &vc->buffer.frame[idx];
1708         if (frm->ulState == S2255_READ_IDLE) {
1709                 int jj;
1710                 unsigned int cc;
1711                 __le32 *pdword; /*data from dsp is little endian */
1712                 int payload;
1713                 /* search for marker codes */
1714                 pdata = (unsigned char *)pipe_info->transfer_buffer;
1715                 pdword = (__le32 *)pdata;
1716                 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1717                         switch (*pdword) {
1718                         case S2255_MARKER_FRAME:
1719                                 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n",
1720                                         jj, pdata[0], pdata[1]);
1721                                 offset = jj + PREFIX_SIZE;
1722                                 bframe = 1;
1723                                 cc = le32_to_cpu(pdword[1]);
1724                                 if (cc >= MAX_CHANNELS) {
1725                                         dprintk(dev, 0,
1726                                                 "bad channel\n");
1727                                         return -EINVAL;
1728                                 }
1729                                 /* reverse it */
1730                                 dev->cc = G_chnmap[cc];
1731                                 vc = &dev->vc[dev->cc];
1732                                 payload =  le32_to_cpu(pdword[3]);
1733                                 if (payload > vc->req_image_size) {
1734                                         vc->bad_payload++;
1735                                         /* discard the bad frame */
1736                                         return -EINVAL;
1737                                 }
1738                                 vc->pkt_size = payload;
1739                                 vc->jpg_size = le32_to_cpu(pdword[4]);
1740                                 break;
1741                         case S2255_MARKER_RESPONSE:
1742
1743                                 pdata += DEF_USB_BLOCK;
1744                                 jj += DEF_USB_BLOCK;
1745                                 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
1746                                         break;
1747                                 cc = G_chnmap[le32_to_cpu(pdword[1])];
1748                                 if (cc >= MAX_CHANNELS)
1749                                         break;
1750                                 vc = &dev->vc[cc];
1751                                 switch (pdword[2]) {
1752                                 case S2255_RESPONSE_SETMODE:
1753                                         /* check if channel valid */
1754                                         /* set mode ready */
1755                                         vc->setmode_ready = 1;
1756                                         wake_up(&vc->wait_setmode);
1757                                         dprintk(dev, 5, "setmode rdy %d\n", cc);
1758                                         break;
1759                                 case S2255_RESPONSE_FW:
1760                                         dev->chn_ready |= (1 << cc);
1761                                         if ((dev->chn_ready & 0x0f) != 0x0f)
1762                                                 break;
1763                                         /* all channels ready */
1764                                         pr_info("s2255: fw loaded\n");
1765                                         atomic_set(&dev->fw_data->fw_state,
1766                                                    S2255_FW_SUCCESS);
1767                                         wake_up(&dev->fw_data->wait_fw);
1768                                         break;
1769                                 case S2255_RESPONSE_STATUS:
1770                                         vc->vidstatus = le32_to_cpu(pdword[3]);
1771                                         vc->vidstatus_ready = 1;
1772                                         wake_up(&vc->wait_vidstatus);
1773                                         dprintk(dev, 5, "vstat %x chan %d\n",
1774                                                 le32_to_cpu(pdword[3]), cc);
1775                                         break;
1776                                 default:
1777                                         pr_info("s2255 unknown resp\n");
1778                                 }
1779                                 pdata++;
1780                                 break;
1781                         default:
1782                                 pdata++;
1783                                 break;
1784                         }
1785                         if (bframe)
1786                                 break;
1787                 } /* for */
1788                 if (!bframe)
1789                         return -EINVAL;
1790         }
1791         vc = &dev->vc[dev->cc];
1792         idx = vc->cur_frame;
1793         frm = &vc->buffer.frame[idx];
1794         /* search done.  now find out if should be acquiring on this channel */
1795         if (!vb2_is_streaming(&vc->vb_vidq)) {
1796                 /* we found a frame, but this channel is turned off */
1797                 frm->ulState = S2255_READ_IDLE;
1798                 return -EINVAL;
1799         }
1800
1801         if (frm->ulState == S2255_READ_IDLE) {
1802                 frm->ulState = S2255_READ_FRAME;
1803                 frm->cur_size = 0;
1804         }
1805
1806         /* skip the marker 512 bytes (and offset if out of sync) */
1807         psrc = (u8 *)pipe_info->transfer_buffer + offset;
1808
1809
1810         if (frm->lpvbits == NULL) {
1811                 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1812                         frm, dev, dev->cc, idx);
1813                 return -ENOMEM;
1814         }
1815
1816         pdest = frm->lpvbits + frm->cur_size;
1817
1818         copy_size = (pipe_info->cur_transfer_size - offset);
1819
1820         size = vc->pkt_size - PREFIX_SIZE;
1821
1822         /* sanity check on pdest */
1823         if ((copy_size + frm->cur_size) < vc->req_image_size)
1824                 memcpy(pdest, psrc, copy_size);
1825
1826         frm->cur_size += copy_size;
1827         dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size);
1828
1829         if (frm->cur_size >= size) {
1830                 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
1831                         dev->cc, idx);
1832                 vc->last_frame = vc->cur_frame;
1833                 vc->cur_frame++;
1834                 /* end of system frame ring buffer, start at zero */
1835                 if ((vc->cur_frame == SYS_FRAMES) ||
1836                     (vc->cur_frame == vc->buffer.dwFrames))
1837                         vc->cur_frame = 0;
1838                 /* frame ready */
1839                 if (vb2_is_streaming(&vc->vb_vidq))
1840                         s2255_got_frame(vc, vc->jpg_size);
1841                 vc->frame_count++;
1842                 frm->ulState = S2255_READ_IDLE;
1843                 frm->cur_size = 0;
1844
1845         }
1846         /* done successfully */
1847         return 0;
1848 }
1849
1850 static void s2255_read_video_callback(struct s2255_dev *dev,
1851                                       struct s2255_pipeinfo *pipe_info)
1852 {
1853         int res;
1854         dprintk(dev, 50, "callback read video\n");
1855
1856         if (dev->cc >= MAX_CHANNELS) {
1857                 dev->cc = 0;
1858                 dev_err(&dev->udev->dev, "invalid channel\n");
1859                 return;
1860         }
1861         /* otherwise copy to the system buffers */
1862         res = save_frame(dev, pipe_info);
1863         if (res != 0)
1864                 dprintk(dev, 4, "s2255: read callback failed\n");
1865
1866         dprintk(dev, 50, "callback read video done\n");
1867         return;
1868 }
1869
1870 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1871                              u16 Index, u16 Value, void *TransferBuffer,
1872                              s32 TransferBufferLength, int bOut)
1873 {
1874         int r;
1875         unsigned char *buf;
1876
1877         buf = kmalloc(TransferBufferLength, GFP_KERNEL);
1878         if (!buf)
1879                 return -ENOMEM;
1880
1881         if (!bOut) {
1882                 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1883                                     Request,
1884                                     USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1885                                     USB_DIR_IN,
1886                                     Value, Index, buf,
1887                                     TransferBufferLength, HZ * 5);
1888
1889                 if (r >= 0)
1890                         memcpy(TransferBuffer, buf, TransferBufferLength);
1891         } else {
1892                 memcpy(buf, TransferBuffer, TransferBufferLength);
1893                 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1894                                     Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1895                                     Value, Index, buf,
1896                                     TransferBufferLength, HZ * 5);
1897         }
1898         kfree(buf);
1899         return r;
1900 }
1901
1902 /*
1903  * retrieve FX2 firmware version. future use.
1904  * @param dev pointer to device extension
1905  * @return -1 for fail, else returns firmware version as an int(16 bits)
1906  */
1907 static int s2255_get_fx2fw(struct s2255_dev *dev)
1908 {
1909         int fw;
1910         int ret;
1911         unsigned char transBuffer[64];
1912         ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
1913                                S2255_VR_IN);
1914         if (ret < 0)
1915                 dprintk(dev, 2, "get fw error: %x\n", ret);
1916         fw = transBuffer[0] + (transBuffer[1] << 8);
1917         dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
1918         return fw;
1919 }
1920
1921 /*
1922  * Create the system ring buffer to copy frames into from the
1923  * usb read pipe.
1924  */
1925 static int s2255_create_sys_buffers(struct s2255_vc *vc)
1926 {
1927         unsigned long i;
1928         unsigned long reqsize;
1929         vc->buffer.dwFrames = SYS_FRAMES;
1930         /* always allocate maximum size(PAL) for system buffers */
1931         reqsize = SYS_FRAMES_MAXSIZE;
1932
1933         if (reqsize > SYS_FRAMES_MAXSIZE)
1934                 reqsize = SYS_FRAMES_MAXSIZE;
1935
1936         for (i = 0; i < SYS_FRAMES; i++) {
1937                 /* allocate the frames */
1938                 vc->buffer.frame[i].lpvbits = vmalloc(reqsize);
1939                 vc->buffer.frame[i].size = reqsize;
1940                 if (vc->buffer.frame[i].lpvbits == NULL) {
1941                         pr_info("out of memory.  using less frames\n");
1942                         vc->buffer.dwFrames = i;
1943                         break;
1944                 }
1945         }
1946
1947         /* make sure internal states are set */
1948         for (i = 0; i < SYS_FRAMES; i++) {
1949                 vc->buffer.frame[i].ulState = 0;
1950                 vc->buffer.frame[i].cur_size = 0;
1951         }
1952
1953         vc->cur_frame = 0;
1954         vc->last_frame = -1;
1955         return 0;
1956 }
1957
1958 static int s2255_release_sys_buffers(struct s2255_vc *vc)
1959 {
1960         unsigned long i;
1961         for (i = 0; i < SYS_FRAMES; i++) {
1962                 vfree(vc->buffer.frame[i].lpvbits);
1963                 vc->buffer.frame[i].lpvbits = NULL;
1964         }
1965         return 0;
1966 }
1967
1968 static int s2255_board_init(struct s2255_dev *dev)
1969 {
1970         struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
1971         int fw_ver;
1972         int j;
1973         struct s2255_pipeinfo *pipe = &dev->pipe;
1974         dprintk(dev, 4, "board init: %p", dev);
1975         memset(pipe, 0, sizeof(*pipe));
1976         pipe->dev = dev;
1977         pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
1978         pipe->max_transfer_size = S2255_USB_XFER_SIZE;
1979
1980         pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
1981                                         GFP_KERNEL);
1982         if (pipe->transfer_buffer == NULL) {
1983                 dprintk(dev, 1, "out of memory!\n");
1984                 return -ENOMEM;
1985         }
1986         /* query the firmware */
1987         fw_ver = s2255_get_fx2fw(dev);
1988
1989         pr_info("s2255: usb firmware version %d.%d\n",
1990                 (fw_ver >> 8) & 0xff,
1991                 fw_ver & 0xff);
1992
1993         if (fw_ver < S2255_CUR_USB_FWVER)
1994                 pr_info("s2255: newer USB firmware available\n");
1995
1996         for (j = 0; j < MAX_CHANNELS; j++) {
1997                 struct s2255_vc *vc = &dev->vc[j];
1998                 vc->mode = mode_def;
1999                 if (dev->pid == 0x2257 && j > 1)
2000                         vc->mode.color |= (1 << 16);
2001                 vc->jpegqual = S2255_DEF_JPEG_QUAL;
2002                 vc->width = LINE_SZ_4CIFS_NTSC;
2003                 vc->height = NUM_LINES_4CIFS_NTSC * 2;
2004                 vc->std = V4L2_STD_NTSC_M;
2005                 vc->fmt = &formats[0];
2006                 vc->mode.restart = 1;
2007                 vc->req_image_size = get_transfer_size(&mode_def);
2008                 vc->frame_count = 0;
2009                 /* create the system buffers */
2010                 s2255_create_sys_buffers(vc);
2011         }
2012         /* start read pipe */
2013         s2255_start_readpipe(dev);
2014         dprintk(dev, 1, "%s: success\n", __func__);
2015         return 0;
2016 }
2017
2018 static int s2255_board_shutdown(struct s2255_dev *dev)
2019 {
2020         u32 i;
2021         dprintk(dev, 1, "%s: dev: %p", __func__,  dev);
2022
2023         for (i = 0; i < MAX_CHANNELS; i++) {
2024                 if (vb2_is_streaming(&dev->vc[i].vb_vidq))
2025                         s2255_stop_acquire(&dev->vc[i]);
2026         }
2027         s2255_stop_readpipe(dev);
2028         for (i = 0; i < MAX_CHANNELS; i++)
2029                 s2255_release_sys_buffers(&dev->vc[i]);
2030         /* release transfer buffer */
2031         kfree(dev->pipe.transfer_buffer);
2032         return 0;
2033 }
2034
2035 static void read_pipe_completion(struct urb *purb)
2036 {
2037         struct s2255_pipeinfo *pipe_info;
2038         struct s2255_dev *dev;
2039         int status;
2040         int pipe;
2041         pipe_info = purb->context;
2042         if (pipe_info == NULL) {
2043                 dev_err(&purb->dev->dev, "no context!\n");
2044                 return;
2045         }
2046         dev = pipe_info->dev;
2047         if (dev == NULL) {
2048                 dev_err(&purb->dev->dev, "no context!\n");
2049                 return;
2050         }
2051         status = purb->status;
2052         /* if shutting down, do not resubmit, exit immediately */
2053         if (status == -ESHUTDOWN) {
2054                 dprintk(dev, 2, "%s: err shutdown\n", __func__);
2055                 pipe_info->err_count++;
2056                 return;
2057         }
2058
2059         if (pipe_info->state == 0) {
2060                 dprintk(dev, 2, "%s: exiting USB pipe", __func__);
2061                 return;
2062         }
2063
2064         if (status == 0)
2065                 s2255_read_video_callback(dev, pipe_info);
2066         else {
2067                 pipe_info->err_count++;
2068                 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status);
2069         }
2070
2071         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2072         /* reuse urb */
2073         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2074                           pipe,
2075                           pipe_info->transfer_buffer,
2076                           pipe_info->cur_transfer_size,
2077                           read_pipe_completion, pipe_info);
2078
2079         if (pipe_info->state != 0) {
2080                 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC))
2081                         dev_err(&dev->udev->dev, "error submitting urb\n");
2082         } else {
2083                 dprintk(dev, 2, "%s :complete state 0\n", __func__);
2084         }
2085         return;
2086 }
2087
2088 static int s2255_start_readpipe(struct s2255_dev *dev)
2089 {
2090         int pipe;
2091         int retval;
2092         struct s2255_pipeinfo *pipe_info = &dev->pipe;
2093         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2094         dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint);
2095         pipe_info->state = 1;
2096         pipe_info->err_count = 0;
2097         pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2098         if (!pipe_info->stream_urb)
2099                 return -ENOMEM;
2100         /* transfer buffer allocated in board_init */
2101         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2102                           pipe,
2103                           pipe_info->transfer_buffer,
2104                           pipe_info->cur_transfer_size,
2105                           read_pipe_completion, pipe_info);
2106         retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2107         if (retval) {
2108                 pr_err("s2255: start read pipe failed\n");
2109                 return retval;
2110         }
2111         return 0;
2112 }
2113
2114 /* starts acquisition process */
2115 static int s2255_start_acquire(struct s2255_vc *vc)
2116 {
2117         int res;
2118         unsigned long chn_rev;
2119         int j;
2120         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2121         __le32 *buffer = dev->cmdbuf;
2122
2123         mutex_lock(&dev->cmdlock);
2124         chn_rev = G_chnmap[vc->idx];
2125         vc->last_frame = -1;
2126         vc->bad_payload = 0;
2127         vc->cur_frame = 0;
2128         for (j = 0; j < SYS_FRAMES; j++) {
2129                 vc->buffer.frame[j].ulState = 0;
2130                 vc->buffer.frame[j].cur_size = 0;
2131         }
2132
2133         /* send the start command */
2134         buffer[0] = IN_DATA_TOKEN;
2135         buffer[1] = (__le32) cpu_to_le32(chn_rev);
2136         buffer[2] = CMD_START;
2137         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2138         if (res != 0)
2139                 dev_err(&dev->udev->dev, "CMD_START error\n");
2140
2141         dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
2142         mutex_unlock(&dev->cmdlock);
2143         return res;
2144 }
2145
2146 static int s2255_stop_acquire(struct s2255_vc *vc)
2147 {
2148         int res;
2149         unsigned long chn_rev;
2150         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2151         __le32 *buffer = dev->cmdbuf;
2152
2153         mutex_lock(&dev->cmdlock);
2154         chn_rev = G_chnmap[vc->idx];
2155         /* send the stop command */
2156         buffer[0] = IN_DATA_TOKEN;
2157         buffer[1] = (__le32) cpu_to_le32(chn_rev);
2158         buffer[2] = CMD_STOP;
2159
2160         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2161         if (res != 0)
2162                 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2163
2164         dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
2165         mutex_unlock(&dev->cmdlock);
2166         return res;
2167 }
2168
2169 static void s2255_stop_readpipe(struct s2255_dev *dev)
2170 {
2171         struct s2255_pipeinfo *pipe = &dev->pipe;
2172
2173         pipe->state = 0;
2174         if (pipe->stream_urb) {
2175                 /* cancel urb */
2176                 usb_kill_urb(pipe->stream_urb);
2177                 usb_free_urb(pipe->stream_urb);
2178                 pipe->stream_urb = NULL;
2179         }
2180         dprintk(dev, 4, "%s", __func__);
2181         return;
2182 }
2183
2184 static void s2255_fwload_start(struct s2255_dev *dev)
2185 {
2186         s2255_reset_dsppower(dev);
2187         dev->fw_data->fw_size = dev->fw_data->fw->size;
2188         atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2189         memcpy(dev->fw_data->pfw_data,
2190                dev->fw_data->fw->data, CHUNK_SIZE);
2191         dev->fw_data->fw_loaded = CHUNK_SIZE;
2192         usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2193                           usb_sndbulkpipe(dev->udev, 2),
2194                           dev->fw_data->pfw_data,
2195                           CHUNK_SIZE, s2255_fwchunk_complete,
2196                           dev->fw_data);
2197         mod_timer(&dev->timer, jiffies + HZ);
2198 }
2199
2200 /* standard usb probe function */
2201 static int s2255_probe(struct usb_interface *interface,
2202                        const struct usb_device_id *id)
2203 {
2204         struct s2255_dev *dev = NULL;
2205         struct usb_host_interface *iface_desc;
2206         struct usb_endpoint_descriptor *endpoint;
2207         int i;
2208         int retval = -ENOMEM;
2209         __le32 *pdata;
2210         int fw_size;
2211
2212         /* allocate memory for our device state and initialize it to zero */
2213         dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2214         if (dev == NULL) {
2215                 s2255_dev_err(&interface->dev, "out of memory\n");
2216                 return -ENOMEM;
2217         }
2218
2219         dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL);
2220         if (dev->cmdbuf == NULL) {
2221                 s2255_dev_err(&interface->dev, "out of memory\n");
2222                 goto errorFWDATA1;
2223         }
2224
2225         atomic_set(&dev->num_channels, 0);
2226         dev->pid = id->idProduct;
2227         dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2228         if (!dev->fw_data)
2229                 goto errorFWDATA1;
2230         mutex_init(&dev->lock);
2231         mutex_init(&dev->cmdlock);
2232         /* grab usb_device and save it */
2233         dev->udev = usb_get_dev(interface_to_usbdev(interface));
2234         if (dev->udev == NULL) {
2235                 dev_err(&interface->dev, "null usb device\n");
2236                 retval = -ENODEV;
2237                 goto errorUDEV;
2238         }
2239         dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n",
2240                 dev, dev->udev, interface);
2241         dev->interface = interface;
2242         /* set up the endpoint information  */
2243         iface_desc = interface->cur_altsetting;
2244         dev_dbg(&interface->dev, "num EP: %d\n",
2245                 iface_desc->desc.bNumEndpoints);
2246         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2247                 endpoint = &iface_desc->endpoint[i].desc;
2248                 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2249                         /* we found the bulk in endpoint */
2250                         dev->read_endpoint = endpoint->bEndpointAddress;
2251                 }
2252         }
2253
2254         if (!dev->read_endpoint) {
2255                 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2256                 goto errorEP;
2257         }
2258         timer_setup(&dev->timer, s2255_timer, 0);
2259         init_waitqueue_head(&dev->fw_data->wait_fw);
2260         for (i = 0; i < MAX_CHANNELS; i++) {
2261                 struct s2255_vc *vc = &dev->vc[i];
2262                 vc->idx = i;
2263                 vc->dev = dev;
2264                 init_waitqueue_head(&vc->wait_setmode);
2265                 init_waitqueue_head(&vc->wait_vidstatus);
2266                 spin_lock_init(&vc->qlock);
2267                 mutex_init(&vc->vb_lock);
2268         }
2269
2270         dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2271         if (!dev->fw_data->fw_urb)
2272                 goto errorFWURB;
2273
2274         dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2275         if (!dev->fw_data->pfw_data) {
2276                 dev_err(&interface->dev, "out of memory!\n");
2277                 goto errorFWDATA2;
2278         }
2279         /* load the first chunk */
2280         if (request_firmware(&dev->fw_data->fw,
2281                              FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2282                 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
2283                 goto errorREQFW;
2284         }
2285         /* check the firmware is valid */
2286         fw_size = dev->fw_data->fw->size;
2287         pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2288
2289         if (*pdata != S2255_FW_MARKER) {
2290                 dev_err(&interface->dev, "Firmware invalid.\n");
2291                 retval = -ENODEV;
2292                 goto errorFWMARKER;
2293         } else {
2294                 /* make sure firmware is the latest */
2295                 __le32 *pRel;
2296                 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2297                 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel));
2298                 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2299                 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2300                         pr_info("s2255: f2255usb.bin out of date.\n");
2301                 if (dev->pid == 0x2257 &&
2302                                 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2303                         pr_warn("2257 needs firmware %d or above.\n",
2304                                 S2255_MIN_DSP_COLORFILTER);
2305         }
2306         usb_reset_device(dev->udev);
2307         /* load 2255 board specific */
2308         retval = s2255_board_init(dev);
2309         if (retval)
2310                 goto errorBOARDINIT;
2311         s2255_fwload_start(dev);
2312         /* loads v4l specific */
2313         retval = s2255_probe_v4l(dev);
2314         if (retval)
2315                 goto errorBOARDINIT;
2316         dev_info(&interface->dev, "Sensoray 2255 detected\n");
2317         return 0;
2318 errorBOARDINIT:
2319         s2255_board_shutdown(dev);
2320 errorFWMARKER:
2321         release_firmware(dev->fw_data->fw);
2322 errorREQFW:
2323         kfree(dev->fw_data->pfw_data);
2324 errorFWDATA2:
2325         usb_free_urb(dev->fw_data->fw_urb);
2326 errorFWURB:
2327         del_timer_sync(&dev->timer);
2328 errorEP:
2329         usb_put_dev(dev->udev);
2330 errorUDEV:
2331         kfree(dev->fw_data);
2332         mutex_destroy(&dev->lock);
2333 errorFWDATA1:
2334         kfree(dev->cmdbuf);
2335         kfree(dev);
2336         pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval);
2337         return retval;
2338 }
2339
2340 /* disconnect routine. when board is removed physically or with rmmod */
2341 static void s2255_disconnect(struct usb_interface *interface)
2342 {
2343         struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2344         int i;
2345         int channels = atomic_read(&dev->num_channels);
2346         mutex_lock(&dev->lock);
2347         v4l2_device_disconnect(&dev->v4l2_dev);
2348         mutex_unlock(&dev->lock);
2349         /*see comments in the uvc_driver.c usb disconnect function */
2350         atomic_inc(&dev->num_channels);
2351         /* unregister each video device. */
2352         for (i = 0; i < channels; i++)
2353                 video_unregister_device(&dev->vc[i].vdev);
2354         /* wake up any of our timers */
2355         atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2356         wake_up(&dev->fw_data->wait_fw);
2357         for (i = 0; i < MAX_CHANNELS; i++) {
2358                 dev->vc[i].setmode_ready = 1;
2359                 wake_up(&dev->vc[i].wait_setmode);
2360                 dev->vc[i].vidstatus_ready = 1;
2361                 wake_up(&dev->vc[i].wait_vidstatus);
2362         }
2363         if (atomic_dec_and_test(&dev->num_channels))
2364                 s2255_destroy(dev);
2365         dev_info(&interface->dev, "%s\n", __func__);
2366 }
2367
2368 static struct usb_driver s2255_driver = {
2369         .name = S2255_DRIVER_NAME,
2370         .probe = s2255_probe,
2371         .disconnect = s2255_disconnect,
2372         .id_table = s2255_table,
2373 };
2374
2375 module_usb_driver(s2255_driver);
2376
2377 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2378 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2379 MODULE_LICENSE("GPL");
2380 MODULE_VERSION(S2255_VERSION);
2381 MODULE_FIRMWARE(FIRMWARE_FILE_NAME);