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