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