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