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