Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/media/usb/s2255/s2255drv.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us