kernel/drivers/media/usb/s2255/s2255drv.c

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