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