2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
4 * Copyright (C) 2007-2014 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.
35 #include <linux/module.h>
36 #include <linux/firmware.h>
37 #include <linux/kernel.h>
38 #include <linux/mutex.h>
39 #include <linux/slab.h>
40 #include <linux/videodev2.h>
42 #include <linux/vmalloc.h>
43 #include <linux/usb.h>
44 #include <media/videobuf2-v4l2.h>
45 #include <media/videobuf2-vmalloc.h>
46 #include <media/v4l2-common.h>
47 #include <media/v4l2-device.h>
48 #include <media/v4l2-ioctl.h>
49 #include <media/v4l2-ctrls.h>
50 #include <media/v4l2-event.h>
52 #define S2255_VERSION "1.25.1"
53 #define FIRMWARE_FILE_NAME "/*(DEBLOBBED)*/"
55 /* default JPEG quality */
56 #define S2255_DEF_JPEG_QUAL 50
57 /* vendor request in */
59 /* vendor request out */
60 #define S2255_VR_OUT 1
62 #define S2255_VR_FW 0x30
63 /* USB endpoint number for configuring the device */
64 #define S2255_CONFIG_EP 2
65 /* maximum time for DSP to start responding after last FW word loaded(ms) */
66 #define S2255_DSP_BOOTTIME 800
67 /* maximum time to wait for firmware to load (ms) */
68 #define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
69 #define S2255_MIN_BUFS 2
70 #define S2255_SETMODE_TIMEOUT 500
71 #define S2255_VIDSTATUS_TIMEOUT 350
72 #define S2255_MARKER_FRAME cpu_to_le32(0x2255DA4AL)
73 #define S2255_MARKER_RESPONSE cpu_to_le32(0x2255ACACL)
74 #define S2255_RESPONSE_SETMODE cpu_to_le32(0x01)
75 #define S2255_RESPONSE_FW cpu_to_le32(0x10)
76 #define S2255_RESPONSE_STATUS cpu_to_le32(0x20)
77 #define S2255_USB_XFER_SIZE (16 * 1024)
78 #define MAX_CHANNELS 4
80 /* maximum size is PAL full size plus room for the marker header(s) */
81 #define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
82 #define DEF_USB_BLOCK S2255_USB_XFER_SIZE
83 #define LINE_SZ_4CIFS_NTSC 640
84 #define LINE_SZ_2CIFS_NTSC 640
85 #define LINE_SZ_1CIFS_NTSC 320
86 #define LINE_SZ_4CIFS_PAL 704
87 #define LINE_SZ_2CIFS_PAL 704
88 #define LINE_SZ_1CIFS_PAL 352
89 #define NUM_LINES_4CIFS_NTSC 240
90 #define NUM_LINES_2CIFS_NTSC 240
91 #define NUM_LINES_1CIFS_NTSC 240
92 #define NUM_LINES_4CIFS_PAL 288
93 #define NUM_LINES_2CIFS_PAL 288
94 #define NUM_LINES_1CIFS_PAL 288
95 #define LINE_SZ_DEF 640
96 #define NUM_LINES_DEF 240
99 /* predefined settings */
100 #define FORMAT_NTSC 1
103 #define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
104 #define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
105 #define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
106 /* SCALE_4CIFSI is the 2 fields interpolated into one */
107 #define SCALE_4CIFSI 4 /* 640x480(NTSC) or 704x576(PAL) high quality */
109 #define COLOR_YUVPL 1 /* YUV planar */
110 #define COLOR_YUVPK 2 /* YUV packed */
111 #define COLOR_Y8 4 /* monochrome */
112 #define COLOR_JPG 5 /* JPEG */
114 #define MASK_COLOR 0x000000ff
115 #define MASK_JPG_QUALITY 0x0000ff00
116 #define MASK_INPUT_TYPE 0x000f0000
117 /* frame decimation. */
118 #define FDEC_1 1 /* capture every frame. default */
119 #define FDEC_2 2 /* capture every 2nd frame */
120 #define FDEC_3 3 /* capture every 3rd frame */
121 #define FDEC_5 5 /* capture every 5th frame */
123 /*-------------------------------------------------------
124 * Default mode parameters.
125 *-------------------------------------------------------*/
126 #define DEF_SCALE SCALE_4CIFS
127 #define DEF_COLOR COLOR_YUVPL
128 #define DEF_FDEC FDEC_1
130 #define DEF_CONTRAST 0x5c
131 #define DEF_SATURATION 0x80
134 /* usb config commands */
135 #define IN_DATA_TOKEN cpu_to_le32(0x2255c0de)
136 #define CMD_2255 0xc2255000
137 #define CMD_SET_MODE cpu_to_le32((CMD_2255 | 0x10))
138 #define CMD_START cpu_to_le32((CMD_2255 | 0x20))
139 #define CMD_STOP cpu_to_le32((CMD_2255 | 0x30))
140 #define CMD_STATUS cpu_to_le32((CMD_2255 | 0x40))
143 u32 format; /* input video format (NTSC, PAL) */
144 u32 scale; /* output video scale */
145 u32 color; /* output video color format */
146 u32 fdec; /* frame decimation */
147 u32 bright; /* brightness */
148 u32 contrast; /* contrast */
149 u32 saturation; /* saturation */
150 u32 hue; /* hue (NTSC only)*/
151 u32 single; /* capture 1 frame at a time (!=0), continuously (==0)*/
152 u32 usb_block; /* block size. should be 4096 of DEF_USB_BLOCK */
153 u32 restart; /* if DSP requires restart */
157 #define S2255_READ_IDLE 0
158 #define S2255_READ_FRAME 1
160 /* frame structure */
161 struct s2255_framei {
163 unsigned long ulState; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
164 void *lpvbits; /* image data */
165 unsigned long cur_size; /* current data copied to it */
168 /* image buffer structure */
169 struct s2255_bufferi {
170 unsigned long dwFrames; /* number of frames in buffer */
171 struct s2255_framei frame[SYS_FRAMES]; /* array of FRAME structures */
174 #define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
175 DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
176 DEF_HUE, 0, DEF_USB_BLOCK, 0}
178 /* for firmware loading, fw_state */
179 #define S2255_FW_NOTLOADED 0
180 #define S2255_FW_LOADED_DSPWAIT 1
181 #define S2255_FW_SUCCESS 2
182 #define S2255_FW_FAILED 3
183 #define S2255_FW_DISCONNECTING 4
184 #define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
185 /* 2255 read states */
186 #define S2255_READ_IDLE 0
187 #define S2255_READ_FRAME 1
194 wait_queue_head_t wait_fw;
195 const struct firmware *fw;
198 struct s2255_pipeinfo {
199 u32 max_transfer_size;
200 u32 cur_transfer_size;
204 void *dev; /* back pointer to s2255_dev struct*/
209 struct s2255_fmt; /*forward declaration */
212 /* 2255 video channel */
214 struct s2255_dev *dev;
215 struct video_device vdev;
216 struct v4l2_ctrl_handler hdl;
217 struct v4l2_ctrl *jpegqual_ctrl;
219 struct list_head buf_list;
220 struct s2255_bufferi buffer;
221 struct s2255_mode mode;
223 /* jpeg compression */
225 /* capture parameters (for high quality mode full size) */
226 struct v4l2_captureparm cap_parm;
229 /* allocated image size */
230 unsigned long req_image_size;
231 /* received packet size */
232 unsigned long pkt_size;
234 unsigned long frame_count;
237 /* if channel configured to default state */
239 wait_queue_head_t wait_setmode;
241 /* video status items */
243 wait_queue_head_t wait_vidstatus;
247 enum v4l2_field field;
248 const struct s2255_fmt *fmt;
249 int idx; /* channel number on device, 0-3 */
250 struct vb2_queue vb_vidq;
251 struct mutex vb_lock; /* streaming lock */
257 struct s2255_vc vc[MAX_CHANNELS];
258 struct v4l2_device v4l2_dev;
259 atomic_t num_channels;
261 struct mutex lock; /* channels[].vdev.lock */
262 struct mutex cmdlock; /* protects cmdbuf */
263 struct usb_device *udev;
264 struct usb_interface *interface;
266 struct timer_list timer;
267 struct s2255_fw *fw_data;
268 struct s2255_pipeinfo pipe;
269 u32 cc; /* current channel */
274 u16 pid; /* product id */
275 #define S2255_CMDBUF_SIZE 512
279 static inline struct s2255_dev *to_s2255_dev(struct v4l2_device *v4l2_dev)
281 return container_of(v4l2_dev, struct s2255_dev, v4l2_dev);
290 /* buffer for one video frame */
291 struct s2255_buffer {
292 /* common v4l buffer stuff -- must be first */
293 struct vb2_v4l2_buffer vb;
294 struct list_head list;
298 /* current cypress EEPROM firmware version */
299 #define S2255_CUR_USB_FWVER ((3 << 8) | 12)
300 /* current DSP FW version */
301 #define S2255_CUR_DSP_FWVER 10104
302 /* Need DSP version 5+ for video status feature */
303 #define S2255_MIN_DSP_STATUS 5
304 #define S2255_MIN_DSP_COLORFILTER 8
305 #define S2255_NORMS (V4L2_STD_ALL)
307 /* private V4L2 controls */
310 * The following chart displays how COLORFILTER should be set
311 * =========================================================
312 * = fourcc = COLORFILTER =
313 * = ===============================
315 * =========================================================
316 * = V4L2_PIX_FMT_GREY(Y8) = monochrome from = monochrome=
317 * = = s-video or = composite =
318 * = = B/W camera = input =
319 * =========================================================
320 * = other = color, svideo = color, =
322 * =========================================================
325 * channels 0-3 on 2255 are composite
326 * channels 0-1 on 2257 are composite, 2-3 are s-video
327 * If COLORFILTER is 0 with a composite color camera connected,
328 * the output will appear monochrome but hatching
330 * COLORFILTER is different from "color killer" and "color effects"
333 #define S2255_V4L2_YC_ON 1
334 #define S2255_V4L2_YC_OFF 0
335 #define V4L2_CID_S2255_COLORFILTER (V4L2_CID_USER_S2255_BASE + 0)
337 /* frame prefix size (sent once every frame) */
338 #define PREFIX_SIZE 512
340 /* Channels on box are in reverse order */
341 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
345 static int s2255_start_readpipe(struct s2255_dev *dev);
346 static void s2255_stop_readpipe(struct s2255_dev *dev);
347 static int s2255_start_acquire(struct s2255_vc *vc);
348 static int s2255_stop_acquire(struct s2255_vc *vc);
349 static void s2255_fillbuff(struct s2255_vc *vc, struct s2255_buffer *buf,
351 static int s2255_set_mode(struct s2255_vc *vc, struct s2255_mode *mode);
352 static int s2255_board_shutdown(struct s2255_dev *dev);
353 static void s2255_fwload_start(struct s2255_dev *dev, int reset);
354 static void s2255_destroy(struct s2255_dev *dev);
355 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
356 u16 index, u16 value, void *buf,
357 s32 buf_len, int bOut);
359 /* dev_err macro with driver name */
360 #define S2255_DRIVER_NAME "s2255"
361 #define s2255_dev_err(dev, fmt, arg...) \
362 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
364 #define dprintk(dev, level, fmt, arg...) \
365 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
367 static struct usb_driver s2255_driver;
369 /* start video number */
370 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
372 /* Enable jpeg capture. */
373 static int jpeg_enable = 1;
375 module_param(debug, int, 0644);
376 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
377 module_param(video_nr, int, 0644);
378 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
379 module_param(jpeg_enable, int, 0644);
380 MODULE_PARM_DESC(jpeg_enable, "Jpeg enable(1-on 0-off) default 1");
382 /* USB device table */
383 #define USB_SENSORAY_VID 0x1943
384 static const struct usb_device_id s2255_table[] = {
385 {USB_DEVICE(USB_SENSORAY_VID, 0x2255)},
386 {USB_DEVICE(USB_SENSORAY_VID, 0x2257)}, /*same family as 2255*/
387 { } /* Terminating entry */
389 MODULE_DEVICE_TABLE(usb, s2255_table);
391 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
394 /* JPEG formats must be defined last to support jpeg_enable parameter */
395 static const struct s2255_fmt formats[] = {
397 .name = "4:2:2, packed, YUYV",
398 .fourcc = V4L2_PIX_FMT_YUYV,
402 .name = "4:2:2, packed, UYVY",
403 .fourcc = V4L2_PIX_FMT_UYVY,
406 .name = "4:2:2, planar, YUV422P",
407 .fourcc = V4L2_PIX_FMT_YUV422P,
412 .fourcc = V4L2_PIX_FMT_GREY,
416 .fourcc = V4L2_PIX_FMT_JPEG,
420 .fourcc = V4L2_PIX_FMT_MJPEG,
425 static int norm_maxw(struct s2255_vc *vc)
427 return (vc->std & V4L2_STD_525_60) ?
428 LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
431 static int norm_maxh(struct s2255_vc *vc)
433 return (vc->std & V4L2_STD_525_60) ?
434 (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
437 static int norm_minw(struct s2255_vc *vc)
439 return (vc->std & V4L2_STD_525_60) ?
440 LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
443 static int norm_minh(struct s2255_vc *vc)
445 return (vc->std & V4L2_STD_525_60) ?
446 (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
451 * TODO: fixme: move YUV reordering to hardware
452 * converts 2255 planar format to yuyv or uyvy
454 static void planar422p_to_yuv_packed(const unsigned char *in,
456 int width, int height,
462 unsigned long size = height * width;
464 pY = (unsigned char *)in;
465 pCr = (unsigned char *)in + height * width;
466 pCb = (unsigned char *)in + height * width + (height * width / 2);
467 for (i = 0; i < size * 2; i += 4) {
468 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
469 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
470 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
471 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
476 static void s2255_reset_dsppower(struct s2255_dev *dev)
478 s2255_vendor_req(dev, 0x40, 0x0000, 0x0001, NULL, 0, 1);
480 s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
482 s2255_vendor_req(dev, 0x10, 0x0000, 0x0000, NULL, 0, 1);
486 /* kickstarts the firmware loading. from probe
488 static void s2255_timer(unsigned long user_data)
490 struct s2255_fw *data = (struct s2255_fw *)user_data;
491 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
492 pr_err("s2255: can't submit urb\n");
493 atomic_set(&data->fw_state, S2255_FW_FAILED);
494 /* wake up anything waiting for the firmware */
495 wake_up(&data->wait_fw);
501 /* this loads the firmware asynchronously.
502 Originally this was done synchronously in probe.
503 But it is better to load it asynchronously here than block
504 inside the probe function. Blocking inside probe affects boot time.
505 FW loading is triggered by the timer in the probe function
507 static void s2255_fwchunk_complete(struct urb *urb)
509 struct s2255_fw *data = urb->context;
510 struct usb_device *udev = urb->dev;
513 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
514 atomic_set(&data->fw_state, S2255_FW_FAILED);
515 /* wake up anything waiting for the firmware */
516 wake_up(&data->wait_fw);
519 if (data->fw_urb == NULL) {
520 s2255_dev_err(&udev->dev, "disconnected\n");
521 atomic_set(&data->fw_state, S2255_FW_FAILED);
522 /* wake up anything waiting for the firmware */
523 wake_up(&data->wait_fw);
526 #define CHUNK_SIZE 512
527 /* all USB transfers must be done with continuous kernel memory.
528 can't allocate more than 128k in current linux kernel, so
529 upload the firmware in chunks
531 if (data->fw_loaded < data->fw_size) {
532 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
533 data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
535 if (len < CHUNK_SIZE)
536 memset(data->pfw_data, 0, CHUNK_SIZE);
538 memcpy(data->pfw_data,
539 (char *) data->fw->data + data->fw_loaded, len);
541 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
542 data->pfw_data, CHUNK_SIZE,
543 s2255_fwchunk_complete, data);
544 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
545 dev_err(&udev->dev, "failed submit URB\n");
546 atomic_set(&data->fw_state, S2255_FW_FAILED);
547 /* wake up anything waiting for the firmware */
548 wake_up(&data->wait_fw);
551 data->fw_loaded += len;
553 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
558 static void s2255_got_frame(struct s2255_vc *vc, int jpgsize)
560 struct s2255_buffer *buf;
561 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
562 unsigned long flags = 0;
564 spin_lock_irqsave(&vc->qlock, flags);
565 if (list_empty(&vc->buf_list)) {
566 dprintk(dev, 1, "No active queue to serve\n");
567 spin_unlock_irqrestore(&vc->qlock, flags);
570 buf = list_entry(vc->buf_list.next,
571 struct s2255_buffer, list);
572 list_del(&buf->list);
573 buf->vb.vb2_buf.timestamp = ktime_get_ns();
574 buf->vb.field = vc->field;
575 buf->vb.sequence = vc->frame_count;
576 spin_unlock_irqrestore(&vc->qlock, flags);
578 s2255_fillbuff(vc, buf, jpgsize);
579 /* tell v4l buffer was filled */
580 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
581 dprintk(dev, 2, "%s: [buf] [%p]\n", __func__, buf);
584 static const struct s2255_fmt *format_by_fourcc(int fourcc)
587 for (i = 0; i < ARRAY_SIZE(formats); i++) {
588 if (-1 == formats[i].fourcc)
590 if (!jpeg_enable && ((formats[i].fourcc == V4L2_PIX_FMT_JPEG) ||
591 (formats[i].fourcc == V4L2_PIX_FMT_MJPEG)))
593 if (formats[i].fourcc == fourcc)
599 /* video buffer vmalloc implementation based partly on VIVI driver which is
600 * Copyright (c) 2006 by
601 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
602 * Ted Walther <ted--a.t--enumera.com>
603 * John Sokol <sokol--a.t--videotechnology.com>
604 * http://v4l.videotechnology.com/
607 static void s2255_fillbuff(struct s2255_vc *vc,
608 struct s2255_buffer *buf, int jpgsize)
612 char *vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
613 unsigned long last_frame;
614 struct s2255_dev *dev = vc->dev;
618 last_frame = vc->last_frame;
619 if (last_frame != -1) {
621 (const char *)vc->buffer.frame[last_frame].lpvbits;
622 switch (vc->fmt->fourcc) {
623 case V4L2_PIX_FMT_YUYV:
624 case V4L2_PIX_FMT_UYVY:
625 planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
630 case V4L2_PIX_FMT_GREY:
631 memcpy(vbuf, tmpbuf, vc->width * vc->height);
633 case V4L2_PIX_FMT_JPEG:
634 case V4L2_PIX_FMT_MJPEG:
635 vb2_set_plane_payload(&buf->vb.vb2_buf, 0, jpgsize);
636 memcpy(vbuf, tmpbuf, jpgsize);
638 case V4L2_PIX_FMT_YUV422P:
640 vc->width * vc->height * 2);
643 pr_info("s2255: unknown format?\n");
647 pr_err("s2255: =======no frame\n");
650 dprintk(dev, 2, "s2255fill at : Buffer 0x%08lx size= %d\n",
651 (unsigned long)vbuf, pos);
655 /* ------------------------------------------------------------------
657 ------------------------------------------------------------------*/
659 static int queue_setup(struct vb2_queue *vq,
660 unsigned int *nbuffers, unsigned int *nplanes,
661 unsigned int sizes[], struct device *alloc_devs[])
663 struct s2255_vc *vc = vb2_get_drv_priv(vq);
664 if (*nbuffers < S2255_MIN_BUFS)
665 *nbuffers = S2255_MIN_BUFS;
667 sizes[0] = vc->width * vc->height * (vc->fmt->depth >> 3);
671 static int buffer_prepare(struct vb2_buffer *vb)
673 struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
674 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
675 struct s2255_buffer *buf = container_of(vbuf, struct s2255_buffer, vb);
680 dprintk(vc->dev, 4, "%s\n", __func__);
684 if ((w < norm_minw(vc)) ||
685 (w > norm_maxw(vc)) ||
686 (h < norm_minh(vc)) ||
687 (h > norm_maxh(vc))) {
688 dprintk(vc->dev, 4, "invalid buffer prepare\n");
691 size = w * h * (vc->fmt->depth >> 3);
692 if (vb2_plane_size(vb, 0) < size) {
693 dprintk(vc->dev, 4, "invalid buffer prepare\n");
697 vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
701 static void buffer_queue(struct vb2_buffer *vb)
703 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
704 struct s2255_buffer *buf = container_of(vbuf, struct s2255_buffer, vb);
705 struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
706 unsigned long flags = 0;
707 dprintk(vc->dev, 1, "%s\n", __func__);
708 spin_lock_irqsave(&vc->qlock, flags);
709 list_add_tail(&buf->list, &vc->buf_list);
710 spin_unlock_irqrestore(&vc->qlock, flags);
713 static int start_streaming(struct vb2_queue *vq, unsigned int count);
714 static void stop_streaming(struct vb2_queue *vq);
716 static const struct vb2_ops s2255_video_qops = {
717 .queue_setup = queue_setup,
718 .buf_prepare = buffer_prepare,
719 .buf_queue = buffer_queue,
720 .start_streaming = start_streaming,
721 .stop_streaming = stop_streaming,
722 .wait_prepare = vb2_ops_wait_prepare,
723 .wait_finish = vb2_ops_wait_finish,
726 static int vidioc_querycap(struct file *file, void *priv,
727 struct v4l2_capability *cap)
729 struct s2255_vc *vc = video_drvdata(file);
730 struct s2255_dev *dev = vc->dev;
732 strlcpy(cap->driver, "s2255", sizeof(cap->driver));
733 strlcpy(cap->card, "s2255", sizeof(cap->card));
734 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
735 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
737 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
741 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
742 struct v4l2_fmtdesc *f)
744 int index = f->index;
746 if (index >= ARRAY_SIZE(formats))
748 if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
749 (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
751 strlcpy(f->description, formats[index].name, sizeof(f->description));
752 f->pixelformat = formats[index].fourcc;
756 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
757 struct v4l2_format *f)
759 struct s2255_vc *vc = video_drvdata(file);
760 int is_ntsc = vc->std & V4L2_STD_525_60;
762 f->fmt.pix.width = vc->width;
763 f->fmt.pix.height = vc->height;
764 if (f->fmt.pix.height >=
765 (is_ntsc ? NUM_LINES_1CIFS_NTSC : NUM_LINES_1CIFS_PAL) * 2)
766 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
768 f->fmt.pix.field = V4L2_FIELD_TOP;
769 f->fmt.pix.pixelformat = vc->fmt->fourcc;
770 f->fmt.pix.bytesperline = f->fmt.pix.width * (vc->fmt->depth >> 3);
771 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
772 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
777 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
778 struct v4l2_format *f)
780 const struct s2255_fmt *fmt;
781 enum v4l2_field field;
782 struct s2255_vc *vc = video_drvdata(file);
783 int is_ntsc = vc->std & V4L2_STD_525_60;
785 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
790 field = f->fmt.pix.field;
792 dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
793 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
796 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
797 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
798 field = V4L2_FIELD_INTERLACED;
800 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
801 field = V4L2_FIELD_TOP;
803 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
804 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
805 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
806 f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
807 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
808 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
810 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
813 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
814 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
815 field = V4L2_FIELD_INTERLACED;
817 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
818 field = V4L2_FIELD_TOP;
820 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL)
821 f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
822 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL)
823 f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
824 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL)
825 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
827 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
829 f->fmt.pix.field = field;
830 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
831 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
832 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
834 dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__,
835 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
839 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
840 struct v4l2_format *f)
842 struct s2255_vc *vc = video_drvdata(file);
843 const struct s2255_fmt *fmt;
844 struct vb2_queue *q = &vc->vb_vidq;
845 struct s2255_mode mode;
848 ret = vidioc_try_fmt_vid_cap(file, vc, f);
853 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
858 if (vb2_is_busy(q)) {
859 dprintk(vc->dev, 1, "queue busy\n");
865 vc->width = f->fmt.pix.width;
866 vc->height = f->fmt.pix.height;
867 vc->field = f->fmt.pix.field;
868 if (vc->width > norm_minw(vc)) {
869 if (vc->height > norm_minh(vc)) {
870 if (vc->cap_parm.capturemode &
871 V4L2_MODE_HIGHQUALITY)
872 mode.scale = SCALE_4CIFSI;
874 mode.scale = SCALE_4CIFS;
876 mode.scale = SCALE_2CIFS;
879 mode.scale = SCALE_1CIFS;
882 switch (vc->fmt->fourcc) {
883 case V4L2_PIX_FMT_GREY:
884 mode.color &= ~MASK_COLOR;
885 mode.color |= COLOR_Y8;
887 case V4L2_PIX_FMT_JPEG:
888 case V4L2_PIX_FMT_MJPEG:
889 mode.color &= ~MASK_COLOR;
890 mode.color |= COLOR_JPG;
891 mode.color |= (vc->jpegqual << 8);
893 case V4L2_PIX_FMT_YUV422P:
894 mode.color &= ~MASK_COLOR;
895 mode.color |= COLOR_YUVPL;
897 case V4L2_PIX_FMT_YUYV:
898 case V4L2_PIX_FMT_UYVY:
900 mode.color &= ~MASK_COLOR;
901 mode.color |= COLOR_YUVPK;
904 if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR))
906 else if (mode.scale != vc->mode.scale)
908 else if (mode.format != vc->mode.format)
911 (void) s2255_set_mode(vc, &mode);
916 /* write to the configuration pipe, synchronously */
917 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
924 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
925 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
930 static u32 get_transfer_size(struct s2255_mode *mode)
932 int linesPerFrame = LINE_SZ_DEF;
933 int pixelsPerLine = NUM_LINES_DEF;
936 unsigned int mask_mult;
941 if (mode->format == FORMAT_NTSC) {
942 switch (mode->scale) {
945 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
946 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
949 linesPerFrame = NUM_LINES_2CIFS_NTSC;
950 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
953 linesPerFrame = NUM_LINES_1CIFS_NTSC;
954 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
959 } else if (mode->format == FORMAT_PAL) {
960 switch (mode->scale) {
963 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
964 pixelsPerLine = LINE_SZ_4CIFS_PAL;
967 linesPerFrame = NUM_LINES_2CIFS_PAL;
968 pixelsPerLine = LINE_SZ_2CIFS_PAL;
971 linesPerFrame = NUM_LINES_1CIFS_PAL;
972 pixelsPerLine = LINE_SZ_1CIFS_PAL;
978 outImageSize = linesPerFrame * pixelsPerLine;
979 if ((mode->color & MASK_COLOR) != COLOR_Y8) {
980 /* 2 bytes/pixel if not monochrome */
984 /* total bytes to send including prefix and 4K padding;
985 must be a multiple of USB_READ_SIZE */
986 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
987 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
988 /* if size not a multiple of USB_READ_SIZE */
989 if (usbInSize & ~mask_mult)
990 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
994 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
996 struct device *dev = &sdev->udev->dev;
997 dev_info(dev, "------------------------------------------------\n");
998 dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
999 dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
1000 dev_info(dev, "bright: 0x%x\n", mode->bright);
1001 dev_info(dev, "------------------------------------------------\n");
1005 * set mode is the function which controls the DSP.
1006 * the restart parameter in struct s2255_mode should be set whenever
1007 * the image size could change via color format, video system or image
1009 * When the restart parameter is set, we sleep for ONE frame to allow the
1010 * DSP time to get the new frame
1012 static int s2255_set_mode(struct s2255_vc *vc,
1013 struct s2255_mode *mode)
1016 unsigned long chn_rev;
1017 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1019 __le32 *buffer = dev->cmdbuf;
1021 mutex_lock(&dev->cmdlock);
1022 chn_rev = G_chnmap[vc->idx];
1023 dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
1024 /* if JPEG, set the quality */
1025 if ((mode->color & MASK_COLOR) == COLOR_JPG) {
1026 mode->color &= ~MASK_COLOR;
1027 mode->color |= COLOR_JPG;
1028 mode->color &= ~MASK_JPG_QUALITY;
1029 mode->color |= (vc->jpegqual << 8);
1033 vc->req_image_size = get_transfer_size(mode);
1034 dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
1036 buffer[0] = IN_DATA_TOKEN;
1037 buffer[1] = (__le32) cpu_to_le32(chn_rev);
1038 buffer[2] = CMD_SET_MODE;
1039 for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++)
1040 buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]);
1041 vc->setmode_ready = 0;
1042 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1044 s2255_print_cfg(dev, mode);
1045 /* wait at least 3 frames before continuing */
1046 if (mode->restart) {
1047 wait_event_timeout(vc->wait_setmode,
1048 (vc->setmode_ready != 0),
1049 msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1050 if (vc->setmode_ready != 1) {
1051 dprintk(dev, 0, "s2255: no set mode response\n");
1055 /* clear the restart flag */
1056 vc->mode.restart = 0;
1057 dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
1058 mutex_unlock(&dev->cmdlock);
1062 static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus)
1066 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1067 __le32 *buffer = dev->cmdbuf;
1069 mutex_lock(&dev->cmdlock);
1070 chn_rev = G_chnmap[vc->idx];
1071 dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
1072 /* form the get vid status command */
1073 buffer[0] = IN_DATA_TOKEN;
1074 buffer[1] = (__le32) cpu_to_le32(chn_rev);
1075 buffer[2] = CMD_STATUS;
1077 vc->vidstatus_ready = 0;
1078 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1079 wait_event_timeout(vc->wait_vidstatus,
1080 (vc->vidstatus_ready != 0),
1081 msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1082 if (vc->vidstatus_ready != 1) {
1083 dprintk(dev, 0, "s2255: no vidstatus response\n");
1086 *pstatus = vc->vidstatus;
1087 dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
1088 mutex_unlock(&dev->cmdlock);
1092 static int start_streaming(struct vb2_queue *vq, unsigned int count)
1094 struct s2255_vc *vc = vb2_get_drv_priv(vq);
1097 vc->last_frame = -1;
1098 vc->bad_payload = 0;
1100 vc->frame_count = 0;
1101 for (j = 0; j < SYS_FRAMES; j++) {
1102 vc->buffer.frame[j].ulState = S2255_READ_IDLE;
1103 vc->buffer.frame[j].cur_size = 0;
1105 return s2255_start_acquire(vc);
1108 /* abort streaming and wait for last buffer */
1109 static void stop_streaming(struct vb2_queue *vq)
1111 struct s2255_vc *vc = vb2_get_drv_priv(vq);
1112 struct s2255_buffer *buf, *node;
1113 unsigned long flags;
1114 (void) s2255_stop_acquire(vc);
1115 spin_lock_irqsave(&vc->qlock, flags);
1116 list_for_each_entry_safe(buf, node, &vc->buf_list, list) {
1117 list_del(&buf->list);
1118 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1119 dprintk(vc->dev, 2, "[%p/%d] done\n",
1120 buf, buf->vb.vb2_buf.index);
1122 spin_unlock_irqrestore(&vc->qlock, flags);
1125 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id i)
1127 struct s2255_vc *vc = video_drvdata(file);
1128 struct s2255_mode mode;
1129 struct vb2_queue *q = &vc->vb_vidq;
1132 * Changing the standard implies a format change, which is not allowed
1133 * while buffers for use with streaming have already been allocated.
1139 if (i & V4L2_STD_525_60) {
1140 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
1141 /* if changing format, reset frame decimation/intervals */
1142 if (mode.format != FORMAT_NTSC) {
1144 mode.format = FORMAT_NTSC;
1146 vc->width = LINE_SZ_4CIFS_NTSC;
1147 vc->height = NUM_LINES_4CIFS_NTSC * 2;
1149 } else if (i & V4L2_STD_625_50) {
1150 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
1151 if (mode.format != FORMAT_PAL) {
1153 mode.format = FORMAT_PAL;
1155 vc->width = LINE_SZ_4CIFS_PAL;
1156 vc->height = NUM_LINES_4CIFS_PAL * 2;
1162 s2255_set_mode(vc, &mode);
1166 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i)
1168 struct s2255_vc *vc = video_drvdata(file);
1174 /* Sensoray 2255 is a multiple channel capture device.
1175 It does not have a "crossbar" of inputs.
1176 We use one V4L device per channel. The user must
1177 be aware that certain combinations are not allowed.
1178 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1179 at once in color(you can do full fps on 4 channels with greyscale.
1181 static int vidioc_enum_input(struct file *file, void *priv,
1182 struct v4l2_input *inp)
1184 struct s2255_vc *vc = video_drvdata(file);
1185 struct s2255_dev *dev = vc->dev;
1188 if (inp->index != 0)
1190 inp->type = V4L2_INPUT_TYPE_CAMERA;
1191 inp->std = S2255_NORMS;
1193 if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1195 rc = s2255_cmd_status(vc, &status);
1196 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
1199 inp->status = (status & 0x01) ? 0
1200 : V4L2_IN_ST_NO_SIGNAL;
1205 strlcpy(inp->name, "Composite", sizeof(inp->name));
1208 strlcpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video",
1215 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1220 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1227 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
1229 struct s2255_vc *vc =
1230 container_of(ctrl->handler, struct s2255_vc, hdl);
1231 struct s2255_mode mode;
1233 /* update the mode to the corresponding value */
1235 case V4L2_CID_BRIGHTNESS:
1236 mode.bright = ctrl->val;
1238 case V4L2_CID_CONTRAST:
1239 mode.contrast = ctrl->val;
1242 mode.hue = ctrl->val;
1244 case V4L2_CID_SATURATION:
1245 mode.saturation = ctrl->val;
1247 case V4L2_CID_S2255_COLORFILTER:
1248 mode.color &= ~MASK_INPUT_TYPE;
1249 mode.color |= !ctrl->val << 16;
1251 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1252 vc->jpegqual = ctrl->val;
1258 /* set mode here. Note: stream does not need restarted.
1259 some V4L programs restart stream unnecessarily
1262 s2255_set_mode(vc, &mode);
1266 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1267 struct v4l2_jpegcompression *jc)
1269 struct s2255_vc *vc = video_drvdata(file);
1271 memset(jc, 0, sizeof(*jc));
1272 jc->quality = vc->jpegqual;
1273 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1277 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1278 const struct v4l2_jpegcompression *jc)
1280 struct s2255_vc *vc = video_drvdata(file);
1282 if (jc->quality < 0 || jc->quality > 100)
1284 v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality);
1285 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1289 static int vidioc_g_parm(struct file *file, void *priv,
1290 struct v4l2_streamparm *sp)
1292 __u32 def_num, def_dem;
1293 struct s2255_vc *vc = video_drvdata(file);
1295 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1297 sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1298 sp->parm.capture.capturemode = vc->cap_parm.capturemode;
1299 sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1300 def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1301 def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1302 sp->parm.capture.timeperframe.denominator = def_dem;
1303 switch (vc->mode.fdec) {
1306 sp->parm.capture.timeperframe.numerator = def_num;
1309 sp->parm.capture.timeperframe.numerator = def_num * 2;
1312 sp->parm.capture.timeperframe.numerator = def_num * 3;
1315 sp->parm.capture.timeperframe.numerator = def_num * 5;
1318 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
1320 sp->parm.capture.capturemode,
1321 sp->parm.capture.timeperframe.numerator,
1322 sp->parm.capture.timeperframe.denominator);
1326 static int vidioc_s_parm(struct file *file, void *priv,
1327 struct v4l2_streamparm *sp)
1329 struct s2255_vc *vc = video_drvdata(file);
1330 struct s2255_mode mode;
1332 __u32 def_num, def_dem;
1333 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1336 /* high quality capture mode requires a stream restart */
1337 if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode)
1338 && vb2_is_streaming(&vc->vb_vidq))
1340 def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1341 def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1342 if (def_dem != sp->parm.capture.timeperframe.denominator)
1343 sp->parm.capture.timeperframe.numerator = def_num;
1344 else if (sp->parm.capture.timeperframe.numerator <= def_num)
1345 sp->parm.capture.timeperframe.numerator = def_num;
1346 else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1347 sp->parm.capture.timeperframe.numerator = def_num * 2;
1349 } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1350 sp->parm.capture.timeperframe.numerator = def_num * 3;
1353 sp->parm.capture.timeperframe.numerator = def_num * 5;
1357 sp->parm.capture.timeperframe.denominator = def_dem;
1358 sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1359 s2255_set_mode(vc, &mode);
1360 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1362 sp->parm.capture.capturemode,
1363 sp->parm.capture.timeperframe.numerator,
1364 sp->parm.capture.timeperframe.denominator, fdec);
1368 #define NUM_SIZE_ENUMS 3
1369 static const struct v4l2_frmsize_discrete ntsc_sizes[] = {
1374 static const struct v4l2_frmsize_discrete pal_sizes[] = {
1380 static int vidioc_enum_framesizes(struct file *file, void *priv,
1381 struct v4l2_frmsizeenum *fe)
1383 struct s2255_vc *vc = video_drvdata(file);
1384 int is_ntsc = vc->std & V4L2_STD_525_60;
1385 const struct s2255_fmt *fmt;
1387 if (fe->index >= NUM_SIZE_ENUMS)
1390 fmt = format_by_fourcc(fe->pixel_format);
1393 fe->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1394 fe->discrete = is_ntsc ? ntsc_sizes[fe->index] : pal_sizes[fe->index];
1398 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1399 struct v4l2_frmivalenum *fe)
1401 struct s2255_vc *vc = video_drvdata(file);
1402 const struct s2255_fmt *fmt;
1403 const struct v4l2_frmsize_discrete *sizes;
1404 int is_ntsc = vc->std & V4L2_STD_525_60;
1405 #define NUM_FRAME_ENUMS 4
1406 int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1409 if (fe->index >= NUM_FRAME_ENUMS)
1412 fmt = format_by_fourcc(fe->pixel_format);
1416 sizes = is_ntsc ? ntsc_sizes : pal_sizes;
1417 for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++)
1418 if (fe->width == sizes->width &&
1419 fe->height == sizes->height)
1421 if (i == NUM_SIZE_ENUMS)
1424 fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1425 fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1426 fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1427 dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
1428 fe->discrete.numerator,
1429 fe->discrete.denominator);
1433 static int s2255_open(struct file *file)
1435 struct s2255_vc *vc = video_drvdata(file);
1436 struct s2255_dev *dev = vc->dev;
1440 rc = v4l2_fh_open(file);
1444 dprintk(dev, 1, "s2255: %s\n", __func__);
1445 state = atomic_read(&dev->fw_data->fw_state);
1447 case S2255_FW_DISCONNECTING:
1449 case S2255_FW_FAILED:
1450 s2255_dev_err(&dev->udev->dev,
1451 "firmware load failed. retrying.\n");
1452 s2255_fwload_start(dev, 1);
1453 wait_event_timeout(dev->fw_data->wait_fw,
1454 ((atomic_read(&dev->fw_data->fw_state)
1455 == S2255_FW_SUCCESS) ||
1456 (atomic_read(&dev->fw_data->fw_state)
1457 == S2255_FW_DISCONNECTING)),
1458 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1459 /* state may have changed, re-read */
1460 state = atomic_read(&dev->fw_data->fw_state);
1462 case S2255_FW_NOTLOADED:
1463 case S2255_FW_LOADED_DSPWAIT:
1464 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1465 driver loaded and then device immediately opened */
1466 pr_info("%s waiting for firmware load\n", __func__);
1467 wait_event_timeout(dev->fw_data->wait_fw,
1468 ((atomic_read(&dev->fw_data->fw_state)
1469 == S2255_FW_SUCCESS) ||
1470 (atomic_read(&dev->fw_data->fw_state)
1471 == S2255_FW_DISCONNECTING)),
1472 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1473 /* state may have changed, re-read */
1474 state = atomic_read(&dev->fw_data->fw_state);
1476 case S2255_FW_SUCCESS:
1480 /* state may have changed in above switch statement */
1482 case S2255_FW_SUCCESS:
1484 case S2255_FW_FAILED:
1485 pr_info("2255 firmware load failed.\n");
1487 case S2255_FW_DISCONNECTING:
1488 pr_info("%s: disconnecting\n", __func__);
1490 case S2255_FW_LOADED_DSPWAIT:
1491 case S2255_FW_NOTLOADED:
1492 pr_info("%s: firmware not loaded, please retry\n",
1495 * Timeout on firmware load means device unusable.
1496 * Set firmware failure state.
1497 * On next s2255_open the firmware will be reloaded.
1499 atomic_set(&dev->fw_data->fw_state,
1503 pr_info("%s: unknown state\n", __func__);
1506 if (!vc->configured) {
1507 /* configure channel to default state */
1508 vc->fmt = &formats[0];
1509 s2255_set_mode(vc, &vc->mode);
1515 static void s2255_destroy(struct s2255_dev *dev)
1517 dprintk(dev, 1, "%s", __func__);
1518 /* board shutdown stops the read pipe if it is running */
1519 s2255_board_shutdown(dev);
1520 /* make sure firmware still not trying to load */
1521 del_timer_sync(&dev->timer); /* only started in .probe and .open */
1522 if (dev->fw_data->fw_urb) {
1523 usb_kill_urb(dev->fw_data->fw_urb);
1524 usb_free_urb(dev->fw_data->fw_urb);
1525 dev->fw_data->fw_urb = NULL;
1527 release_firmware(dev->fw_data->fw);
1528 kfree(dev->fw_data->pfw_data);
1529 kfree(dev->fw_data);
1530 /* reset the DSP so firmware can be reloaded next time */
1531 s2255_reset_dsppower(dev);
1532 mutex_destroy(&dev->lock);
1533 usb_put_dev(dev->udev);
1534 v4l2_device_unregister(&dev->v4l2_dev);
1539 static const struct v4l2_file_operations s2255_fops_v4l = {
1540 .owner = THIS_MODULE,
1542 .release = vb2_fop_release,
1543 .poll = vb2_fop_poll,
1544 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1545 .mmap = vb2_fop_mmap,
1546 .read = vb2_fop_read,
1549 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1550 .vidioc_querycap = vidioc_querycap,
1551 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1552 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1553 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1554 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1555 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1556 .vidioc_querybuf = vb2_ioctl_querybuf,
1557 .vidioc_qbuf = vb2_ioctl_qbuf,
1558 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1559 .vidioc_s_std = vidioc_s_std,
1560 .vidioc_g_std = vidioc_g_std,
1561 .vidioc_enum_input = vidioc_enum_input,
1562 .vidioc_g_input = vidioc_g_input,
1563 .vidioc_s_input = vidioc_s_input,
1564 .vidioc_streamon = vb2_ioctl_streamon,
1565 .vidioc_streamoff = vb2_ioctl_streamoff,
1566 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1567 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1568 .vidioc_s_parm = vidioc_s_parm,
1569 .vidioc_g_parm = vidioc_g_parm,
1570 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1571 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1572 .vidioc_log_status = v4l2_ctrl_log_status,
1573 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1574 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1577 static void s2255_video_device_release(struct video_device *vdev)
1579 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1580 struct s2255_vc *vc =
1581 container_of(vdev, struct s2255_vc, vdev);
1583 dprintk(dev, 4, "%s, chnls: %d\n", __func__,
1584 atomic_read(&dev->num_channels));
1586 v4l2_ctrl_handler_free(&vc->hdl);
1588 if (atomic_dec_and_test(&dev->num_channels))
1593 static const struct video_device template = {
1595 .fops = &s2255_fops_v4l,
1596 .ioctl_ops = &s2255_ioctl_ops,
1597 .release = s2255_video_device_release,
1598 .tvnorms = S2255_NORMS,
1601 static const struct v4l2_ctrl_ops s2255_ctrl_ops = {
1602 .s_ctrl = s2255_s_ctrl,
1605 static const struct v4l2_ctrl_config color_filter_ctrl = {
1606 .ops = &s2255_ctrl_ops,
1607 .name = "Color Filter",
1608 .id = V4L2_CID_S2255_COLORFILTER,
1609 .type = V4L2_CTRL_TYPE_BOOLEAN,
1615 static int s2255_probe_v4l(struct s2255_dev *dev)
1619 int cur_nr = video_nr;
1620 struct s2255_vc *vc;
1621 struct vb2_queue *q;
1623 ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1626 /* initialize all video 4 linux */
1627 /* register 4 video devices */
1628 for (i = 0; i < MAX_CHANNELS; i++) {
1630 INIT_LIST_HEAD(&vc->buf_list);
1632 v4l2_ctrl_handler_init(&vc->hdl, 6);
1633 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1634 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
1635 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1636 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
1637 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1638 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
1639 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1640 V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
1641 vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl,
1643 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1644 0, 100, 1, S2255_DEF_JPEG_QUAL);
1645 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1646 (dev->pid != 0x2257 || vc->idx <= 1))
1647 v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl,
1649 if (vc->hdl.error) {
1650 ret = vc->hdl.error;
1651 v4l2_ctrl_handler_free(&vc->hdl);
1652 dev_err(&dev->udev->dev, "couldn't register control\n");
1656 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1657 q->io_modes = VB2_MMAP | VB2_READ | VB2_USERPTR;
1659 q->lock = &vc->vb_lock;
1660 q->buf_struct_size = sizeof(struct s2255_buffer);
1661 q->mem_ops = &vb2_vmalloc_memops;
1662 q->ops = &s2255_video_qops;
1663 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1664 ret = vb2_queue_init(q);
1666 dev_err(&dev->udev->dev,
1667 "%s vb2_queue_init 0x%x\n", __func__, ret);
1670 /* register video devices */
1671 vc->vdev = template;
1673 vc->vdev.ctrl_handler = &vc->hdl;
1674 vc->vdev.lock = &dev->lock;
1675 vc->vdev.v4l2_dev = &dev->v4l2_dev;
1676 video_set_drvdata(&vc->vdev, vc);
1678 ret = video_register_device(&vc->vdev,
1682 ret = video_register_device(&vc->vdev,
1687 dev_err(&dev->udev->dev,
1688 "failed to register video device!\n");
1691 atomic_inc(&dev->num_channels);
1692 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1693 video_device_node_name(&vc->vdev));
1696 pr_info("Sensoray 2255 V4L driver Revision: %s\n",
1698 /* if no channels registered, return error and probe will fail*/
1699 if (atomic_read(&dev->num_channels) == 0) {
1700 v4l2_device_unregister(&dev->v4l2_dev);
1703 if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1704 pr_warn("s2255: Not all channels available.\n");
1708 /* this function moves the usb stream read pipe data
1709 * into the system buffers.
1710 * returns 0 on success, EAGAIN if more data to process( call this
1713 * Received frame structure:
1714 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1715 * bytes 4-7: channel: 0-3
1716 * bytes 8-11: payload size: size of the frame
1717 * bytes 12-payloadsize+12: frame data
1719 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1725 unsigned long copy_size;
1728 struct s2255_framei *frm;
1729 unsigned char *pdata;
1730 struct s2255_vc *vc;
1731 dprintk(dev, 100, "buffer to user\n");
1732 vc = &dev->vc[dev->cc];
1733 idx = vc->cur_frame;
1734 frm = &vc->buffer.frame[idx];
1735 if (frm->ulState == S2255_READ_IDLE) {
1738 __le32 *pdword; /*data from dsp is little endian */
1740 /* search for marker codes */
1741 pdata = (unsigned char *)pipe_info->transfer_buffer;
1742 pdword = (__le32 *)pdata;
1743 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1745 case S2255_MARKER_FRAME:
1746 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n",
1747 jj, pdata[0], pdata[1]);
1748 offset = jj + PREFIX_SIZE;
1750 cc = le32_to_cpu(pdword[1]);
1751 if (cc >= MAX_CHANNELS) {
1757 dev->cc = G_chnmap[cc];
1758 vc = &dev->vc[dev->cc];
1759 payload = le32_to_cpu(pdword[3]);
1760 if (payload > vc->req_image_size) {
1762 /* discard the bad frame */
1765 vc->pkt_size = payload;
1766 vc->jpg_size = le32_to_cpu(pdword[4]);
1768 case S2255_MARKER_RESPONSE:
1770 pdata += DEF_USB_BLOCK;
1771 jj += DEF_USB_BLOCK;
1772 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
1774 cc = G_chnmap[le32_to_cpu(pdword[1])];
1775 if (cc >= MAX_CHANNELS)
1778 switch (pdword[2]) {
1779 case S2255_RESPONSE_SETMODE:
1780 /* check if channel valid */
1781 /* set mode ready */
1782 vc->setmode_ready = 1;
1783 wake_up(&vc->wait_setmode);
1784 dprintk(dev, 5, "setmode rdy %d\n", cc);
1786 case S2255_RESPONSE_FW:
1787 dev->chn_ready |= (1 << cc);
1788 if ((dev->chn_ready & 0x0f) != 0x0f)
1790 /* all channels ready */
1791 pr_info("s2255: fw loaded\n");
1792 atomic_set(&dev->fw_data->fw_state,
1794 wake_up(&dev->fw_data->wait_fw);
1796 case S2255_RESPONSE_STATUS:
1797 vc->vidstatus = le32_to_cpu(pdword[3]);
1798 vc->vidstatus_ready = 1;
1799 wake_up(&vc->wait_vidstatus);
1800 dprintk(dev, 5, "vstat %x chan %d\n",
1801 le32_to_cpu(pdword[3]), cc);
1804 pr_info("s2255 unknown resp\n");
1818 vc = &dev->vc[dev->cc];
1819 idx = vc->cur_frame;
1820 frm = &vc->buffer.frame[idx];
1821 /* search done. now find out if should be acquiring on this channel */
1822 if (!vb2_is_streaming(&vc->vb_vidq)) {
1823 /* we found a frame, but this channel is turned off */
1824 frm->ulState = S2255_READ_IDLE;
1828 if (frm->ulState == S2255_READ_IDLE) {
1829 frm->ulState = S2255_READ_FRAME;
1833 /* skip the marker 512 bytes (and offset if out of sync) */
1834 psrc = (u8 *)pipe_info->transfer_buffer + offset;
1837 if (frm->lpvbits == NULL) {
1838 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1839 frm, dev, dev->cc, idx);
1843 pdest = frm->lpvbits + frm->cur_size;
1845 copy_size = (pipe_info->cur_transfer_size - offset);
1847 size = vc->pkt_size - PREFIX_SIZE;
1849 /* sanity check on pdest */
1850 if ((copy_size + frm->cur_size) < vc->req_image_size)
1851 memcpy(pdest, psrc, copy_size);
1853 frm->cur_size += copy_size;
1854 dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size);
1856 if (frm->cur_size >= size) {
1857 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
1859 vc->last_frame = vc->cur_frame;
1861 /* end of system frame ring buffer, start at zero */
1862 if ((vc->cur_frame == SYS_FRAMES) ||
1863 (vc->cur_frame == vc->buffer.dwFrames))
1866 if (vb2_is_streaming(&vc->vb_vidq))
1867 s2255_got_frame(vc, vc->jpg_size);
1869 frm->ulState = S2255_READ_IDLE;
1873 /* done successfully */
1877 static void s2255_read_video_callback(struct s2255_dev *dev,
1878 struct s2255_pipeinfo *pipe_info)
1881 dprintk(dev, 50, "callback read video\n");
1883 if (dev->cc >= MAX_CHANNELS) {
1885 dev_err(&dev->udev->dev, "invalid channel\n");
1888 /* otherwise copy to the system buffers */
1889 res = save_frame(dev, pipe_info);
1891 dprintk(dev, 4, "s2255: read callback failed\n");
1893 dprintk(dev, 50, "callback read video done\n");
1897 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1898 u16 Index, u16 Value, void *TransferBuffer,
1899 s32 TransferBufferLength, int bOut)
1904 buf = kmalloc(TransferBufferLength, GFP_KERNEL);
1909 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1911 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1914 TransferBufferLength, USB_CTRL_SET_TIMEOUT);
1917 memcpy(TransferBuffer, buf, TransferBufferLength);
1919 memcpy(buf, TransferBuffer, TransferBufferLength);
1920 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1921 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1923 TransferBufferLength, USB_CTRL_SET_TIMEOUT);
1930 * retrieve FX2 firmware version. future use.
1931 * @param dev pointer to device extension
1932 * @return -1 for fail, else returns firmware version as an int(16 bits)
1934 static int s2255_get_fx2fw(struct s2255_dev *dev)
1938 unsigned char transBuffer[64];
1939 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
1942 dprintk(dev, 2, "get fw error: %x\n", ret);
1943 fw = transBuffer[0] + (transBuffer[1] << 8);
1944 dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
1949 * Create the system ring buffer to copy frames into from the
1952 static int s2255_create_sys_buffers(struct s2255_vc *vc)
1955 unsigned long reqsize;
1956 vc->buffer.dwFrames = SYS_FRAMES;
1957 /* always allocate maximum size(PAL) for system buffers */
1958 reqsize = SYS_FRAMES_MAXSIZE;
1960 if (reqsize > SYS_FRAMES_MAXSIZE)
1961 reqsize = SYS_FRAMES_MAXSIZE;
1963 for (i = 0; i < SYS_FRAMES; i++) {
1964 /* allocate the frames */
1965 vc->buffer.frame[i].lpvbits = vmalloc(reqsize);
1966 vc->buffer.frame[i].size = reqsize;
1967 if (vc->buffer.frame[i].lpvbits == NULL) {
1968 pr_info("out of memory. using less frames\n");
1969 vc->buffer.dwFrames = i;
1974 /* make sure internal states are set */
1975 for (i = 0; i < SYS_FRAMES; i++) {
1976 vc->buffer.frame[i].ulState = 0;
1977 vc->buffer.frame[i].cur_size = 0;
1981 vc->last_frame = -1;
1985 static int s2255_release_sys_buffers(struct s2255_vc *vc)
1988 for (i = 0; i < SYS_FRAMES; i++) {
1989 vfree(vc->buffer.frame[i].lpvbits);
1990 vc->buffer.frame[i].lpvbits = NULL;
1995 static int s2255_board_init(struct s2255_dev *dev)
1997 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2000 struct s2255_pipeinfo *pipe = &dev->pipe;
2001 dprintk(dev, 4, "board init: %p", dev);
2002 memset(pipe, 0, sizeof(*pipe));
2004 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2005 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
2007 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2009 if (pipe->transfer_buffer == NULL) {
2010 dprintk(dev, 1, "out of memory!\n");
2013 /* query the firmware */
2014 fw_ver = s2255_get_fx2fw(dev);
2016 pr_info("s2255: usb firmware version %d.%d\n",
2017 (fw_ver >> 8) & 0xff,
2020 if (fw_ver < S2255_CUR_USB_FWVER)
2021 pr_info("s2255: newer USB firmware available\n");
2023 for (j = 0; j < MAX_CHANNELS; j++) {
2024 struct s2255_vc *vc = &dev->vc[j];
2025 vc->mode = mode_def;
2026 if (dev->pid == 0x2257 && j > 1)
2027 vc->mode.color |= (1 << 16);
2028 vc->jpegqual = S2255_DEF_JPEG_QUAL;
2029 vc->width = LINE_SZ_4CIFS_NTSC;
2030 vc->height = NUM_LINES_4CIFS_NTSC * 2;
2031 vc->std = V4L2_STD_NTSC_M;
2032 vc->fmt = &formats[0];
2033 vc->mode.restart = 1;
2034 vc->req_image_size = get_transfer_size(&mode_def);
2035 vc->frame_count = 0;
2036 /* create the system buffers */
2037 s2255_create_sys_buffers(vc);
2039 /* start read pipe */
2040 s2255_start_readpipe(dev);
2041 dprintk(dev, 1, "%s: success\n", __func__);
2045 static int s2255_board_shutdown(struct s2255_dev *dev)
2048 dprintk(dev, 1, "%s: dev: %p", __func__, dev);
2050 for (i = 0; i < MAX_CHANNELS; i++) {
2051 if (vb2_is_streaming(&dev->vc[i].vb_vidq))
2052 s2255_stop_acquire(&dev->vc[i]);
2054 s2255_stop_readpipe(dev);
2055 for (i = 0; i < MAX_CHANNELS; i++)
2056 s2255_release_sys_buffers(&dev->vc[i]);
2057 /* release transfer buffer */
2058 kfree(dev->pipe.transfer_buffer);
2062 static void read_pipe_completion(struct urb *purb)
2064 struct s2255_pipeinfo *pipe_info;
2065 struct s2255_dev *dev;
2068 pipe_info = purb->context;
2069 if (pipe_info == NULL) {
2070 dev_err(&purb->dev->dev, "no context!\n");
2073 dev = pipe_info->dev;
2075 dev_err(&purb->dev->dev, "no context!\n");
2078 status = purb->status;
2079 /* if shutting down, do not resubmit, exit immediately */
2080 if (status == -ESHUTDOWN) {
2081 dprintk(dev, 2, "%s: err shutdown\n", __func__);
2082 pipe_info->err_count++;
2086 if (pipe_info->state == 0) {
2087 dprintk(dev, 2, "%s: exiting USB pipe", __func__);
2092 s2255_read_video_callback(dev, pipe_info);
2094 pipe_info->err_count++;
2095 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status);
2098 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2100 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2102 pipe_info->transfer_buffer,
2103 pipe_info->cur_transfer_size,
2104 read_pipe_completion, pipe_info);
2106 if (pipe_info->state != 0) {
2107 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC))
2108 dev_err(&dev->udev->dev, "error submitting urb\n");
2110 dprintk(dev, 2, "%s :complete state 0\n", __func__);
2115 static int s2255_start_readpipe(struct s2255_dev *dev)
2119 struct s2255_pipeinfo *pipe_info = &dev->pipe;
2120 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2121 dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint);
2122 pipe_info->state = 1;
2123 pipe_info->err_count = 0;
2124 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2125 if (!pipe_info->stream_urb)
2127 /* transfer buffer allocated in board_init */
2128 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2130 pipe_info->transfer_buffer,
2131 pipe_info->cur_transfer_size,
2132 read_pipe_completion, pipe_info);
2133 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2135 pr_err("s2255: start read pipe failed\n");
2141 /* starts acquisition process */
2142 static int s2255_start_acquire(struct s2255_vc *vc)
2145 unsigned long chn_rev;
2147 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2148 __le32 *buffer = dev->cmdbuf;
2150 mutex_lock(&dev->cmdlock);
2151 chn_rev = G_chnmap[vc->idx];
2152 vc->last_frame = -1;
2153 vc->bad_payload = 0;
2155 for (j = 0; j < SYS_FRAMES; j++) {
2156 vc->buffer.frame[j].ulState = 0;
2157 vc->buffer.frame[j].cur_size = 0;
2160 /* send the start command */
2161 buffer[0] = IN_DATA_TOKEN;
2162 buffer[1] = (__le32) cpu_to_le32(chn_rev);
2163 buffer[2] = CMD_START;
2164 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2166 dev_err(&dev->udev->dev, "CMD_START error\n");
2168 dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
2169 mutex_unlock(&dev->cmdlock);
2173 static int s2255_stop_acquire(struct s2255_vc *vc)
2176 unsigned long chn_rev;
2177 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2178 __le32 *buffer = dev->cmdbuf;
2180 mutex_lock(&dev->cmdlock);
2181 chn_rev = G_chnmap[vc->idx];
2182 /* send the stop command */
2183 buffer[0] = IN_DATA_TOKEN;
2184 buffer[1] = (__le32) cpu_to_le32(chn_rev);
2185 buffer[2] = CMD_STOP;
2187 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2189 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2191 dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
2192 mutex_unlock(&dev->cmdlock);
2196 static void s2255_stop_readpipe(struct s2255_dev *dev)
2198 struct s2255_pipeinfo *pipe = &dev->pipe;
2201 if (pipe->stream_urb) {
2203 usb_kill_urb(pipe->stream_urb);
2204 usb_free_urb(pipe->stream_urb);
2205 pipe->stream_urb = NULL;
2207 dprintk(dev, 4, "%s", __func__);
2211 static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2214 s2255_reset_dsppower(dev);
2215 dev->fw_data->fw_size = dev->fw_data->fw->size;
2216 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2217 memcpy(dev->fw_data->pfw_data,
2218 dev->fw_data->fw->data, CHUNK_SIZE);
2219 dev->fw_data->fw_loaded = CHUNK_SIZE;
2220 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2221 usb_sndbulkpipe(dev->udev, 2),
2222 dev->fw_data->pfw_data,
2223 CHUNK_SIZE, s2255_fwchunk_complete,
2225 mod_timer(&dev->timer, jiffies + HZ);
2228 /* standard usb probe function */
2229 static int s2255_probe(struct usb_interface *interface,
2230 const struct usb_device_id *id)
2232 struct s2255_dev *dev = NULL;
2233 struct usb_host_interface *iface_desc;
2234 struct usb_endpoint_descriptor *endpoint;
2236 int retval = -ENOMEM;
2240 /* allocate memory for our device state and initialize it to zero */
2241 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2243 s2255_dev_err(&interface->dev, "out of memory\n");
2247 dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL);
2248 if (dev->cmdbuf == NULL) {
2249 s2255_dev_err(&interface->dev, "out of memory\n");
2253 atomic_set(&dev->num_channels, 0);
2254 dev->pid = id->idProduct;
2255 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2258 mutex_init(&dev->lock);
2259 mutex_init(&dev->cmdlock);
2260 /* grab usb_device and save it */
2261 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2262 if (dev->udev == NULL) {
2263 dev_err(&interface->dev, "null usb device\n");
2267 dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n",
2268 dev, dev->udev, interface);
2269 dev->interface = interface;
2270 /* set up the endpoint information */
2271 iface_desc = interface->cur_altsetting;
2272 dev_dbg(&interface->dev, "num EP: %d\n",
2273 iface_desc->desc.bNumEndpoints);
2274 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2275 endpoint = &iface_desc->endpoint[i].desc;
2276 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2277 /* we found the bulk in endpoint */
2278 dev->read_endpoint = endpoint->bEndpointAddress;
2282 if (!dev->read_endpoint) {
2283 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2286 setup_timer(&dev->timer, s2255_timer, (unsigned long)dev->fw_data);
2287 init_waitqueue_head(&dev->fw_data->wait_fw);
2288 for (i = 0; i < MAX_CHANNELS; i++) {
2289 struct s2255_vc *vc = &dev->vc[i];
2292 init_waitqueue_head(&vc->wait_setmode);
2293 init_waitqueue_head(&vc->wait_vidstatus);
2294 spin_lock_init(&vc->qlock);
2295 mutex_init(&vc->vb_lock);
2298 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2299 if (!dev->fw_data->fw_urb)
2302 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2303 if (!dev->fw_data->pfw_data) {
2304 dev_err(&interface->dev, "out of memory!\n");
2307 /* load the first chunk */
2308 if (reject_firmware(&dev->fw_data->fw,
2309 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2310 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
2313 /* check the firmware is valid */
2314 fw_size = dev->fw_data->fw->size;
2315 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2317 if (*pdata != S2255_FW_MARKER) {
2318 dev_err(&interface->dev, "Firmware invalid.\n");
2322 /* make sure firmware is the latest */
2324 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2325 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel));
2326 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2327 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2328 pr_info("s2255: /*(DEBLOBBED)*/ out of date.\n");
2329 if (dev->pid == 0x2257 &&
2330 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2331 pr_warn("2257 needs firmware %d or above.\n",
2332 S2255_MIN_DSP_COLORFILTER);
2334 usb_reset_device(dev->udev);
2335 /* load 2255 board specific */
2336 retval = s2255_board_init(dev);
2338 goto errorBOARDINIT;
2339 s2255_fwload_start(dev, 0);
2340 /* loads v4l specific */
2341 retval = s2255_probe_v4l(dev);
2343 goto errorBOARDINIT;
2344 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2347 s2255_board_shutdown(dev);
2349 release_firmware(dev->fw_data->fw);
2351 kfree(dev->fw_data->pfw_data);
2353 usb_free_urb(dev->fw_data->fw_urb);
2355 del_timer_sync(&dev->timer);
2357 usb_put_dev(dev->udev);
2359 kfree(dev->fw_data);
2360 mutex_destroy(&dev->lock);
2364 pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval);
2368 /* disconnect routine. when board is removed physically or with rmmod */
2369 static void s2255_disconnect(struct usb_interface *interface)
2371 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2373 int channels = atomic_read(&dev->num_channels);
2374 mutex_lock(&dev->lock);
2375 v4l2_device_disconnect(&dev->v4l2_dev);
2376 mutex_unlock(&dev->lock);
2377 /*see comments in the uvc_driver.c usb disconnect function */
2378 atomic_inc(&dev->num_channels);
2379 /* unregister each video device. */
2380 for (i = 0; i < channels; i++)
2381 video_unregister_device(&dev->vc[i].vdev);
2382 /* wake up any of our timers */
2383 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2384 wake_up(&dev->fw_data->wait_fw);
2385 for (i = 0; i < MAX_CHANNELS; i++) {
2386 dev->vc[i].setmode_ready = 1;
2387 wake_up(&dev->vc[i].wait_setmode);
2388 dev->vc[i].vidstatus_ready = 1;
2389 wake_up(&dev->vc[i].wait_vidstatus);
2391 if (atomic_dec_and_test(&dev->num_channels))
2393 dev_info(&interface->dev, "%s\n", __func__);
2396 static struct usb_driver s2255_driver = {
2397 .name = S2255_DRIVER_NAME,
2398 .probe = s2255_probe,
2399 .disconnect = s2255_disconnect,
2400 .id_table = s2255_table,
2403 module_usb_driver(s2255_driver);
2405 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2406 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2407 MODULE_LICENSE("GPL");
2408 MODULE_VERSION(S2255_VERSION);