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