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