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