drivers/media/video/s2255drv.c

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