92dfb1845ff4f1623ab5b61bc6f2d92a39477e37
[linux-3.10.git] / 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         .type = VID_TYPE_CAPTURE,
1709         .fops = &s2255_fops_v4l,
1710         .ioctl_ops = &s2255_ioctl_ops,
1711         .minor = -1,
1712         .release = video_device_release,
1713         .tvnorms = S2255_NORMS,
1714         .current_norm = V4L2_STD_NTSC_M,
1715 };
1716
1717 static int s2255_probe_v4l(struct s2255_dev *dev)
1718 {
1719         int ret;
1720         int i;
1721         int cur_nr = video_nr;
1722
1723         /* initialize all video 4 linux */
1724         list_add_tail(&dev->s2255_devlist, &s2255_devlist);
1725         /* register 4 video devices */
1726         for (i = 0; i < MAX_CHANNELS; i++) {
1727                 INIT_LIST_HEAD(&dev->vidq[i].active);
1728                 dev->vidq[i].dev = dev;
1729                 dev->vidq[i].channel = i;
1730                 dev->vidq[i].kthread = NULL;
1731                 /* register 4 video devices */
1732                 dev->vdev[i] = video_device_alloc();
1733                 memcpy(dev->vdev[i], &template, sizeof(struct video_device));
1734                 dev->vdev[i]->parent = &dev->interface->dev;
1735                 if (video_nr == -1)
1736                         ret = video_register_device(dev->vdev[i],
1737                                                     VFL_TYPE_GRABBER,
1738                                                     video_nr);
1739                 else
1740                         ret = video_register_device(dev->vdev[i],
1741                                                     VFL_TYPE_GRABBER,
1742                                                     cur_nr + i);
1743                 dev->vdev[i]->priv = dev;
1744
1745                 if (ret != 0) {
1746                         dev_err(&dev->udev->dev,
1747                                 "failed to register video device!\n");
1748                         return ret;
1749                 }
1750         }
1751         printk(KERN_INFO "Sensoray 2255 V4L driver\n");
1752         return ret;
1753 }
1754
1755 static void s2255_exit_v4l(struct s2255_dev *dev)
1756 {
1757         struct list_head *list;
1758         int i;
1759         /* unregister the video devices */
1760         while (!list_empty(&s2255_devlist)) {
1761                 list = s2255_devlist.next;
1762                 list_del(list);
1763         }
1764         for (i = 0; i < MAX_CHANNELS; i++) {
1765                 if (-1 != dev->vdev[i]->minor)
1766                         video_unregister_device(dev->vdev[i]);
1767                 else
1768                         video_device_release(dev->vdev[i]);
1769         }
1770 }
1771
1772 /* this function moves the usb stream read pipe data
1773  * into the system buffers.
1774  * returns 0 on success, EAGAIN if more data to process( call this
1775  * function again).
1776  *
1777  * Received frame structure:
1778  * bytes 0-3:  marker : 0x2255DA4AL (FRAME_MARKER)
1779  * bytes 4-7:  channel: 0-3
1780  * bytes 8-11: payload size:  size of the frame
1781  * bytes 12-payloadsize+12:  frame data
1782  */
1783 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1784 {
1785         static int dbgsync; /* = 0; */
1786         char *pdest;
1787         u32 offset = 0;
1788         int bsync = 0;
1789         int btrunc = 0;
1790         char *psrc;
1791         unsigned long copy_size;
1792         unsigned long size;
1793         s32 idx = -1;
1794         struct s2255_framei *frm;
1795         unsigned char *pdata;
1796         unsigned long cur_size;
1797         int bsearch = 0;
1798         struct s2255_bufferi *buf;
1799         dprintk(100, "buffer to user\n");
1800
1801         idx = dev->cur_frame[dev->cc];
1802         buf = &dev->buffer[dev->cc];
1803         frm = &buf->frame[idx];
1804
1805         if (frm->ulState == 0) {
1806                 frm->ulState = 1;
1807                 frm->cur_size = 0;
1808                 bsearch = 1;
1809         } else if (frm->ulState == 2) {
1810                 /* system frame was not freed */
1811                 dprintk(2, "sys frame not free.  overrun ringbuf\n");
1812                 bsearch = 1;
1813                 frm->ulState = 1;
1814                 frm->cur_size = 0;
1815         }
1816
1817         if (bsearch) {
1818                 if (*(s32 *) pipe_info->transfer_buffer != FRAME_MARKER) {
1819                         u32 jj;
1820                         if (dbgsync == 0) {
1821                                 dprintk(3, "not synched, discarding all packets"
1822                                         "until marker\n");
1823
1824                                 dbgsync++;
1825                         }
1826                         pdata = (unsigned char *)pipe_info->transfer_buffer;
1827                         for (jj = 0; jj < (pipe_info->cur_transfer_size - 12);
1828                              jj++) {
1829                                 if (*(s32 *) pdata == FRAME_MARKER) {
1830                                         int cc;
1831                                         dprintk(3,
1832                                                 "found frame marker at offset:"
1833                                                 " %d [%x %x]\n", jj, pdata[0],
1834                                                 pdata[1]);
1835                                         offset = jj;
1836                                         bsync = 1;
1837                                         cc = *(u32 *) (pdata + sizeof(u32));
1838                                         if (cc >= MAX_CHANNELS) {
1839                                                 printk(KERN_ERR
1840                                                        "bad channel\n");
1841                                                 return -EINVAL;
1842                                         }
1843                                         /* reverse it */
1844                                         dev->cc = G_chnmap[cc];
1845                                         break;
1846                                 }
1847                                 pdata++;
1848                         }
1849                         if (bsync == 0)
1850                                 return -EINVAL;
1851                 } else {
1852                         u32 *pword;
1853                         u32 payload;
1854                         int cc;
1855                         dbgsync = 0;
1856                         bsync = 1;
1857                         pword = (u32 *) pipe_info->transfer_buffer;
1858                         cc = pword[1];
1859
1860                         if (cc >= MAX_CHANNELS) {
1861                                 printk("invalid channel found. "
1862                                         "throwing out data!\n");
1863                                 return -EINVAL;
1864                         }
1865                         dev->cc = G_chnmap[cc];
1866                         payload = pword[2];
1867                         if (payload != dev->req_image_size[dev->cc]) {
1868                                 dprintk(1, "[%d][%d]unexpected payload: %d"
1869                                         "required: %lu \n", cc, dev->cc,
1870                                         payload, dev->req_image_size[dev->cc]);
1871                                 dev->bad_payload[dev->cc]++;
1872                                 /* discard the bad frame */
1873                                 return -EINVAL;
1874                         }
1875
1876                 }
1877         }
1878         /* search done.  now find out if should be acquiring
1879            on this channel */
1880         if (!dev->b_acquire[dev->cc]) {
1881                 frm->ulState = 0;
1882                 return -EINVAL;
1883         }
1884
1885         idx = dev->cur_frame[dev->cc];
1886         frm = &dev->buffer[dev->cc].frame[idx];
1887
1888         if (frm->ulState == 0) {
1889                 frm->ulState = 1;
1890                 frm->cur_size = 0;
1891         } else if (frm->ulState == 2) {
1892                 /* system frame ring buffer overrun */
1893                 dprintk(2, "sys frame overrun.  overwriting frame %d %d\n",
1894                         dev->cc, idx);
1895                 frm->ulState = 1;
1896                 frm->cur_size = 0;
1897         }
1898
1899         if (bsync) {
1900                 /* skip the marker 512 bytes (and offset if out of sync) */
1901                 psrc = (u8 *)pipe_info->transfer_buffer + offset + PREFIX_SIZE;
1902         } else {
1903                 psrc = (u8 *)pipe_info->transfer_buffer;
1904         }
1905
1906         if (frm->lpvbits == NULL) {
1907                 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
1908                         frm, dev, dev->cc, idx);
1909                 return -ENOMEM;
1910         }
1911
1912         pdest = frm->lpvbits + frm->cur_size;
1913
1914         if (bsync) {
1915                 copy_size =
1916                     (pipe_info->cur_transfer_size - offset) - PREFIX_SIZE;
1917                 if (copy_size > pipe_info->cur_transfer_size) {
1918                         printk("invalid copy size, overflow!\n");
1919                         return -ENOMEM;
1920                 }
1921         } else {
1922                 copy_size = pipe_info->cur_transfer_size;
1923         }
1924
1925         cur_size = frm->cur_size;
1926         size = dev->req_image_size[dev->cc];
1927
1928         if ((copy_size + cur_size) > size) {
1929                 copy_size = size - cur_size;
1930                 btrunc = 1;
1931         }
1932
1933         memcpy(pdest, psrc, copy_size);
1934         cur_size += copy_size;
1935         frm->cur_size += copy_size;
1936         dprintk(50, "cur_size size %lu size %lu \n", cur_size, size);
1937
1938         if (cur_size >= (size - PREFIX_SIZE)) {
1939                 u32 cc = dev->cc;
1940                 frm->ulState = 2;
1941                 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
1942                         cc, idx);
1943                 dev->last_frame[cc] = dev->cur_frame[cc];
1944                 dev->cur_frame[cc]++;
1945                 /* end of system frame ring buffer, start at zero */
1946                 if ((dev->cur_frame[cc] == SYS_FRAMES) ||
1947                     (dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
1948                         dev->cur_frame[cc] = 0;
1949
1950                 /* signal the semaphore for this channel */
1951                 if (dev->b_acquire[cc])
1952                         s2255_got_frame(dev, cc);
1953                 dev->frame_count[cc]++;
1954         }
1955         /* frame was truncated */
1956         if (btrunc) {
1957                 /* return more data to process */
1958                 return EAGAIN;
1959         }
1960         /* done successfully */
1961         return 0;
1962 }
1963
1964 static void s2255_read_video_callback(struct s2255_dev *dev,
1965                                       struct s2255_pipeinfo *pipe_info)
1966 {
1967         int res;
1968         dprintk(50, "callback read video \n");
1969
1970         if (dev->cc >= MAX_CHANNELS) {
1971                 dev->cc = 0;
1972                 dev_err(&dev->udev->dev, "invalid channel\n");
1973                 return;
1974         }
1975         /* otherwise copy to the system buffers */
1976         res = save_frame(dev, pipe_info);
1977         if (res == EAGAIN)
1978                 save_frame(dev, pipe_info);
1979
1980         dprintk(50, "callback read video done\n");
1981         return;
1982 }
1983
1984 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1985                              u16 Index, u16 Value, void *TransferBuffer,
1986                              s32 TransferBufferLength, int bOut)
1987 {
1988         int r;
1989         if (!bOut) {
1990                 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1991                                     Request,
1992                                     USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1993                                     USB_DIR_IN,
1994                                     Value, Index, TransferBuffer,
1995                                     TransferBufferLength, HZ * 5);
1996         } else {
1997                 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1998                                     Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1999                                     Value, Index, TransferBuffer,
2000                                     TransferBufferLength, HZ * 5);
2001         }
2002         return r;
2003 }
2004
2005 /*
2006  * retrieve FX2 firmware version. future use.
2007  * @param dev pointer to device extension
2008  * @return -1 for fail, else returns firmware version as an int(16 bits)
2009  */
2010 static int s2255_get_fx2fw(struct s2255_dev *dev)
2011 {
2012         int fw;
2013         int ret;
2014         unsigned char transBuffer[64];
2015         ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2016                                S2255_VR_IN);
2017         if (ret < 0)
2018                 dprintk(2, "get fw error: %x\n", ret);
2019         fw = transBuffer[0] + (transBuffer[1] << 8);
2020         dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2021         return fw;
2022 }
2023
2024 /*
2025  * Create the system ring buffer to copy frames into from the
2026  * usb read pipe.
2027  */
2028 static int s2255_create_sys_buffers(struct s2255_dev *dev, unsigned long chn)
2029 {
2030         unsigned long i;
2031         unsigned long reqsize;
2032         dprintk(1, "create sys buffers\n");
2033         if (chn >= MAX_CHANNELS)
2034                 return -1;
2035
2036         dev->buffer[chn].dwFrames = SYS_FRAMES;
2037
2038         /* always allocate maximum size(PAL) for system buffers */
2039         reqsize = SYS_FRAMES_MAXSIZE;
2040
2041         if (reqsize > SYS_FRAMES_MAXSIZE)
2042                 reqsize = SYS_FRAMES_MAXSIZE;
2043
2044         for (i = 0; i < SYS_FRAMES; i++) {
2045                 /* allocate the frames */
2046                 dev->buffer[chn].frame[i].lpvbits = vmalloc(reqsize);
2047
2048                 dprintk(1, "valloc %p chan %lu, idx %lu, pdata %p\n",
2049                         &dev->buffer[chn].frame[i], chn, i,
2050                         dev->buffer[chn].frame[i].lpvbits);
2051                 dev->buffer[chn].frame[i].size = reqsize;
2052                 if (dev->buffer[chn].frame[i].lpvbits == NULL) {
2053                         printk(KERN_INFO "out of memory.  using less frames\n");
2054                         dev->buffer[chn].dwFrames = i;
2055                         break;
2056                 }
2057         }
2058
2059         /* make sure internal states are set */
2060         for (i = 0; i < SYS_FRAMES; i++) {
2061                 dev->buffer[chn].frame[i].ulState = 0;
2062                 dev->buffer[chn].frame[i].cur_size = 0;
2063         }
2064
2065         dev->cur_frame[chn] = 0;
2066         dev->last_frame[chn] = -1;
2067         return 0;
2068 }
2069
2070 static int s2255_release_sys_buffers(struct s2255_dev *dev,
2071                                      unsigned long channel)
2072 {
2073         unsigned long i;
2074         dprintk(1, "release sys buffers\n");
2075         for (i = 0; i < SYS_FRAMES; i++) {
2076                 if (dev->buffer[channel].frame[i].lpvbits) {
2077                         dprintk(1, "vfree %p\n",
2078                                 dev->buffer[channel].frame[i].lpvbits);
2079                         vfree(dev->buffer[channel].frame[i].lpvbits);
2080                 }
2081                 dev->buffer[channel].frame[i].lpvbits = NULL;
2082         }
2083         return 0;
2084 }
2085
2086 static int s2255_board_init(struct s2255_dev *dev)
2087 {
2088         int j;
2089         struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2090         int fw_ver;
2091         dprintk(4, "board init: %p", dev);
2092
2093         for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2094                 struct s2255_pipeinfo *pipe = &dev->pipes[j];
2095
2096                 memset(pipe, 0, sizeof(*pipe));
2097                 pipe->dev = dev;
2098                 pipe->cur_transfer_size = DEFAULT_PIPE_USBBLOCK;
2099                 pipe->max_transfer_size = MAX_PIPE_USBBLOCK;
2100
2101                 if (pipe->cur_transfer_size > pipe->max_transfer_size)
2102                         pipe->cur_transfer_size = pipe->max_transfer_size;
2103                 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2104                                                 GFP_KERNEL);
2105                 if (pipe->transfer_buffer == NULL) {
2106                         dprintk(1, "out of memory!\n");
2107                         return -ENOMEM;
2108                 }
2109
2110         }
2111
2112         /* query the firmware */
2113         fw_ver = s2255_get_fx2fw(dev);
2114
2115         printk(KERN_INFO "2255 usb firmware version %d \n", fw_ver);
2116         if (fw_ver < CUR_USB_FWVER)
2117                 err("usb firmware not up to date %d\n", fw_ver);
2118
2119         for (j = 0; j < MAX_CHANNELS; j++) {
2120                 dev->b_acquire[j] = 0;
2121                 dev->mode[j] = mode_def;
2122                 dev->cur_fmt[j] = &formats[0];
2123                 dev->mode[j].restart = 1;
2124                 dev->req_image_size[j] = get_transfer_size(&mode_def);
2125                 dev->frame_count[j] = 0;
2126                 /* create the system buffers */
2127                 s2255_create_sys_buffers(dev, j);
2128         }
2129         /* start read pipe */
2130         s2255_start_readpipe(dev);
2131
2132         dprintk(1, "S2255: board initialized\n");
2133         return 0;
2134 }
2135
2136 static int s2255_board_shutdown(struct s2255_dev *dev)
2137 {
2138         u32 i;
2139
2140         dprintk(1, "S2255: board shutdown: %p", dev);
2141
2142         for (i = 0; i < MAX_CHANNELS; i++) {
2143                 if (dev->b_acquire[i])
2144                         s2255_stop_acquire(dev, i);
2145         }
2146
2147         s2255_stop_readpipe(dev);
2148
2149         for (i = 0; i < MAX_CHANNELS; i++)
2150                 s2255_release_sys_buffers(dev, i);
2151
2152         /* release transfer buffers */
2153         for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2154                 struct s2255_pipeinfo *pipe = &dev->pipes[i];
2155                 kfree(pipe->transfer_buffer);
2156         }
2157         return 0;
2158 }
2159
2160 static void read_pipe_completion(struct urb *purb)
2161 {
2162         struct s2255_pipeinfo *pipe_info;
2163         struct s2255_dev *dev;
2164         int status;
2165         int pipe;
2166
2167         pipe_info = purb->context;
2168         dprintk(100, "read pipe completion %p, status %d\n", purb,
2169                 purb->status);
2170         if (pipe_info == NULL) {
2171                 err("no context !");
2172                 return;
2173         }
2174
2175         dev = pipe_info->dev;
2176         if (dev == NULL) {
2177                 err("no context !");
2178                 return;
2179         }
2180         status = purb->status;
2181         if (status != 0) {
2182                 dprintk(2, "read_pipe_completion: err\n");
2183                 return;
2184         }
2185
2186         if (pipe_info->state == 0) {
2187                 dprintk(2, "exiting USB pipe");
2188                 return;
2189         }
2190
2191         s2255_read_video_callback(dev, pipe_info);
2192
2193         pipe_info->err_count = 0;
2194         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2195         /* reuse urb */
2196         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2197                           pipe,
2198                           pipe_info->transfer_buffer,
2199                           pipe_info->cur_transfer_size,
2200                           read_pipe_completion, pipe_info);
2201
2202         if (pipe_info->state != 0) {
2203                 if (usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL)) {
2204                         dev_err(&dev->udev->dev, "error submitting urb\n");
2205                         usb_free_urb(pipe_info->stream_urb);
2206                 }
2207         } else {
2208                 dprintk(2, "read pipe complete state 0\n");
2209         }
2210         return;
2211 }
2212
2213 static int s2255_start_readpipe(struct s2255_dev *dev)
2214 {
2215         int pipe;
2216         int retval;
2217         int i;
2218         struct s2255_pipeinfo *pipe_info = dev->pipes;
2219         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2220         dprintk(2, "start pipe IN %d\n", dev->read_endpoint);
2221
2222         for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2223                 pipe_info->state = 1;
2224                 pipe_info->buf_index = (u32) i;
2225                 pipe_info->priority_set = 0;
2226                 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2227                 if (!pipe_info->stream_urb) {
2228                         dev_err(&dev->udev->dev,
2229                                 "ReadStream: Unable to alloc URB");
2230                         return -ENOMEM;
2231                 }
2232                 /* transfer buffer allocated in board_init */
2233                 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2234                                   pipe,
2235                                   pipe_info->transfer_buffer,
2236                                   pipe_info->cur_transfer_size,
2237                                   read_pipe_completion, pipe_info);
2238
2239                 pipe_info->urb_size = sizeof(pipe_info->stream_urb);
2240                 dprintk(4, "submitting URB %p\n", pipe_info->stream_urb);
2241                 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2242                 if (retval) {
2243                         printk(KERN_ERR "s2255: start read pipe failed\n");
2244                         return retval;
2245                 }
2246         }
2247
2248         return 0;
2249 }
2250
2251 /* starts acquisition process */
2252 static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn)
2253 {
2254         unsigned char *buffer;
2255         int res;
2256         unsigned long chn_rev;
2257         int j;
2258         if (chn >= MAX_CHANNELS) {
2259                 dprintk(2, "start acquire failed, bad channel %lu\n", chn);
2260                 return -1;
2261         }
2262
2263         chn_rev = G_chnmap[chn];
2264         dprintk(1, "S2255: start acquire %lu \n", chn);
2265
2266         buffer = kzalloc(512, GFP_KERNEL);
2267         if (buffer == NULL) {
2268                 dev_err(&dev->udev->dev, "out of mem\n");
2269                 return -ENOMEM;
2270         }
2271
2272         dev->last_frame[chn] = -1;
2273         dev->bad_payload[chn] = 0;
2274         dev->cur_frame[chn] = 0;
2275         for (j = 0; j < SYS_FRAMES; j++) {
2276                 dev->buffer[chn].frame[j].ulState = 0;
2277                 dev->buffer[chn].frame[j].cur_size = 0;
2278         }
2279
2280         /* send the start command */
2281         *(u32 *) buffer = IN_DATA_TOKEN;
2282         *((u32 *) buffer + 1) = (u32) chn_rev;
2283         *((u32 *) buffer + 2) = (u32) CMD_START;
2284         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2285         if (res != 0)
2286                 dev_err(&dev->udev->dev, "CMD_START error\n");
2287
2288         dprintk(2, "start acquire exit[%lu] %d \n", chn, res);
2289         kfree(buffer);
2290         return 0;
2291 }
2292
2293 static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
2294 {
2295         unsigned char *buffer;
2296         int res;
2297         unsigned long chn_rev;
2298
2299         if (chn >= MAX_CHANNELS) {
2300                 dprintk(2, "stop acquire failed, bad channel %lu\n", chn);
2301                 return -1;
2302         }
2303         chn_rev = G_chnmap[chn];
2304
2305         buffer = kzalloc(512, GFP_KERNEL);
2306         if (buffer == NULL) {
2307                 dev_err(&dev->udev->dev, "out of mem\n");
2308                 return -ENOMEM;
2309         }
2310
2311         /* send the stop command */
2312         dprintk(4, "stop acquire %lu\n", chn);
2313         *(u32 *) buffer = IN_DATA_TOKEN;
2314         *((u32 *) buffer + 1) = (u32) chn_rev;
2315         *((u32 *) buffer + 2) = CMD_STOP;
2316         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2317
2318         if (res != 0)
2319                 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2320
2321         dprintk(4, "stop acquire: releasing states \n");
2322
2323         kfree(buffer);
2324         dev->b_acquire[chn] = 0;
2325
2326         return 0;
2327 }
2328
2329 static void s2255_stop_readpipe(struct s2255_dev *dev)
2330 {
2331         int j;
2332
2333         if (dev == NULL) {
2334                 err("s2255: invalid device");
2335                 return;
2336         }
2337         dprintk(4, "stop read pipe\n");
2338         for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2339                 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2340                 if (pipe_info) {
2341                         if (pipe_info->state == 0)
2342                                 continue;
2343                         pipe_info->state = 0;
2344                         pipe_info->prev_state = 1;
2345
2346                 }
2347         }
2348
2349         for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2350                 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2351                 if (pipe_info->stream_urb) {
2352                         /* cancel urb */
2353                         usb_kill_urb(pipe_info->stream_urb);
2354                         usb_free_urb(pipe_info->stream_urb);
2355                         pipe_info->stream_urb = NULL;
2356                 }
2357         }
2358         dprintk(2, "s2255 stop read pipe: %d\n", j);
2359         return;
2360 }
2361
2362 static void s2255_fwload_start(struct s2255_dev *dev)
2363 {
2364         dev->fw_data->fw_size = dev->fw_data->fw->size;
2365         atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2366         memcpy(dev->fw_data->pfw_data,
2367                dev->fw_data->fw->data, CHUNK_SIZE);
2368         dev->fw_data->fw_loaded = CHUNK_SIZE;
2369         usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2370                           usb_sndbulkpipe(dev->udev, 2),
2371                           dev->fw_data->pfw_data,
2372                           CHUNK_SIZE, s2255_fwchunk_complete,
2373                           dev->fw_data);
2374         mod_timer(&dev->timer, jiffies + HZ);
2375 }
2376
2377 /* standard usb probe function */
2378 static int s2255_probe(struct usb_interface *interface,
2379                        const struct usb_device_id *id)
2380 {
2381         struct s2255_dev *dev = NULL;
2382         struct usb_host_interface *iface_desc;
2383         struct usb_endpoint_descriptor *endpoint;
2384         int i;
2385         int retval = -ENOMEM;
2386
2387         dprintk(2, "s2255: probe\n");
2388
2389         /* allocate memory for our device state and initialize it to zero */
2390         dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2391         if (dev == NULL) {
2392                 err("s2255: out of memory");
2393                 goto error;
2394         }
2395
2396         dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2397         if (!dev->fw_data)
2398                 goto error;
2399
2400         mutex_init(&dev->lock);
2401         mutex_init(&dev->open_lock);
2402
2403         /* grab usb_device and save it */
2404         dev->udev = usb_get_dev(interface_to_usbdev(interface));
2405         if (dev->udev == NULL) {
2406                 dev_err(&interface->dev, "null usb device\n");
2407                 retval = -ENODEV;
2408                 goto error;
2409         }
2410         kref_init(&dev->kref);
2411         dprintk(1, "dev: %p, kref: %p udev %p interface %p\n", dev, &dev->kref,
2412                 dev->udev, interface);
2413         dev->interface = interface;
2414         /* set up the endpoint information  */
2415         iface_desc = interface->cur_altsetting;
2416         dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2417         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2418                 endpoint = &iface_desc->endpoint[i].desc;
2419                 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2420                         /* we found the bulk in endpoint */
2421                         dev->read_endpoint = endpoint->bEndpointAddress;
2422                 }
2423         }
2424
2425         if (!dev->read_endpoint) {
2426                 dev_err(&interface->dev, "Could not find bulk-in endpoint");
2427                 goto error;
2428         }
2429
2430         /* set intfdata */
2431         usb_set_intfdata(interface, dev);
2432
2433         dprintk(100, "after intfdata %p\n", dev);
2434
2435         init_timer(&dev->timer);
2436         dev->timer.function = s2255_timer;
2437         dev->timer.data = (unsigned long)dev->fw_data;
2438
2439         init_waitqueue_head(&dev->fw_data->wait_fw);
2440
2441
2442         dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2443
2444         if (!dev->fw_data->fw_urb) {
2445                 dev_err(&interface->dev, "out of memory!\n");
2446                 goto error;
2447         }
2448         dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2449         if (!dev->fw_data->pfw_data) {
2450                 dev_err(&interface->dev, "out of memory!\n");
2451                 goto error;
2452         }
2453         /* load the first chunk */
2454         if (request_firmware(&dev->fw_data->fw,
2455                              FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2456                 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2457                 goto error;
2458         }
2459
2460         /* loads v4l specific */
2461         s2255_probe_v4l(dev);
2462         /* load 2255 board specific */
2463         s2255_board_init(dev);
2464
2465         dprintk(4, "before probe done %p\n", dev);
2466         spin_lock_init(&dev->slock);
2467
2468         s2255_fwload_start(dev);
2469         dev_info(&interface->dev, "Sensoray 2255 detected\n");
2470         return 0;
2471 error:
2472         return retval;
2473 }
2474
2475 /* disconnect routine. when board is removed physically or with rmmod */
2476 static void s2255_disconnect(struct usb_interface *interface)
2477 {
2478         struct s2255_dev *dev = NULL;
2479         dprintk(1, "s2255: disconnect interface %p\n", interface);
2480         dev = usb_get_intfdata(interface);
2481         if (dev) {
2482                 kref_put(&dev->kref, s2255_destroy);
2483                 dprintk(1, "s2255drv: disconnect\n");
2484                 dev_info(&interface->dev, "s2255usb now disconnected\n");
2485         }
2486         usb_set_intfdata(interface, NULL);
2487 }
2488
2489 static struct usb_driver s2255_driver = {
2490         .name = "s2255",
2491         .probe = s2255_probe,
2492         .disconnect = s2255_disconnect,
2493         .id_table = s2255_table,
2494 };
2495
2496 static int __init usb_s2255_init(void)
2497 {
2498         int result;
2499
2500         /* register this driver with the USB subsystem */
2501         result = usb_register(&s2255_driver);
2502
2503         if (result)
2504                 err("usb_register failed. Error number %d", result);
2505
2506         dprintk(2, "s2255_init: done\n");
2507         return result;
2508 }
2509
2510 static void __exit usb_s2255_exit(void)
2511 {
2512         usb_deregister(&s2255_driver);
2513 }
2514
2515 module_init(usb_s2255_init);
2516 module_exit(usb_s2255_exit);
2517
2518 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2519 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2520 MODULE_LICENSE("GPL");