2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
4 * Copyright (C) 2007-2008 by Sensoray Company Inc.
7 * Some video buffer code based on vivi driver:
9 * Sensoray 2255 device supports 4 simultaneous channels.
10 * The channels are not "crossbar" inputs, they are physically
11 * attached to separate video decoders.
13 * Because of USB2.0 bandwidth limitations. There is only a
14 * certain amount of data which may be transferred at one time.
16 * Example maximum bandwidth utilization:
18 * -full size, color mode YUYV or YUV422P: 2 channels at once
20 * -full or half size Grey scale: all 4 channels at once
22 * -half size, color mode YUYV or YUV422P: all 4 channels at once
24 * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
26 * (TODO: Incorporate videodev2 frame rate(FR) enumeration,
27 * which is currently experimental.)
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.
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.
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.
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>
51 #include <media/videobuf-vmalloc.h>
52 #include <media/v4l2-common.h>
53 #include <media/v4l2-ioctl.h>
54 #include <linux/vmalloc.h>
55 #include <linux/usb.h>
57 #define FIRMWARE_FILE_NAME "f2255usb.bin"
61 /* default JPEG quality */
62 #define S2255_DEF_JPEG_QUAL 50
63 /* vendor request in */
65 /* vendor request out */
66 #define S2255_VR_OUT 1
68 #define S2255_VR_FW 0x30
69 /* USB endpoint number for configuring the device */
70 #define S2255_CONFIG_EP 2
71 /* maximum time for DSP to start responding after last FW word loaded(ms) */
72 #define S2255_DSP_BOOTTIME 800
73 /* maximum time to wait for firmware to load (ms) */
74 #define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
75 #define S2255_DEF_BUFS 16
76 #define S2255_SETMODE_TIMEOUT 500
77 #define MAX_CHANNELS 4
78 #define S2255_MARKER_FRAME 0x2255DA4AL
79 #define S2255_MARKER_RESPONSE 0x2255ACACL
80 #define S2255_USB_XFER_SIZE (16 * 1024)
81 #define MAX_CHANNELS 4
82 #define MAX_PIPE_BUFFERS 1
84 /* maximum size is PAL full size plus room for the marker header(s) */
85 #define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
86 #define DEF_USB_BLOCK S2255_USB_XFER_SIZE
87 #define LINE_SZ_4CIFS_NTSC 640
88 #define LINE_SZ_2CIFS_NTSC 640
89 #define LINE_SZ_1CIFS_NTSC 320
90 #define LINE_SZ_4CIFS_PAL 704
91 #define LINE_SZ_2CIFS_PAL 704
92 #define LINE_SZ_1CIFS_PAL 352
93 #define NUM_LINES_4CIFS_NTSC 240
94 #define NUM_LINES_2CIFS_NTSC 240
95 #define NUM_LINES_1CIFS_NTSC 240
96 #define NUM_LINES_4CIFS_PAL 288
97 #define NUM_LINES_2CIFS_PAL 288
98 #define NUM_LINES_1CIFS_PAL 288
99 #define LINE_SZ_DEF 640
100 #define NUM_LINES_DEF 240
103 /* predefined settings */
104 #define FORMAT_NTSC 1
107 #define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
108 #define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
109 #define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
111 #define COLOR_YUVPL 1 /* YUV planar */
112 #define COLOR_YUVPK 2 /* YUV packed */
113 #define COLOR_Y8 4 /* monochrome */
114 #define COLOR_JPG 5 /* JPEG */
115 #define MASK_COLOR 0xff
116 #define MASK_JPG_QUALITY 0xff00
118 /* frame decimation. Not implemented by V4L yet(experimental in V4L) */
119 #define FDEC_1 1 /* capture every frame. default */
120 #define FDEC_2 2 /* capture every 2nd frame */
121 #define FDEC_3 3 /* capture every 3rd frame */
122 #define FDEC_5 5 /* capture every 5th frame */
124 /*-------------------------------------------------------
125 * Default mode parameters.
126 *-------------------------------------------------------*/
127 #define DEF_SCALE SCALE_4CIFS
128 #define DEF_COLOR COLOR_YUVPL
129 #define DEF_FDEC FDEC_1
131 #define DEF_CONTRAST 0x5c
132 #define DEF_SATURATION 0x80
135 /* usb config commands */
136 #define IN_DATA_TOKEN 0x2255c0de
137 #define CMD_2255 0xc2255000
138 #define CMD_SET_MODE (CMD_2255 | 0x10)
139 #define CMD_START (CMD_2255 | 0x20)
140 #define CMD_STOP (CMD_2255 | 0x30)
141 #define CMD_STATUS (CMD_2255 | 0x40)
144 u32 format; /* input video format (NTSC, PAL) */
145 u32 scale; /* output video scale */
146 u32 color; /* output video color format */
147 u32 fdec; /* frame decimation */
148 u32 bright; /* brightness */
149 u32 contrast; /* contrast */
150 u32 saturation; /* saturation */
151 u32 hue; /* hue (NTSC only)*/
152 u32 single; /* capture 1 frame at a time (!=0), continuously (==0)*/
153 u32 usb_block; /* block size. should be 4096 of DEF_USB_BLOCK */
154 u32 restart; /* if DSP requires restart */
158 #define S2255_READ_IDLE 0
159 #define S2255_READ_FRAME 1
161 /* frame structure */
162 struct s2255_framei {
164 unsigned long ulState; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
165 void *lpvbits; /* image data */
166 unsigned long cur_size; /* current data copied to it */
169 /* image buffer structure */
170 struct s2255_bufferi {
171 unsigned long dwFrames; /* number of frames in buffer */
172 struct s2255_framei frame[SYS_FRAMES]; /* array of FRAME structures */
175 #define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
176 DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
177 DEF_HUE, 0, DEF_USB_BLOCK, 0}
179 struct s2255_dmaqueue {
180 struct list_head active;
181 /* thread for acquisition */
182 struct task_struct *kthread;
184 struct s2255_dev *dev;
188 /* for firmware loading, fw_state */
189 #define S2255_FW_NOTLOADED 0
190 #define S2255_FW_LOADED_DSPWAIT 1
191 #define S2255_FW_SUCCESS 2
192 #define S2255_FW_FAILED 3
193 #define S2255_FW_DISCONNECTING 4
195 #define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
196 /* 2255 read states */
197 #define S2255_READ_IDLE 0
198 #define S2255_READ_FRAME 1
205 wait_queue_head_t wait_fw;
206 const struct firmware *fw;
209 struct s2255_pipeinfo {
210 u32 max_transfer_size;
211 u32 cur_transfer_size;
218 void *dev; /* back pointer to s2255_dev struct*/
225 struct s2255_fmt; /*forward declaration */
229 int users[MAX_CHANNELS];
231 struct mutex open_lock;
232 int resources[MAX_CHANNELS];
233 struct usb_device *udev;
234 struct usb_interface *interface;
237 struct s2255_dmaqueue vidq[MAX_CHANNELS];
238 struct video_device *vdev[MAX_CHANNELS];
239 struct list_head s2255_devlist;
240 struct timer_list timer;
241 struct s2255_fw *fw_data;
244 struct s2255_pipeinfo pipes[MAX_PIPE_BUFFERS];
245 struct s2255_bufferi buffer[MAX_CHANNELS];
246 struct s2255_mode mode[MAX_CHANNELS];
247 /* jpeg compression */
248 struct v4l2_jpegcompression jc[MAX_CHANNELS];
249 const struct s2255_fmt *cur_fmt[MAX_CHANNELS];
250 int cur_frame[MAX_CHANNELS];
251 int last_frame[MAX_CHANNELS];
252 u32 cc; /* current channel */
253 int b_acquire[MAX_CHANNELS];
254 /* allocated image size */
255 unsigned long req_image_size[MAX_CHANNELS];
256 /* received packet size */
257 unsigned long pkt_size[MAX_CHANNELS];
258 int bad_payload[MAX_CHANNELS];
259 unsigned long frame_count[MAX_CHANNELS];
262 int jpg_size[MAX_CHANNELS];
263 /* if channel configured to default state */
264 int chn_configured[MAX_CHANNELS];
265 wait_queue_head_t wait_setmode[MAX_CHANNELS];
266 int setmode_ready[MAX_CHANNELS];
271 #define to_s2255_dev(d) container_of(d, struct s2255_dev, kref)
279 /* buffer for one video frame */
280 struct s2255_buffer {
281 /* common v4l buffer stuff -- must be first */
282 struct videobuf_buffer vb;
283 const struct s2255_fmt *fmt;
287 struct s2255_dev *dev;
288 const struct s2255_fmt *fmt;
291 struct videobuf_queue vb_vidq;
292 enum v4l2_buf_type type;
294 /* mode below is the desired mode.
295 mode in s2255_dev is the current mode that was last set */
296 struct s2255_mode mode;
297 int resources[MAX_CHANNELS];
300 #define CUR_USB_FWVER 774 /* current cypress EEPROM firmware version */
301 #define S2255_MAJOR_VERSION 1
302 #define S2255_MINOR_VERSION 13
303 #define S2255_RELEASE 0
304 #define S2255_VERSION KERNEL_VERSION(S2255_MAJOR_VERSION, \
305 S2255_MINOR_VERSION, \
309 #define USB_S2255_VENDOR_ID 0x1943
310 #define USB_S2255_PRODUCT_ID 0x2255
311 #define S2255_NORMS (V4L2_STD_PAL | V4L2_STD_NTSC)
312 /* frame prefix size (sent once every frame) */
313 #define PREFIX_SIZE 512
315 /* Channels on box are in reverse order */
316 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
318 static LIST_HEAD(s2255_devlist);
321 static int *s2255_debug = &debug;
323 static int s2255_start_readpipe(struct s2255_dev *dev);
324 static void s2255_stop_readpipe(struct s2255_dev *dev);
325 static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn);
326 static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn);
327 static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
328 int chn, int jpgsize);
329 static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
330 struct s2255_mode *mode);
331 static int s2255_board_shutdown(struct s2255_dev *dev);
332 static void s2255_exit_v4l(struct s2255_dev *dev);
333 static void s2255_fwload_start(struct s2255_dev *dev, int reset);
334 static void s2255_destroy(struct kref *kref);
335 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
336 u16 index, u16 value, void *buf,
337 s32 buf_len, int bOut);
339 /* dev_err macro with driver name */
340 #define S2255_DRIVER_NAME "s2255"
341 #define s2255_dev_err(dev, fmt, arg...) \
342 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
344 #define dprintk(level, fmt, arg...) \
346 if (*s2255_debug >= (level)) { \
347 printk(KERN_DEBUG S2255_DRIVER_NAME \
352 static struct usb_driver s2255_driver;
355 /* Declare static vars that will be used as parameters */
356 static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
358 /* start video number */
359 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
361 module_param(debug, int, 0644);
362 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
363 module_param(vid_limit, int, 0644);
364 MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)");
365 module_param(video_nr, int, 0644);
366 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
368 /* USB device table */
369 static struct usb_device_id s2255_table[] = {
370 {USB_DEVICE(USB_S2255_VENDOR_ID, USB_S2255_PRODUCT_ID)},
371 { } /* Terminating entry */
373 MODULE_DEVICE_TABLE(usb, s2255_table);
376 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
378 /* supported controls */
379 static struct v4l2_queryctrl s2255_qctrl[] = {
381 .id = V4L2_CID_BRIGHTNESS,
382 .type = V4L2_CTRL_TYPE_INTEGER,
383 .name = "Brightness",
390 .id = V4L2_CID_CONTRAST,
391 .type = V4L2_CTRL_TYPE_INTEGER,
396 .default_value = DEF_CONTRAST,
399 .id = V4L2_CID_SATURATION,
400 .type = V4L2_CTRL_TYPE_INTEGER,
401 .name = "Saturation",
405 .default_value = DEF_SATURATION,
409 .type = V4L2_CTRL_TYPE_INTEGER,
414 .default_value = DEF_HUE,
419 static int qctl_regs[ARRAY_SIZE(s2255_qctrl)];
422 static const struct s2255_fmt formats[] = {
424 .name = "4:2:2, planar, YUV422P",
425 .fourcc = V4L2_PIX_FMT_YUV422P,
429 .name = "4:2:2, packed, YUYV",
430 .fourcc = V4L2_PIX_FMT_YUYV,
434 .name = "4:2:2, packed, UYVY",
435 .fourcc = V4L2_PIX_FMT_UYVY,
439 .fourcc = V4L2_PIX_FMT_JPEG,
443 .fourcc = V4L2_PIX_FMT_GREY,
448 static int norm_maxw(struct video_device *vdev)
450 return (vdev->current_norm & V4L2_STD_NTSC) ?
451 LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
454 static int norm_maxh(struct video_device *vdev)
456 return (vdev->current_norm & V4L2_STD_NTSC) ?
457 (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
460 static int norm_minw(struct video_device *vdev)
462 return (vdev->current_norm & V4L2_STD_NTSC) ?
463 LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
466 static int norm_minh(struct video_device *vdev)
468 return (vdev->current_norm & V4L2_STD_NTSC) ?
469 (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
474 * TODO: fixme: move YUV reordering to hardware
475 * converts 2255 planar format to yuyv or uyvy
477 static void planar422p_to_yuv_packed(const unsigned char *in,
479 int width, int height,
485 unsigned long size = height * width;
487 pY = (unsigned char *)in;
488 pCr = (unsigned char *)in + height * width;
489 pCb = (unsigned char *)in + height * width + (height * width / 2);
490 for (i = 0; i < size * 2; i += 4) {
491 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
492 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
493 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
494 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
499 static void s2255_reset_dsppower(struct s2255_dev *dev)
501 s2255_vendor_req(dev, 0x40, 0x0b0b, 0x0b0b, NULL, 0, 1);
503 s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
507 /* kickstarts the firmware loading. from probe
509 static void s2255_timer(unsigned long user_data)
511 struct s2255_fw *data = (struct s2255_fw *)user_data;
512 dprintk(100, "s2255 timer\n");
513 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
514 printk(KERN_ERR "s2255: can't submit urb\n");
515 atomic_set(&data->fw_state, S2255_FW_FAILED);
516 /* wake up anything waiting for the firmware */
517 wake_up(&data->wait_fw);
523 /* this loads the firmware asynchronously.
524 Originally this was done synchroously in probe.
525 But it is better to load it asynchronously here than block
526 inside the probe function. Blocking inside probe affects boot time.
527 FW loading is triggered by the timer in the probe function
529 static void s2255_fwchunk_complete(struct urb *urb)
531 struct s2255_fw *data = urb->context;
532 struct usb_device *udev = urb->dev;
534 dprintk(100, "udev %p urb %p", udev, urb);
536 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
537 atomic_set(&data->fw_state, S2255_FW_FAILED);
538 /* wake up anything waiting for the firmware */
539 wake_up(&data->wait_fw);
542 if (data->fw_urb == NULL) {
543 s2255_dev_err(&udev->dev, "disconnected\n");
544 atomic_set(&data->fw_state, S2255_FW_FAILED);
545 /* wake up anything waiting for the firmware */
546 wake_up(&data->wait_fw);
549 #define CHUNK_SIZE 512
550 /* all USB transfers must be done with continuous kernel memory.
551 can't allocate more than 128k in current linux kernel, so
552 upload the firmware in chunks
554 if (data->fw_loaded < data->fw_size) {
555 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
556 data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
558 if (len < CHUNK_SIZE)
559 memset(data->pfw_data, 0, CHUNK_SIZE);
561 dprintk(100, "completed len %d, loaded %d \n", len,
564 memcpy(data->pfw_data,
565 (char *) data->fw->data + data->fw_loaded, len);
567 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
568 data->pfw_data, CHUNK_SIZE,
569 s2255_fwchunk_complete, data);
570 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
571 dev_err(&udev->dev, "failed submit URB\n");
572 atomic_set(&data->fw_state, S2255_FW_FAILED);
573 /* wake up anything waiting for the firmware */
574 wake_up(&data->wait_fw);
577 data->fw_loaded += len;
579 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
581 dprintk(100, "2255 complete done\n");
586 static int s2255_got_frame(struct s2255_dev *dev, int chn, int jpgsize)
588 struct s2255_dmaqueue *dma_q = &dev->vidq[chn];
589 struct s2255_buffer *buf;
590 unsigned long flags = 0;
592 dprintk(2, "wakeup: %p channel: %d\n", &dma_q, chn);
593 spin_lock_irqsave(&dev->slock, flags);
595 if (list_empty(&dma_q->active)) {
596 dprintk(1, "No active queue to serve\n");
600 buf = list_entry(dma_q->active.next,
601 struct s2255_buffer, vb.queue);
603 if (!waitqueue_active(&buf->vb.done)) {
608 list_del(&buf->vb.queue);
609 do_gettimeofday(&buf->vb.ts);
610 dprintk(100, "[%p/%d] wakeup\n", buf, buf->vb.i);
611 s2255_fillbuff(dev, buf, dma_q->channel, jpgsize);
612 wake_up(&buf->vb.done);
613 dprintk(2, "wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
615 spin_unlock_irqrestore(&dev->slock, flags);
620 static const struct s2255_fmt *format_by_fourcc(int fourcc)
624 for (i = 0; i < ARRAY_SIZE(formats); i++) {
625 if (-1 == formats[i].fourcc)
627 if (formats[i].fourcc == fourcc)
636 /* video buffer vmalloc implementation based partly on VIVI driver which is
637 * Copyright (c) 2006 by
638 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
639 * Ted Walther <ted--a.t--enumera.com>
640 * John Sokol <sokol--a.t--videotechnology.com>
641 * http://v4l.videotechnology.com/
644 static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
645 int chn, int jpgsize)
650 char *vbuf = videobuf_to_vmalloc(&buf->vb);
651 unsigned long last_frame;
652 struct s2255_framei *frm;
657 last_frame = dev->last_frame[chn];
658 if (last_frame != -1) {
659 frm = &dev->buffer[chn].frame[last_frame];
661 (const char *)dev->buffer[chn].frame[last_frame].lpvbits;
662 switch (buf->fmt->fourcc) {
663 case V4L2_PIX_FMT_YUYV:
664 case V4L2_PIX_FMT_UYVY:
665 planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
670 case V4L2_PIX_FMT_GREY:
671 memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
673 case V4L2_PIX_FMT_JPEG:
674 buf->vb.size = jpgsize;
675 memcpy(vbuf, tmpbuf, buf->vb.size);
677 case V4L2_PIX_FMT_YUV422P:
679 buf->vb.width * buf->vb.height * 2);
682 printk(KERN_DEBUG "s2255: unknown format?\n");
684 dev->last_frame[chn] = -1;
686 printk(KERN_ERR "s2255: =======no frame\n");
690 dprintk(2, "s2255fill at : Buffer 0x%08lx size= %d\n",
691 (unsigned long)vbuf, pos);
692 /* tell v4l buffer was filled */
694 buf->vb.field_count = dev->frame_count[chn] * 2;
695 do_gettimeofday(&ts);
697 buf->vb.state = VIDEOBUF_DONE;
701 /* ------------------------------------------------------------------
703 ------------------------------------------------------------------*/
705 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
708 struct s2255_fh *fh = vq->priv_data;
710 *size = fh->width * fh->height * (fh->fmt->depth >> 3);
713 *count = S2255_DEF_BUFS;
715 while (*size * (*count) > vid_limit * 1024 * 1024)
721 static void free_buffer(struct videobuf_queue *vq, struct s2255_buffer *buf)
723 dprintk(4, "%s\n", __func__);
725 videobuf_waiton(&buf->vb, 0, 0);
726 videobuf_vmalloc_free(&buf->vb);
727 buf->vb.state = VIDEOBUF_NEEDS_INIT;
730 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
731 enum v4l2_field field)
733 struct s2255_fh *fh = vq->priv_data;
734 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
736 dprintk(4, "%s, field=%d\n", __func__, field);
740 if ((fh->width < norm_minw(fh->dev->vdev[fh->channel])) ||
741 (fh->width > norm_maxw(fh->dev->vdev[fh->channel])) ||
742 (fh->height < norm_minh(fh->dev->vdev[fh->channel])) ||
743 (fh->height > norm_maxh(fh->dev->vdev[fh->channel]))) {
744 dprintk(4, "invalid buffer prepare\n");
748 buf->vb.size = fh->width * fh->height * (fh->fmt->depth >> 3);
750 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
751 dprintk(4, "invalid buffer prepare\n");
756 buf->vb.width = fh->width;
757 buf->vb.height = fh->height;
758 buf->vb.field = field;
761 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
762 rc = videobuf_iolock(vq, &buf->vb, NULL);
767 buf->vb.state = VIDEOBUF_PREPARED;
770 free_buffer(vq, buf);
774 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
776 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
777 struct s2255_fh *fh = vq->priv_data;
778 struct s2255_dev *dev = fh->dev;
779 struct s2255_dmaqueue *vidq = &dev->vidq[fh->channel];
781 dprintk(1, "%s\n", __func__);
783 buf->vb.state = VIDEOBUF_QUEUED;
784 list_add_tail(&buf->vb.queue, &vidq->active);
787 static void buffer_release(struct videobuf_queue *vq,
788 struct videobuf_buffer *vb)
790 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
791 struct s2255_fh *fh = vq->priv_data;
792 dprintk(4, "%s %d\n", __func__, fh->channel);
793 free_buffer(vq, buf);
796 static struct videobuf_queue_ops s2255_video_qops = {
797 .buf_setup = buffer_setup,
798 .buf_prepare = buffer_prepare,
799 .buf_queue = buffer_queue,
800 .buf_release = buffer_release,
804 static int res_get(struct s2255_dev *dev, struct s2255_fh *fh)
807 mutex_lock(&dev->lock);
808 if (dev->resources[fh->channel]) {
809 /* no, someone else uses it */
810 mutex_unlock(&dev->lock);
813 /* it's free, grab it */
814 dev->resources[fh->channel] = 1;
815 fh->resources[fh->channel] = 1;
816 dprintk(1, "s2255: res: get\n");
817 mutex_unlock(&dev->lock);
821 static int res_locked(struct s2255_dev *dev, struct s2255_fh *fh)
823 return dev->resources[fh->channel];
826 static int res_check(struct s2255_fh *fh)
828 return fh->resources[fh->channel];
832 static void res_free(struct s2255_dev *dev, struct s2255_fh *fh)
834 mutex_lock(&dev->lock);
835 dev->resources[fh->channel] = 0;
836 fh->resources[fh->channel] = 0;
837 mutex_unlock(&dev->lock);
838 dprintk(1, "res: put\n");
842 static int vidioc_querycap(struct file *file, void *priv,
843 struct v4l2_capability *cap)
845 struct s2255_fh *fh = file->private_data;
846 struct s2255_dev *dev = fh->dev;
847 strlcpy(cap->driver, "s2255", sizeof(cap->driver));
848 strlcpy(cap->card, "s2255", sizeof(cap->card));
849 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
850 cap->version = S2255_VERSION;
851 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
855 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
856 struct v4l2_fmtdesc *f)
862 if (index >= ARRAY_SIZE(formats))
865 dprintk(4, "name %s\n", formats[index].name);
866 strlcpy(f->description, formats[index].name, sizeof(f->description));
867 f->pixelformat = formats[index].fourcc;
871 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
872 struct v4l2_format *f)
874 struct s2255_fh *fh = priv;
876 f->fmt.pix.width = fh->width;
877 f->fmt.pix.height = fh->height;
878 f->fmt.pix.field = fh->vb_vidq.field;
879 f->fmt.pix.pixelformat = fh->fmt->fourcc;
880 f->fmt.pix.bytesperline = f->fmt.pix.width * (fh->fmt->depth >> 3);
881 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
885 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
886 struct v4l2_format *f)
888 const struct s2255_fmt *fmt;
889 enum v4l2_field field;
891 struct s2255_fh *fh = priv;
892 struct s2255_dev *dev = fh->dev;
896 (dev->vdev[fh->channel]->current_norm & V4L2_STD_NTSC) ? 1 : 0;
898 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
903 field = f->fmt.pix.field;
904 if (field == V4L2_FIELD_ANY)
907 dprintk(4, "try format %d \n", is_ntsc);
908 /* supports 3 sizes. see s2255drv.h */
909 dprintk(50, "width test %d, height %d\n",
910 f->fmt.pix.width, f->fmt.pix.height);
913 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
914 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
916 field = V4L2_FIELD_SEQ_TB;
917 } else if (!((field == V4L2_FIELD_INTERLACED) ||
918 (field == V4L2_FIELD_SEQ_TB) ||
919 (field == V4L2_FIELD_INTERLACED_TB))) {
920 dprintk(1, "unsupported field setting\n");
924 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
926 field = V4L2_FIELD_TOP;
927 } else if (!((field == V4L2_FIELD_TOP) ||
928 (field == V4L2_FIELD_BOTTOM))) {
929 dprintk(1, "unsupported field setting\n");
934 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
935 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
936 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
937 f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
938 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
939 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
941 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
944 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
945 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
947 field = V4L2_FIELD_SEQ_TB;
948 } else if (!((field == V4L2_FIELD_INTERLACED) ||
949 (field == V4L2_FIELD_SEQ_TB) ||
950 (field == V4L2_FIELD_INTERLACED_TB))) {
951 dprintk(1, "unsupported field setting\n");
955 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
957 field = V4L2_FIELD_TOP;
958 } else if (!((field == V4L2_FIELD_TOP) ||
959 (field == V4L2_FIELD_BOTTOM))) {
960 dprintk(1, "unsupported field setting\n");
964 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) {
965 dprintk(50, "pal 704\n");
966 f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
967 field = V4L2_FIELD_SEQ_TB;
968 } else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL) {
969 dprintk(50, "pal 352A\n");
970 f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
971 field = V4L2_FIELD_TOP;
972 } else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL) {
973 dprintk(50, "pal 352B\n");
974 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
975 field = V4L2_FIELD_TOP;
977 dprintk(50, "pal 352C\n");
978 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
979 field = V4L2_FIELD_TOP;
983 dprintk(50, "width %d height %d field %d \n", f->fmt.pix.width,
984 f->fmt.pix.height, f->fmt.pix.field);
985 f->fmt.pix.field = field;
986 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
987 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
991 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
992 struct v4l2_format *f)
994 struct s2255_fh *fh = priv;
995 const struct s2255_fmt *fmt;
996 struct videobuf_queue *q = &fh->vb_vidq;
1000 ret = vidioc_try_fmt_vid_cap(file, fh, f);
1005 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1010 mutex_lock(&q->vb_lock);
1012 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1013 dprintk(1, "queue busy\n");
1018 if (res_locked(fh->dev, fh)) {
1019 dprintk(1, "can't change format after started\n");
1025 fh->width = f->fmt.pix.width;
1026 fh->height = f->fmt.pix.height;
1027 fh->vb_vidq.field = f->fmt.pix.field;
1029 norm = norm_minw(fh->dev->vdev[fh->channel]);
1030 if (fh->width > norm_minw(fh->dev->vdev[fh->channel])) {
1031 if (fh->height > norm_minh(fh->dev->vdev[fh->channel]))
1032 fh->mode.scale = SCALE_4CIFS;
1034 fh->mode.scale = SCALE_2CIFS;
1037 fh->mode.scale = SCALE_1CIFS;
1041 switch (fh->fmt->fourcc) {
1042 case V4L2_PIX_FMT_GREY:
1043 fh->mode.color = COLOR_Y8;
1045 case V4L2_PIX_FMT_JPEG:
1046 fh->mode.color = COLOR_JPG |
1047 (fh->dev->jc[fh->channel].quality << 8);
1049 case V4L2_PIX_FMT_YUV422P:
1050 fh->mode.color = COLOR_YUVPL;
1052 case V4L2_PIX_FMT_YUYV:
1053 case V4L2_PIX_FMT_UYVY:
1055 fh->mode.color = COLOR_YUVPK;
1060 mutex_unlock(&q->vb_lock);
1064 static int vidioc_reqbufs(struct file *file, void *priv,
1065 struct v4l2_requestbuffers *p)
1068 struct s2255_fh *fh = priv;
1069 rc = videobuf_reqbufs(&fh->vb_vidq, p);
1073 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1076 struct s2255_fh *fh = priv;
1077 rc = videobuf_querybuf(&fh->vb_vidq, p);
1081 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1084 struct s2255_fh *fh = priv;
1085 rc = videobuf_qbuf(&fh->vb_vidq, p);
1089 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1092 struct s2255_fh *fh = priv;
1093 rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
1097 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1098 static int vidioc_cgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1100 struct s2255_fh *fh = priv;
1102 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1106 /* write to the configuration pipe, synchronously */
1107 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1114 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
1115 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
1120 static u32 get_transfer_size(struct s2255_mode *mode)
1122 int linesPerFrame = LINE_SZ_DEF;
1123 int pixelsPerLine = NUM_LINES_DEF;
1126 unsigned int mask_mult;
1131 if (mode->format == FORMAT_NTSC) {
1132 switch (mode->scale) {
1134 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
1135 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
1138 linesPerFrame = NUM_LINES_2CIFS_NTSC;
1139 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
1142 linesPerFrame = NUM_LINES_1CIFS_NTSC;
1143 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
1148 } else if (mode->format == FORMAT_PAL) {
1149 switch (mode->scale) {
1151 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
1152 pixelsPerLine = LINE_SZ_4CIFS_PAL;
1155 linesPerFrame = NUM_LINES_2CIFS_PAL;
1156 pixelsPerLine = LINE_SZ_2CIFS_PAL;
1159 linesPerFrame = NUM_LINES_1CIFS_PAL;
1160 pixelsPerLine = LINE_SZ_1CIFS_PAL;
1166 outImageSize = linesPerFrame * pixelsPerLine;
1167 if ((mode->color & MASK_COLOR) != COLOR_Y8) {
1168 /* 2 bytes/pixel if not monochrome */
1172 /* total bytes to send including prefix and 4K padding;
1173 must be a multiple of USB_READ_SIZE */
1174 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
1175 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
1176 /* if size not a multiple of USB_READ_SIZE */
1177 if (usbInSize & ~mask_mult)
1178 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
1182 static void dump_verify_mode(struct s2255_dev *sdev, struct s2255_mode *mode)
1184 struct device *dev = &sdev->udev->dev;
1185 dev_info(dev, "------------------------------------------------\n");
1186 dev_info(dev, "verify mode\n");
1187 dev_info(dev, "format: %d\n", mode->format);
1188 dev_info(dev, "scale: %d\n", mode->scale);
1189 dev_info(dev, "fdec: %d\n", mode->fdec);
1190 dev_info(dev, "color: %d\n", mode->color);
1191 dev_info(dev, "bright: 0x%x\n", mode->bright);
1192 dev_info(dev, "restart: 0x%x\n", mode->restart);
1193 dev_info(dev, "usb_block: 0x%x\n", mode->usb_block);
1194 dev_info(dev, "single: 0x%x\n", mode->single);
1195 dev_info(dev, "------------------------------------------------\n");
1199 * set mode is the function which controls the DSP.
1200 * the restart parameter in struct s2255_mode should be set whenever
1201 * the image size could change via color format, video system or image
1203 * When the restart parameter is set, we sleep for ONE frame to allow the
1204 * DSP time to get the new frame
1206 static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
1207 struct s2255_mode *mode)
1211 unsigned long chn_rev;
1213 mutex_lock(&dev->lock);
1214 chn_rev = G_chnmap[chn];
1215 dprintk(3, "mode scale [%ld] %p %d\n", chn, mode, mode->scale);
1216 dprintk(3, "mode scale [%ld] %p %d\n", chn, &dev->mode[chn],
1217 dev->mode[chn].scale);
1218 dprintk(2, "mode contrast %x\n", mode->contrast);
1220 /* if JPEG, set the quality */
1221 if ((mode->color & MASK_COLOR) == COLOR_JPG)
1222 mode->color = (dev->jc[chn].quality << 8) | COLOR_JPG;
1225 dev->mode[chn] = *mode;
1226 dev->req_image_size[chn] = get_transfer_size(mode);
1227 dprintk(1, "transfer size %ld\n", dev->req_image_size[chn]);
1229 buffer = kzalloc(512, GFP_KERNEL);
1230 if (buffer == NULL) {
1231 dev_err(&dev->udev->dev, "out of mem\n");
1232 mutex_unlock(&dev->lock);
1237 buffer[0] = IN_DATA_TOKEN;
1238 buffer[1] = (u32) chn_rev;
1239 buffer[2] = CMD_SET_MODE;
1240 memcpy(&buffer[3], &dev->mode[chn], sizeof(struct s2255_mode));
1241 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1243 dump_verify_mode(dev, mode);
1245 dprintk(1, "set mode done chn %lu, %d\n", chn, res);
1247 /* wait at least 3 frames before continuing */
1248 if (mode->restart) {
1249 dev->setmode_ready[chn] = 0;
1250 wait_event_timeout(dev->wait_setmode[chn],
1251 (dev->setmode_ready[chn] != 0),
1252 msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1253 if (dev->setmode_ready[chn] != 1) {
1254 printk(KERN_DEBUG "s2255: no set mode response\n");
1259 /* clear the restart flag */
1260 dev->mode[chn].restart = 0;
1261 mutex_unlock(&dev->lock);
1265 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1268 struct s2255_fh *fh = priv;
1269 struct s2255_dev *dev = fh->dev;
1270 struct s2255_mode *new_mode;
1271 struct s2255_mode *old_mode;
1274 dprintk(4, "%s\n", __func__);
1275 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1276 dev_err(&dev->udev->dev, "invalid fh type0\n");
1279 if (i != fh->type) {
1280 dev_err(&dev->udev->dev, "invalid fh type1\n");
1284 if (!res_get(dev, fh)) {
1285 s2255_dev_err(&dev->udev->dev, "stream busy\n");
1289 /* send a set mode command everytime with restart.
1290 in case we switch resolutions or other parameters */
1292 new_mode = &fh->mode;
1293 old_mode = &fh->dev->mode[chn];
1295 if (new_mode->color != old_mode->color)
1296 new_mode->restart = 1;
1297 else if (new_mode->scale != old_mode->scale)
1298 new_mode->restart = 1;
1299 else if (new_mode->format != old_mode->format)
1300 new_mode->restart = 1;
1302 s2255_set_mode(dev, chn, new_mode);
1303 new_mode->restart = 0;
1304 *old_mode = *new_mode;
1305 dev->cur_fmt[chn] = fh->fmt;
1306 dprintk(1, "%s[%d]\n", __func__, chn);
1307 dev->last_frame[chn] = -1;
1308 dev->bad_payload[chn] = 0;
1309 dev->cur_frame[chn] = 0;
1310 dev->frame_count[chn] = 0;
1311 for (j = 0; j < SYS_FRAMES; j++) {
1312 dev->buffer[chn].frame[j].ulState = S2255_READ_IDLE;
1313 dev->buffer[chn].frame[j].cur_size = 0;
1315 res = videobuf_streamon(&fh->vb_vidq);
1317 s2255_start_acquire(dev, chn);
1318 dev->b_acquire[chn] = 1;
1325 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1328 struct s2255_fh *fh = priv;
1329 struct s2255_dev *dev = fh->dev;
1331 dprintk(4, "%s\n, channel: %d", __func__, fh->channel);
1332 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1333 printk(KERN_ERR "invalid fh type0\n");
1336 if (i != fh->type) {
1337 printk(KERN_ERR "invalid type i\n");
1340 s2255_stop_acquire(dev, fh->channel);
1341 res = videobuf_streamoff(&fh->vb_vidq);
1348 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1350 struct s2255_fh *fh = priv;
1351 struct s2255_mode *mode;
1352 struct videobuf_queue *q = &fh->vb_vidq;
1355 mutex_lock(&q->vb_lock);
1356 if (videobuf_queue_is_busy(q)) {
1357 dprintk(1, "queue busy\n");
1362 if (res_locked(fh->dev, fh)) {
1363 dprintk(1, "can't change standard after started\n");
1369 if (*i & V4L2_STD_NTSC) {
1370 dprintk(4, "vidioc_s_std NTSC\n");
1371 mode->format = FORMAT_NTSC;
1372 } else if (*i & V4L2_STD_PAL) {
1373 dprintk(4, "vidioc_s_std PAL\n");
1374 mode->format = FORMAT_PAL;
1379 mutex_unlock(&q->vb_lock);
1383 /* Sensoray 2255 is a multiple channel capture device.
1384 It does not have a "crossbar" of inputs.
1385 We use one V4L device per channel. The user must
1386 be aware that certain combinations are not allowed.
1387 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1388 at once in color(you can do full fps on 4 channels with greyscale.
1390 static int vidioc_enum_input(struct file *file, void *priv,
1391 struct v4l2_input *inp)
1393 if (inp->index != 0)
1396 inp->type = V4L2_INPUT_TYPE_CAMERA;
1397 inp->std = S2255_NORMS;
1398 strlcpy(inp->name, "Camera", sizeof(inp->name));
1402 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1407 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1414 /* --- controls ---------------------------------------------- */
1415 static int vidioc_queryctrl(struct file *file, void *priv,
1416 struct v4l2_queryctrl *qc)
1420 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1421 if (qc->id && qc->id == s2255_qctrl[i].id) {
1422 memcpy(qc, &(s2255_qctrl[i]), sizeof(*qc));
1426 dprintk(4, "query_ctrl -EINVAL %d\n", qc->id);
1430 static int vidioc_g_ctrl(struct file *file, void *priv,
1431 struct v4l2_control *ctrl)
1435 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1436 if (ctrl->id == s2255_qctrl[i].id) {
1437 ctrl->value = qctl_regs[i];
1440 dprintk(4, "g_ctrl -EINVAL\n");
1445 static int vidioc_s_ctrl(struct file *file, void *priv,
1446 struct v4l2_control *ctrl)
1449 struct s2255_fh *fh = priv;
1450 struct s2255_dev *dev = fh->dev;
1451 struct s2255_mode *mode;
1453 dprintk(4, "vidioc_s_ctrl\n");
1454 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++) {
1455 if (ctrl->id == s2255_qctrl[i].id) {
1456 if (ctrl->value < s2255_qctrl[i].minimum ||
1457 ctrl->value > s2255_qctrl[i].maximum)
1460 qctl_regs[i] = ctrl->value;
1461 /* update the mode to the corresponding value */
1463 case V4L2_CID_BRIGHTNESS:
1464 mode->bright = ctrl->value;
1466 case V4L2_CID_CONTRAST:
1467 mode->contrast = ctrl->value;
1470 mode->hue = ctrl->value;
1472 case V4L2_CID_SATURATION:
1473 mode->saturation = ctrl->value;
1477 /* set mode here. Note: stream does not need restarted.
1478 some V4L programs restart stream unnecessarily
1481 s2255_set_mode(dev, fh->channel, mode);
1488 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1489 struct v4l2_jpegcompression *jc)
1491 struct s2255_fh *fh = priv;
1492 struct s2255_dev *dev = fh->dev;
1493 *jc = dev->jc[fh->channel];
1494 dprintk(2, "getting jpegcompression, quality %d\n", jc->quality);
1498 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1499 struct v4l2_jpegcompression *jc)
1501 struct s2255_fh *fh = priv;
1502 struct s2255_dev *dev = fh->dev;
1503 if (jc->quality < 0 || jc->quality > 100)
1505 dev->jc[fh->channel].quality = jc->quality;
1506 dprintk(2, "setting jpeg quality %d\n", jc->quality);
1509 static int s2255_open(struct file *file)
1511 int minor = video_devdata(file)->minor;
1512 struct s2255_dev *h, *dev = NULL;
1513 struct s2255_fh *fh;
1514 struct list_head *list;
1515 enum v4l2_buf_type type = 0;
1517 int cur_channel = -1;
1519 dprintk(1, "s2255: open called (minor=%d)\n", minor);
1522 list_for_each(list, &s2255_devlist) {
1523 h = list_entry(list, struct s2255_dev, s2255_devlist);
1524 for (i = 0; i < MAX_CHANNELS; i++) {
1525 if (h->vdev[i]->minor == minor) {
1528 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1533 if ((NULL == dev) || (cur_channel == -1)) {
1535 printk(KERN_INFO "s2255: openv4l no dev\n");
1539 if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_DISCONNECTING) {
1541 printk(KERN_INFO "disconnecting\n");
1544 kref_get(&dev->kref);
1545 mutex_lock(&dev->open_lock);
1547 dev->users[cur_channel]++;
1548 dprintk(4, "s2255: open_handles %d\n", dev->users[cur_channel]);
1550 switch (atomic_read(&dev->fw_data->fw_state)) {
1551 case S2255_FW_FAILED:
1552 s2255_dev_err(&dev->udev->dev,
1553 "firmware load failed. retrying.\n");
1554 s2255_fwload_start(dev, 1);
1555 wait_event_timeout(dev->fw_data->wait_fw,
1556 ((atomic_read(&dev->fw_data->fw_state)
1557 == S2255_FW_SUCCESS) ||
1558 (atomic_read(&dev->fw_data->fw_state)
1559 == S2255_FW_DISCONNECTING)),
1560 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1562 case S2255_FW_NOTLOADED:
1563 case S2255_FW_LOADED_DSPWAIT:
1564 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1565 driver loaded and then device immediately opened */
1566 printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1567 wait_event_timeout(dev->fw_data->wait_fw,
1568 ((atomic_read(&dev->fw_data->fw_state)
1569 == S2255_FW_SUCCESS) ||
1570 (atomic_read(&dev->fw_data->fw_state)
1571 == S2255_FW_DISCONNECTING)),
1572 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1574 case S2255_FW_SUCCESS:
1578 state = atomic_read(&dev->fw_data->fw_state);
1579 if (state != S2255_FW_SUCCESS) {
1582 case S2255_FW_FAILED:
1583 printk(KERN_INFO "2255 FW load failed. %d\n", state);
1586 case S2255_FW_DISCONNECTING:
1587 printk(KERN_INFO "%s: disconnecting\n", __func__);
1590 case S2255_FW_LOADED_DSPWAIT:
1591 case S2255_FW_NOTLOADED:
1592 printk(KERN_INFO "%s: firmware not loaded yet"
1593 "please try again later\n",
1598 printk(KERN_INFO "%s: unknown state\n", __func__);
1602 dev->users[cur_channel]--;
1603 mutex_unlock(&dev->open_lock);
1604 kref_put(&dev->kref, s2255_destroy);
1609 /* allocate + initialize per filehandle data */
1610 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1612 dev->users[cur_channel]--;
1613 mutex_unlock(&dev->open_lock);
1614 kref_put(&dev->kref, s2255_destroy);
1619 file->private_data = fh;
1621 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1622 fh->mode = dev->mode[cur_channel];
1623 fh->fmt = dev->cur_fmt[cur_channel];
1624 /* default 4CIF NTSC */
1625 fh->width = LINE_SZ_4CIFS_NTSC;
1626 fh->height = NUM_LINES_4CIFS_NTSC * 2;
1627 fh->channel = cur_channel;
1629 /* configure channel to default state */
1630 if (!dev->chn_configured[cur_channel]) {
1631 s2255_set_mode(dev, cur_channel, &fh->mode);
1632 dev->chn_configured[cur_channel] = 1;
1636 /* Put all controls at a sane state */
1637 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1638 qctl_regs[i] = s2255_qctrl[i].default_value;
1640 dprintk(1, "s2255drv: open minor=%d type=%s users=%d\n",
1641 minor, v4l2_type_names[type], dev->users[cur_channel]);
1642 dprintk(2, "s2255drv: open: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n",
1643 (unsigned long)fh, (unsigned long)dev,
1644 (unsigned long)&dev->vidq[cur_channel]);
1645 dprintk(4, "s2255drv: open: list_empty active=%d\n",
1646 list_empty(&dev->vidq[cur_channel].active));
1648 videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1651 V4L2_FIELD_INTERLACED,
1652 sizeof(struct s2255_buffer), fh);
1654 mutex_unlock(&dev->open_lock);
1660 static unsigned int s2255_poll(struct file *file,
1661 struct poll_table_struct *wait)
1663 struct s2255_fh *fh = file->private_data;
1665 dprintk(100, "%s\n", __func__);
1667 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1670 rc = videobuf_poll_stream(file, &fh->vb_vidq, wait);
1674 static void s2255_destroy(struct kref *kref)
1676 struct s2255_dev *dev = to_s2255_dev(kref);
1677 struct list_head *list;
1680 printk(KERN_ERR "s2255drv: kref problem\n");
1683 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
1684 wake_up(&dev->fw_data->wait_fw);
1685 for (i = 0; i < MAX_CHANNELS; i++) {
1686 dev->setmode_ready[i] = 1;
1687 wake_up(&dev->wait_setmode[i]);
1689 mutex_lock(&dev->open_lock);
1690 /* reset the DSP so firmware can be reload next time */
1691 s2255_reset_dsppower(dev);
1692 s2255_exit_v4l(dev);
1693 /* board shutdown stops the read pipe if it is running */
1694 s2255_board_shutdown(dev);
1695 /* make sure firmware still not trying to load */
1696 del_timer(&dev->timer); /* only started in .probe and .open */
1698 if (dev->fw_data->fw_urb) {
1699 dprintk(2, "kill fw_urb\n");
1700 usb_kill_urb(dev->fw_data->fw_urb);
1701 usb_free_urb(dev->fw_data->fw_urb);
1702 dev->fw_data->fw_urb = NULL;
1704 if (dev->fw_data->fw)
1705 release_firmware(dev->fw_data->fw);
1706 kfree(dev->fw_data->pfw_data);
1707 kfree(dev->fw_data);
1708 usb_put_dev(dev->udev);
1709 dprintk(1, "%s", __func__);
1712 while (!list_empty(&s2255_devlist)) {
1713 list = s2255_devlist.next;
1716 mutex_unlock(&dev->open_lock);
1719 static int s2255_close(struct file *file)
1721 struct s2255_fh *fh = file->private_data;
1722 struct s2255_dev *dev = fh->dev;
1723 int minor = video_devdata(file)->minor;
1727 mutex_lock(&dev->open_lock);
1729 /* turn off stream */
1730 if (res_check(fh)) {
1731 if (dev->b_acquire[fh->channel])
1732 s2255_stop_acquire(dev, fh->channel);
1733 videobuf_streamoff(&fh->vb_vidq);
1737 videobuf_mmap_free(&fh->vb_vidq);
1738 dev->users[fh->channel]--;
1740 mutex_unlock(&dev->open_lock);
1742 kref_put(&dev->kref, s2255_destroy);
1743 dprintk(1, "s2255: close called (minor=%d, users=%d)\n",
1744 minor, dev->users[fh->channel]);
1749 static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1751 struct s2255_fh *fh = file->private_data;
1756 dprintk(4, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1758 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1760 dprintk(4, "vma start=0x%08lx, size=%ld, ret=%d\n",
1761 (unsigned long)vma->vm_start,
1762 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1767 static const struct v4l2_file_operations s2255_fops_v4l = {
1768 .owner = THIS_MODULE,
1770 .release = s2255_close,
1772 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
1773 .mmap = s2255_mmap_v4l,
1776 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1777 .vidioc_querycap = vidioc_querycap,
1778 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1779 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1780 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1781 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1782 .vidioc_reqbufs = vidioc_reqbufs,
1783 .vidioc_querybuf = vidioc_querybuf,
1784 .vidioc_qbuf = vidioc_qbuf,
1785 .vidioc_dqbuf = vidioc_dqbuf,
1786 .vidioc_s_std = vidioc_s_std,
1787 .vidioc_enum_input = vidioc_enum_input,
1788 .vidioc_g_input = vidioc_g_input,
1789 .vidioc_s_input = vidioc_s_input,
1790 .vidioc_queryctrl = vidioc_queryctrl,
1791 .vidioc_g_ctrl = vidioc_g_ctrl,
1792 .vidioc_s_ctrl = vidioc_s_ctrl,
1793 .vidioc_streamon = vidioc_streamon,
1794 .vidioc_streamoff = vidioc_streamoff,
1795 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1796 .vidiocgmbuf = vidioc_cgmbuf,
1798 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1799 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1802 static struct video_device template = {
1804 .fops = &s2255_fops_v4l,
1805 .ioctl_ops = &s2255_ioctl_ops,
1807 .release = video_device_release,
1808 .tvnorms = S2255_NORMS,
1809 .current_norm = V4L2_STD_NTSC_M,
1812 static int s2255_probe_v4l(struct s2255_dev *dev)
1816 int cur_nr = video_nr;
1818 /* initialize all video 4 linux */
1819 list_add_tail(&dev->s2255_devlist, &s2255_devlist);
1820 /* register 4 video devices */
1821 for (i = 0; i < MAX_CHANNELS; i++) {
1822 INIT_LIST_HEAD(&dev->vidq[i].active);
1823 dev->vidq[i].dev = dev;
1824 dev->vidq[i].channel = i;
1825 dev->vidq[i].kthread = NULL;
1826 /* register 4 video devices */
1827 dev->vdev[i] = video_device_alloc();
1828 memcpy(dev->vdev[i], &template, sizeof(struct video_device));
1829 dev->vdev[i]->parent = &dev->interface->dev;
1831 ret = video_register_device(dev->vdev[i],
1835 ret = video_register_device(dev->vdev[i],
1838 video_set_drvdata(dev->vdev[i], dev);
1841 dev_err(&dev->udev->dev,
1842 "failed to register video device!\n");
1846 printk(KERN_INFO "Sensoray 2255 V4L driver\n");
1850 static void s2255_exit_v4l(struct s2255_dev *dev)
1854 for (i = 0; i < MAX_CHANNELS; i++) {
1855 if (-1 != dev->vdev[i]->minor) {
1856 video_unregister_device(dev->vdev[i]);
1857 printk(KERN_INFO "s2255 unregistered\n");
1859 video_device_release(dev->vdev[i]);
1860 printk(KERN_INFO "s2255 released\n");
1865 /* this function moves the usb stream read pipe data
1866 * into the system buffers.
1867 * returns 0 on success, EAGAIN if more data to process( call this
1870 * Received frame structure:
1871 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1872 * bytes 4-7: channel: 0-3
1873 * bytes 8-11: payload size: size of the frame
1874 * bytes 12-payloadsize+12: frame data
1876 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1882 unsigned long copy_size;
1885 struct s2255_framei *frm;
1886 unsigned char *pdata;
1888 dprintk(100, "buffer to user\n");
1890 idx = dev->cur_frame[dev->cc];
1891 frm = &dev->buffer[dev->cc].frame[idx];
1893 if (frm->ulState == S2255_READ_IDLE) {
1898 /* search for marker codes */
1899 pdata = (unsigned char *)pipe_info->transfer_buffer;
1900 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1901 switch (*(s32 *) pdata) {
1902 case S2255_MARKER_FRAME:
1903 pdword = (s32 *)pdata;
1904 dprintk(4, "found frame marker at offset:"
1905 " %d [%x %x]\n", jj, pdata[0],
1907 offset = jj + PREFIX_SIZE;
1910 if (cc >= MAX_CHANNELS) {
1916 dev->cc = G_chnmap[cc];
1917 payload = pdword[3];
1918 if (payload > dev->req_image_size[dev->cc]) {
1919 dev->bad_payload[dev->cc]++;
1920 /* discard the bad frame */
1923 dev->pkt_size[dev->cc] = payload;
1924 dev->jpg_size[dev->cc] = pdword[4];
1926 case S2255_MARKER_RESPONSE:
1927 pdword = (s32 *)pdata;
1928 pdata += DEF_USB_BLOCK;
1929 jj += DEF_USB_BLOCK;
1930 if (pdword[1] >= MAX_CHANNELS)
1932 cc = G_chnmap[pdword[1]];
1933 if (!(cc >= 0 && cc < MAX_CHANNELS))
1935 switch (pdword[2]) {
1937 /* check if channel valid */
1938 /* set mode ready */
1939 dev->setmode_ready[cc] = 1;
1940 wake_up(&dev->wait_setmode[cc]);
1941 dprintk(5, "setmode ready %d\n", cc);
1945 dev->chn_ready |= (1 << cc);
1946 if ((dev->chn_ready & 0x0f) != 0x0f)
1948 /* all channels ready */
1949 printk(KERN_INFO "s2255: fw loaded\n");
1950 atomic_set(&dev->fw_data->fw_state,
1952 wake_up(&dev->fw_data->wait_fw);
1955 printk(KERN_INFO "s2255 unknwn resp\n");
1969 idx = dev->cur_frame[dev->cc];
1970 frm = &dev->buffer[dev->cc].frame[idx];
1972 /* search done. now find out if should be acquiring on this channel */
1973 if (!dev->b_acquire[dev->cc]) {
1974 /* we found a frame, but this channel is turned off */
1975 frm->ulState = S2255_READ_IDLE;
1979 if (frm->ulState == S2255_READ_IDLE) {
1980 frm->ulState = S2255_READ_FRAME;
1984 /* skip the marker 512 bytes (and offset if out of sync) */
1985 psrc = (u8 *)pipe_info->transfer_buffer + offset;
1988 if (frm->lpvbits == NULL) {
1989 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
1990 frm, dev, dev->cc, idx);
1994 pdest = frm->lpvbits + frm->cur_size;
1996 copy_size = (pipe_info->cur_transfer_size - offset);
1998 size = dev->pkt_size[dev->cc] - PREFIX_SIZE;
2000 /* sanity check on pdest */
2001 if ((copy_size + frm->cur_size) < dev->req_image_size[dev->cc])
2002 memcpy(pdest, psrc, copy_size);
2004 frm->cur_size += copy_size;
2005 dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
2007 if (frm->cur_size >= size) {
2010 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
2012 dev->last_frame[cc] = dev->cur_frame[cc];
2013 dev->cur_frame[cc]++;
2014 /* end of system frame ring buffer, start at zero */
2015 if ((dev->cur_frame[cc] == SYS_FRAMES) ||
2016 (dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
2017 dev->cur_frame[cc] = 0;
2019 if (dev->b_acquire[cc])
2020 s2255_got_frame(dev, cc, dev->jpg_size[cc]);
2021 dev->frame_count[cc]++;
2022 frm->ulState = S2255_READ_IDLE;
2026 /* done successfully */
2030 static void s2255_read_video_callback(struct s2255_dev *dev,
2031 struct s2255_pipeinfo *pipe_info)
2034 dprintk(50, "callback read video \n");
2036 if (dev->cc >= MAX_CHANNELS) {
2038 dev_err(&dev->udev->dev, "invalid channel\n");
2041 /* otherwise copy to the system buffers */
2042 res = save_frame(dev, pipe_info);
2044 dprintk(4, "s2255: read callback failed\n");
2046 dprintk(50, "callback read video done\n");
2050 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
2051 u16 Index, u16 Value, void *TransferBuffer,
2052 s32 TransferBufferLength, int bOut)
2056 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2058 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
2060 Value, Index, TransferBuffer,
2061 TransferBufferLength, HZ * 5);
2063 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2064 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2065 Value, Index, TransferBuffer,
2066 TransferBufferLength, HZ * 5);
2072 * retrieve FX2 firmware version. future use.
2073 * @param dev pointer to device extension
2074 * @return -1 for fail, else returns firmware version as an int(16 bits)
2076 static int s2255_get_fx2fw(struct s2255_dev *dev)
2080 unsigned char transBuffer[64];
2081 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2084 dprintk(2, "get fw error: %x\n", ret);
2085 fw = transBuffer[0] + (transBuffer[1] << 8);
2086 dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2091 * Create the system ring buffer to copy frames into from the
2094 static int s2255_create_sys_buffers(struct s2255_dev *dev, unsigned long chn)
2097 unsigned long reqsize;
2098 dprintk(1, "create sys buffers\n");
2099 if (chn >= MAX_CHANNELS)
2102 dev->buffer[chn].dwFrames = SYS_FRAMES;
2104 /* always allocate maximum size(PAL) for system buffers */
2105 reqsize = SYS_FRAMES_MAXSIZE;
2107 if (reqsize > SYS_FRAMES_MAXSIZE)
2108 reqsize = SYS_FRAMES_MAXSIZE;
2110 for (i = 0; i < SYS_FRAMES; i++) {
2111 /* allocate the frames */
2112 dev->buffer[chn].frame[i].lpvbits = vmalloc(reqsize);
2114 dprintk(1, "valloc %p chan %lu, idx %lu, pdata %p\n",
2115 &dev->buffer[chn].frame[i], chn, i,
2116 dev->buffer[chn].frame[i].lpvbits);
2117 dev->buffer[chn].frame[i].size = reqsize;
2118 if (dev->buffer[chn].frame[i].lpvbits == NULL) {
2119 printk(KERN_INFO "out of memory. using less frames\n");
2120 dev->buffer[chn].dwFrames = i;
2125 /* make sure internal states are set */
2126 for (i = 0; i < SYS_FRAMES; i++) {
2127 dev->buffer[chn].frame[i].ulState = 0;
2128 dev->buffer[chn].frame[i].cur_size = 0;
2131 dev->cur_frame[chn] = 0;
2132 dev->last_frame[chn] = -1;
2136 static int s2255_release_sys_buffers(struct s2255_dev *dev,
2137 unsigned long channel)
2140 dprintk(1, "release sys buffers\n");
2141 for (i = 0; i < SYS_FRAMES; i++) {
2142 if (dev->buffer[channel].frame[i].lpvbits) {
2143 dprintk(1, "vfree %p\n",
2144 dev->buffer[channel].frame[i].lpvbits);
2145 vfree(dev->buffer[channel].frame[i].lpvbits);
2147 dev->buffer[channel].frame[i].lpvbits = NULL;
2152 static int s2255_board_init(struct s2255_dev *dev)
2155 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2157 dprintk(4, "board init: %p", dev);
2159 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2160 struct s2255_pipeinfo *pipe = &dev->pipes[j];
2162 memset(pipe, 0, sizeof(*pipe));
2164 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2165 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
2167 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2169 if (pipe->transfer_buffer == NULL) {
2170 dprintk(1, "out of memory!\n");
2176 /* query the firmware */
2177 fw_ver = s2255_get_fx2fw(dev);
2179 printk(KERN_INFO "2255 usb firmware version %d \n", fw_ver);
2180 if (fw_ver < CUR_USB_FWVER)
2181 dev_err(&dev->udev->dev,
2182 "usb firmware not up to date %d\n", fw_ver);
2184 for (j = 0; j < MAX_CHANNELS; j++) {
2185 dev->b_acquire[j] = 0;
2186 dev->mode[j] = mode_def;
2187 dev->jc[j].quality = S2255_DEF_JPEG_QUAL;
2188 dev->cur_fmt[j] = &formats[0];
2189 dev->mode[j].restart = 1;
2190 dev->req_image_size[j] = get_transfer_size(&mode_def);
2191 dev->frame_count[j] = 0;
2192 /* create the system buffers */
2193 s2255_create_sys_buffers(dev, j);
2195 /* start read pipe */
2196 s2255_start_readpipe(dev);
2198 dprintk(1, "S2255: board initialized\n");
2202 static int s2255_board_shutdown(struct s2255_dev *dev)
2206 dprintk(1, "S2255: board shutdown: %p", dev);
2208 for (i = 0; i < MAX_CHANNELS; i++) {
2209 if (dev->b_acquire[i])
2210 s2255_stop_acquire(dev, i);
2213 s2255_stop_readpipe(dev);
2215 for (i = 0; i < MAX_CHANNELS; i++)
2216 s2255_release_sys_buffers(dev, i);
2218 /* release transfer buffers */
2219 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2220 struct s2255_pipeinfo *pipe = &dev->pipes[i];
2221 kfree(pipe->transfer_buffer);
2226 static void read_pipe_completion(struct urb *purb)
2228 struct s2255_pipeinfo *pipe_info;
2229 struct s2255_dev *dev;
2233 pipe_info = purb->context;
2234 dprintk(100, "read pipe completion %p, status %d\n", purb,
2236 if (pipe_info == NULL) {
2237 dev_err(&purb->dev->dev, "no context!\n");
2241 dev = pipe_info->dev;
2243 dev_err(&purb->dev->dev, "no context!\n");
2246 status = purb->status;
2248 dprintk(2, "read_pipe_completion: err\n");
2252 if (pipe_info->state == 0) {
2253 dprintk(2, "exiting USB pipe");
2257 s2255_read_video_callback(dev, pipe_info);
2259 pipe_info->err_count = 0;
2260 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2262 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2264 pipe_info->transfer_buffer,
2265 pipe_info->cur_transfer_size,
2266 read_pipe_completion, pipe_info);
2268 if (pipe_info->state != 0) {
2269 if (usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL)) {
2270 dev_err(&dev->udev->dev, "error submitting urb\n");
2271 usb_free_urb(pipe_info->stream_urb);
2274 dprintk(2, "read pipe complete state 0\n");
2279 static int s2255_start_readpipe(struct s2255_dev *dev)
2284 struct s2255_pipeinfo *pipe_info = dev->pipes;
2285 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2286 dprintk(2, "start pipe IN %d\n", dev->read_endpoint);
2288 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2289 pipe_info->state = 1;
2290 pipe_info->buf_index = (u32) i;
2291 pipe_info->priority_set = 0;
2292 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2293 if (!pipe_info->stream_urb) {
2294 dev_err(&dev->udev->dev,
2295 "ReadStream: Unable to alloc URB\n");
2298 /* transfer buffer allocated in board_init */
2299 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2301 pipe_info->transfer_buffer,
2302 pipe_info->cur_transfer_size,
2303 read_pipe_completion, pipe_info);
2305 pipe_info->urb_size = sizeof(pipe_info->stream_urb);
2306 dprintk(4, "submitting URB %p\n", pipe_info->stream_urb);
2307 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2309 printk(KERN_ERR "s2255: start read pipe failed\n");
2317 /* starts acquisition process */
2318 static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn)
2320 unsigned char *buffer;
2322 unsigned long chn_rev;
2324 if (chn >= MAX_CHANNELS) {
2325 dprintk(2, "start acquire failed, bad channel %lu\n", chn);
2329 chn_rev = G_chnmap[chn];
2330 dprintk(1, "S2255: start acquire %lu \n", chn);
2332 buffer = kzalloc(512, GFP_KERNEL);
2333 if (buffer == NULL) {
2334 dev_err(&dev->udev->dev, "out of mem\n");
2338 dev->last_frame[chn] = -1;
2339 dev->bad_payload[chn] = 0;
2340 dev->cur_frame[chn] = 0;
2341 for (j = 0; j < SYS_FRAMES; j++) {
2342 dev->buffer[chn].frame[j].ulState = 0;
2343 dev->buffer[chn].frame[j].cur_size = 0;
2346 /* send the start command */
2347 *(u32 *) buffer = IN_DATA_TOKEN;
2348 *((u32 *) buffer + 1) = (u32) chn_rev;
2349 *((u32 *) buffer + 2) = (u32) CMD_START;
2350 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2352 dev_err(&dev->udev->dev, "CMD_START error\n");
2354 dprintk(2, "start acquire exit[%lu] %d \n", chn, res);
2359 static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
2361 unsigned char *buffer;
2363 unsigned long chn_rev;
2365 if (chn >= MAX_CHANNELS) {
2366 dprintk(2, "stop acquire failed, bad channel %lu\n", chn);
2369 chn_rev = G_chnmap[chn];
2371 buffer = kzalloc(512, GFP_KERNEL);
2372 if (buffer == NULL) {
2373 dev_err(&dev->udev->dev, "out of mem\n");
2377 /* send the stop command */
2378 dprintk(4, "stop acquire %lu\n", chn);
2379 *(u32 *) buffer = IN_DATA_TOKEN;
2380 *((u32 *) buffer + 1) = (u32) chn_rev;
2381 *((u32 *) buffer + 2) = CMD_STOP;
2382 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2385 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2387 dprintk(4, "stop acquire: releasing states \n");
2390 dev->b_acquire[chn] = 0;
2395 static void s2255_stop_readpipe(struct s2255_dev *dev)
2400 s2255_dev_err(&dev->udev->dev, "invalid device\n");
2403 dprintk(4, "stop read pipe\n");
2404 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2405 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2407 if (pipe_info->state == 0)
2409 pipe_info->state = 0;
2410 pipe_info->prev_state = 1;
2415 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2416 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2417 if (pipe_info->stream_urb) {
2419 usb_kill_urb(pipe_info->stream_urb);
2420 usb_free_urb(pipe_info->stream_urb);
2421 pipe_info->stream_urb = NULL;
2424 dprintk(2, "s2255 stop read pipe: %d\n", j);
2428 static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2431 s2255_reset_dsppower(dev);
2432 dev->fw_data->fw_size = dev->fw_data->fw->size;
2433 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2434 memcpy(dev->fw_data->pfw_data,
2435 dev->fw_data->fw->data, CHUNK_SIZE);
2436 dev->fw_data->fw_loaded = CHUNK_SIZE;
2437 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2438 usb_sndbulkpipe(dev->udev, 2),
2439 dev->fw_data->pfw_data,
2440 CHUNK_SIZE, s2255_fwchunk_complete,
2442 mod_timer(&dev->timer, jiffies + HZ);
2445 /* standard usb probe function */
2446 static int s2255_probe(struct usb_interface *interface,
2447 const struct usb_device_id *id)
2449 struct s2255_dev *dev = NULL;
2450 struct usb_host_interface *iface_desc;
2451 struct usb_endpoint_descriptor *endpoint;
2453 int retval = -ENOMEM;
2457 dprintk(2, "s2255: probe\n");
2459 /* allocate memory for our device state and initialize it to zero */
2460 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2462 s2255_dev_err(&interface->dev, "out of memory\n");
2466 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2470 mutex_init(&dev->lock);
2471 mutex_init(&dev->open_lock);
2473 /* grab usb_device and save it */
2474 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2475 if (dev->udev == NULL) {
2476 dev_err(&interface->dev, "null usb device\n");
2480 kref_init(&dev->kref);
2481 dprintk(1, "dev: %p, kref: %p udev %p interface %p\n", dev, &dev->kref,
2482 dev->udev, interface);
2483 dev->interface = interface;
2484 /* set up the endpoint information */
2485 iface_desc = interface->cur_altsetting;
2486 dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2487 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2488 endpoint = &iface_desc->endpoint[i].desc;
2489 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2490 /* we found the bulk in endpoint */
2491 dev->read_endpoint = endpoint->bEndpointAddress;
2495 if (!dev->read_endpoint) {
2496 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2501 usb_set_intfdata(interface, dev);
2503 dprintk(100, "after intfdata %p\n", dev);
2505 init_timer(&dev->timer);
2506 dev->timer.function = s2255_timer;
2507 dev->timer.data = (unsigned long)dev->fw_data;
2509 init_waitqueue_head(&dev->fw_data->wait_fw);
2510 for (i = 0; i < MAX_CHANNELS; i++)
2511 init_waitqueue_head(&dev->wait_setmode[i]);
2514 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2516 if (!dev->fw_data->fw_urb) {
2517 dev_err(&interface->dev, "out of memory!\n");
2520 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2521 if (!dev->fw_data->pfw_data) {
2522 dev_err(&interface->dev, "out of memory!\n");
2525 /* load the first chunk */
2526 if (request_firmware(&dev->fw_data->fw,
2527 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2528 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2531 /* check the firmware is valid */
2532 fw_size = dev->fw_data->fw->size;
2533 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2535 if (*pdata != S2255_FW_MARKER) {
2536 printk(KERN_INFO "Firmware invalid.\n");
2540 /* make sure firmware is the latest */
2542 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2543 printk(KERN_INFO "s2255 dsp fw version %x\n", *pRel);
2545 /* loads v4l specific */
2546 s2255_probe_v4l(dev);
2547 usb_reset_device(dev->udev);
2548 /* load 2255 board specific */
2549 s2255_board_init(dev);
2551 dprintk(4, "before probe done %p\n", dev);
2552 spin_lock_init(&dev->slock);
2554 s2255_fwload_start(dev, 0);
2555 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2561 /* disconnect routine. when board is removed physically or with rmmod */
2562 static void s2255_disconnect(struct usb_interface *interface)
2564 struct s2255_dev *dev = NULL;
2566 dprintk(1, "s2255: disconnect interface %p\n", interface);
2567 dev = usb_get_intfdata(interface);
2570 * wake up any of the timers to allow open_lock to be
2573 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2574 wake_up(&dev->fw_data->wait_fw);
2575 for (i = 0; i < MAX_CHANNELS; i++) {
2576 dev->setmode_ready[i] = 1;
2577 wake_up(&dev->wait_setmode[i]);
2580 mutex_lock(&dev->open_lock);
2581 usb_set_intfdata(interface, NULL);
2582 mutex_unlock(&dev->open_lock);
2585 kref_put(&dev->kref, s2255_destroy);
2586 dprintk(1, "s2255drv: disconnect\n");
2587 dev_info(&interface->dev, "s2255usb now disconnected\n");
2591 static struct usb_driver s2255_driver = {
2592 .name = S2255_DRIVER_NAME,
2593 .probe = s2255_probe,
2594 .disconnect = s2255_disconnect,
2595 .id_table = s2255_table,
2598 static int __init usb_s2255_init(void)
2602 /* register this driver with the USB subsystem */
2603 result = usb_register(&s2255_driver);
2606 pr_err(KBUILD_MODNAME
2607 ": usb_register failed. Error number %d\n", result);
2609 dprintk(2, "s2255_init: done\n");
2613 static void __exit usb_s2255_exit(void)
2615 usb_deregister(&s2255_driver);
2618 module_init(usb_s2255_init);
2619 module_exit(usb_s2255_exit);
2621 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2622 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2623 MODULE_LICENSE("GPL");