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 int 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         int rc = 0;
 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                 rc = -1;
 571                 goto unlock;
 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         s2255_fillbuff(vc, buf, jpgsize);
 578         dprintk(dev, 2, "%s: [buf] [%p]\n", __func__, buf);
 579 unlock:
 580         spin_unlock_irqrestore(&vc->qlock, flags);
 581         return rc;
 582 }
 583
 584 static const struct s2255_fmt *format_by_fourcc(int fourcc)
 585 {
 586         unsigned int i;
 587         for (i = 0; i < ARRAY_SIZE(formats); i++) {
 588                 if (-1 == formats[i].fourcc)
 589                         continue;
 590                 if (!jpeg_enable && ((formats[i].fourcc == V4L2_PIX_FMT_JPEG) ||
 591                                      (formats[i].fourcc == V4L2_PIX_FMT_MJPEG)))
 592                         continue;
 593                 if (formats[i].fourcc == fourcc)
 594                         return formats + i;
 595         }
 596         return NULL;
 597 }
 598
 599 /* video buffer vmalloc implementation based partly on VIVI driver which is
 600  *          Copyright (c) 2006 by
 601  *                  Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
 602  *                  Ted Walther <ted--a.t--enumera.com>
 603  *                  John Sokol <sokol--a.t--videotechnology.com>
 604  *                  http://v4l.videotechnology.com/
 605  *
 606  */
 607 static void s2255_fillbuff(struct s2255_vc *vc,
 608                            struct s2255_buffer *buf, int jpgsize)
 609 {
 610         int pos = 0;
 611         const char *tmpbuf;
 612         char *vbuf = vb2_plane_vaddr(&buf->vb, 0);
 613         unsigned long last_frame;
 614         struct s2255_dev *dev = vc->dev;
 615
 616         if (!vbuf)
 617                 return;
 618         last_frame = vc->last_frame;
 619         if (last_frame != -1) {
 620                 tmpbuf =
 621                     (const char *)vc->buffer.frame[last_frame].lpvbits;
 622                 switch (vc->fmt->fourcc) {
 623                 case V4L2_PIX_FMT_YUYV:
 624                 case V4L2_PIX_FMT_UYVY:
 625                         planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
 626                                                  vbuf, vc->width,
 627                                                  vc->height,
 628                                                  vc->fmt->fourcc);
 629                         break;
 630                 case V4L2_PIX_FMT_GREY:
 631                         memcpy(vbuf, tmpbuf, vc->width * vc->height);
 632                         break;
 633                 case V4L2_PIX_FMT_JPEG:
 634                 case V4L2_PIX_FMT_MJPEG:
 635                         buf->vb.v4l2_buf.length = jpgsize;
 636                         memcpy(vbuf, tmpbuf, jpgsize);
 637                         break;
 638                 case V4L2_PIX_FMT_YUV422P:
 639                         memcpy(vbuf, tmpbuf,
 640                                vc->width * vc->height * 2);
 641                         break;
 642                 default:
 643                         pr_info("s2255: unknown format?\n");
 644                 }
 645                 vc->last_frame = -1;
 646         } else {
 647                 pr_err("s2255: =======no frame\n");
 648                 return;
 649         }
 650         dprintk(dev, 2, "s2255fill at : Buffer 0x%08lx size= %d\n",
 651                 (unsigned long)vbuf, pos);
 652         /* tell v4l buffer was filled */
 653         buf->vb.v4l2_buf.field = vc->field;
 654         buf->vb.v4l2_buf.sequence = vc->frame_count;
 655         v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 656         vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 657 }
 658
 659
 660 /* ------------------------------------------------------------------
 661    Videobuf operations
 662    ------------------------------------------------------------------*/
 663
 664 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 665                        unsigned int *nbuffers, unsigned int *nplanes,
 666                        unsigned int sizes[], void *alloc_ctxs[])
 667 {
 668         struct s2255_vc *vc = vb2_get_drv_priv(vq);
 669         if (*nbuffers < S2255_MIN_BUFS)
 670                 *nbuffers = S2255_MIN_BUFS;
 671         *nplanes = 1;
 672         sizes[0] = vc->width * vc->height * (vc->fmt->depth >> 3);
 673         return 0;
 674 }
 675
 676 static int buffer_prepare(struct vb2_buffer *vb)
 677 {
 678         struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
 679         struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
 680         int w = vc->width;
 681         int h = vc->height;
 682         unsigned long size;
 683
 684         dprintk(vc->dev, 4, "%s\n", __func__);
 685         if (vc->fmt == NULL)
 686                 return -EINVAL;
 687
 688         if ((w < norm_minw(vc)) ||
 689             (w > norm_maxw(vc)) ||
 690             (h < norm_minh(vc)) ||
 691             (h > norm_maxh(vc))) {
 692                 dprintk(vc->dev, 4, "invalid buffer prepare\n");
 693                 return -EINVAL;
 694         }
 695         size = w * h * (vc->fmt->depth >> 3);
 696         if (vb2_plane_size(vb, 0) < size) {
 697                 dprintk(vc->dev, 4, "invalid buffer prepare\n");
 698                 return -EINVAL;
 699         }
 700
 701         vb2_set_plane_payload(&buf->vb, 0, size);
 702         return 0;
 703 }
 704
 705 static void buffer_queue(struct vb2_buffer *vb)
 706 {
 707         struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
 708         struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
 709         unsigned long flags = 0;
 710         dprintk(vc->dev, 1, "%s\n", __func__);
 711         spin_lock_irqsave(&vc->qlock, flags);
 712         list_add_tail(&buf->list, &vc->buf_list);
 713         spin_unlock_irqrestore(&vc->qlock, flags);
 714 }
 715
 716 static int start_streaming(struct vb2_queue *vq, unsigned int count);
 717 static int stop_streaming(struct vb2_queue *vq);
 718
 719 static struct vb2_ops s2255_video_qops = {
 720         .queue_setup = queue_setup,
 721         .buf_prepare = buffer_prepare,
 722         .buf_queue = buffer_queue,
 723         .start_streaming = start_streaming,
 724         .stop_streaming = stop_streaming,
 725         .wait_prepare = vb2_ops_wait_prepare,
 726         .wait_finish = vb2_ops_wait_finish,
 727 };
 728
 729 static int vidioc_querycap(struct file *file, void *priv,
 730                            struct v4l2_capability *cap)
 731 {
 732         struct s2255_vc *vc = video_drvdata(file);
 733         struct s2255_dev *dev = vc->dev;
 734
 735         strlcpy(cap->driver, "s2255", sizeof(cap->driver));
 736         strlcpy(cap->card, "s2255", sizeof(cap->card));
 737         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 738         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
 739                 V4L2_CAP_READWRITE;
 740         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 741         return 0;
 742 }
 743
 744 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
 745                                struct v4l2_fmtdesc *f)
 746 {
 747         int index = f->index;
 748
 749         if (index >= ARRAY_SIZE(formats))
 750                 return -EINVAL;
 751         if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
 752                         (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
 753                 return -EINVAL;
 754         strlcpy(f->description, formats[index].name, sizeof(f->description));
 755         f->pixelformat = formats[index].fourcc;
 756         return 0;
 757 }
 758
 759 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 760                             struct v4l2_format *f)
 761 {
 762         struct s2255_vc *vc = video_drvdata(file);
 763         int is_ntsc = vc->std & V4L2_STD_525_60;
 764
 765         f->fmt.pix.width = vc->width;
 766         f->fmt.pix.height = vc->height;
 767         if (f->fmt.pix.height >=
 768             (is_ntsc ? NUM_LINES_1CIFS_NTSC : NUM_LINES_1CIFS_PAL) * 2)
 769                 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
 770         else
 771                 f->fmt.pix.field = V4L2_FIELD_TOP;
 772         f->fmt.pix.pixelformat = vc->fmt->fourcc;
 773         f->fmt.pix.bytesperline = f->fmt.pix.width * (vc->fmt->depth >> 3);
 774         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 775         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 776         f->fmt.pix.priv = 0;
 777         return 0;
 778 }
 779
 780 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 781                               struct v4l2_format *f)
 782 {
 783         const struct s2255_fmt *fmt;
 784         enum v4l2_field field;
 785         struct s2255_vc *vc = video_drvdata(file);
 786         int is_ntsc = vc->std & V4L2_STD_525_60;
 787
 788         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 789
 790         if (fmt == NULL)
 791                 return -EINVAL;
 792
 793         field = f->fmt.pix.field;
 794
 795         dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
 796                 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
 797         if (is_ntsc) {
 798                 /* NTSC */
 799                 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
 800                         f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
 801                         field = V4L2_FIELD_INTERLACED;
 802                 } else {
 803                         f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
 804                         field = V4L2_FIELD_TOP;
 805                 }
 806                 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
 807                         f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
 808                 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
 809                         f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
 810                 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
 811                         f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
 812                 else
 813                         f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
 814         } else {
 815                 /* PAL */
 816                 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
 817                         f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
 818                         field = V4L2_FIELD_INTERLACED;
 819                 } else {
 820                         f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
 821                         field = V4L2_FIELD_TOP;
 822                 }
 823                 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL)
 824                         f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
 825                 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL)
 826                         f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
 827                 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL)
 828                         f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
 829                 else
 830                         f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
 831         }
 832         f->fmt.pix.field = field;
 833         f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
 834         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 835         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 836         f->fmt.pix.priv = 0;
 837         dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__,
 838                 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
 839         return 0;
 840 }
 841
 842 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 843                             struct v4l2_format *f)
 844 {
 845         struct s2255_vc *vc = video_drvdata(file);
 846         const struct s2255_fmt *fmt;
 847         struct vb2_queue *q = &vc->vb_vidq;
 848         struct s2255_mode mode;
 849         int ret;
 850
 851         ret = vidioc_try_fmt_vid_cap(file, vc, f);
 852
 853         if (ret < 0)
 854                 return ret;
 855
 856         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 857
 858         if (fmt == NULL)
 859                 return -EINVAL;
 860
 861         if (vb2_is_busy(q)) {
 862                 dprintk(vc->dev, 1, "queue busy\n");
 863                 return -EBUSY;
 864         }
 865
 866         mode = vc->mode;
 867         vc->fmt = fmt;
 868         vc->width = f->fmt.pix.width;
 869         vc->height = f->fmt.pix.height;
 870         vc->field = f->fmt.pix.field;
 871         if (vc->width > norm_minw(vc)) {
 872                 if (vc->height > norm_minh(vc)) {
 873                         if (vc->cap_parm.capturemode &
 874                             V4L2_MODE_HIGHQUALITY)
 875                                 mode.scale = SCALE_4CIFSI;
 876                         else
 877                                 mode.scale = SCALE_4CIFS;
 878                 } else
 879                         mode.scale = SCALE_2CIFS;
 880
 881         } else {
 882                 mode.scale = SCALE_1CIFS;
 883         }
 884         /* color mode */
 885         switch (vc->fmt->fourcc) {
 886         case V4L2_PIX_FMT_GREY:
 887                 mode.color &= ~MASK_COLOR;
 888                 mode.color |= COLOR_Y8;
 889                 break;
 890         case V4L2_PIX_FMT_JPEG:
 891         case V4L2_PIX_FMT_MJPEG:
 892                 mode.color &= ~MASK_COLOR;
 893                 mode.color |= COLOR_JPG;
 894                 mode.color |= (vc->jpegqual << 8);
 895                 break;
 896         case V4L2_PIX_FMT_YUV422P:
 897                 mode.color &= ~MASK_COLOR;
 898                 mode.color |= COLOR_YUVPL;
 899                 break;
 900         case V4L2_PIX_FMT_YUYV:
 901         case V4L2_PIX_FMT_UYVY:
 902         default:
 903                 mode.color &= ~MASK_COLOR;
 904                 mode.color |= COLOR_YUVPK;
 905                 break;
 906         }
 907         if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR))
 908                 mode.restart = 1;
 909         else if (mode.scale != vc->mode.scale)
 910                 mode.restart = 1;
 911         else if (mode.format != vc->mode.format)
 912                 mode.restart = 1;
 913         vc->mode = mode;
 914         (void) s2255_set_mode(vc, &mode);
 915         return 0;
 916 }
 917
 918
 919 /* write to the configuration pipe, synchronously */
 920 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
 921                               int size)
 922 {
 923         int pipe;
 924         int done;
 925         long retval = -1;
 926         if (udev) {
 927                 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
 928                 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
 929         }
 930         return retval;
 931 }
 932
 933 static u32 get_transfer_size(struct s2255_mode *mode)
 934 {
 935         int linesPerFrame = LINE_SZ_DEF;
 936         int pixelsPerLine = NUM_LINES_DEF;
 937         u32 outImageSize;
 938         u32 usbInSize;
 939         unsigned int mask_mult;
 940
 941         if (mode == NULL)
 942                 return 0;
 943
 944         if (mode->format == FORMAT_NTSC) {
 945                 switch (mode->scale) {
 946                 case SCALE_4CIFS:
 947                 case SCALE_4CIFSI:
 948                         linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
 949                         pixelsPerLine = LINE_SZ_4CIFS_NTSC;
 950                         break;
 951                 case SCALE_2CIFS:
 952                         linesPerFrame = NUM_LINES_2CIFS_NTSC;
 953                         pixelsPerLine = LINE_SZ_2CIFS_NTSC;
 954                         break;
 955                 case SCALE_1CIFS:
 956                         linesPerFrame = NUM_LINES_1CIFS_NTSC;
 957                         pixelsPerLine = LINE_SZ_1CIFS_NTSC;
 958                         break;
 959                 default:
 960                         break;
 961                 }
 962         } else if (mode->format == FORMAT_PAL) {
 963                 switch (mode->scale) {
 964                 case SCALE_4CIFS:
 965                 case SCALE_4CIFSI:
 966                         linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
 967                         pixelsPerLine = LINE_SZ_4CIFS_PAL;
 968                         break;
 969                 case SCALE_2CIFS:
 970                         linesPerFrame = NUM_LINES_2CIFS_PAL;
 971                         pixelsPerLine = LINE_SZ_2CIFS_PAL;
 972                         break;
 973                 case SCALE_1CIFS:
 974                         linesPerFrame = NUM_LINES_1CIFS_PAL;
 975                         pixelsPerLine = LINE_SZ_1CIFS_PAL;
 976                         break;
 977                 default:
 978                         break;
 979                 }
 980         }
 981         outImageSize = linesPerFrame * pixelsPerLine;
 982         if ((mode->color & MASK_COLOR) != COLOR_Y8) {
 983                 /* 2 bytes/pixel if not monochrome */
 984                 outImageSize *= 2;
 985         }
 986
 987         /* total bytes to send including prefix and 4K padding;
 988            must be a multiple of USB_READ_SIZE */
 989         usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
 990         mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
 991         /* if size not a multiple of USB_READ_SIZE */
 992         if (usbInSize & ~mask_mult)
 993                 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
 994         return usbInSize;
 995 }
 996
 997 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
 998 {
 999         struct device *dev = &sdev->udev->dev;
1000         dev_info(dev, "------------------------------------------------\n");
1001         dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
1002         dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
1003         dev_info(dev, "bright: 0x%x\n", mode->bright);
1004         dev_info(dev, "------------------------------------------------\n");
1005 }
1006
1007 /*
1008  * set mode is the function which controls the DSP.
1009  * the restart parameter in struct s2255_mode should be set whenever
1010  * the image size could change via color format, video system or image
1011  * size.
1012  * When the restart parameter is set, we sleep for ONE frame to allow the
1013  * DSP time to get the new frame
1014  */
1015 static int s2255_set_mode(struct s2255_vc *vc,
1016                           struct s2255_mode *mode)
1017 {
1018         int res;
1019         unsigned long chn_rev;
1020         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1021         int i;
1022         __le32 *buffer = dev->cmdbuf;
1023
1024         mutex_lock(&dev->cmdlock);
1025         chn_rev = G_chnmap[vc->idx];
1026         dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
1027         /* if JPEG, set the quality */
1028         if ((mode->color & MASK_COLOR) == COLOR_JPG) {
1029                 mode->color &= ~MASK_COLOR;
1030                 mode->color |= COLOR_JPG;
1031                 mode->color &= ~MASK_JPG_QUALITY;
1032                 mode->color |= (vc->jpegqual << 8);
1033         }
1034         /* save the mode */
1035         vc->mode = *mode;
1036         vc->req_image_size = get_transfer_size(mode);
1037         dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
1038         /* set the mode */
1039         buffer[0] = IN_DATA_TOKEN;
1040         buffer[1] = (__le32) cpu_to_le32(chn_rev);
1041         buffer[2] = CMD_SET_MODE;
1042         for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++)
1043                 buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]);
1044         vc->setmode_ready = 0;
1045         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1046         if (debug)
1047                 s2255_print_cfg(dev, mode);
1048         /* wait at least 3 frames before continuing */
1049         if (mode->restart) {
1050                 wait_event_timeout(vc->wait_setmode,
1051                                    (vc->setmode_ready != 0),
1052                                    msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1053                 if (vc->setmode_ready != 1) {
1054                         dprintk(dev, 0, "s2255: no set mode response\n");
1055                         res = -EFAULT;
1056                 }
1057         }
1058         /* clear the restart flag */
1059         vc->mode.restart = 0;
1060         dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
1061         mutex_unlock(&dev->cmdlock);
1062         return res;
1063 }
1064
1065 static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus)
1066 {
1067         int res;
1068         u32 chn_rev;
1069         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1070         __le32 *buffer = dev->cmdbuf;
1071
1072         mutex_lock(&dev->cmdlock);
1073         chn_rev = G_chnmap[vc->idx];
1074         dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
1075         /* form the get vid status command */
1076         buffer[0] = IN_DATA_TOKEN;
1077         buffer[1] = (__le32) cpu_to_le32(chn_rev);
1078         buffer[2] = CMD_STATUS;
1079         *pstatus = 0;
1080         vc->vidstatus_ready = 0;
1081         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1082         wait_event_timeout(vc->wait_vidstatus,
1083                            (vc->vidstatus_ready != 0),
1084                            msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1085         if (vc->vidstatus_ready != 1) {
1086                 dprintk(dev, 0, "s2255: no vidstatus response\n");
1087                 res = -EFAULT;
1088         }
1089         *pstatus = vc->vidstatus;
1090         dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
1091         mutex_unlock(&dev->cmdlock);
1092         return res;
1093 }
1094
1095 static int start_streaming(struct vb2_queue *vq, unsigned int count)
1096 {
1097         struct s2255_vc *vc = vb2_get_drv_priv(vq);
1098         int j;
1099
1100         vc->last_frame = -1;
1101         vc->bad_payload = 0;
1102         vc->cur_frame = 0;
1103         vc->frame_count = 0;
1104         for (j = 0; j < SYS_FRAMES; j++) {
1105                 vc->buffer.frame[j].ulState = S2255_READ_IDLE;
1106                 vc->buffer.frame[j].cur_size = 0;
1107         }
1108         return s2255_start_acquire(vc);
1109 }
1110
1111 /* abort streaming and wait for last buffer */
1112 static int stop_streaming(struct vb2_queue *vq)
1113 {
1114         struct s2255_vc *vc = vb2_get_drv_priv(vq);
1115         struct s2255_buffer *buf, *node;
1116         unsigned long flags;
1117         (void) s2255_stop_acquire(vc);
1118         spin_lock_irqsave(&vc->qlock, flags);
1119         list_for_each_entry_safe(buf, node, &vc->buf_list, list) {
1120                 list_del(&buf->list);
1121                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
1122                 dprintk(vc->dev, 2, "[%p/%d] done\n",
1123                         buf, buf->vb.v4l2_buf.index);
1124         }
1125         spin_unlock_irqrestore(&vc->qlock, flags);
1126         return 0;
1127 }
1128
1129 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id i)
1130 {
1131         struct s2255_vc *vc = video_drvdata(file);
1132         struct s2255_mode mode;
1133         struct vb2_queue *q = &vc->vb_vidq;
1134
1135         /*
1136          * Changing the standard implies a format change, which is not allowed
1137          * while buffers for use with streaming have already been allocated.
1138          */
1139         if (vb2_is_busy(q))
1140                 return -EBUSY;
1141
1142         mode = vc->mode;
1143         if (i & V4L2_STD_525_60) {
1144                 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
1145                 /* if changing format, reset frame decimation/intervals */
1146                 if (mode.format != FORMAT_NTSC) {
1147                         mode.restart = 1;
1148                         mode.format = FORMAT_NTSC;
1149                         mode.fdec = FDEC_1;
1150                         vc->width = LINE_SZ_4CIFS_NTSC;
1151                         vc->height = NUM_LINES_4CIFS_NTSC * 2;
1152                 }
1153         } else if (i & V4L2_STD_625_50) {
1154                 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
1155                 if (mode.format != FORMAT_PAL) {
1156                         mode.restart = 1;
1157                         mode.format = FORMAT_PAL;
1158                         mode.fdec = FDEC_1;
1159                         vc->width = LINE_SZ_4CIFS_PAL;
1160                         vc->height = NUM_LINES_4CIFS_PAL * 2;
1161                 }
1162         } else
1163                 return -EINVAL;
1164         vc->std = i;
1165         if (mode.restart)
1166                 s2255_set_mode(vc, &mode);
1167         return 0;
1168 }
1169
1170 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i)
1171 {
1172         struct s2255_vc *vc = video_drvdata(file);
1173
1174         *i = vc->std;
1175         return 0;
1176 }
1177
1178 /* Sensoray 2255 is a multiple channel capture device.
1179    It does not have a "crossbar" of inputs.
1180    We use one V4L device per channel. The user must
1181    be aware that certain combinations are not allowed.
1182    For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1183    at once in color(you can do full fps on 4 channels with greyscale.
1184 */
1185 static int vidioc_enum_input(struct file *file, void *priv,
1186                              struct v4l2_input *inp)
1187 {
1188         struct s2255_vc *vc = video_drvdata(file);
1189         struct s2255_dev *dev = vc->dev;
1190         u32 status = 0;
1191
1192         if (inp->index != 0)
1193                 return -EINVAL;
1194         inp->type = V4L2_INPUT_TYPE_CAMERA;
1195         inp->std = S2255_NORMS;
1196         inp->status = 0;
1197         if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1198                 int rc;
1199                 rc = s2255_cmd_status(vc, &status);
1200                 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
1201                         rc, status);
1202                 if (rc == 0)
1203                         inp->status =  (status & 0x01) ? 0
1204                                 : V4L2_IN_ST_NO_SIGNAL;
1205         }
1206         switch (dev->pid) {
1207         case 0x2255:
1208         default:
1209                 strlcpy(inp->name, "Composite", sizeof(inp->name));
1210                 break;
1211         case 0x2257:
1212                 strlcpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video",
1213                         sizeof(inp->name));
1214                 break;
1215         }
1216         return 0;
1217 }
1218
1219 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1220 {
1221         *i = 0;
1222         return 0;
1223 }
1224 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1225 {
1226         if (i > 0)
1227                 return -EINVAL;
1228         return 0;
1229 }
1230
1231 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
1232 {
1233         struct s2255_vc *vc =
1234                 container_of(ctrl->handler, struct s2255_vc, hdl);
1235         struct s2255_mode mode;
1236         mode = vc->mode;
1237         /* update the mode to the corresponding value */
1238         switch (ctrl->id) {
1239         case V4L2_CID_BRIGHTNESS:
1240                 mode.bright = ctrl->val;
1241                 break;
1242         case V4L2_CID_CONTRAST:
1243                 mode.contrast = ctrl->val;
1244                 break;
1245         case V4L2_CID_HUE:
1246                 mode.hue = ctrl->val;
1247                 break;
1248         case V4L2_CID_SATURATION:
1249                 mode.saturation = ctrl->val;
1250                 break;
1251         case V4L2_CID_S2255_COLORFILTER:
1252                 mode.color &= ~MASK_INPUT_TYPE;
1253                 mode.color |= !ctrl->val << 16;
1254                 break;
1255         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1256                 vc->jpegqual = ctrl->val;
1257                 return 0;
1258         default:
1259                 return -EINVAL;
1260         }
1261         mode.restart = 0;
1262         /* set mode here.  Note: stream does not need restarted.
1263            some V4L programs restart stream unnecessarily
1264            after a s_crtl.
1265         */
1266         s2255_set_mode(vc, &mode);
1267         return 0;
1268 }
1269
1270 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1271                          struct v4l2_jpegcompression *jc)
1272 {
1273         struct s2255_vc *vc = video_drvdata(file);
1274
1275         memset(jc, 0, sizeof(*jc));
1276         jc->quality = vc->jpegqual;
1277         dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1278         return 0;
1279 }
1280
1281 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1282                          const struct v4l2_jpegcompression *jc)
1283 {
1284         struct s2255_vc *vc = video_drvdata(file);
1285
1286         if (jc->quality < 0 || jc->quality > 100)
1287                 return -EINVAL;
1288         v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality);
1289         dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1290         return 0;
1291 }
1292
1293 static int vidioc_g_parm(struct file *file, void *priv,
1294                          struct v4l2_streamparm *sp)
1295 {
1296         __u32 def_num, def_dem;
1297         struct s2255_vc *vc = video_drvdata(file);
1298
1299         if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1300                 return -EINVAL;
1301         sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1302         sp->parm.capture.capturemode = vc->cap_parm.capturemode;
1303         sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1304         def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1305         def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1306         sp->parm.capture.timeperframe.denominator = def_dem;
1307         switch (vc->mode.fdec) {
1308         default:
1309         case FDEC_1:
1310                 sp->parm.capture.timeperframe.numerator = def_num;
1311                 break;
1312         case FDEC_2:
1313                 sp->parm.capture.timeperframe.numerator = def_num * 2;
1314                 break;
1315         case FDEC_3:
1316                 sp->parm.capture.timeperframe.numerator = def_num * 3;
1317                 break;
1318         case FDEC_5:
1319                 sp->parm.capture.timeperframe.numerator = def_num * 5;
1320                 break;
1321         }
1322         dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
1323                 __func__,
1324                 sp->parm.capture.capturemode,
1325                 sp->parm.capture.timeperframe.numerator,
1326                 sp->parm.capture.timeperframe.denominator);
1327         return 0;
1328 }
1329
1330 static int vidioc_s_parm(struct file *file, void *priv,
1331                          struct v4l2_streamparm *sp)
1332 {
1333         struct s2255_vc *vc = video_drvdata(file);
1334         struct s2255_mode mode;
1335         int fdec = FDEC_1;
1336         __u32 def_num, def_dem;
1337         if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1338                 return -EINVAL;
1339         mode = vc->mode;
1340         /* high quality capture mode requires a stream restart */
1341         if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode)
1342             && vb2_is_streaming(&vc->vb_vidq))
1343                 return -EBUSY;
1344         def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1345         def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1346         if (def_dem != sp->parm.capture.timeperframe.denominator)
1347                 sp->parm.capture.timeperframe.numerator = def_num;
1348         else if (sp->parm.capture.timeperframe.numerator <= def_num)
1349                 sp->parm.capture.timeperframe.numerator = def_num;
1350         else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1351                 sp->parm.capture.timeperframe.numerator = def_num * 2;
1352                 fdec = FDEC_2;
1353         } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1354                 sp->parm.capture.timeperframe.numerator = def_num * 3;
1355                 fdec = FDEC_3;
1356         } else {
1357                 sp->parm.capture.timeperframe.numerator = def_num * 5;
1358                 fdec = FDEC_5;
1359         }
1360         mode.fdec = fdec;
1361         sp->parm.capture.timeperframe.denominator = def_dem;
1362         sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1363         s2255_set_mode(vc, &mode);
1364         dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1365                 __func__,
1366                 sp->parm.capture.capturemode,
1367                 sp->parm.capture.timeperframe.numerator,
1368                 sp->parm.capture.timeperframe.denominator, fdec);
1369         return 0;
1370 }
1371
1372 #define NUM_SIZE_ENUMS 3
1373 static const struct v4l2_frmsize_discrete ntsc_sizes[] = {
1374         { 640, 480 },
1375         { 640, 240 },
1376         { 320, 240 },
1377 };
1378 static const struct v4l2_frmsize_discrete pal_sizes[] = {
1379         { 704, 576 },
1380         { 704, 288 },
1381         { 352, 288 },
1382 };
1383
1384 static int vidioc_enum_framesizes(struct file *file, void *priv,
1385                             struct v4l2_frmsizeenum *fe)
1386 {
1387         struct s2255_vc *vc = video_drvdata(file);
1388         int is_ntsc = vc->std & V4L2_STD_525_60;
1389         const struct s2255_fmt *fmt;
1390
1391         if (fe->index >= NUM_SIZE_ENUMS)
1392                 return -EINVAL;
1393
1394         fmt = format_by_fourcc(fe->pixel_format);
1395         if (fmt == NULL)
1396                 return -EINVAL;
1397         fe->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1398         fe->discrete = is_ntsc ?  ntsc_sizes[fe->index] : pal_sizes[fe->index];
1399         return 0;
1400 }
1401
1402 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1403                             struct v4l2_frmivalenum *fe)
1404 {
1405         struct s2255_vc *vc = video_drvdata(file);
1406         const struct s2255_fmt *fmt;
1407         const struct v4l2_frmsize_discrete *sizes;
1408         int is_ntsc = vc->std & V4L2_STD_525_60;
1409 #define NUM_FRAME_ENUMS 4
1410         int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1411         int i;
1412
1413         if (fe->index >= NUM_FRAME_ENUMS)
1414                 return -EINVAL;
1415
1416         fmt = format_by_fourcc(fe->pixel_format);
1417         if (fmt == NULL)
1418                 return -EINVAL;
1419
1420         sizes = is_ntsc ? ntsc_sizes : pal_sizes;
1421         for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++)
1422                 if (fe->width == sizes->width &&
1423                     fe->height == sizes->height)
1424                         break;
1425         if (i == NUM_SIZE_ENUMS)
1426                 return -EINVAL;
1427
1428         fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1429         fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1430         fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1431         dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
1432                 fe->discrete.numerator,
1433                 fe->discrete.denominator);
1434         return 0;
1435 }
1436
1437 static int s2255_open(struct file *file)
1438 {
1439         struct s2255_vc *vc = video_drvdata(file);
1440         struct s2255_dev *dev = vc->dev;
1441         int state;
1442         int rc = 0;
1443
1444         rc = v4l2_fh_open(file);
1445         if (rc != 0)
1446                 return rc;
1447
1448         dprintk(dev, 1, "s2255: %s\n", __func__);
1449         state = atomic_read(&dev->fw_data->fw_state);
1450         switch (state) {
1451         case S2255_FW_DISCONNECTING:
1452                 return -ENODEV;
1453         case S2255_FW_FAILED:
1454                 s2255_dev_err(&dev->udev->dev,
1455                         "firmware load failed. retrying.\n");
1456                 s2255_fwload_start(dev, 1);
1457                 wait_event_timeout(dev->fw_data->wait_fw,
1458                                    ((atomic_read(&dev->fw_data->fw_state)
1459                                      == S2255_FW_SUCCESS) ||
1460                                     (atomic_read(&dev->fw_data->fw_state)
1461                                      == S2255_FW_DISCONNECTING)),
1462                                    msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1463                 /* state may have changed, re-read */
1464                 state = atomic_read(&dev->fw_data->fw_state);
1465                 break;
1466         case S2255_FW_NOTLOADED:
1467         case S2255_FW_LOADED_DSPWAIT:
1468                 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1469                    driver loaded and then device immediately opened */
1470                 pr_info("%s waiting for firmware load\n", __func__);
1471                 wait_event_timeout(dev->fw_data->wait_fw,
1472                                    ((atomic_read(&dev->fw_data->fw_state)
1473                                      == S2255_FW_SUCCESS) ||
1474                                     (atomic_read(&dev->fw_data->fw_state)
1475                                      == S2255_FW_DISCONNECTING)),
1476                                    msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1477                 /* state may have changed, re-read */
1478                 state = atomic_read(&dev->fw_data->fw_state);
1479                 break;
1480         case S2255_FW_SUCCESS:
1481         default:
1482                 break;
1483         }
1484         /* state may have changed in above switch statement */
1485         switch (state) {
1486         case S2255_FW_SUCCESS:
1487                 break;
1488         case S2255_FW_FAILED:
1489                 pr_info("2255 firmware load failed.\n");
1490                 return -ENODEV;
1491         case S2255_FW_DISCONNECTING:
1492                 pr_info("%s: disconnecting\n", __func__);
1493                 return -ENODEV;
1494         case S2255_FW_LOADED_DSPWAIT:
1495         case S2255_FW_NOTLOADED:
1496                 pr_info("%s: firmware not loaded, please retry\n",
1497                         __func__);
1498                 /*
1499                  * Timeout on firmware load means device unusable.
1500                  * Set firmware failure state.
1501                  * On next s2255_open the firmware will be reloaded.
1502                  */
1503                 atomic_set(&dev->fw_data->fw_state,
1504                            S2255_FW_FAILED);
1505                 return -EAGAIN;
1506         default:
1507                 pr_info("%s: unknown state\n", __func__);
1508                 return -EFAULT;
1509         }
1510         if (!vc->configured) {
1511                 /* configure channel to default state */
1512                 vc->fmt = &formats[0];
1513                 s2255_set_mode(vc, &vc->mode);
1514                 vc->configured = 1;
1515         }
1516         return 0;
1517 }
1518
1519 static void s2255_destroy(struct s2255_dev *dev)
1520 {
1521         dprintk(dev, 1, "%s", __func__);
1522         /* board shutdown stops the read pipe if it is running */
1523         s2255_board_shutdown(dev);
1524         /* make sure firmware still not trying to load */
1525         del_timer(&dev->timer);  /* only started in .probe and .open */
1526         if (dev->fw_data->fw_urb) {
1527                 usb_kill_urb(dev->fw_data->fw_urb);
1528                 usb_free_urb(dev->fw_data->fw_urb);
1529                 dev->fw_data->fw_urb = NULL;
1530         }
1531         release_firmware(dev->fw_data->fw);
1532         kfree(dev->fw_data->pfw_data);
1533         kfree(dev->fw_data);
1534         /* reset the DSP so firmware can be reloaded next time */
1535         s2255_reset_dsppower(dev);
1536         mutex_destroy(&dev->lock);
1537         usb_put_dev(dev->udev);
1538         v4l2_device_unregister(&dev->v4l2_dev);
1539         kfree(dev->cmdbuf);
1540         kfree(dev);
1541 }
1542
1543 static const struct v4l2_file_operations s2255_fops_v4l = {
1544         .owner = THIS_MODULE,
1545         .open = s2255_open,
1546         .release = vb2_fop_release,
1547         .poll = vb2_fop_poll,
1548         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1549         .mmap = vb2_fop_mmap,
1550         .read = vb2_fop_read,
1551 };
1552
1553 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1554         .vidioc_querycap = vidioc_querycap,
1555         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1556         .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1557         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1558         .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1559         .vidioc_reqbufs = vb2_ioctl_reqbufs,
1560         .vidioc_querybuf = vb2_ioctl_querybuf,
1561         .vidioc_qbuf = vb2_ioctl_qbuf,
1562         .vidioc_dqbuf = vb2_ioctl_dqbuf,
1563         .vidioc_s_std = vidioc_s_std,
1564         .vidioc_g_std = vidioc_g_std,
1565         .vidioc_enum_input = vidioc_enum_input,
1566         .vidioc_g_input = vidioc_g_input,
1567         .vidioc_s_input = vidioc_s_input,
1568         .vidioc_streamon = vb2_ioctl_streamon,
1569         .vidioc_streamoff = vb2_ioctl_streamoff,
1570         .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1571         .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1572         .vidioc_s_parm = vidioc_s_parm,
1573         .vidioc_g_parm = vidioc_g_parm,
1574         .vidioc_enum_framesizes = vidioc_enum_framesizes,
1575         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1576         .vidioc_log_status  = v4l2_ctrl_log_status,
1577         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1578         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1579 };
1580
1581 static void s2255_video_device_release(struct video_device *vdev)
1582 {
1583         struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1584         struct s2255_vc *vc =
1585                 container_of(vdev, struct s2255_vc, vdev);
1586
1587         dprintk(dev, 4, "%s, chnls: %d\n", __func__,
1588                 atomic_read(&dev->num_channels));
1589
1590         v4l2_ctrl_handler_free(&vc->hdl);
1591
1592         if (atomic_dec_and_test(&dev->num_channels))
1593                 s2255_destroy(dev);
1594         return;
1595 }
1596
1597 static struct video_device template = {
1598         .name = "s2255v",
1599         .fops = &s2255_fops_v4l,
1600         .ioctl_ops = &s2255_ioctl_ops,
1601         .release = s2255_video_device_release,
1602         .tvnorms = S2255_NORMS,
1603 };
1604
1605 static const struct v4l2_ctrl_ops s2255_ctrl_ops = {
1606         .s_ctrl = s2255_s_ctrl,
1607 };
1608
1609 static const struct v4l2_ctrl_config color_filter_ctrl = {
1610         .ops = &s2255_ctrl_ops,
1611         .name = "Color Filter",
1612         .id = V4L2_CID_S2255_COLORFILTER,
1613         .type = V4L2_CTRL_TYPE_BOOLEAN,
1614         .max = 1,
1615         .step = 1,
1616         .def = 1,
1617 };
1618
1619 static int s2255_probe_v4l(struct s2255_dev *dev)
1620 {
1621         int ret;
1622         int i;
1623         int cur_nr = video_nr;
1624         struct s2255_vc *vc;
1625         struct vb2_queue *q;
1626
1627         ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1628         if (ret)
1629                 return ret;
1630         /* initialize all video 4 linux */
1631         /* register 4 video devices */
1632         for (i = 0; i < MAX_CHANNELS; i++) {
1633                 vc = &dev->vc[i];
1634                 INIT_LIST_HEAD(&vc->buf_list);
1635
1636                 v4l2_ctrl_handler_init(&vc->hdl, 6);
1637                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1638                                 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
1639                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1640                                 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
1641                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1642                                 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
1643                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1644                                 V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
1645                 vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl,
1646                                 &s2255_ctrl_ops,
1647                                 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1648                                 0, 100, 1, S2255_DEF_JPEG_QUAL);
1649                 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1650                     (dev->pid != 0x2257 || vc->idx <= 1))
1651                         v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl,
1652                                              NULL);
1653                 if (vc->hdl.error) {
1654                         ret = vc->hdl.error;
1655                         v4l2_ctrl_handler_free(&vc->hdl);
1656                         dev_err(&dev->udev->dev, "couldn't register control\n");
1657                         break;
1658                 }
1659                 q = &vc->vb_vidq;
1660                 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1661                 q->io_modes = VB2_MMAP | VB2_READ | VB2_USERPTR;
1662                 q->drv_priv = vc;
1663                 q->lock = &vc->vb_lock;
1664                 q->buf_struct_size = sizeof(struct s2255_buffer);
1665                 q->mem_ops = &vb2_vmalloc_memops;
1666                 q->ops = &s2255_video_qops;
1667                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1668                 ret = vb2_queue_init(q);
1669                 if (ret != 0) {
1670                         dev_err(&dev->udev->dev,
1671                                 "%s vb2_queue_init 0x%x\n", __func__, ret);
1672                         break;
1673                 }
1674                 /* register video devices */
1675                 vc->vdev = template;
1676                 vc->vdev.queue = q;
1677                 vc->vdev.ctrl_handler = &vc->hdl;
1678                 vc->vdev.lock = &dev->lock;
1679                 vc->vdev.v4l2_dev = &dev->v4l2_dev;
1680                 set_bit(V4L2_FL_USE_FH_PRIO, &vc->vdev.flags);
1681                 video_set_drvdata(&vc->vdev, vc);
1682                 if (video_nr == -1)
1683                         ret = video_register_device(&vc->vdev,
1684                                                     VFL_TYPE_GRABBER,
1685                                                     video_nr);
1686                 else
1687                         ret = video_register_device(&vc->vdev,
1688                                                     VFL_TYPE_GRABBER,
1689                                                     cur_nr + i);
1690
1691                 if (ret) {
1692                         dev_err(&dev->udev->dev,
1693                                 "failed to register video device!\n");
1694                         break;
1695                 }
1696                 atomic_inc(&dev->num_channels);
1697                 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1698                           video_device_node_name(&vc->vdev));
1699
1700         }
1701         pr_info("Sensoray 2255 V4L driver Revision: %s\n",
1702                 S2255_VERSION);
1703         /* if no channels registered, return error and probe will fail*/
1704         if (atomic_read(&dev->num_channels) == 0) {
1705                 v4l2_device_unregister(&dev->v4l2_dev);
1706                 return ret;
1707         }
1708         if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1709                 pr_warn("s2255: Not all channels available.\n");
1710         return 0;
1711 }
1712
1713 /* this function moves the usb stream read pipe data
1714  * into the system buffers.
1715  * returns 0 on success, EAGAIN if more data to process( call this
1716  * function again).
1717  *
1718  * Received frame structure:
1719  * bytes 0-3:  marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1720  * bytes 4-7:  channel: 0-3
1721  * bytes 8-11: payload size:  size of the frame
1722  * bytes 12-payloadsize+12:  frame data
1723  */
1724 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1725 {
1726         char *pdest;
1727         u32 offset = 0;
1728         int bframe = 0;
1729         char *psrc;
1730         unsigned long copy_size;
1731         unsigned long size;
1732         s32 idx = -1;
1733         struct s2255_framei *frm;
1734         unsigned char *pdata;
1735         struct s2255_vc *vc;
1736         dprintk(dev, 100, "buffer to user\n");
1737         vc = &dev->vc[dev->cc];
1738         idx = vc->cur_frame;
1739         frm = &vc->buffer.frame[idx];
1740         if (frm->ulState == S2255_READ_IDLE) {
1741                 int jj;
1742                 unsigned int cc;
1743                 __le32 *pdword; /*data from dsp is little endian */
1744                 int payload;
1745                 /* search for marker codes */
1746                 pdata = (unsigned char *)pipe_info->transfer_buffer;
1747                 pdword = (__le32 *)pdata;
1748                 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1749                         switch (*pdword) {
1750                         case S2255_MARKER_FRAME:
1751                                 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n",
1752                                         jj, pdata[0], pdata[1]);
1753                                 offset = jj + PREFIX_SIZE;
1754                                 bframe = 1;
1755                                 cc = le32_to_cpu(pdword[1]);
1756                                 if (cc >= MAX_CHANNELS) {
1757                                         dprintk(dev, 0,
1758                                                 "bad channel\n");
1759                                         return -EINVAL;
1760                                 }
1761                                 /* reverse it */
1762                                 dev->cc = G_chnmap[cc];
1763                                 vc = &dev->vc[dev->cc];
1764                                 payload =  le32_to_cpu(pdword[3]);
1765                                 if (payload > vc->req_image_size) {
1766                                         vc->bad_payload++;
1767                                         /* discard the bad frame */
1768                                         return -EINVAL;
1769                                 }
1770                                 vc->pkt_size = payload;
1771                                 vc->jpg_size = le32_to_cpu(pdword[4]);
1772                                 break;
1773                         case S2255_MARKER_RESPONSE:
1774
1775                                 pdata += DEF_USB_BLOCK;
1776                                 jj += DEF_USB_BLOCK;
1777                                 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
1778                                         break;
1779                                 cc = G_chnmap[le32_to_cpu(pdword[1])];
1780                                 if (cc >= MAX_CHANNELS)
1781                                         break;
1782                                 vc = &dev->vc[cc];
1783                                 switch (pdword[2]) {
1784                                 case S2255_RESPONSE_SETMODE:
1785                                         /* check if channel valid */
1786                                         /* set mode ready */
1787                                         vc->setmode_ready = 1;
1788                                         wake_up(&vc->wait_setmode);
1789                                         dprintk(dev, 5, "setmode rdy %d\n", cc);
1790                                         break;
1791                                 case S2255_RESPONSE_FW:
1792                                         dev->chn_ready |= (1 << cc);
1793                                         if ((dev->chn_ready & 0x0f) != 0x0f)
1794                                                 break;
1795                                         /* all channels ready */
1796                                         pr_info("s2255: fw loaded\n");
1797                                         atomic_set(&dev->fw_data->fw_state,
1798                                                    S2255_FW_SUCCESS);
1799                                         wake_up(&dev->fw_data->wait_fw);
1800                                         break;
1801                                 case S2255_RESPONSE_STATUS:
1802                                         vc->vidstatus = le32_to_cpu(pdword[3]);
1803                                         vc->vidstatus_ready = 1;
1804                                         wake_up(&vc->wait_vidstatus);
1805                                         dprintk(dev, 5, "vstat %x chan %d\n",
1806                                                 le32_to_cpu(pdword[3]), cc);
1807                                         break;
1808                                 default:
1809                                         pr_info("s2255 unknown resp\n");
1810                                 }
1811                         default:
1812                                 pdata++;
1813                                 break;
1814                         }
1815                         if (bframe)
1816                                 break;
1817                 } /* for */
1818                 if (!bframe)
1819                         return -EINVAL;
1820         }
1821         vc = &dev->vc[dev->cc];
1822         idx = vc->cur_frame;
1823         frm = &vc->buffer.frame[idx];
1824         /* search done.  now find out if should be acquiring on this channel */
1825         if (!vb2_is_streaming(&vc->vb_vidq)) {
1826                 /* we found a frame, but this channel is turned off */
1827                 frm->ulState = S2255_READ_IDLE;
1828                 return -EINVAL;
1829         }
1830
1831         if (frm->ulState == S2255_READ_IDLE) {
1832                 frm->ulState = S2255_READ_FRAME;
1833                 frm->cur_size = 0;
1834         }
1835
1836         /* skip the marker 512 bytes (and offset if out of sync) */
1837         psrc = (u8 *)pipe_info->transfer_buffer + offset;
1838
1839
1840         if (frm->lpvbits == NULL) {
1841                 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1842                         frm, dev, dev->cc, idx);
1843                 return -ENOMEM;
1844         }
1845
1846         pdest = frm->lpvbits + frm->cur_size;
1847
1848         copy_size = (pipe_info->cur_transfer_size - offset);
1849
1850         size = vc->pkt_size - PREFIX_SIZE;
1851
1852         /* sanity check on pdest */
1853         if ((copy_size + frm->cur_size) < vc->req_image_size)
1854                 memcpy(pdest, psrc, copy_size);
1855
1856         frm->cur_size += copy_size;
1857         dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size);
1858
1859         if (frm->cur_size >= size) {
1860                 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
1861                         dev->cc, idx);
1862                 vc->last_frame = vc->cur_frame;
1863                 vc->cur_frame++;
1864                 /* end of system frame ring buffer, start at zero */
1865                 if ((vc->cur_frame == SYS_FRAMES) ||
1866                     (vc->cur_frame == vc->buffer.dwFrames))
1867                         vc->cur_frame = 0;
1868                 /* frame ready */
1869                 if (vb2_is_streaming(&vc->vb_vidq))
1870                         s2255_got_frame(vc, vc->jpg_size);
1871                 vc->frame_count++;
1872                 frm->ulState = S2255_READ_IDLE;
1873                 frm->cur_size = 0;
1874
1875         }
1876         /* done successfully */
1877         return 0;
1878 }
1879
1880 static void s2255_read_video_callback(struct s2255_dev *dev,
1881                                       struct s2255_pipeinfo *pipe_info)
1882 {
1883         int res;
1884         dprintk(dev, 50, "callback read video\n");
1885
1886         if (dev->cc >= MAX_CHANNELS) {
1887                 dev->cc = 0;
1888                 dev_err(&dev->udev->dev, "invalid channel\n");
1889                 return;
1890         }
1891         /* otherwise copy to the system buffers */
1892         res = save_frame(dev, pipe_info);
1893         if (res != 0)
1894                 dprintk(dev, 4, "s2255: read callback failed\n");
1895
1896         dprintk(dev, 50, "callback read video done\n");
1897         return;
1898 }
1899
1900 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1901                              u16 Index, u16 Value, void *TransferBuffer,
1902                              s32 TransferBufferLength, int bOut)
1903 {
1904         int r;
1905         if (!bOut) {
1906                 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1907                                     Request,
1908                                     USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1909                                     USB_DIR_IN,
1910                                     Value, Index, TransferBuffer,
1911                                     TransferBufferLength, HZ * 5);
1912         } else {
1913                 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1914                                     Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1915                                     Value, Index, TransferBuffer,
1916                                     TransferBufferLength, HZ * 5);
1917         }
1918         return r;
1919 }
1920
1921 /*
1922  * retrieve FX2 firmware version. future use.
1923  * @param dev pointer to device extension
1924  * @return -1 for fail, else returns firmware version as an int(16 bits)
1925  */
1926 static int s2255_get_fx2fw(struct s2255_dev *dev)
1927 {
1928         int fw;
1929         int ret;
1930         unsigned char transBuffer[64];
1931         ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
1932                                S2255_VR_IN);
1933         if (ret < 0)
1934                 dprintk(dev, 2, "get fw error: %x\n", ret);
1935         fw = transBuffer[0] + (transBuffer[1] << 8);
1936         dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
1937         return fw;
1938 }
1939
1940 /*
1941  * Create the system ring buffer to copy frames into from the
1942  * usb read pipe.
1943  */
1944 static int s2255_create_sys_buffers(struct s2255_vc *vc)
1945 {
1946         unsigned long i;
1947         unsigned long reqsize;
1948         vc->buffer.dwFrames = SYS_FRAMES;
1949         /* always allocate maximum size(PAL) for system buffers */
1950         reqsize = SYS_FRAMES_MAXSIZE;
1951
1952         if (reqsize > SYS_FRAMES_MAXSIZE)
1953                 reqsize = SYS_FRAMES_MAXSIZE;
1954
1955         for (i = 0; i < SYS_FRAMES; i++) {
1956                 /* allocate the frames */
1957                 vc->buffer.frame[i].lpvbits = vmalloc(reqsize);
1958                 vc->buffer.frame[i].size = reqsize;
1959                 if (vc->buffer.frame[i].lpvbits == NULL) {
1960                         pr_info("out of memory.  using less frames\n");
1961                         vc->buffer.dwFrames = i;
1962                         break;
1963                 }
1964         }
1965
1966         /* make sure internal states are set */
1967         for (i = 0; i < SYS_FRAMES; i++) {
1968                 vc->buffer.frame[i].ulState = 0;
1969                 vc->buffer.frame[i].cur_size = 0;
1970         }
1971
1972         vc->cur_frame = 0;
1973         vc->last_frame = -1;
1974         return 0;
1975 }
1976
1977 static int s2255_release_sys_buffers(struct s2255_vc *vc)
1978 {
1979         unsigned long i;
1980         for (i = 0; i < SYS_FRAMES; i++) {
1981                 if (vc->buffer.frame[i].lpvbits)
1982                         vfree(vc->buffer.frame[i].lpvbits);
1983                 vc->buffer.frame[i].lpvbits = NULL;
1984         }
1985         return 0;
1986 }
1987
1988 static int s2255_board_init(struct s2255_dev *dev)
1989 {
1990         struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
1991         int fw_ver;
1992         int j;
1993         struct s2255_pipeinfo *pipe = &dev->pipe;
1994         dprintk(dev, 4, "board init: %p", dev);
1995         memset(pipe, 0, sizeof(*pipe));
1996         pipe->dev = dev;
1997         pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
1998         pipe->max_transfer_size = S2255_USB_XFER_SIZE;
1999
2000         pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2001                                         GFP_KERNEL);
2002         if (pipe->transfer_buffer == NULL) {
2003                 dprintk(dev, 1, "out of memory!\n");
2004                 return -ENOMEM;
2005         }
2006         /* query the firmware */
2007         fw_ver = s2255_get_fx2fw(dev);
2008
2009         pr_info("s2255: usb firmware version %d.%d\n",
2010                 (fw_ver >> 8) & 0xff,
2011                 fw_ver & 0xff);
2012
2013         if (fw_ver < S2255_CUR_USB_FWVER)
2014                 pr_info("s2255: newer USB firmware available\n");
2015
2016         for (j = 0; j < MAX_CHANNELS; j++) {
2017                 struct s2255_vc *vc = &dev->vc[j];
2018                 vc->mode = mode_def;
2019                 if (dev->pid == 0x2257 && j > 1)
2020                         vc->mode.color |= (1 << 16);
2021                 vc->jpegqual = S2255_DEF_JPEG_QUAL;
2022                 vc->width = LINE_SZ_4CIFS_NTSC;
2023                 vc->height = NUM_LINES_4CIFS_NTSC * 2;
2024                 vc->std = V4L2_STD_NTSC_M;
2025                 vc->fmt = &formats[0];
2026                 vc->mode.restart = 1;
2027                 vc->req_image_size = get_transfer_size(&mode_def);
2028                 vc->frame_count = 0;
2029                 /* create the system buffers */
2030                 s2255_create_sys_buffers(vc);
2031         }
2032         /* start read pipe */
2033         s2255_start_readpipe(dev);
2034         dprintk(dev, 1, "%s: success\n", __func__);
2035         return 0;
2036 }
2037
2038 static int s2255_board_shutdown(struct s2255_dev *dev)
2039 {
2040         u32 i;
2041         dprintk(dev, 1, "%s: dev: %p", __func__,  dev);
2042
2043         for (i = 0; i < MAX_CHANNELS; i++) {
2044                 if (vb2_is_streaming(&dev->vc[i].vb_vidq))
2045                         s2255_stop_acquire(&dev->vc[i]);
2046         }
2047         s2255_stop_readpipe(dev);
2048         for (i = 0; i < MAX_CHANNELS; i++)
2049                 s2255_release_sys_buffers(&dev->vc[i]);
2050         /* release transfer buffer */
2051         kfree(dev->pipe.transfer_buffer);
2052         return 0;
2053 }
2054
2055 static void read_pipe_completion(struct urb *purb)
2056 {
2057         struct s2255_pipeinfo *pipe_info;
2058         struct s2255_dev *dev;
2059         int status;
2060         int pipe;
2061         pipe_info = purb->context;
2062         if (pipe_info == NULL) {
2063                 dev_err(&purb->dev->dev, "no context!\n");
2064                 return;
2065         }
2066         dev = pipe_info->dev;
2067         if (dev == NULL) {
2068                 dev_err(&purb->dev->dev, "no context!\n");
2069                 return;
2070         }
2071         status = purb->status;
2072         /* if shutting down, do not resubmit, exit immediately */
2073         if (status == -ESHUTDOWN) {
2074                 dprintk(dev, 2, "%s: err shutdown\n", __func__);
2075                 pipe_info->err_count++;
2076                 return;
2077         }
2078
2079         if (pipe_info->state == 0) {
2080                 dprintk(dev, 2, "%s: exiting USB pipe", __func__);
2081                 return;
2082         }
2083
2084         if (status == 0)
2085                 s2255_read_video_callback(dev, pipe_info);
2086         else {
2087                 pipe_info->err_count++;
2088                 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status);
2089         }
2090
2091         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2092         /* reuse urb */
2093         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2094                           pipe,
2095                           pipe_info->transfer_buffer,
2096                           pipe_info->cur_transfer_size,
2097                           read_pipe_completion, pipe_info);
2098
2099         if (pipe_info->state != 0) {
2100                 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC))
2101                         dev_err(&dev->udev->dev, "error submitting urb\n");
2102         } else {
2103                 dprintk(dev, 2, "%s :complete state 0\n", __func__);
2104         }
2105         return;
2106 }
2107
2108 static int s2255_start_readpipe(struct s2255_dev *dev)
2109 {
2110         int pipe;
2111         int retval;
2112         struct s2255_pipeinfo *pipe_info = &dev->pipe;
2113         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2114         dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint);
2115         pipe_info->state = 1;
2116         pipe_info->err_count = 0;
2117         pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2118         if (!pipe_info->stream_urb) {
2119                 dev_err(&dev->udev->dev,
2120                         "ReadStream: Unable to alloc URB\n");
2121                 return -ENOMEM;
2122         }
2123         /* transfer buffer allocated in board_init */
2124         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2125                           pipe,
2126                           pipe_info->transfer_buffer,
2127                           pipe_info->cur_transfer_size,
2128                           read_pipe_completion, pipe_info);
2129         retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2130         if (retval) {
2131                 pr_err("s2255: start read pipe failed\n");
2132                 return retval;
2133         }
2134         return 0;
2135 }
2136
2137 /* starts acquisition process */
2138 static int s2255_start_acquire(struct s2255_vc *vc)
2139 {
2140         int res;
2141         unsigned long chn_rev;
2142         int j;
2143         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2144         __le32 *buffer = dev->cmdbuf;
2145
2146         mutex_lock(&dev->cmdlock);
2147         chn_rev = G_chnmap[vc->idx];
2148         vc->last_frame = -1;
2149         vc->bad_payload = 0;
2150         vc->cur_frame = 0;
2151         for (j = 0; j < SYS_FRAMES; j++) {
2152                 vc->buffer.frame[j].ulState = 0;
2153                 vc->buffer.frame[j].cur_size = 0;
2154         }
2155
2156         /* send the start command */
2157         buffer[0] = IN_DATA_TOKEN;
2158         buffer[1] = (__le32) cpu_to_le32(chn_rev);
2159         buffer[2] = CMD_START;
2160         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2161         if (res != 0)
2162                 dev_err(&dev->udev->dev, "CMD_START error\n");
2163
2164         dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
2165         mutex_unlock(&dev->cmdlock);
2166         return res;
2167 }
2168
2169 static int s2255_stop_acquire(struct s2255_vc *vc)
2170 {
2171         int res;
2172         unsigned long chn_rev;
2173         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2174         __le32 *buffer = dev->cmdbuf;
2175
2176         mutex_lock(&dev->cmdlock);
2177         chn_rev = G_chnmap[vc->idx];
2178         /* send the stop command */
2179         buffer[0] = IN_DATA_TOKEN;
2180         buffer[1] = (__le32) cpu_to_le32(chn_rev);
2181         buffer[2] = CMD_STOP;
2182
2183         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2184         if (res != 0)
2185                 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2186
2187         dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
2188         mutex_unlock(&dev->cmdlock);
2189         return res;
2190 }
2191
2192 static void s2255_stop_readpipe(struct s2255_dev *dev)
2193 {
2194         struct s2255_pipeinfo *pipe = &dev->pipe;
2195
2196         pipe->state = 0;
2197         if (pipe->stream_urb) {
2198                 /* cancel urb */
2199                 usb_kill_urb(pipe->stream_urb);
2200                 usb_free_urb(pipe->stream_urb);
2201                 pipe->stream_urb = NULL;
2202         }
2203         dprintk(dev, 4, "%s", __func__);
2204         return;
2205 }
2206
2207 static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2208 {
2209         if (reset)
2210                 s2255_reset_dsppower(dev);
2211         dev->fw_data->fw_size = dev->fw_data->fw->size;
2212         atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2213         memcpy(dev->fw_data->pfw_data,
2214                dev->fw_data->fw->data, CHUNK_SIZE);
2215         dev->fw_data->fw_loaded = CHUNK_SIZE;
2216         usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2217                           usb_sndbulkpipe(dev->udev, 2),
2218                           dev->fw_data->pfw_data,
2219                           CHUNK_SIZE, s2255_fwchunk_complete,
2220                           dev->fw_data);
2221         mod_timer(&dev->timer, jiffies + HZ);
2222 }
2223
2224 /* standard usb probe function */
2225 static int s2255_probe(struct usb_interface *interface,
2226                        const struct usb_device_id *id)
2227 {
2228         struct s2255_dev *dev = NULL;
2229         struct usb_host_interface *iface_desc;
2230         struct usb_endpoint_descriptor *endpoint;
2231         int i;
2232         int retval = -ENOMEM;
2233         __le32 *pdata;
2234         int fw_size;
2235
2236         /* allocate memory for our device state and initialize it to zero */
2237         dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2238         if (dev == NULL) {
2239                 s2255_dev_err(&interface->dev, "out of memory\n");
2240                 return -ENOMEM;
2241         }
2242
2243         dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL);
2244         if (dev->cmdbuf == NULL) {
2245                 s2255_dev_err(&interface->dev, "out of memory\n");
2246                 return -ENOMEM;
2247         }
2248
2249         atomic_set(&dev->num_channels, 0);
2250         dev->pid = le16_to_cpu(id->idProduct);
2251         dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2252         if (!dev->fw_data)
2253                 goto errorFWDATA1;
2254         mutex_init(&dev->lock);
2255         mutex_init(&dev->cmdlock);
2256         /* grab usb_device and save it */
2257         dev->udev = usb_get_dev(interface_to_usbdev(interface));
2258         if (dev->udev == NULL) {
2259                 dev_err(&interface->dev, "null usb device\n");
2260                 retval = -ENODEV;
2261                 goto errorUDEV;
2262         }
2263         dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n",
2264                 dev, dev->udev, interface);
2265         dev->interface = interface;
2266         /* set up the endpoint information  */
2267         iface_desc = interface->cur_altsetting;
2268         dev_dbg(&interface->dev, "num EP: %d\n",
2269                 iface_desc->desc.bNumEndpoints);
2270         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2271                 endpoint = &iface_desc->endpoint[i].desc;
2272                 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2273                         /* we found the bulk in endpoint */
2274                         dev->read_endpoint = endpoint->bEndpointAddress;
2275                 }
2276         }
2277
2278         if (!dev->read_endpoint) {
2279                 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2280                 goto errorEP;
2281         }
2282         init_timer(&dev->timer);
2283         dev->timer.function = s2255_timer;
2284         dev->timer.data = (unsigned long)dev->fw_data;
2285         init_waitqueue_head(&dev->fw_data->wait_fw);
2286         for (i = 0; i < MAX_CHANNELS; i++) {
2287                 struct s2255_vc *vc = &dev->vc[i];
2288                 vc->idx = i;
2289                 vc->dev = dev;
2290                 init_waitqueue_head(&vc->wait_setmode);
2291                 init_waitqueue_head(&vc->wait_vidstatus);
2292                 spin_lock_init(&vc->qlock);
2293                 mutex_init(&vc->vb_lock);
2294         }
2295
2296         dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2297         if (!dev->fw_data->fw_urb) {
2298                 dev_err(&interface->dev, "out of memory!\n");
2299                 goto errorFWURB;
2300         }
2301
2302         dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2303         if (!dev->fw_data->pfw_data) {
2304                 dev_err(&interface->dev, "out of memory!\n");
2305                 goto errorFWDATA2;
2306         }
2307         /* load the first chunk */
2308         if (request_firmware(&dev->fw_data->fw,
2309                              FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2310                 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
2311                 goto errorREQFW;
2312         }
2313         /* check the firmware is valid */
2314         fw_size = dev->fw_data->fw->size;
2315         pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2316
2317         if (*pdata != S2255_FW_MARKER) {
2318                 dev_err(&interface->dev, "Firmware invalid.\n");
2319                 retval = -ENODEV;
2320                 goto errorFWMARKER;
2321         } else {
2322                 /* make sure firmware is the latest */
2323                 __le32 *pRel;
2324                 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2325                 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel));
2326                 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2327                 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2328                         pr_info("s2255: f2255usb.bin out of date.\n");
2329                 if (dev->pid == 0x2257 &&
2330                                 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2331                         pr_warn("2257 needs firmware %d or above.\n",
2332                                 S2255_MIN_DSP_COLORFILTER);
2333         }
2334         usb_reset_device(dev->udev);
2335         /* load 2255 board specific */
2336         retval = s2255_board_init(dev);
2337         if (retval)
2338                 goto errorBOARDINIT;
2339         s2255_fwload_start(dev, 0);
2340         /* loads v4l specific */
2341         retval = s2255_probe_v4l(dev);
2342         if (retval)
2343                 goto errorBOARDINIT;
2344         dev_info(&interface->dev, "Sensoray 2255 detected\n");
2345         return 0;
2346 errorBOARDINIT:
2347         s2255_board_shutdown(dev);
2348 errorFWMARKER:
2349         release_firmware(dev->fw_data->fw);
2350 errorREQFW:
2351         kfree(dev->fw_data->pfw_data);
2352 errorFWDATA2:
2353         usb_free_urb(dev->fw_data->fw_urb);
2354 errorFWURB:
2355         del_timer(&dev->timer);
2356 errorEP:
2357         usb_put_dev(dev->udev);
2358 errorUDEV:
2359         kfree(dev->fw_data);
2360         mutex_destroy(&dev->lock);
2361 errorFWDATA1:
2362         kfree(dev->cmdbuf);
2363         kfree(dev);
2364         pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval);
2365         return retval;
2366 }
2367
2368 /* disconnect routine. when board is removed physically or with rmmod */
2369 static void s2255_disconnect(struct usb_interface *interface)
2370 {
2371         struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2372         int i;
2373         int channels = atomic_read(&dev->num_channels);
2374         mutex_lock(&dev->lock);
2375         v4l2_device_disconnect(&dev->v4l2_dev);
2376         mutex_unlock(&dev->lock);
2377         /*see comments in the uvc_driver.c usb disconnect function */
2378         atomic_inc(&dev->num_channels);
2379         /* unregister each video device. */
2380         for (i = 0; i < channels; i++)
2381                 video_unregister_device(&dev->vc[i].vdev);
2382         /* wake up any of our timers */
2383         atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2384         wake_up(&dev->fw_data->wait_fw);
2385         for (i = 0; i < MAX_CHANNELS; i++) {
2386                 dev->vc[i].setmode_ready = 1;
2387                 wake_up(&dev->vc[i].wait_setmode);
2388                 dev->vc[i].vidstatus_ready = 1;
2389                 wake_up(&dev->vc[i].wait_vidstatus);
2390         }
2391         if (atomic_dec_and_test(&dev->num_channels))
2392                 s2255_destroy(dev);
2393         dev_info(&interface->dev, "%s\n", __func__);
2394 }
2395
2396 static struct usb_driver s2255_driver = {
2397         .name = S2255_DRIVER_NAME,
2398         .probe = s2255_probe,
2399         .disconnect = s2255_disconnect,
2400         .id_table = s2255_table,
2401 };
2402
2403 module_usb_driver(s2255_driver);
2404
2405 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2406 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2407 MODULE_LICENSE("GPL");
2408 MODULE_VERSION(S2255_VERSION);
2409 MODULE_FIRMWARE(FIRMWARE_FILE_NAME);