git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/s2255drv.c

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