2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
4 * Copyright (C) 2007-2010 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
19 * -full or half size Grey scale: all 4 channels at once
20 * -half size, color mode YUYV or YUV422P: all 4 channels at once
21 * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2 of the License, or
27 * (at your option) any later version.
29 * This program is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 * GNU General Public License for more details.
34 * You should have received a copy of the GNU General Public License
35 * along with this program; if not, write to the Free Software
36 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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>
46 #include <media/videobuf-vmalloc.h>
47 #include <media/v4l2-common.h>
48 #include <media/v4l2-device.h>
49 #include <media/v4l2-ioctl.h>
50 #include <linux/vmalloc.h>
51 #include <linux/usb.h>
53 #define S2255_VERSION "1.22.1"
54 #define FIRMWARE_FILE_NAME "f2255usb.bin"
56 /* default JPEG quality */
57 #define S2255_DEF_JPEG_QUAL 50
58 /* vendor request in */
60 /* vendor request out */
61 #define S2255_VR_OUT 1
63 #define S2255_VR_FW 0x30
64 /* USB endpoint number for configuring the device */
65 #define S2255_CONFIG_EP 2
66 /* maximum time for DSP to start responding after last FW word loaded(ms) */
67 #define S2255_DSP_BOOTTIME 800
68 /* maximum time to wait for firmware to load (ms) */
69 #define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
70 #define S2255_DEF_BUFS 16
71 #define S2255_SETMODE_TIMEOUT 500
72 #define S2255_VIDSTATUS_TIMEOUT 350
73 #define S2255_MARKER_FRAME cpu_to_le32(0x2255DA4AL)
74 #define S2255_MARKER_RESPONSE cpu_to_le32(0x2255ACACL)
75 #define S2255_RESPONSE_SETMODE cpu_to_le32(0x01)
76 #define S2255_RESPONSE_FW cpu_to_le32(0x10)
77 #define S2255_RESPONSE_STATUS cpu_to_le32(0x20)
78 #define S2255_USB_XFER_SIZE (16 * 1024)
79 #define MAX_CHANNELS 4
81 /* maximum size is PAL full size plus room for the marker header(s) */
82 #define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
83 #define DEF_USB_BLOCK S2255_USB_XFER_SIZE
84 #define LINE_SZ_4CIFS_NTSC 640
85 #define LINE_SZ_2CIFS_NTSC 640
86 #define LINE_SZ_1CIFS_NTSC 320
87 #define LINE_SZ_4CIFS_PAL 704
88 #define LINE_SZ_2CIFS_PAL 704
89 #define LINE_SZ_1CIFS_PAL 352
90 #define NUM_LINES_4CIFS_NTSC 240
91 #define NUM_LINES_2CIFS_NTSC 240
92 #define NUM_LINES_1CIFS_NTSC 240
93 #define NUM_LINES_4CIFS_PAL 288
94 #define NUM_LINES_2CIFS_PAL 288
95 #define NUM_LINES_1CIFS_PAL 288
96 #define LINE_SZ_DEF 640
97 #define NUM_LINES_DEF 240
100 /* predefined settings */
101 #define FORMAT_NTSC 1
104 #define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
105 #define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
106 #define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
107 /* SCALE_4CIFSI is the 2 fields interpolated into one */
108 #define SCALE_4CIFSI 4 /* 640x480(NTSC) or 704x576(PAL) high quality */
110 #define COLOR_YUVPL 1 /* YUV planar */
111 #define COLOR_YUVPK 2 /* YUV packed */
112 #define COLOR_Y8 4 /* monochrome */
113 #define COLOR_JPG 5 /* JPEG */
115 #define MASK_COLOR 0x000000ff
116 #define MASK_JPG_QUALITY 0x0000ff00
117 #define MASK_INPUT_TYPE 0x000f0000
118 /* frame decimation. */
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 cpu_to_le32(0x2255c0de)
137 #define CMD_2255 0xc2255000
138 #define CMD_SET_MODE cpu_to_le32((CMD_2255 | 0x10))
139 #define CMD_START cpu_to_le32((CMD_2255 | 0x20))
140 #define CMD_STOP cpu_to_le32((CMD_2255 | 0x30))
141 #define CMD_STATUS cpu_to_le32((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 struct s2255_dev *dev;
184 /* for firmware loading, fw_state */
185 #define S2255_FW_NOTLOADED 0
186 #define S2255_FW_LOADED_DSPWAIT 1
187 #define S2255_FW_SUCCESS 2
188 #define S2255_FW_FAILED 3
189 #define S2255_FW_DISCONNECTING 4
190 #define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
191 /* 2255 read states */
192 #define S2255_READ_IDLE 0
193 #define S2255_READ_FRAME 1
200 wait_queue_head_t wait_fw;
201 const struct firmware *fw;
204 struct s2255_pipeinfo {
205 u32 max_transfer_size;
206 u32 cur_transfer_size;
210 void *dev; /* back pointer to s2255_dev struct*/
215 struct s2255_fmt; /*forward declaration */
218 struct s2255_channel {
219 struct video_device vdev;
221 struct s2255_dmaqueue vidq;
222 struct s2255_bufferi buffer;
223 struct s2255_mode mode;
224 /* jpeg compression */
225 struct v4l2_jpegcompression jc;
226 /* capture parameters (for high quality mode full size) */
227 struct v4l2_captureparm cap_parm;
232 /* allocated image size */
233 unsigned long req_image_size;
234 /* received packet size */
235 unsigned long pkt_size;
237 unsigned long frame_count;
240 /* if channel configured to default state */
242 wait_queue_head_t wait_setmode;
244 /* video status items */
246 wait_queue_head_t wait_vidstatus;
250 const struct s2255_fmt *fmt;
251 int idx; /* channel number on device, 0-3 */
256 struct s2255_channel channel[MAX_CHANNELS];
257 struct v4l2_device v4l2_dev;
258 atomic_t num_channels;
260 struct mutex lock; /* channels[].vdev.lock */
261 struct mutex open_lock;
262 struct usb_device *udev;
263 struct usb_interface *interface;
265 struct timer_list timer;
266 struct s2255_fw *fw_data;
267 struct s2255_pipeinfo pipe;
268 u32 cc; /* current channel */
272 /* dsp firmware version (f2255usb.bin) */
274 u16 pid; /* product id */
277 static inline struct s2255_dev *to_s2255_dev(struct v4l2_device *v4l2_dev)
279 return container_of(v4l2_dev, struct s2255_dev, v4l2_dev);
288 /* buffer for one video frame */
289 struct s2255_buffer {
290 /* common v4l buffer stuff -- must be first */
291 struct videobuf_buffer vb;
292 const struct s2255_fmt *fmt;
296 struct s2255_dev *dev;
297 struct videobuf_queue vb_vidq;
298 enum v4l2_buf_type type;
299 struct s2255_channel *channel;
303 /* current cypress EEPROM firmware version */
304 #define S2255_CUR_USB_FWVER ((3 << 8) | 12)
305 /* current DSP FW version */
306 #define S2255_CUR_DSP_FWVER 10104
307 /* Need DSP version 5+ for video status feature */
308 #define S2255_MIN_DSP_STATUS 5
309 #define S2255_MIN_DSP_COLORFILTER 8
310 #define S2255_NORMS (V4L2_STD_PAL | V4L2_STD_NTSC)
312 /* private V4L2 controls */
315 * The following chart displays how COLORFILTER should be set
316 * =========================================================
317 * = fourcc = COLORFILTER =
318 * = ===============================
320 * =========================================================
321 * = V4L2_PIX_FMT_GREY(Y8) = monochrome from = monochrome=
322 * = = s-video or = composite =
323 * = = B/W camera = input =
324 * =========================================================
325 * = other = color, svideo = color, =
327 * =========================================================
330 * channels 0-3 on 2255 are composite
331 * channels 0-1 on 2257 are composite, 2-3 are s-video
332 * If COLORFILTER is 0 with a composite color camera connected,
333 * the output will appear monochrome but hatching
335 * COLORFILTER is different from "color killer" and "color effects"
338 #define S2255_V4L2_YC_ON 1
339 #define S2255_V4L2_YC_OFF 0
340 #define V4L2_CID_PRIVATE_COLORFILTER (V4L2_CID_PRIVATE_BASE + 0)
342 /* frame prefix size (sent once every frame) */
343 #define PREFIX_SIZE 512
345 /* Channels on box are in reverse order */
346 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
349 static int *s2255_debug = &debug;
351 static int s2255_start_readpipe(struct s2255_dev *dev);
352 static void s2255_stop_readpipe(struct s2255_dev *dev);
353 static int s2255_start_acquire(struct s2255_channel *channel);
354 static int s2255_stop_acquire(struct s2255_channel *channel);
355 static void s2255_fillbuff(struct s2255_channel *chn, struct s2255_buffer *buf,
357 static int s2255_set_mode(struct s2255_channel *chan, struct s2255_mode *mode);
358 static int s2255_board_shutdown(struct s2255_dev *dev);
359 static void s2255_fwload_start(struct s2255_dev *dev, int reset);
360 static void s2255_destroy(struct s2255_dev *dev);
361 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
362 u16 index, u16 value, void *buf,
363 s32 buf_len, int bOut);
365 /* dev_err macro with driver name */
366 #define S2255_DRIVER_NAME "s2255"
367 #define s2255_dev_err(dev, fmt, arg...) \
368 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
370 #define dprintk(level, fmt, arg...) \
372 if (*s2255_debug >= (level)) { \
373 printk(KERN_DEBUG S2255_DRIVER_NAME \
378 static struct usb_driver s2255_driver;
380 /* Declare static vars that will be used as parameters */
381 static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
383 /* start video number */
384 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
386 /* Enable jpeg capture. */
387 static int jpeg_enable = 1;
389 module_param(debug, int, 0644);
390 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
391 module_param(vid_limit, int, 0644);
392 MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)");
393 module_param(video_nr, int, 0644);
394 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
395 module_param(jpeg_enable, int, 0644);
396 MODULE_PARM_DESC(jpeg_enable, "Jpeg enable(1-on 0-off) default 1");
398 /* USB device table */
399 #define USB_SENSORAY_VID 0x1943
400 static struct usb_device_id s2255_table[] = {
401 {USB_DEVICE(USB_SENSORAY_VID, 0x2255)},
402 {USB_DEVICE(USB_SENSORAY_VID, 0x2257)}, /*same family as 2255*/
403 { } /* Terminating entry */
405 MODULE_DEVICE_TABLE(usb, s2255_table);
407 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
410 /* JPEG formats must be defined last to support jpeg_enable parameter */
411 static const struct s2255_fmt formats[] = {
413 .name = "4:2:2, planar, YUV422P",
414 .fourcc = V4L2_PIX_FMT_YUV422P,
418 .name = "4:2:2, packed, YUYV",
419 .fourcc = V4L2_PIX_FMT_YUYV,
423 .name = "4:2:2, packed, UYVY",
424 .fourcc = V4L2_PIX_FMT_UYVY,
428 .fourcc = V4L2_PIX_FMT_GREY,
432 .fourcc = V4L2_PIX_FMT_JPEG,
436 .fourcc = V4L2_PIX_FMT_MJPEG,
441 static int norm_maxw(struct video_device *vdev)
443 return (vdev->current_norm & V4L2_STD_NTSC) ?
444 LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
447 static int norm_maxh(struct video_device *vdev)
449 return (vdev->current_norm & V4L2_STD_NTSC) ?
450 (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
453 static int norm_minw(struct video_device *vdev)
455 return (vdev->current_norm & V4L2_STD_NTSC) ?
456 LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
459 static int norm_minh(struct video_device *vdev)
461 return (vdev->current_norm & V4L2_STD_NTSC) ?
462 (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
467 * TODO: fixme: move YUV reordering to hardware
468 * converts 2255 planar format to yuyv or uyvy
470 static void planar422p_to_yuv_packed(const unsigned char *in,
472 int width, int height,
478 unsigned long size = height * width;
480 pY = (unsigned char *)in;
481 pCr = (unsigned char *)in + height * width;
482 pCb = (unsigned char *)in + height * width + (height * width / 2);
483 for (i = 0; i < size * 2; i += 4) {
484 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
485 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
486 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
487 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
492 static void s2255_reset_dsppower(struct s2255_dev *dev)
494 s2255_vendor_req(dev, 0x40, 0x0000, 0x0001, NULL, 0, 1);
496 s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
498 s2255_vendor_req(dev, 0x10, 0x0000, 0x0000, NULL, 0, 1);
502 /* kickstarts the firmware loading. from probe
504 static void s2255_timer(unsigned long user_data)
506 struct s2255_fw *data = (struct s2255_fw *)user_data;
507 dprintk(100, "%s\n", __func__);
508 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
509 printk(KERN_ERR "s2255: can't submit urb\n");
510 atomic_set(&data->fw_state, S2255_FW_FAILED);
511 /* wake up anything waiting for the firmware */
512 wake_up(&data->wait_fw);
518 /* this loads the firmware asynchronously.
519 Originally this was done synchroously in probe.
520 But it is better to load it asynchronously here than block
521 inside the probe function. Blocking inside probe affects boot time.
522 FW loading is triggered by the timer in the probe function
524 static void s2255_fwchunk_complete(struct urb *urb)
526 struct s2255_fw *data = urb->context;
527 struct usb_device *udev = urb->dev;
529 dprintk(100, "%s: udev %p urb %p", __func__, udev, urb);
531 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
532 atomic_set(&data->fw_state, S2255_FW_FAILED);
533 /* wake up anything waiting for the firmware */
534 wake_up(&data->wait_fw);
537 if (data->fw_urb == NULL) {
538 s2255_dev_err(&udev->dev, "disconnected\n");
539 atomic_set(&data->fw_state, S2255_FW_FAILED);
540 /* wake up anything waiting for the firmware */
541 wake_up(&data->wait_fw);
544 #define CHUNK_SIZE 512
545 /* all USB transfers must be done with continuous kernel memory.
546 can't allocate more than 128k in current linux kernel, so
547 upload the firmware in chunks
549 if (data->fw_loaded < data->fw_size) {
550 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
551 data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
553 if (len < CHUNK_SIZE)
554 memset(data->pfw_data, 0, CHUNK_SIZE);
556 dprintk(100, "completed len %d, loaded %d \n", len,
559 memcpy(data->pfw_data,
560 (char *) data->fw->data + data->fw_loaded, len);
562 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
563 data->pfw_data, CHUNK_SIZE,
564 s2255_fwchunk_complete, data);
565 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
566 dev_err(&udev->dev, "failed submit URB\n");
567 atomic_set(&data->fw_state, S2255_FW_FAILED);
568 /* wake up anything waiting for the firmware */
569 wake_up(&data->wait_fw);
572 data->fw_loaded += len;
574 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
575 dprintk(100, "%s: firmware upload complete\n", __func__);
581 static int s2255_got_frame(struct s2255_channel *channel, int jpgsize)
583 struct s2255_dmaqueue *dma_q = &channel->vidq;
584 struct s2255_buffer *buf;
585 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
586 unsigned long flags = 0;
588 spin_lock_irqsave(&dev->slock, flags);
589 if (list_empty(&dma_q->active)) {
590 dprintk(1, "No active queue to serve\n");
594 buf = list_entry(dma_q->active.next,
595 struct s2255_buffer, vb.queue);
596 list_del(&buf->vb.queue);
597 do_gettimeofday(&buf->vb.ts);
598 s2255_fillbuff(channel, buf, jpgsize);
599 wake_up(&buf->vb.done);
600 dprintk(2, "%s: [buf/i] [%p/%d]\n", __func__, buf, buf->vb.i);
602 spin_unlock_irqrestore(&dev->slock, flags);
606 static const struct s2255_fmt *format_by_fourcc(int fourcc)
609 for (i = 0; i < ARRAY_SIZE(formats); i++) {
610 if (-1 == formats[i].fourcc)
612 if (!jpeg_enable && ((formats[i].fourcc == V4L2_PIX_FMT_JPEG) ||
613 (formats[i].fourcc == V4L2_PIX_FMT_MJPEG)))
615 if (formats[i].fourcc == fourcc)
621 /* video buffer vmalloc implementation based partly on VIVI driver which is
622 * Copyright (c) 2006 by
623 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
624 * Ted Walther <ted--a.t--enumera.com>
625 * John Sokol <sokol--a.t--videotechnology.com>
626 * http://v4l.videotechnology.com/
629 static void s2255_fillbuff(struct s2255_channel *channel,
630 struct s2255_buffer *buf, int jpgsize)
635 char *vbuf = videobuf_to_vmalloc(&buf->vb);
636 unsigned long last_frame;
640 last_frame = channel->last_frame;
641 if (last_frame != -1) {
643 (const char *)channel->buffer.frame[last_frame].lpvbits;
644 switch (buf->fmt->fourcc) {
645 case V4L2_PIX_FMT_YUYV:
646 case V4L2_PIX_FMT_UYVY:
647 planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
652 case V4L2_PIX_FMT_GREY:
653 memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
655 case V4L2_PIX_FMT_JPEG:
656 case V4L2_PIX_FMT_MJPEG:
657 buf->vb.size = jpgsize;
658 memcpy(vbuf, tmpbuf, buf->vb.size);
660 case V4L2_PIX_FMT_YUV422P:
662 buf->vb.width * buf->vb.height * 2);
665 printk(KERN_DEBUG "s2255: unknown format?\n");
667 channel->last_frame = -1;
669 printk(KERN_ERR "s2255: =======no frame\n");
673 dprintk(2, "s2255fill at : Buffer 0x%08lx size= %d\n",
674 (unsigned long)vbuf, pos);
675 /* tell v4l buffer was filled */
677 buf->vb.field_count = channel->frame_count * 2;
678 do_gettimeofday(&ts);
680 buf->vb.state = VIDEOBUF_DONE;
684 /* ------------------------------------------------------------------
686 ------------------------------------------------------------------*/
688 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
691 struct s2255_fh *fh = vq->priv_data;
692 struct s2255_channel *channel = fh->channel;
693 *size = channel->width * channel->height * (channel->fmt->depth >> 3);
696 *count = S2255_DEF_BUFS;
698 if (*size * *count > vid_limit * 1024 * 1024)
699 *count = (vid_limit * 1024 * 1024) / *size;
704 static void free_buffer(struct videobuf_queue *vq, struct s2255_buffer *buf)
706 dprintk(4, "%s\n", __func__);
708 videobuf_vmalloc_free(&buf->vb);
709 buf->vb.state = VIDEOBUF_NEEDS_INIT;
712 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
713 enum v4l2_field field)
715 struct s2255_fh *fh = vq->priv_data;
716 struct s2255_channel *channel = fh->channel;
717 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
719 int w = channel->width;
720 int h = channel->height;
721 dprintk(4, "%s, field=%d\n", __func__, field);
722 if (channel->fmt == NULL)
725 if ((w < norm_minw(&channel->vdev)) ||
726 (w > norm_maxw(&channel->vdev)) ||
727 (h < norm_minh(&channel->vdev)) ||
728 (h > norm_maxh(&channel->vdev))) {
729 dprintk(4, "invalid buffer prepare\n");
732 buf->vb.size = w * h * (channel->fmt->depth >> 3);
733 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
734 dprintk(4, "invalid buffer prepare\n");
738 buf->fmt = channel->fmt;
741 buf->vb.field = field;
743 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
744 rc = videobuf_iolock(vq, &buf->vb, NULL);
749 buf->vb.state = VIDEOBUF_PREPARED;
752 free_buffer(vq, buf);
756 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
758 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
759 struct s2255_fh *fh = vq->priv_data;
760 struct s2255_channel *channel = fh->channel;
761 struct s2255_dmaqueue *vidq = &channel->vidq;
762 dprintk(1, "%s\n", __func__);
763 buf->vb.state = VIDEOBUF_QUEUED;
764 list_add_tail(&buf->vb.queue, &vidq->active);
767 static void buffer_release(struct videobuf_queue *vq,
768 struct videobuf_buffer *vb)
770 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
771 struct s2255_fh *fh = vq->priv_data;
772 dprintk(4, "%s %d\n", __func__, fh->channel->idx);
773 free_buffer(vq, buf);
776 static struct videobuf_queue_ops s2255_video_qops = {
777 .buf_setup = buffer_setup,
778 .buf_prepare = buffer_prepare,
779 .buf_queue = buffer_queue,
780 .buf_release = buffer_release,
784 static int res_get(struct s2255_fh *fh)
786 struct s2255_channel *channel = fh->channel;
788 if (channel->resources)
789 return 0; /* no, someone else uses it */
790 /* it's free, grab it */
791 channel->resources = 1;
793 dprintk(1, "s2255: res: get\n");
797 static int res_locked(struct s2255_fh *fh)
799 return fh->channel->resources;
802 static int res_check(struct s2255_fh *fh)
804 return fh->resources;
808 static void res_free(struct s2255_fh *fh)
810 struct s2255_channel *channel = fh->channel;
811 channel->resources = 0;
813 dprintk(1, "res: put\n");
816 static int vidioc_querymenu(struct file *file, void *priv,
817 struct v4l2_querymenu *qmenu)
819 static const char *colorfilter[] = {
824 if (qmenu->id == V4L2_CID_PRIVATE_COLORFILTER) {
826 const char **menu_items = colorfilter;
827 for (i = 0; i < qmenu->index && menu_items[i]; i++)
828 ; /* do nothing (from v4l2-common.c) */
829 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
831 strlcpy(qmenu->name, menu_items[qmenu->index],
832 sizeof(qmenu->name));
835 return v4l2_ctrl_query_menu(qmenu, NULL, NULL);
838 static int vidioc_querycap(struct file *file, void *priv,
839 struct v4l2_capability *cap)
841 struct s2255_fh *fh = file->private_data;
842 struct s2255_dev *dev = fh->dev;
843 strlcpy(cap->driver, "s2255", sizeof(cap->driver));
844 strlcpy(cap->card, "s2255", sizeof(cap->card));
845 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
846 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
850 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
851 struct v4l2_fmtdesc *f)
853 int index = f->index;
855 if (index >= ARRAY_SIZE(formats))
857 if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
858 (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
860 dprintk(4, "name %s\n", formats[index].name);
861 strlcpy(f->description, formats[index].name, sizeof(f->description));
862 f->pixelformat = formats[index].fourcc;
866 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
867 struct v4l2_format *f)
869 struct s2255_fh *fh = priv;
870 struct s2255_channel *channel = fh->channel;
872 f->fmt.pix.width = channel->width;
873 f->fmt.pix.height = channel->height;
874 f->fmt.pix.field = fh->vb_vidq.field;
875 f->fmt.pix.pixelformat = channel->fmt->fourcc;
876 f->fmt.pix.bytesperline = f->fmt.pix.width * (channel->fmt->depth >> 3);
877 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
881 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
882 struct v4l2_format *f)
884 const struct s2255_fmt *fmt;
885 enum v4l2_field field;
887 struct s2255_fh *fh = priv;
888 struct s2255_channel *channel = fh->channel;
891 (channel->vdev.current_norm & V4L2_STD_NTSC) ? 1 : 0;
893 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
898 field = f->fmt.pix.field;
899 if (field == V4L2_FIELD_ANY)
902 dprintk(50, "%s NTSC: %d suggested width: %d, height: %d\n",
903 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
906 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
907 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
909 field = V4L2_FIELD_SEQ_TB;
910 } else if (!((field == V4L2_FIELD_INTERLACED) ||
911 (field == V4L2_FIELD_SEQ_TB) ||
912 (field == V4L2_FIELD_INTERLACED_TB))) {
913 dprintk(1, "unsupported field setting\n");
917 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
919 field = V4L2_FIELD_TOP;
920 } else if (!((field == V4L2_FIELD_TOP) ||
921 (field == V4L2_FIELD_BOTTOM))) {
922 dprintk(1, "unsupported field setting\n");
927 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
928 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
929 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
930 f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
931 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
932 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
934 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
937 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
938 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
940 field = V4L2_FIELD_SEQ_TB;
941 } else if (!((field == V4L2_FIELD_INTERLACED) ||
942 (field == V4L2_FIELD_SEQ_TB) ||
943 (field == V4L2_FIELD_INTERLACED_TB))) {
944 dprintk(1, "unsupported field setting\n");
948 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
950 field = V4L2_FIELD_TOP;
951 } else if (!((field == V4L2_FIELD_TOP) ||
952 (field == V4L2_FIELD_BOTTOM))) {
953 dprintk(1, "unsupported field setting\n");
957 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) {
958 f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
959 field = V4L2_FIELD_SEQ_TB;
960 } else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL) {
961 f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
962 field = V4L2_FIELD_TOP;
963 } else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL) {
964 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
965 field = V4L2_FIELD_TOP;
967 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
968 field = V4L2_FIELD_TOP;
971 f->fmt.pix.field = field;
972 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
973 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
974 dprintk(50, "%s: set width %d height %d field %d\n", __func__,
975 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
979 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
980 struct v4l2_format *f)
982 struct s2255_fh *fh = priv;
983 struct s2255_channel *channel = fh->channel;
984 const struct s2255_fmt *fmt;
985 struct videobuf_queue *q = &fh->vb_vidq;
986 struct s2255_mode mode;
989 ret = vidioc_try_fmt_vid_cap(file, fh, f);
994 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
999 mutex_lock(&q->vb_lock);
1001 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1002 dprintk(1, "queue busy\n");
1007 if (res_locked(fh)) {
1008 dprintk(1, "%s: channel busy\n", __func__);
1012 mode = channel->mode;
1014 channel->width = f->fmt.pix.width;
1015 channel->height = f->fmt.pix.height;
1016 fh->vb_vidq.field = f->fmt.pix.field;
1018 if (channel->width > norm_minw(&channel->vdev)) {
1019 if (channel->height > norm_minh(&channel->vdev)) {
1020 if (channel->cap_parm.capturemode &
1021 V4L2_MODE_HIGHQUALITY)
1022 mode.scale = SCALE_4CIFSI;
1024 mode.scale = SCALE_4CIFS;
1026 mode.scale = SCALE_2CIFS;
1029 mode.scale = SCALE_1CIFS;
1032 switch (channel->fmt->fourcc) {
1033 case V4L2_PIX_FMT_GREY:
1034 mode.color &= ~MASK_COLOR;
1035 mode.color |= COLOR_Y8;
1037 case V4L2_PIX_FMT_JPEG:
1038 case V4L2_PIX_FMT_MJPEG:
1039 mode.color &= ~MASK_COLOR;
1040 mode.color |= COLOR_JPG;
1041 mode.color |= (channel->jc.quality << 8);
1043 case V4L2_PIX_FMT_YUV422P:
1044 mode.color &= ~MASK_COLOR;
1045 mode.color |= COLOR_YUVPL;
1047 case V4L2_PIX_FMT_YUYV:
1048 case V4L2_PIX_FMT_UYVY:
1050 mode.color &= ~MASK_COLOR;
1051 mode.color |= COLOR_YUVPK;
1054 if ((mode.color & MASK_COLOR) != (channel->mode.color & MASK_COLOR))
1056 else if (mode.scale != channel->mode.scale)
1058 else if (mode.format != channel->mode.format)
1060 channel->mode = mode;
1061 (void) s2255_set_mode(channel, &mode);
1064 mutex_unlock(&q->vb_lock);
1068 static int vidioc_reqbufs(struct file *file, void *priv,
1069 struct v4l2_requestbuffers *p)
1072 struct s2255_fh *fh = priv;
1073 rc = videobuf_reqbufs(&fh->vb_vidq, p);
1077 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1080 struct s2255_fh *fh = priv;
1081 rc = videobuf_querybuf(&fh->vb_vidq, p);
1085 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1088 struct s2255_fh *fh = priv;
1089 rc = videobuf_qbuf(&fh->vb_vidq, p);
1093 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1096 struct s2255_fh *fh = priv;
1097 rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
1101 /* write to the configuration pipe, synchronously */
1102 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1109 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
1110 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
1115 static u32 get_transfer_size(struct s2255_mode *mode)
1117 int linesPerFrame = LINE_SZ_DEF;
1118 int pixelsPerLine = NUM_LINES_DEF;
1121 unsigned int mask_mult;
1126 if (mode->format == FORMAT_NTSC) {
1127 switch (mode->scale) {
1130 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
1131 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
1134 linesPerFrame = NUM_LINES_2CIFS_NTSC;
1135 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
1138 linesPerFrame = NUM_LINES_1CIFS_NTSC;
1139 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
1144 } else if (mode->format == FORMAT_PAL) {
1145 switch (mode->scale) {
1148 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
1149 pixelsPerLine = LINE_SZ_4CIFS_PAL;
1152 linesPerFrame = NUM_LINES_2CIFS_PAL;
1153 pixelsPerLine = LINE_SZ_2CIFS_PAL;
1156 linesPerFrame = NUM_LINES_1CIFS_PAL;
1157 pixelsPerLine = LINE_SZ_1CIFS_PAL;
1163 outImageSize = linesPerFrame * pixelsPerLine;
1164 if ((mode->color & MASK_COLOR) != COLOR_Y8) {
1165 /* 2 bytes/pixel if not monochrome */
1169 /* total bytes to send including prefix and 4K padding;
1170 must be a multiple of USB_READ_SIZE */
1171 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
1172 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
1173 /* if size not a multiple of USB_READ_SIZE */
1174 if (usbInSize & ~mask_mult)
1175 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
1179 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
1181 struct device *dev = &sdev->udev->dev;
1182 dev_info(dev, "------------------------------------------------\n");
1183 dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
1184 dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
1185 dev_info(dev, "bright: 0x%x\n", mode->bright);
1186 dev_info(dev, "------------------------------------------------\n");
1190 * set mode is the function which controls the DSP.
1191 * the restart parameter in struct s2255_mode should be set whenever
1192 * the image size could change via color format, video system or image
1194 * When the restart parameter is set, we sleep for ONE frame to allow the
1195 * DSP time to get the new frame
1197 static int s2255_set_mode(struct s2255_channel *channel,
1198 struct s2255_mode *mode)
1202 unsigned long chn_rev;
1203 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
1204 chn_rev = G_chnmap[channel->idx];
1205 dprintk(3, "%s channel: %d\n", __func__, channel->idx);
1206 /* if JPEG, set the quality */
1207 if ((mode->color & MASK_COLOR) == COLOR_JPG) {
1208 mode->color &= ~MASK_COLOR;
1209 mode->color |= COLOR_JPG;
1210 mode->color &= ~MASK_JPG_QUALITY;
1211 mode->color |= (channel->jc.quality << 8);
1214 channel->mode = *mode;
1215 channel->req_image_size = get_transfer_size(mode);
1216 dprintk(1, "%s: reqsize %ld\n", __func__, channel->req_image_size);
1217 buffer = kzalloc(512, GFP_KERNEL);
1218 if (buffer == NULL) {
1219 dev_err(&dev->udev->dev, "out of mem\n");
1223 buffer[0] = IN_DATA_TOKEN;
1224 buffer[1] = (__le32) cpu_to_le32(chn_rev);
1225 buffer[2] = CMD_SET_MODE;
1226 memcpy(&buffer[3], &channel->mode, sizeof(struct s2255_mode));
1227 channel->setmode_ready = 0;
1228 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1230 s2255_print_cfg(dev, mode);
1232 /* wait at least 3 frames before continuing */
1233 if (mode->restart) {
1234 wait_event_timeout(channel->wait_setmode,
1235 (channel->setmode_ready != 0),
1236 msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1237 if (channel->setmode_ready != 1) {
1238 printk(KERN_DEBUG "s2255: no set mode response\n");
1242 /* clear the restart flag */
1243 channel->mode.restart = 0;
1244 dprintk(1, "%s chn %d, result: %d\n", __func__, channel->idx, res);
1248 static int s2255_cmd_status(struct s2255_channel *channel, u32 *pstatus)
1253 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
1254 chn_rev = G_chnmap[channel->idx];
1255 dprintk(4, "%s chan %d\n", __func__, channel->idx);
1256 buffer = kzalloc(512, GFP_KERNEL);
1257 if (buffer == NULL) {
1258 dev_err(&dev->udev->dev, "out of mem\n");
1261 /* form the get vid status command */
1262 buffer[0] = IN_DATA_TOKEN;
1263 buffer[1] = (__le32) cpu_to_le32(chn_rev);
1264 buffer[2] = CMD_STATUS;
1266 channel->vidstatus_ready = 0;
1267 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1269 wait_event_timeout(channel->wait_vidstatus,
1270 (channel->vidstatus_ready != 0),
1271 msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1272 if (channel->vidstatus_ready != 1) {
1273 printk(KERN_DEBUG "s2255: no vidstatus response\n");
1276 *pstatus = channel->vidstatus;
1277 dprintk(4, "%s, vid status %d\n", __func__, *pstatus);
1281 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1284 struct s2255_fh *fh = priv;
1285 struct s2255_dev *dev = fh->dev;
1286 struct s2255_channel *channel = fh->channel;
1288 dprintk(4, "%s\n", __func__);
1289 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1290 dev_err(&dev->udev->dev, "invalid fh type0\n");
1293 if (i != fh->type) {
1294 dev_err(&dev->udev->dev, "invalid fh type1\n");
1299 s2255_dev_err(&dev->udev->dev, "stream busy\n");
1302 channel->last_frame = -1;
1303 channel->bad_payload = 0;
1304 channel->cur_frame = 0;
1305 channel->frame_count = 0;
1306 for (j = 0; j < SYS_FRAMES; j++) {
1307 channel->buffer.frame[j].ulState = S2255_READ_IDLE;
1308 channel->buffer.frame[j].cur_size = 0;
1310 res = videobuf_streamon(&fh->vb_vidq);
1312 s2255_start_acquire(channel);
1313 channel->b_acquire = 1;
1320 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1322 struct s2255_fh *fh = priv;
1323 dprintk(4, "%s\n, channel: %d", __func__, fh->channel->idx);
1324 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1325 printk(KERN_ERR "invalid fh type0\n");
1328 if (i != fh->type) {
1329 printk(KERN_ERR "invalid type i\n");
1332 s2255_stop_acquire(fh->channel);
1333 videobuf_streamoff(&fh->vb_vidq);
1338 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1340 struct s2255_fh *fh = priv;
1341 struct s2255_mode mode;
1342 struct videobuf_queue *q = &fh->vb_vidq;
1344 mutex_lock(&q->vb_lock);
1345 if (videobuf_queue_is_busy(q)) {
1346 dprintk(1, "queue busy\n");
1350 if (res_locked(fh)) {
1351 dprintk(1, "can't change standard after started\n");
1355 mode = fh->channel->mode;
1356 if (*i & V4L2_STD_NTSC) {
1357 dprintk(4, "%s NTSC\n", __func__);
1358 /* if changing format, reset frame decimation/intervals */
1359 if (mode.format != FORMAT_NTSC) {
1361 mode.format = FORMAT_NTSC;
1364 } else if (*i & V4L2_STD_PAL) {
1365 dprintk(4, "%s PAL\n", __func__);
1366 if (mode.format != FORMAT_PAL) {
1368 mode.format = FORMAT_PAL;
1375 s2255_set_mode(fh->channel, &mode);
1377 mutex_unlock(&q->vb_lock);
1381 /* Sensoray 2255 is a multiple channel capture device.
1382 It does not have a "crossbar" of inputs.
1383 We use one V4L device per channel. The user must
1384 be aware that certain combinations are not allowed.
1385 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1386 at once in color(you can do full fps on 4 channels with greyscale.
1388 static int vidioc_enum_input(struct file *file, void *priv,
1389 struct v4l2_input *inp)
1391 struct s2255_fh *fh = priv;
1392 struct s2255_dev *dev = fh->dev;
1393 struct s2255_channel *channel = fh->channel;
1395 if (inp->index != 0)
1397 inp->type = V4L2_INPUT_TYPE_CAMERA;
1398 inp->std = S2255_NORMS;
1400 if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1402 rc = s2255_cmd_status(fh->channel, &status);
1403 dprintk(4, "s2255_cmd_status rc: %d status %x\n", rc, status);
1405 inp->status = (status & 0x01) ? 0
1406 : V4L2_IN_ST_NO_SIGNAL;
1411 strlcpy(inp->name, "Composite", sizeof(inp->name));
1414 strlcpy(inp->name, (channel->idx < 2) ? "Composite" : "S-Video",
1421 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1426 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1433 /* --- controls ---------------------------------------------- */
1434 static int vidioc_queryctrl(struct file *file, void *priv,
1435 struct v4l2_queryctrl *qc)
1437 struct s2255_fh *fh = priv;
1438 struct s2255_channel *channel = fh->channel;
1439 struct s2255_dev *dev = fh->dev;
1441 case V4L2_CID_BRIGHTNESS:
1442 v4l2_ctrl_query_fill(qc, -127, 127, 1, DEF_BRIGHT);
1444 case V4L2_CID_CONTRAST:
1445 v4l2_ctrl_query_fill(qc, 0, 255, 1, DEF_CONTRAST);
1447 case V4L2_CID_SATURATION:
1448 v4l2_ctrl_query_fill(qc, 0, 255, 1, DEF_SATURATION);
1451 v4l2_ctrl_query_fill(qc, 0, 255, 1, DEF_HUE);
1453 case V4L2_CID_PRIVATE_COLORFILTER:
1454 if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
1456 if ((dev->pid == 0x2257) && (channel->idx > 1))
1458 strlcpy(qc->name, "Color Filter", sizeof(qc->name));
1459 qc->type = V4L2_CTRL_TYPE_MENU;
1463 qc->default_value = 1;
1469 dprintk(4, "%s, id %d\n", __func__, qc->id);
1473 static int vidioc_g_ctrl(struct file *file, void *priv,
1474 struct v4l2_control *ctrl)
1476 struct s2255_fh *fh = priv;
1477 struct s2255_dev *dev = fh->dev;
1478 struct s2255_channel *channel = fh->channel;
1480 case V4L2_CID_BRIGHTNESS:
1481 ctrl->value = channel->mode.bright;
1483 case V4L2_CID_CONTRAST:
1484 ctrl->value = channel->mode.contrast;
1486 case V4L2_CID_SATURATION:
1487 ctrl->value = channel->mode.saturation;
1490 ctrl->value = channel->mode.hue;
1492 case V4L2_CID_PRIVATE_COLORFILTER:
1493 if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
1495 if ((dev->pid == 0x2257) && (channel->idx > 1))
1497 ctrl->value = !((channel->mode.color & MASK_INPUT_TYPE) >> 16);
1502 dprintk(4, "%s, id %d val %d\n", __func__, ctrl->id, ctrl->value);
1506 static int vidioc_s_ctrl(struct file *file, void *priv,
1507 struct v4l2_control *ctrl)
1509 struct s2255_fh *fh = priv;
1510 struct s2255_channel *channel = fh->channel;
1511 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
1512 struct s2255_mode mode;
1513 mode = channel->mode;
1514 dprintk(4, "%s\n", __func__);
1515 /* update the mode to the corresponding value */
1517 case V4L2_CID_BRIGHTNESS:
1518 mode.bright = ctrl->value;
1520 case V4L2_CID_CONTRAST:
1521 mode.contrast = ctrl->value;
1524 mode.hue = ctrl->value;
1526 case V4L2_CID_SATURATION:
1527 mode.saturation = ctrl->value;
1529 case V4L2_CID_PRIVATE_COLORFILTER:
1530 if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
1532 if ((dev->pid == 0x2257) && (channel->idx > 1))
1534 mode.color &= ~MASK_INPUT_TYPE;
1535 mode.color |= ((ctrl->value ? 0 : 1) << 16);
1541 /* set mode here. Note: stream does not need restarted.
1542 some V4L programs restart stream unnecessarily
1545 s2255_set_mode(fh->channel, &mode);
1549 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1550 struct v4l2_jpegcompression *jc)
1552 struct s2255_fh *fh = priv;
1553 struct s2255_channel *channel = fh->channel;
1555 dprintk(2, "%s: quality %d\n", __func__, jc->quality);
1559 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1560 struct v4l2_jpegcompression *jc)
1562 struct s2255_fh *fh = priv;
1563 struct s2255_channel *channel = fh->channel;
1564 if (jc->quality < 0 || jc->quality > 100)
1566 channel->jc.quality = jc->quality;
1567 dprintk(2, "%s: quality %d\n", __func__, jc->quality);
1571 static int vidioc_g_parm(struct file *file, void *priv,
1572 struct v4l2_streamparm *sp)
1574 struct s2255_fh *fh = priv;
1575 __u32 def_num, def_dem;
1576 struct s2255_channel *channel = fh->channel;
1577 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1579 memset(sp, 0, sizeof(struct v4l2_streamparm));
1580 sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1581 sp->parm.capture.capturemode = channel->cap_parm.capturemode;
1582 def_num = (channel->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1583 def_dem = (channel->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1584 sp->parm.capture.timeperframe.denominator = def_dem;
1585 switch (channel->mode.fdec) {
1588 sp->parm.capture.timeperframe.numerator = def_num;
1591 sp->parm.capture.timeperframe.numerator = def_num * 2;
1594 sp->parm.capture.timeperframe.numerator = def_num * 3;
1597 sp->parm.capture.timeperframe.numerator = def_num * 5;
1600 dprintk(4, "%s capture mode, %d timeperframe %d/%d\n", __func__,
1601 sp->parm.capture.capturemode,
1602 sp->parm.capture.timeperframe.numerator,
1603 sp->parm.capture.timeperframe.denominator);
1607 static int vidioc_s_parm(struct file *file, void *priv,
1608 struct v4l2_streamparm *sp)
1610 struct s2255_fh *fh = priv;
1611 struct s2255_channel *channel = fh->channel;
1612 struct s2255_mode mode;
1614 __u32 def_num, def_dem;
1615 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1617 mode = channel->mode;
1618 /* high quality capture mode requires a stream restart */
1619 if (channel->cap_parm.capturemode
1620 != sp->parm.capture.capturemode && res_locked(fh))
1622 def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1623 def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1624 if (def_dem != sp->parm.capture.timeperframe.denominator)
1625 sp->parm.capture.timeperframe.numerator = def_num;
1626 else if (sp->parm.capture.timeperframe.numerator <= def_num)
1627 sp->parm.capture.timeperframe.numerator = def_num;
1628 else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1629 sp->parm.capture.timeperframe.numerator = def_num * 2;
1631 } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1632 sp->parm.capture.timeperframe.numerator = def_num * 3;
1635 sp->parm.capture.timeperframe.numerator = def_num * 5;
1639 sp->parm.capture.timeperframe.denominator = def_dem;
1640 s2255_set_mode(channel, &mode);
1641 dprintk(4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1643 sp->parm.capture.capturemode,
1644 sp->parm.capture.timeperframe.numerator,
1645 sp->parm.capture.timeperframe.denominator, fdec);
1649 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1650 struct v4l2_frmivalenum *fe)
1653 #define NUM_FRAME_ENUMS 4
1654 int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1655 if (fe->index < 0 || fe->index >= NUM_FRAME_ENUMS)
1657 switch (fe->width) {
1659 if (fe->height != 240 && fe->height != 480)
1664 if (fe->height != 240)
1669 if (fe->height != 288 && fe->height != 576)
1673 if (fe->height != 288)
1679 fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1680 fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1681 fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1682 dprintk(4, "%s discrete %d/%d\n", __func__, fe->discrete.numerator,
1683 fe->discrete.denominator);
1687 static int s2255_open(struct file *file)
1689 struct video_device *vdev = video_devdata(file);
1690 struct s2255_channel *channel = video_drvdata(file);
1691 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1692 struct s2255_fh *fh;
1693 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1695 dprintk(1, "s2255: open called (dev=%s)\n",
1696 video_device_node_name(vdev));
1698 * open lock necessary to prevent multiple instances
1699 * of v4l-conf (or other programs) from simultaneously
1700 * reloading firmware.
1702 mutex_lock(&dev->open_lock);
1703 state = atomic_read(&dev->fw_data->fw_state);
1705 case S2255_FW_DISCONNECTING:
1706 mutex_unlock(&dev->open_lock);
1708 case S2255_FW_FAILED:
1709 s2255_dev_err(&dev->udev->dev,
1710 "firmware load failed. retrying.\n");
1711 s2255_fwload_start(dev, 1);
1712 wait_event_timeout(dev->fw_data->wait_fw,
1713 ((atomic_read(&dev->fw_data->fw_state)
1714 == S2255_FW_SUCCESS) ||
1715 (atomic_read(&dev->fw_data->fw_state)
1716 == S2255_FW_DISCONNECTING)),
1717 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1718 /* state may have changed, re-read */
1719 state = atomic_read(&dev->fw_data->fw_state);
1721 case S2255_FW_NOTLOADED:
1722 case S2255_FW_LOADED_DSPWAIT:
1723 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1724 driver loaded and then device immediately opened */
1725 printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1726 wait_event_timeout(dev->fw_data->wait_fw,
1727 ((atomic_read(&dev->fw_data->fw_state)
1728 == S2255_FW_SUCCESS) ||
1729 (atomic_read(&dev->fw_data->fw_state)
1730 == S2255_FW_DISCONNECTING)),
1731 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1732 /* state may have changed, re-read */
1733 state = atomic_read(&dev->fw_data->fw_state);
1735 case S2255_FW_SUCCESS:
1739 /* state may have changed in above switch statement */
1741 case S2255_FW_SUCCESS:
1743 case S2255_FW_FAILED:
1744 printk(KERN_INFO "2255 firmware load failed.\n");
1745 mutex_unlock(&dev->open_lock);
1747 case S2255_FW_DISCONNECTING:
1748 printk(KERN_INFO "%s: disconnecting\n", __func__);
1749 mutex_unlock(&dev->open_lock);
1751 case S2255_FW_LOADED_DSPWAIT:
1752 case S2255_FW_NOTLOADED:
1753 printk(KERN_INFO "%s: firmware not loaded yet"
1754 "please try again later\n",
1757 * Timeout on firmware load means device unusable.
1758 * Set firmware failure state.
1759 * On next s2255_open the firmware will be reloaded.
1761 atomic_set(&dev->fw_data->fw_state,
1763 mutex_unlock(&dev->open_lock);
1766 printk(KERN_INFO "%s: unknown state\n", __func__);
1767 mutex_unlock(&dev->open_lock);
1770 mutex_unlock(&dev->open_lock);
1771 /* allocate + initialize per filehandle data */
1772 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1775 file->private_data = fh;
1777 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1778 fh->channel = channel;
1779 if (!channel->configured) {
1780 /* configure channel to default state */
1781 channel->fmt = &formats[0];
1782 s2255_set_mode(channel, &channel->mode);
1783 channel->configured = 1;
1785 dprintk(1, "%s: dev=%s type=%s\n", __func__,
1786 video_device_node_name(vdev), v4l2_type_names[type]);
1787 dprintk(2, "%s: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n", __func__,
1788 (unsigned long)fh, (unsigned long)dev,
1789 (unsigned long)&channel->vidq);
1790 dprintk(4, "%s: list_empty active=%d\n", __func__,
1791 list_empty(&channel->vidq.active));
1792 videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1795 V4L2_FIELD_INTERLACED,
1796 sizeof(struct s2255_buffer),
1802 static unsigned int s2255_poll(struct file *file,
1803 struct poll_table_struct *wait)
1805 struct s2255_fh *fh = file->private_data;
1807 dprintk(100, "%s\n", __func__);
1808 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1810 rc = videobuf_poll_stream(file, &fh->vb_vidq, wait);
1814 static void s2255_destroy(struct s2255_dev *dev)
1816 /* board shutdown stops the read pipe if it is running */
1817 s2255_board_shutdown(dev);
1818 /* make sure firmware still not trying to load */
1819 del_timer(&dev->timer); /* only started in .probe and .open */
1820 if (dev->fw_data->fw_urb) {
1821 usb_kill_urb(dev->fw_data->fw_urb);
1822 usb_free_urb(dev->fw_data->fw_urb);
1823 dev->fw_data->fw_urb = NULL;
1825 release_firmware(dev->fw_data->fw);
1826 kfree(dev->fw_data->pfw_data);
1827 kfree(dev->fw_data);
1828 /* reset the DSP so firmware can be reloaded next time */
1829 s2255_reset_dsppower(dev);
1830 mutex_destroy(&dev->open_lock);
1831 mutex_destroy(&dev->lock);
1832 usb_put_dev(dev->udev);
1833 v4l2_device_unregister(&dev->v4l2_dev);
1834 dprintk(1, "%s", __func__);
1838 static int s2255_release(struct file *file)
1840 struct s2255_fh *fh = file->private_data;
1841 struct s2255_dev *dev = fh->dev;
1842 struct video_device *vdev = video_devdata(file);
1843 struct s2255_channel *channel = fh->channel;
1846 /* turn off stream */
1847 if (res_check(fh)) {
1848 if (channel->b_acquire)
1849 s2255_stop_acquire(fh->channel);
1850 videobuf_streamoff(&fh->vb_vidq);
1853 videobuf_mmap_free(&fh->vb_vidq);
1854 dprintk(1, "%s (dev=%s)\n", __func__, video_device_node_name(vdev));
1859 static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1861 struct s2255_fh *fh = file->private_data;
1866 dprintk(4, "%s, vma=0x%08lx\n", __func__, (unsigned long)vma);
1867 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1868 dprintk(4, "%s vma start=0x%08lx, size=%ld, ret=%d\n", __func__,
1869 (unsigned long)vma->vm_start,
1870 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1874 static const struct v4l2_file_operations s2255_fops_v4l = {
1875 .owner = THIS_MODULE,
1877 .release = s2255_release,
1879 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1880 .mmap = s2255_mmap_v4l,
1883 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1884 .vidioc_querymenu = vidioc_querymenu,
1885 .vidioc_querycap = vidioc_querycap,
1886 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1887 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1888 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1889 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1890 .vidioc_reqbufs = vidioc_reqbufs,
1891 .vidioc_querybuf = vidioc_querybuf,
1892 .vidioc_qbuf = vidioc_qbuf,
1893 .vidioc_dqbuf = vidioc_dqbuf,
1894 .vidioc_s_std = vidioc_s_std,
1895 .vidioc_enum_input = vidioc_enum_input,
1896 .vidioc_g_input = vidioc_g_input,
1897 .vidioc_s_input = vidioc_s_input,
1898 .vidioc_queryctrl = vidioc_queryctrl,
1899 .vidioc_g_ctrl = vidioc_g_ctrl,
1900 .vidioc_s_ctrl = vidioc_s_ctrl,
1901 .vidioc_streamon = vidioc_streamon,
1902 .vidioc_streamoff = vidioc_streamoff,
1903 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1904 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1905 .vidioc_s_parm = vidioc_s_parm,
1906 .vidioc_g_parm = vidioc_g_parm,
1907 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1910 static void s2255_video_device_release(struct video_device *vdev)
1912 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1913 dprintk(4, "%s, chnls: %d \n", __func__,
1914 atomic_read(&dev->num_channels));
1915 if (atomic_dec_and_test(&dev->num_channels))
1920 static struct video_device template = {
1922 .fops = &s2255_fops_v4l,
1923 .ioctl_ops = &s2255_ioctl_ops,
1924 .release = s2255_video_device_release,
1925 .tvnorms = S2255_NORMS,
1926 .current_norm = V4L2_STD_NTSC_M,
1929 static int s2255_probe_v4l(struct s2255_dev *dev)
1933 int cur_nr = video_nr;
1934 struct s2255_channel *channel;
1935 ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1938 /* initialize all video 4 linux */
1939 /* register 4 video devices */
1940 for (i = 0; i < MAX_CHANNELS; i++) {
1941 channel = &dev->channel[i];
1942 INIT_LIST_HEAD(&channel->vidq.active);
1943 channel->vidq.dev = dev;
1944 /* register 4 video devices */
1945 channel->vdev = template;
1946 channel->vdev.lock = &dev->lock;
1947 /* Locking in file operations other than ioctl should be done
1948 by the driver, not the V4L2 core.
1949 This driver needs auditing so that this flag can be removed. */
1950 set_bit(V4L2_FL_LOCK_ALL_FOPS, &channel->vdev.flags);
1951 channel->vdev.v4l2_dev = &dev->v4l2_dev;
1952 video_set_drvdata(&channel->vdev, channel);
1954 ret = video_register_device(&channel->vdev,
1958 ret = video_register_device(&channel->vdev,
1963 dev_err(&dev->udev->dev,
1964 "failed to register video device!\n");
1967 atomic_inc(&dev->num_channels);
1968 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1969 video_device_node_name(&channel->vdev));
1972 printk(KERN_INFO "Sensoray 2255 V4L driver Revision: %s\n",
1974 /* if no channels registered, return error and probe will fail*/
1975 if (atomic_read(&dev->num_channels) == 0) {
1976 v4l2_device_unregister(&dev->v4l2_dev);
1979 if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1980 printk(KERN_WARNING "s2255: Not all channels available.\n");
1984 /* this function moves the usb stream read pipe data
1985 * into the system buffers.
1986 * returns 0 on success, EAGAIN if more data to process( call this
1989 * Received frame structure:
1990 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1991 * bytes 4-7: channel: 0-3
1992 * bytes 8-11: payload size: size of the frame
1993 * bytes 12-payloadsize+12: frame data
1995 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
2001 unsigned long copy_size;
2004 struct s2255_framei *frm;
2005 unsigned char *pdata;
2006 struct s2255_channel *channel;
2007 dprintk(100, "buffer to user\n");
2008 channel = &dev->channel[dev->cc];
2009 idx = channel->cur_frame;
2010 frm = &channel->buffer.frame[idx];
2011 if (frm->ulState == S2255_READ_IDLE) {
2014 __le32 *pdword; /*data from dsp is little endian */
2016 /* search for marker codes */
2017 pdata = (unsigned char *)pipe_info->transfer_buffer;
2018 pdword = (__le32 *)pdata;
2019 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
2021 case S2255_MARKER_FRAME:
2022 dprintk(4, "found frame marker at offset:"
2023 " %d [%x %x]\n", jj, pdata[0],
2025 offset = jj + PREFIX_SIZE;
2027 cc = le32_to_cpu(pdword[1]);
2028 if (cc >= MAX_CHANNELS) {
2034 dev->cc = G_chnmap[cc];
2035 channel = &dev->channel[dev->cc];
2036 payload = le32_to_cpu(pdword[3]);
2037 if (payload > channel->req_image_size) {
2038 channel->bad_payload++;
2039 /* discard the bad frame */
2042 channel->pkt_size = payload;
2043 channel->jpg_size = le32_to_cpu(pdword[4]);
2045 case S2255_MARKER_RESPONSE:
2047 pdata += DEF_USB_BLOCK;
2048 jj += DEF_USB_BLOCK;
2049 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
2051 cc = G_chnmap[le32_to_cpu(pdword[1])];
2052 if (cc >= MAX_CHANNELS)
2054 channel = &dev->channel[cc];
2055 switch (pdword[2]) {
2056 case S2255_RESPONSE_SETMODE:
2057 /* check if channel valid */
2058 /* set mode ready */
2059 channel->setmode_ready = 1;
2060 wake_up(&channel->wait_setmode);
2061 dprintk(5, "setmode ready %d\n", cc);
2063 case S2255_RESPONSE_FW:
2064 dev->chn_ready |= (1 << cc);
2065 if ((dev->chn_ready & 0x0f) != 0x0f)
2067 /* all channels ready */
2068 printk(KERN_INFO "s2255: fw loaded\n");
2069 atomic_set(&dev->fw_data->fw_state,
2071 wake_up(&dev->fw_data->wait_fw);
2073 case S2255_RESPONSE_STATUS:
2074 channel->vidstatus = le32_to_cpu(pdword[3]);
2075 channel->vidstatus_ready = 1;
2076 wake_up(&channel->wait_vidstatus);
2077 dprintk(5, "got vidstatus %x chan %d\n",
2078 le32_to_cpu(pdword[3]), cc);
2081 printk(KERN_INFO "s2255 unknown resp\n");
2093 channel = &dev->channel[dev->cc];
2094 idx = channel->cur_frame;
2095 frm = &channel->buffer.frame[idx];
2096 /* search done. now find out if should be acquiring on this channel */
2097 if (!channel->b_acquire) {
2098 /* we found a frame, but this channel is turned off */
2099 frm->ulState = S2255_READ_IDLE;
2103 if (frm->ulState == S2255_READ_IDLE) {
2104 frm->ulState = S2255_READ_FRAME;
2108 /* skip the marker 512 bytes (and offset if out of sync) */
2109 psrc = (u8 *)pipe_info->transfer_buffer + offset;
2112 if (frm->lpvbits == NULL) {
2113 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
2114 frm, dev, dev->cc, idx);
2118 pdest = frm->lpvbits + frm->cur_size;
2120 copy_size = (pipe_info->cur_transfer_size - offset);
2122 size = channel->pkt_size - PREFIX_SIZE;
2124 /* sanity check on pdest */
2125 if ((copy_size + frm->cur_size) < channel->req_image_size)
2126 memcpy(pdest, psrc, copy_size);
2128 frm->cur_size += copy_size;
2129 dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
2131 if (frm->cur_size >= size) {
2132 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
2134 channel->last_frame = channel->cur_frame;
2135 channel->cur_frame++;
2136 /* end of system frame ring buffer, start at zero */
2137 if ((channel->cur_frame == SYS_FRAMES) ||
2138 (channel->cur_frame == channel->buffer.dwFrames))
2139 channel->cur_frame = 0;
2141 if (channel->b_acquire)
2142 s2255_got_frame(channel, channel->jpg_size);
2143 channel->frame_count++;
2144 frm->ulState = S2255_READ_IDLE;
2148 /* done successfully */
2152 static void s2255_read_video_callback(struct s2255_dev *dev,
2153 struct s2255_pipeinfo *pipe_info)
2156 dprintk(50, "callback read video \n");
2158 if (dev->cc >= MAX_CHANNELS) {
2160 dev_err(&dev->udev->dev, "invalid channel\n");
2163 /* otherwise copy to the system buffers */
2164 res = save_frame(dev, pipe_info);
2166 dprintk(4, "s2255: read callback failed\n");
2168 dprintk(50, "callback read video done\n");
2172 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
2173 u16 Index, u16 Value, void *TransferBuffer,
2174 s32 TransferBufferLength, int bOut)
2178 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2180 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
2182 Value, Index, TransferBuffer,
2183 TransferBufferLength, HZ * 5);
2185 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2186 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2187 Value, Index, TransferBuffer,
2188 TransferBufferLength, HZ * 5);
2194 * retrieve FX2 firmware version. future use.
2195 * @param dev pointer to device extension
2196 * @return -1 for fail, else returns firmware version as an int(16 bits)
2198 static int s2255_get_fx2fw(struct s2255_dev *dev)
2202 unsigned char transBuffer[64];
2203 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2206 dprintk(2, "get fw error: %x\n", ret);
2207 fw = transBuffer[0] + (transBuffer[1] << 8);
2208 dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2213 * Create the system ring buffer to copy frames into from the
2216 static int s2255_create_sys_buffers(struct s2255_channel *channel)
2219 unsigned long reqsize;
2220 dprintk(1, "create sys buffers\n");
2221 channel->buffer.dwFrames = SYS_FRAMES;
2222 /* always allocate maximum size(PAL) for system buffers */
2223 reqsize = SYS_FRAMES_MAXSIZE;
2225 if (reqsize > SYS_FRAMES_MAXSIZE)
2226 reqsize = SYS_FRAMES_MAXSIZE;
2228 for (i = 0; i < SYS_FRAMES; i++) {
2229 /* allocate the frames */
2230 channel->buffer.frame[i].lpvbits = vmalloc(reqsize);
2231 dprintk(1, "valloc %p chan %d, idx %lu, pdata %p\n",
2232 &channel->buffer.frame[i], channel->idx, i,
2233 channel->buffer.frame[i].lpvbits);
2234 channel->buffer.frame[i].size = reqsize;
2235 if (channel->buffer.frame[i].lpvbits == NULL) {
2236 printk(KERN_INFO "out of memory. using less frames\n");
2237 channel->buffer.dwFrames = i;
2242 /* make sure internal states are set */
2243 for (i = 0; i < SYS_FRAMES; i++) {
2244 channel->buffer.frame[i].ulState = 0;
2245 channel->buffer.frame[i].cur_size = 0;
2248 channel->cur_frame = 0;
2249 channel->last_frame = -1;
2253 static int s2255_release_sys_buffers(struct s2255_channel *channel)
2256 dprintk(1, "release sys buffers\n");
2257 for (i = 0; i < SYS_FRAMES; i++) {
2258 if (channel->buffer.frame[i].lpvbits) {
2259 dprintk(1, "vfree %p\n",
2260 channel->buffer.frame[i].lpvbits);
2261 vfree(channel->buffer.frame[i].lpvbits);
2263 channel->buffer.frame[i].lpvbits = NULL;
2268 static int s2255_board_init(struct s2255_dev *dev)
2270 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2273 struct s2255_pipeinfo *pipe = &dev->pipe;
2274 dprintk(4, "board init: %p", dev);
2275 memset(pipe, 0, sizeof(*pipe));
2277 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2278 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
2280 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2282 if (pipe->transfer_buffer == NULL) {
2283 dprintk(1, "out of memory!\n");
2286 /* query the firmware */
2287 fw_ver = s2255_get_fx2fw(dev);
2289 printk(KERN_INFO "s2255: usb firmware version %d.%d\n",
2290 (fw_ver >> 8) & 0xff,
2293 if (fw_ver < S2255_CUR_USB_FWVER)
2294 printk(KERN_INFO "s2255: newer USB firmware available\n");
2296 for (j = 0; j < MAX_CHANNELS; j++) {
2297 struct s2255_channel *channel = &dev->channel[j];
2298 channel->b_acquire = 0;
2299 channel->mode = mode_def;
2300 if (dev->pid == 0x2257 && j > 1)
2301 channel->mode.color |= (1 << 16);
2302 channel->jc.quality = S2255_DEF_JPEG_QUAL;
2303 channel->width = LINE_SZ_4CIFS_NTSC;
2304 channel->height = NUM_LINES_4CIFS_NTSC * 2;
2305 channel->fmt = &formats[0];
2306 channel->mode.restart = 1;
2307 channel->req_image_size = get_transfer_size(&mode_def);
2308 channel->frame_count = 0;
2309 /* create the system buffers */
2310 s2255_create_sys_buffers(channel);
2312 /* start read pipe */
2313 s2255_start_readpipe(dev);
2314 dprintk(1, "%s: success\n", __func__);
2318 static int s2255_board_shutdown(struct s2255_dev *dev)
2321 dprintk(1, "%s: dev: %p", __func__, dev);
2323 for (i = 0; i < MAX_CHANNELS; i++) {
2324 if (dev->channel[i].b_acquire)
2325 s2255_stop_acquire(&dev->channel[i]);
2327 s2255_stop_readpipe(dev);
2328 for (i = 0; i < MAX_CHANNELS; i++)
2329 s2255_release_sys_buffers(&dev->channel[i]);
2330 /* release transfer buffer */
2331 kfree(dev->pipe.transfer_buffer);
2335 static void read_pipe_completion(struct urb *purb)
2337 struct s2255_pipeinfo *pipe_info;
2338 struct s2255_dev *dev;
2341 pipe_info = purb->context;
2342 dprintk(100, "%s: urb:%p, status %d\n", __func__, purb,
2344 if (pipe_info == NULL) {
2345 dev_err(&purb->dev->dev, "no context!\n");
2349 dev = pipe_info->dev;
2351 dev_err(&purb->dev->dev, "no context!\n");
2354 status = purb->status;
2355 /* if shutting down, do not resubmit, exit immediately */
2356 if (status == -ESHUTDOWN) {
2357 dprintk(2, "%s: err shutdown\n", __func__);
2358 pipe_info->err_count++;
2362 if (pipe_info->state == 0) {
2363 dprintk(2, "%s: exiting USB pipe", __func__);
2368 s2255_read_video_callback(dev, pipe_info);
2370 pipe_info->err_count++;
2371 dprintk(1, "%s: failed URB %d\n", __func__, status);
2374 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2376 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2378 pipe_info->transfer_buffer,
2379 pipe_info->cur_transfer_size,
2380 read_pipe_completion, pipe_info);
2382 if (pipe_info->state != 0) {
2383 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC)) {
2384 dev_err(&dev->udev->dev, "error submitting urb\n");
2387 dprintk(2, "%s :complete state 0\n", __func__);
2392 static int s2255_start_readpipe(struct s2255_dev *dev)
2396 struct s2255_pipeinfo *pipe_info = &dev->pipe;
2397 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2398 dprintk(2, "%s: IN %d\n", __func__, dev->read_endpoint);
2399 pipe_info->state = 1;
2400 pipe_info->err_count = 0;
2401 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2402 if (!pipe_info->stream_urb) {
2403 dev_err(&dev->udev->dev,
2404 "ReadStream: Unable to alloc URB\n");
2407 /* transfer buffer allocated in board_init */
2408 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2410 pipe_info->transfer_buffer,
2411 pipe_info->cur_transfer_size,
2412 read_pipe_completion, pipe_info);
2413 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2415 printk(KERN_ERR "s2255: start read pipe failed\n");
2421 /* starts acquisition process */
2422 static int s2255_start_acquire(struct s2255_channel *channel)
2424 unsigned char *buffer;
2426 unsigned long chn_rev;
2428 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
2429 chn_rev = G_chnmap[channel->idx];
2430 buffer = kzalloc(512, GFP_KERNEL);
2431 if (buffer == NULL) {
2432 dev_err(&dev->udev->dev, "out of mem\n");
2436 channel->last_frame = -1;
2437 channel->bad_payload = 0;
2438 channel->cur_frame = 0;
2439 for (j = 0; j < SYS_FRAMES; j++) {
2440 channel->buffer.frame[j].ulState = 0;
2441 channel->buffer.frame[j].cur_size = 0;
2444 /* send the start command */
2445 *(__le32 *) buffer = IN_DATA_TOKEN;
2446 *((__le32 *) buffer + 1) = (__le32) cpu_to_le32(chn_rev);
2447 *((__le32 *) buffer + 2) = CMD_START;
2448 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2450 dev_err(&dev->udev->dev, "CMD_START error\n");
2452 dprintk(2, "start acquire exit[%d] %d \n", channel->idx, res);
2457 static int s2255_stop_acquire(struct s2255_channel *channel)
2459 unsigned char *buffer;
2461 unsigned long chn_rev;
2462 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
2463 chn_rev = G_chnmap[channel->idx];
2464 buffer = kzalloc(512, GFP_KERNEL);
2465 if (buffer == NULL) {
2466 dev_err(&dev->udev->dev, "out of mem\n");
2469 /* send the stop command */
2470 *(__le32 *) buffer = IN_DATA_TOKEN;
2471 *((__le32 *) buffer + 1) = (__le32) cpu_to_le32(chn_rev);
2472 *((__le32 *) buffer + 2) = CMD_STOP;
2473 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2475 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2477 channel->b_acquire = 0;
2478 dprintk(4, "%s: chn %d, res %d\n", __func__, channel->idx, res);
2482 static void s2255_stop_readpipe(struct s2255_dev *dev)
2484 struct s2255_pipeinfo *pipe = &dev->pipe;
2487 if (pipe->stream_urb) {
2489 usb_kill_urb(pipe->stream_urb);
2490 usb_free_urb(pipe->stream_urb);
2491 pipe->stream_urb = NULL;
2493 dprintk(4, "%s", __func__);
2497 static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2500 s2255_reset_dsppower(dev);
2501 dev->fw_data->fw_size = dev->fw_data->fw->size;
2502 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2503 memcpy(dev->fw_data->pfw_data,
2504 dev->fw_data->fw->data, CHUNK_SIZE);
2505 dev->fw_data->fw_loaded = CHUNK_SIZE;
2506 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2507 usb_sndbulkpipe(dev->udev, 2),
2508 dev->fw_data->pfw_data,
2509 CHUNK_SIZE, s2255_fwchunk_complete,
2511 mod_timer(&dev->timer, jiffies + HZ);
2514 /* standard usb probe function */
2515 static int s2255_probe(struct usb_interface *interface,
2516 const struct usb_device_id *id)
2518 struct s2255_dev *dev = NULL;
2519 struct usb_host_interface *iface_desc;
2520 struct usb_endpoint_descriptor *endpoint;
2522 int retval = -ENOMEM;
2525 dprintk(2, "%s\n", __func__);
2526 /* allocate memory for our device state and initialize it to zero */
2527 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2529 s2255_dev_err(&interface->dev, "out of memory\n");
2532 atomic_set(&dev->num_channels, 0);
2533 dev->pid = id->idProduct;
2534 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2537 mutex_init(&dev->lock);
2538 mutex_init(&dev->open_lock);
2539 /* grab usb_device and save it */
2540 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2541 if (dev->udev == NULL) {
2542 dev_err(&interface->dev, "null usb device\n");
2546 dprintk(1, "dev: %p, udev %p interface %p\n", dev,
2547 dev->udev, interface);
2548 dev->interface = interface;
2549 /* set up the endpoint information */
2550 iface_desc = interface->cur_altsetting;
2551 dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2552 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2553 endpoint = &iface_desc->endpoint[i].desc;
2554 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2555 /* we found the bulk in endpoint */
2556 dev->read_endpoint = endpoint->bEndpointAddress;
2560 if (!dev->read_endpoint) {
2561 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2564 init_timer(&dev->timer);
2565 dev->timer.function = s2255_timer;
2566 dev->timer.data = (unsigned long)dev->fw_data;
2567 init_waitqueue_head(&dev->fw_data->wait_fw);
2568 for (i = 0; i < MAX_CHANNELS; i++) {
2569 struct s2255_channel *channel = &dev->channel[i];
2570 dev->channel[i].idx = i;
2571 init_waitqueue_head(&channel->wait_setmode);
2572 init_waitqueue_head(&channel->wait_vidstatus);
2575 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2576 if (!dev->fw_data->fw_urb) {
2577 dev_err(&interface->dev, "out of memory!\n");
2581 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2582 if (!dev->fw_data->pfw_data) {
2583 dev_err(&interface->dev, "out of memory!\n");
2586 /* load the first chunk */
2587 if (request_firmware(&dev->fw_data->fw,
2588 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2589 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2592 /* check the firmware is valid */
2593 fw_size = dev->fw_data->fw->size;
2594 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2596 if (*pdata != S2255_FW_MARKER) {
2597 printk(KERN_INFO "Firmware invalid.\n");
2601 /* make sure firmware is the latest */
2603 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2604 printk(KERN_INFO "s2255 dsp fw version %x\n", *pRel);
2605 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2606 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2607 printk(KERN_INFO "s2255: f2255usb.bin out of date.\n");
2608 if (dev->pid == 0x2257 &&
2609 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2610 printk(KERN_WARNING "s2255: 2257 requires firmware %d"
2611 " or above.\n", S2255_MIN_DSP_COLORFILTER);
2613 usb_reset_device(dev->udev);
2614 /* load 2255 board specific */
2615 retval = s2255_board_init(dev);
2617 goto errorBOARDINIT;
2618 spin_lock_init(&dev->slock);
2619 s2255_fwload_start(dev, 0);
2620 /* loads v4l specific */
2621 retval = s2255_probe_v4l(dev);
2623 goto errorBOARDINIT;
2624 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2627 s2255_board_shutdown(dev);
2629 release_firmware(dev->fw_data->fw);
2631 kfree(dev->fw_data->pfw_data);
2633 usb_free_urb(dev->fw_data->fw_urb);
2635 del_timer(&dev->timer);
2637 usb_put_dev(dev->udev);
2639 kfree(dev->fw_data);
2640 mutex_destroy(&dev->open_lock);
2641 mutex_destroy(&dev->lock);
2644 printk(KERN_WARNING "Sensoray 2255 driver load failed: 0x%x\n", retval);
2648 /* disconnect routine. when board is removed physically or with rmmod */
2649 static void s2255_disconnect(struct usb_interface *interface)
2651 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2653 int channels = atomic_read(&dev->num_channels);
2654 mutex_lock(&dev->lock);
2655 v4l2_device_disconnect(&dev->v4l2_dev);
2656 mutex_unlock(&dev->lock);
2657 /*see comments in the uvc_driver.c usb disconnect function */
2658 atomic_inc(&dev->num_channels);
2659 /* unregister each video device. */
2660 for (i = 0; i < channels; i++)
2661 video_unregister_device(&dev->channel[i].vdev);
2662 /* wake up any of our timers */
2663 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2664 wake_up(&dev->fw_data->wait_fw);
2665 for (i = 0; i < MAX_CHANNELS; i++) {
2666 dev->channel[i].setmode_ready = 1;
2667 wake_up(&dev->channel[i].wait_setmode);
2668 dev->channel[i].vidstatus_ready = 1;
2669 wake_up(&dev->channel[i].wait_vidstatus);
2671 if (atomic_dec_and_test(&dev->num_channels))
2673 dev_info(&interface->dev, "%s\n", __func__);
2676 static struct usb_driver s2255_driver = {
2677 .name = S2255_DRIVER_NAME,
2678 .probe = s2255_probe,
2679 .disconnect = s2255_disconnect,
2680 .id_table = s2255_table,
2683 module_usb_driver(s2255_driver);
2685 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2686 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2687 MODULE_LICENSE("GPL");
2688 MODULE_VERSION(S2255_VERSION);
2689 MODULE_FIRMWARE(FIRMWARE_FILE_NAME);