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.
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 <linux/vmalloc.h>
47 #include <linux/usb.h>
48 #include <media/videobuf2-vmalloc.h>
49 #include <media/v4l2-common.h>
50 #include <media/v4l2-device.h>
51 #include <media/v4l2-ioctl.h>
52 #include <media/v4l2-ctrls.h>
53 #include <media/v4l2-event.h>
55 #define S2255_VERSION "1.25.1"
56 #define FIRMWARE_FILE_NAME "f2255usb.bin"
58 /* default JPEG quality */
59 #define S2255_DEF_JPEG_QUAL 50
60 /* vendor request in */
62 /* vendor request out */
63 #define S2255_VR_OUT 1
65 #define S2255_VR_FW 0x30
66 /* USB endpoint number for configuring the device */
67 #define S2255_CONFIG_EP 2
68 /* maximum time for DSP to start responding after last FW word loaded(ms) */
69 #define S2255_DSP_BOOTTIME 800
70 /* maximum time to wait for firmware to load (ms) */
71 #define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
72 #define S2255_MIN_BUFS 2
73 #define S2255_SETMODE_TIMEOUT 500
74 #define S2255_VIDSTATUS_TIMEOUT 350
75 #define S2255_MARKER_FRAME cpu_to_le32(0x2255DA4AL)
76 #define S2255_MARKER_RESPONSE cpu_to_le32(0x2255ACACL)
77 #define S2255_RESPONSE_SETMODE cpu_to_le32(0x01)
78 #define S2255_RESPONSE_FW cpu_to_le32(0x10)
79 #define S2255_RESPONSE_STATUS cpu_to_le32(0x20)
80 #define S2255_USB_XFER_SIZE (16 * 1024)
81 #define MAX_CHANNELS 4
83 /* maximum size is PAL full size plus room for the marker header(s) */
84 #define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
85 #define DEF_USB_BLOCK S2255_USB_XFER_SIZE
86 #define LINE_SZ_4CIFS_NTSC 640
87 #define LINE_SZ_2CIFS_NTSC 640
88 #define LINE_SZ_1CIFS_NTSC 320
89 #define LINE_SZ_4CIFS_PAL 704
90 #define LINE_SZ_2CIFS_PAL 704
91 #define LINE_SZ_1CIFS_PAL 352
92 #define NUM_LINES_4CIFS_NTSC 240
93 #define NUM_LINES_2CIFS_NTSC 240
94 #define NUM_LINES_1CIFS_NTSC 240
95 #define NUM_LINES_4CIFS_PAL 288
96 #define NUM_LINES_2CIFS_PAL 288
97 #define NUM_LINES_1CIFS_PAL 288
98 #define LINE_SZ_DEF 640
99 #define NUM_LINES_DEF 240
102 /* predefined settings */
103 #define FORMAT_NTSC 1
106 #define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
107 #define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
108 #define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
109 /* SCALE_4CIFSI is the 2 fields interpolated into one */
110 #define SCALE_4CIFSI 4 /* 640x480(NTSC) or 704x576(PAL) high quality */
112 #define COLOR_YUVPL 1 /* YUV planar */
113 #define COLOR_YUVPK 2 /* YUV packed */
114 #define COLOR_Y8 4 /* monochrome */
115 #define COLOR_JPG 5 /* JPEG */
117 #define MASK_COLOR 0x000000ff
118 #define MASK_JPG_QUALITY 0x0000ff00
119 #define MASK_INPUT_TYPE 0x000f0000
120 /* frame decimation. */
121 #define FDEC_1 1 /* capture every frame. default */
122 #define FDEC_2 2 /* capture every 2nd frame */
123 #define FDEC_3 3 /* capture every 3rd frame */
124 #define FDEC_5 5 /* capture every 5th frame */
126 /*-------------------------------------------------------
127 * Default mode parameters.
128 *-------------------------------------------------------*/
129 #define DEF_SCALE SCALE_4CIFS
130 #define DEF_COLOR COLOR_YUVPL
131 #define DEF_FDEC FDEC_1
133 #define DEF_CONTRAST 0x5c
134 #define DEF_SATURATION 0x80
137 /* usb config commands */
138 #define IN_DATA_TOKEN cpu_to_le32(0x2255c0de)
139 #define CMD_2255 0xc2255000
140 #define CMD_SET_MODE cpu_to_le32((CMD_2255 | 0x10))
141 #define CMD_START cpu_to_le32((CMD_2255 | 0x20))
142 #define CMD_STOP cpu_to_le32((CMD_2255 | 0x30))
143 #define CMD_STATUS cpu_to_le32((CMD_2255 | 0x40))
146 u32 format
; /* input video format (NTSC, PAL) */
147 u32 scale
; /* output video scale */
148 u32 color
; /* output video color format */
149 u32 fdec
; /* frame decimation */
150 u32 bright
; /* brightness */
151 u32 contrast
; /* contrast */
152 u32 saturation
; /* saturation */
153 u32 hue
; /* hue (NTSC only)*/
154 u32 single
; /* capture 1 frame at a time (!=0), continuously (==0)*/
155 u32 usb_block
; /* block size. should be 4096 of DEF_USB_BLOCK */
156 u32 restart
; /* if DSP requires restart */
160 #define S2255_READ_IDLE 0
161 #define S2255_READ_FRAME 1
163 /* frame structure */
164 struct s2255_framei
{
166 unsigned long ulState
; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
167 void *lpvbits
; /* image data */
168 unsigned long cur_size
; /* current data copied to it */
171 /* image buffer structure */
172 struct s2255_bufferi
{
173 unsigned long dwFrames
; /* number of frames in buffer */
174 struct s2255_framei frame
[SYS_FRAMES
]; /* array of FRAME structures */
177 #define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
178 DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
179 DEF_HUE, 0, DEF_USB_BLOCK, 0}
181 /* for firmware loading, fw_state */
182 #define S2255_FW_NOTLOADED 0
183 #define S2255_FW_LOADED_DSPWAIT 1
184 #define S2255_FW_SUCCESS 2
185 #define S2255_FW_FAILED 3
186 #define S2255_FW_DISCONNECTING 4
187 #define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
188 /* 2255 read states */
189 #define S2255_READ_IDLE 0
190 #define S2255_READ_FRAME 1
197 wait_queue_head_t wait_fw
;
198 const struct firmware
*fw
;
201 struct s2255_pipeinfo
{
202 u32 max_transfer_size
;
203 u32 cur_transfer_size
;
207 void *dev
; /* back pointer to s2255_dev struct*/
212 struct s2255_fmt
; /*forward declaration */
215 /* 2255 video channel */
217 struct s2255_dev
*dev
;
218 struct video_device vdev
;
219 struct v4l2_ctrl_handler hdl
;
220 struct v4l2_ctrl
*jpegqual_ctrl
;
222 struct list_head buf_list
;
223 struct s2255_bufferi buffer
;
224 struct s2255_mode mode
;
226 /* jpeg compression */
228 /* capture parameters (for high quality mode full size) */
229 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 enum v4l2_field field
;
251 const struct s2255_fmt
*fmt
;
252 int idx
; /* channel number on device, 0-3 */
253 struct vb2_queue vb_vidq
;
254 struct mutex vb_lock
; /* streaming lock */
260 struct s2255_vc vc
[MAX_CHANNELS
];
261 struct v4l2_device v4l2_dev
;
262 atomic_t num_channels
;
264 struct mutex lock
; /* channels[].vdev.lock */
265 struct mutex cmdlock
; /* protects cmdbuf */
266 struct usb_device
*udev
;
267 struct usb_interface
*interface
;
269 struct timer_list timer
;
270 struct s2255_fw
*fw_data
;
271 struct s2255_pipeinfo pipe
;
272 u32 cc
; /* current channel */
275 /* dsp firmware version (f2255usb.bin) */
277 u16 pid
; /* product id */
278 #define S2255_CMDBUF_SIZE 512
282 static inline struct s2255_dev
*to_s2255_dev(struct v4l2_device
*v4l2_dev
)
284 return container_of(v4l2_dev
, struct s2255_dev
, v4l2_dev
);
293 /* buffer for one video frame */
294 struct s2255_buffer
{
295 /* common v4l buffer stuff -- must be first */
296 struct vb2_buffer vb
;
297 struct list_head list
;
301 /* current cypress EEPROM firmware version */
302 #define S2255_CUR_USB_FWVER ((3 << 8) | 12)
303 /* current DSP FW version */
304 #define S2255_CUR_DSP_FWVER 10104
305 /* Need DSP version 5+ for video status feature */
306 #define S2255_MIN_DSP_STATUS 5
307 #define S2255_MIN_DSP_COLORFILTER 8
308 #define S2255_NORMS (V4L2_STD_ALL)
310 /* private V4L2 controls */
313 * The following chart displays how COLORFILTER should be set
314 * =========================================================
315 * = fourcc = COLORFILTER =
316 * = ===============================
318 * =========================================================
319 * = V4L2_PIX_FMT_GREY(Y8) = monochrome from = monochrome=
320 * = = s-video or = composite =
321 * = = B/W camera = input =
322 * =========================================================
323 * = other = color, svideo = color, =
325 * =========================================================
328 * channels 0-3 on 2255 are composite
329 * channels 0-1 on 2257 are composite, 2-3 are s-video
330 * If COLORFILTER is 0 with a composite color camera connected,
331 * the output will appear monochrome but hatching
333 * COLORFILTER is different from "color killer" and "color effects"
336 #define S2255_V4L2_YC_ON 1
337 #define S2255_V4L2_YC_OFF 0
338 #define V4L2_CID_S2255_COLORFILTER (V4L2_CID_USER_S2255_BASE + 0)
340 /* frame prefix size (sent once every frame) */
341 #define PREFIX_SIZE 512
343 /* Channels on box are in reverse order */
344 static unsigned long G_chnmap
[MAX_CHANNELS
] = {3, 2, 1, 0};
348 static int s2255_start_readpipe(struct s2255_dev
*dev
);
349 static void s2255_stop_readpipe(struct s2255_dev
*dev
);
350 static int s2255_start_acquire(struct s2255_vc
*vc
);
351 static int s2255_stop_acquire(struct s2255_vc
*vc
);
352 static void s2255_fillbuff(struct s2255_vc
*vc
, struct s2255_buffer
*buf
,
354 static int s2255_set_mode(struct s2255_vc
*vc
, struct s2255_mode
*mode
);
355 static int s2255_board_shutdown(struct s2255_dev
*dev
);
356 static void s2255_fwload_start(struct s2255_dev
*dev
, int reset
);
357 static void s2255_destroy(struct s2255_dev
*dev
);
358 static long s2255_vendor_req(struct s2255_dev
*dev
, unsigned char req
,
359 u16 index
, u16 value
, void *buf
,
360 s32 buf_len
, int bOut
);
362 /* dev_err macro with driver name */
363 #define S2255_DRIVER_NAME "s2255"
364 #define s2255_dev_err(dev, fmt, arg...) \
365 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
367 #define dprintk(dev, level, fmt, arg...) \
368 v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
370 static struct usb_driver s2255_driver
;
372 /* start video number */
373 static int video_nr
= -1; /* /dev/videoN, -1 for autodetect */
375 /* Enable jpeg capture. */
376 static int jpeg_enable
= 1;
378 module_param(debug
, int, 0644);
379 MODULE_PARM_DESC(debug
, "Debug level(0-100) default 0");
380 module_param(video_nr
, int, 0644);
381 MODULE_PARM_DESC(video_nr
, "start video minor(-1 default autodetect)");
382 module_param(jpeg_enable
, int, 0644);
383 MODULE_PARM_DESC(jpeg_enable
, "Jpeg enable(1-on 0-off) default 1");
385 /* USB device table */
386 #define USB_SENSORAY_VID 0x1943
387 static struct usb_device_id s2255_table
[] = {
388 {USB_DEVICE(USB_SENSORAY_VID
, 0x2255)},
389 {USB_DEVICE(USB_SENSORAY_VID
, 0x2257)}, /*same family as 2255*/
390 { } /* Terminating entry */
392 MODULE_DEVICE_TABLE(usb
, s2255_table
);
394 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
397 /* JPEG formats must be defined last to support jpeg_enable parameter */
398 static const struct s2255_fmt formats
[] = {
400 .name
= "4:2:2, packed, YUYV",
401 .fourcc
= V4L2_PIX_FMT_YUYV
,
405 .name
= "4:2:2, packed, UYVY",
406 .fourcc
= V4L2_PIX_FMT_UYVY
,
409 .name
= "4:2:2, planar, YUV422P",
410 .fourcc
= V4L2_PIX_FMT_YUV422P
,
415 .fourcc
= V4L2_PIX_FMT_GREY
,
419 .fourcc
= V4L2_PIX_FMT_JPEG
,
423 .fourcc
= V4L2_PIX_FMT_MJPEG
,
428 static int norm_maxw(struct s2255_vc
*vc
)
430 return (vc
->std
& V4L2_STD_525_60
) ?
431 LINE_SZ_4CIFS_NTSC
: LINE_SZ_4CIFS_PAL
;
434 static int norm_maxh(struct s2255_vc
*vc
)
436 return (vc
->std
& V4L2_STD_525_60
) ?
437 (NUM_LINES_1CIFS_NTSC
* 2) : (NUM_LINES_1CIFS_PAL
* 2);
440 static int norm_minw(struct s2255_vc
*vc
)
442 return (vc
->std
& V4L2_STD_525_60
) ?
443 LINE_SZ_1CIFS_NTSC
: LINE_SZ_1CIFS_PAL
;
446 static int norm_minh(struct s2255_vc
*vc
)
448 return (vc
->std
& V4L2_STD_525_60
) ?
449 (NUM_LINES_1CIFS_NTSC
) : (NUM_LINES_1CIFS_PAL
);
454 * TODO: fixme: move YUV reordering to hardware
455 * converts 2255 planar format to yuyv or uyvy
457 static void planar422p_to_yuv_packed(const unsigned char *in
,
459 int width
, int height
,
465 unsigned long size
= height
* width
;
467 pY
= (unsigned char *)in
;
468 pCr
= (unsigned char *)in
+ height
* width
;
469 pCb
= (unsigned char *)in
+ height
* width
+ (height
* width
/ 2);
470 for (i
= 0; i
< size
* 2; i
+= 4) {
471 out
[i
] = (fmt
== V4L2_PIX_FMT_YUYV
) ? *pY
++ : *pCr
++;
472 out
[i
+ 1] = (fmt
== V4L2_PIX_FMT_YUYV
) ? *pCr
++ : *pY
++;
473 out
[i
+ 2] = (fmt
== V4L2_PIX_FMT_YUYV
) ? *pY
++ : *pCb
++;
474 out
[i
+ 3] = (fmt
== V4L2_PIX_FMT_YUYV
) ? *pCb
++ : *pY
++;
479 static void s2255_reset_dsppower(struct s2255_dev
*dev
)
481 s2255_vendor_req(dev
, 0x40, 0x0000, 0x0001, NULL
, 0, 1);
483 s2255_vendor_req(dev
, 0x50, 0x0000, 0x0000, NULL
, 0, 1);
485 s2255_vendor_req(dev
, 0x10, 0x0000, 0x0000, NULL
, 0, 1);
489 /* kickstarts the firmware loading. from probe
491 static void s2255_timer(unsigned long user_data
)
493 struct s2255_fw
*data
= (struct s2255_fw
*)user_data
;
494 if (usb_submit_urb(data
->fw_urb
, GFP_ATOMIC
) < 0) {
495 pr_err("s2255: can't submit urb\n");
496 atomic_set(&data
->fw_state
, S2255_FW_FAILED
);
497 /* wake up anything waiting for the firmware */
498 wake_up(&data
->wait_fw
);
504 /* this loads the firmware asynchronously.
505 Originally this was done synchronously in probe.
506 But it is better to load it asynchronously here than block
507 inside the probe function. Blocking inside probe affects boot time.
508 FW loading is triggered by the timer in the probe function
510 static void s2255_fwchunk_complete(struct urb
*urb
)
512 struct s2255_fw
*data
= urb
->context
;
513 struct usb_device
*udev
= urb
->dev
;
516 dev_err(&udev
->dev
, "URB failed with status %d\n", urb
->status
);
517 atomic_set(&data
->fw_state
, S2255_FW_FAILED
);
518 /* wake up anything waiting for the firmware */
519 wake_up(&data
->wait_fw
);
522 if (data
->fw_urb
== NULL
) {
523 s2255_dev_err(&udev
->dev
, "disconnected\n");
524 atomic_set(&data
->fw_state
, S2255_FW_FAILED
);
525 /* wake up anything waiting for the firmware */
526 wake_up(&data
->wait_fw
);
529 #define CHUNK_SIZE 512
530 /* all USB transfers must be done with continuous kernel memory.
531 can't allocate more than 128k in current linux kernel, so
532 upload the firmware in chunks
534 if (data
->fw_loaded
< data
->fw_size
) {
535 len
= (data
->fw_loaded
+ CHUNK_SIZE
) > data
->fw_size
?
536 data
->fw_size
% CHUNK_SIZE
: CHUNK_SIZE
;
538 if (len
< CHUNK_SIZE
)
539 memset(data
->pfw_data
, 0, CHUNK_SIZE
);
541 memcpy(data
->pfw_data
,
542 (char *) data
->fw
->data
+ data
->fw_loaded
, len
);
544 usb_fill_bulk_urb(data
->fw_urb
, udev
, usb_sndbulkpipe(udev
, 2),
545 data
->pfw_data
, CHUNK_SIZE
,
546 s2255_fwchunk_complete
, data
);
547 if (usb_submit_urb(data
->fw_urb
, GFP_ATOMIC
) < 0) {
548 dev_err(&udev
->dev
, "failed submit URB\n");
549 atomic_set(&data
->fw_state
, S2255_FW_FAILED
);
550 /* wake up anything waiting for the firmware */
551 wake_up(&data
->wait_fw
);
554 data
->fw_loaded
+= len
;
556 atomic_set(&data
->fw_state
, S2255_FW_LOADED_DSPWAIT
);
561 static int s2255_got_frame(struct s2255_vc
*vc
, int jpgsize
)
563 struct s2255_buffer
*buf
;
564 struct s2255_dev
*dev
= to_s2255_dev(vc
->vdev
.v4l2_dev
);
565 unsigned long flags
= 0;
567 spin_lock_irqsave(&vc
->qlock
, flags
);
568 if (list_empty(&vc
->buf_list
)) {
569 dprintk(dev
, 1, "No active queue to serve\n");
573 buf
= list_entry(vc
->buf_list
.next
,
574 struct s2255_buffer
, list
);
575 list_del(&buf
->list
);
576 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
577 s2255_fillbuff(vc
, buf
, jpgsize
);
578 dprintk(dev
, 2, "%s: [buf] [%p]\n", __func__
, buf
);
580 spin_unlock_irqrestore(&vc
->qlock
, flags
);
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
, 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 buf
->vb
.v4l2_buf
.length
= 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
);
652 /* tell v4l buffer was filled */
653 buf
->vb
.v4l2_buf
.field
= vc
->field
;
654 buf
->vb
.v4l2_buf
.sequence
= vc
->frame_count
;
655 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
656 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_DONE
);
660 /* ------------------------------------------------------------------
662 ------------------------------------------------------------------*/
664 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*fmt
,
665 unsigned int *nbuffers
, unsigned int *nplanes
,
666 unsigned int sizes
[], void *alloc_ctxs
[])
668 struct s2255_vc
*vc
= vb2_get_drv_priv(vq
);
669 if (*nbuffers
< S2255_MIN_BUFS
)
670 *nbuffers
= S2255_MIN_BUFS
;
672 sizes
[0] = vc
->width
* vc
->height
* (vc
->fmt
->depth
>> 3);
676 static int buffer_prepare(struct vb2_buffer
*vb
)
678 struct s2255_vc
*vc
= vb2_get_drv_priv(vb
->vb2_queue
);
679 struct s2255_buffer
*buf
= container_of(vb
, struct s2255_buffer
, vb
);
684 dprintk(vc
->dev
, 4, "%s\n", __func__
);
688 if ((w
< norm_minw(vc
)) ||
689 (w
> norm_maxw(vc
)) ||
690 (h
< norm_minh(vc
)) ||
691 (h
> norm_maxh(vc
))) {
692 dprintk(vc
->dev
, 4, "invalid buffer prepare\n");
695 size
= w
* h
* (vc
->fmt
->depth
>> 3);
696 if (vb2_plane_size(vb
, 0) < size
) {
697 dprintk(vc
->dev
, 4, "invalid buffer prepare\n");
701 vb2_set_plane_payload(&buf
->vb
, 0, size
);
705 static void buffer_queue(struct vb2_buffer
*vb
)
707 struct s2255_buffer
*buf
= container_of(vb
, struct s2255_buffer
, vb
);
708 struct s2255_vc
*vc
= vb2_get_drv_priv(vb
->vb2_queue
);
709 unsigned long flags
= 0;
710 dprintk(vc
->dev
, 1, "%s\n", __func__
);
711 spin_lock_irqsave(&vc
->qlock
, flags
);
712 list_add_tail(&buf
->list
, &vc
->buf_list
);
713 spin_unlock_irqrestore(&vc
->qlock
, flags
);
716 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
);
717 static void stop_streaming(struct vb2_queue
*vq
);
719 static struct vb2_ops s2255_video_qops
= {
720 .queue_setup
= queue_setup
,
721 .buf_prepare
= buffer_prepare
,
722 .buf_queue
= buffer_queue
,
723 .start_streaming
= start_streaming
,
724 .stop_streaming
= stop_streaming
,
725 .wait_prepare
= vb2_ops_wait_prepare
,
726 .wait_finish
= vb2_ops_wait_finish
,
729 static int vidioc_querycap(struct file
*file
, void *priv
,
730 struct v4l2_capability
*cap
)
732 struct s2255_vc
*vc
= video_drvdata(file
);
733 struct s2255_dev
*dev
= vc
->dev
;
735 strlcpy(cap
->driver
, "s2255", sizeof(cap
->driver
));
736 strlcpy(cap
->card
, "s2255", sizeof(cap
->card
));
737 usb_make_path(dev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
738 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_STREAMING
|
740 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
744 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
745 struct v4l2_fmtdesc
*f
)
747 int index
= f
->index
;
749 if (index
>= ARRAY_SIZE(formats
))
751 if (!jpeg_enable
&& ((formats
[index
].fourcc
== V4L2_PIX_FMT_JPEG
) ||
752 (formats
[index
].fourcc
== V4L2_PIX_FMT_MJPEG
)))
754 strlcpy(f
->description
, formats
[index
].name
, sizeof(f
->description
));
755 f
->pixelformat
= formats
[index
].fourcc
;
759 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
760 struct v4l2_format
*f
)
762 struct s2255_vc
*vc
= video_drvdata(file
);
763 int is_ntsc
= vc
->std
& V4L2_STD_525_60
;
765 f
->fmt
.pix
.width
= vc
->width
;
766 f
->fmt
.pix
.height
= vc
->height
;
767 if (f
->fmt
.pix
.height
>=
768 (is_ntsc
? NUM_LINES_1CIFS_NTSC
: NUM_LINES_1CIFS_PAL
) * 2)
769 f
->fmt
.pix
.field
= V4L2_FIELD_INTERLACED
;
771 f
->fmt
.pix
.field
= V4L2_FIELD_TOP
;
772 f
->fmt
.pix
.pixelformat
= vc
->fmt
->fourcc
;
773 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
* (vc
->fmt
->depth
>> 3);
774 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
775 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
780 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
781 struct v4l2_format
*f
)
783 const struct s2255_fmt
*fmt
;
784 enum v4l2_field field
;
785 struct s2255_vc
*vc
= video_drvdata(file
);
786 int is_ntsc
= vc
->std
& V4L2_STD_525_60
;
788 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
793 field
= f
->fmt
.pix
.field
;
795 dprintk(vc
->dev
, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
796 __func__
, is_ntsc
, f
->fmt
.pix
.width
, f
->fmt
.pix
.height
);
799 if (f
->fmt
.pix
.height
>= NUM_LINES_1CIFS_NTSC
* 2) {
800 f
->fmt
.pix
.height
= NUM_LINES_1CIFS_NTSC
* 2;
801 field
= V4L2_FIELD_INTERLACED
;
803 f
->fmt
.pix
.height
= NUM_LINES_1CIFS_NTSC
;
804 field
= V4L2_FIELD_TOP
;
806 if (f
->fmt
.pix
.width
>= LINE_SZ_4CIFS_NTSC
)
807 f
->fmt
.pix
.width
= LINE_SZ_4CIFS_NTSC
;
808 else if (f
->fmt
.pix
.width
>= LINE_SZ_2CIFS_NTSC
)
809 f
->fmt
.pix
.width
= LINE_SZ_2CIFS_NTSC
;
810 else if (f
->fmt
.pix
.width
>= LINE_SZ_1CIFS_NTSC
)
811 f
->fmt
.pix
.width
= LINE_SZ_1CIFS_NTSC
;
813 f
->fmt
.pix
.width
= LINE_SZ_1CIFS_NTSC
;
816 if (f
->fmt
.pix
.height
>= NUM_LINES_1CIFS_PAL
* 2) {
817 f
->fmt
.pix
.height
= NUM_LINES_1CIFS_PAL
* 2;
818 field
= V4L2_FIELD_INTERLACED
;
820 f
->fmt
.pix
.height
= NUM_LINES_1CIFS_PAL
;
821 field
= V4L2_FIELD_TOP
;
823 if (f
->fmt
.pix
.width
>= LINE_SZ_4CIFS_PAL
)
824 f
->fmt
.pix
.width
= LINE_SZ_4CIFS_PAL
;
825 else if (f
->fmt
.pix
.width
>= LINE_SZ_2CIFS_PAL
)
826 f
->fmt
.pix
.width
= LINE_SZ_2CIFS_PAL
;
827 else if (f
->fmt
.pix
.width
>= LINE_SZ_1CIFS_PAL
)
828 f
->fmt
.pix
.width
= LINE_SZ_1CIFS_PAL
;
830 f
->fmt
.pix
.width
= LINE_SZ_1CIFS_PAL
;
832 f
->fmt
.pix
.field
= field
;
833 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
834 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
835 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
837 dprintk(vc
->dev
, 50, "%s: set width %d height %d field %d\n", __func__
,
838 f
->fmt
.pix
.width
, f
->fmt
.pix
.height
, f
->fmt
.pix
.field
);
842 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
843 struct v4l2_format
*f
)
845 struct s2255_vc
*vc
= video_drvdata(file
);
846 const struct s2255_fmt
*fmt
;
847 struct vb2_queue
*q
= &vc
->vb_vidq
;
848 struct s2255_mode mode
;
851 ret
= vidioc_try_fmt_vid_cap(file
, vc
, f
);
856 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
861 if (vb2_is_busy(q
)) {
862 dprintk(vc
->dev
, 1, "queue busy\n");
868 vc
->width
= f
->fmt
.pix
.width
;
869 vc
->height
= f
->fmt
.pix
.height
;
870 vc
->field
= f
->fmt
.pix
.field
;
871 if (vc
->width
> norm_minw(vc
)) {
872 if (vc
->height
> norm_minh(vc
)) {
873 if (vc
->cap_parm
.capturemode
&
874 V4L2_MODE_HIGHQUALITY
)
875 mode
.scale
= SCALE_4CIFSI
;
877 mode
.scale
= SCALE_4CIFS
;
879 mode
.scale
= SCALE_2CIFS
;
882 mode
.scale
= SCALE_1CIFS
;
885 switch (vc
->fmt
->fourcc
) {
886 case V4L2_PIX_FMT_GREY
:
887 mode
.color
&= ~MASK_COLOR
;
888 mode
.color
|= COLOR_Y8
;
890 case V4L2_PIX_FMT_JPEG
:
891 case V4L2_PIX_FMT_MJPEG
:
892 mode
.color
&= ~MASK_COLOR
;
893 mode
.color
|= COLOR_JPG
;
894 mode
.color
|= (vc
->jpegqual
<< 8);
896 case V4L2_PIX_FMT_YUV422P
:
897 mode
.color
&= ~MASK_COLOR
;
898 mode
.color
|= COLOR_YUVPL
;
900 case V4L2_PIX_FMT_YUYV
:
901 case V4L2_PIX_FMT_UYVY
:
903 mode
.color
&= ~MASK_COLOR
;
904 mode
.color
|= COLOR_YUVPK
;
907 if ((mode
.color
& MASK_COLOR
) != (vc
->mode
.color
& MASK_COLOR
))
909 else if (mode
.scale
!= vc
->mode
.scale
)
911 else if (mode
.format
!= vc
->mode
.format
)
914 (void) s2255_set_mode(vc
, &mode
);
919 /* write to the configuration pipe, synchronously */
920 static int s2255_write_config(struct usb_device
*udev
, unsigned char *pbuf
,
927 pipe
= usb_sndbulkpipe(udev
, S2255_CONFIG_EP
);
928 retval
= usb_bulk_msg(udev
, pipe
, pbuf
, size
, &done
, 500);
933 static u32
get_transfer_size(struct s2255_mode
*mode
)
935 int linesPerFrame
= LINE_SZ_DEF
;
936 int pixelsPerLine
= NUM_LINES_DEF
;
939 unsigned int mask_mult
;
944 if (mode
->format
== FORMAT_NTSC
) {
945 switch (mode
->scale
) {
948 linesPerFrame
= NUM_LINES_4CIFS_NTSC
* 2;
949 pixelsPerLine
= LINE_SZ_4CIFS_NTSC
;
952 linesPerFrame
= NUM_LINES_2CIFS_NTSC
;
953 pixelsPerLine
= LINE_SZ_2CIFS_NTSC
;
956 linesPerFrame
= NUM_LINES_1CIFS_NTSC
;
957 pixelsPerLine
= LINE_SZ_1CIFS_NTSC
;
962 } else if (mode
->format
== FORMAT_PAL
) {
963 switch (mode
->scale
) {
966 linesPerFrame
= NUM_LINES_4CIFS_PAL
* 2;
967 pixelsPerLine
= LINE_SZ_4CIFS_PAL
;
970 linesPerFrame
= NUM_LINES_2CIFS_PAL
;
971 pixelsPerLine
= LINE_SZ_2CIFS_PAL
;
974 linesPerFrame
= NUM_LINES_1CIFS_PAL
;
975 pixelsPerLine
= LINE_SZ_1CIFS_PAL
;
981 outImageSize
= linesPerFrame
* pixelsPerLine
;
982 if ((mode
->color
& MASK_COLOR
) != COLOR_Y8
) {
983 /* 2 bytes/pixel if not monochrome */
987 /* total bytes to send including prefix and 4K padding;
988 must be a multiple of USB_READ_SIZE */
989 usbInSize
= outImageSize
+ PREFIX_SIZE
; /* always send prefix */
990 mask_mult
= 0xffffffffUL
- DEF_USB_BLOCK
+ 1;
991 /* if size not a multiple of USB_READ_SIZE */
992 if (usbInSize
& ~mask_mult
)
993 usbInSize
= (usbInSize
& mask_mult
) + (DEF_USB_BLOCK
);
997 static void s2255_print_cfg(struct s2255_dev
*sdev
, struct s2255_mode
*mode
)
999 struct device
*dev
= &sdev
->udev
->dev
;
1000 dev_info(dev
, "------------------------------------------------\n");
1001 dev_info(dev
, "format: %d\nscale %d\n", mode
->format
, mode
->scale
);
1002 dev_info(dev
, "fdec: %d\ncolor %d\n", mode
->fdec
, mode
->color
);
1003 dev_info(dev
, "bright: 0x%x\n", mode
->bright
);
1004 dev_info(dev
, "------------------------------------------------\n");
1008 * set mode is the function which controls the DSP.
1009 * the restart parameter in struct s2255_mode should be set whenever
1010 * the image size could change via color format, video system or image
1012 * When the restart parameter is set, we sleep for ONE frame to allow the
1013 * DSP time to get the new frame
1015 static int s2255_set_mode(struct s2255_vc
*vc
,
1016 struct s2255_mode
*mode
)
1019 unsigned long chn_rev
;
1020 struct s2255_dev
*dev
= to_s2255_dev(vc
->vdev
.v4l2_dev
);
1022 __le32
*buffer
= dev
->cmdbuf
;
1024 mutex_lock(&dev
->cmdlock
);
1025 chn_rev
= G_chnmap
[vc
->idx
];
1026 dprintk(dev
, 3, "%s channel: %d\n", __func__
, vc
->idx
);
1027 /* if JPEG, set the quality */
1028 if ((mode
->color
& MASK_COLOR
) == COLOR_JPG
) {
1029 mode
->color
&= ~MASK_COLOR
;
1030 mode
->color
|= COLOR_JPG
;
1031 mode
->color
&= ~MASK_JPG_QUALITY
;
1032 mode
->color
|= (vc
->jpegqual
<< 8);
1036 vc
->req_image_size
= get_transfer_size(mode
);
1037 dprintk(dev
, 1, "%s: reqsize %ld\n", __func__
, vc
->req_image_size
);
1039 buffer
[0] = IN_DATA_TOKEN
;
1040 buffer
[1] = (__le32
) cpu_to_le32(chn_rev
);
1041 buffer
[2] = CMD_SET_MODE
;
1042 for (i
= 0; i
< sizeof(struct s2255_mode
) / sizeof(u32
); i
++)
1043 buffer
[3 + i
] = cpu_to_le32(((u32
*)&vc
->mode
)[i
]);
1044 vc
->setmode_ready
= 0;
1045 res
= s2255_write_config(dev
->udev
, (unsigned char *)buffer
, 512);
1047 s2255_print_cfg(dev
, mode
);
1048 /* wait at least 3 frames before continuing */
1049 if (mode
->restart
) {
1050 wait_event_timeout(vc
->wait_setmode
,
1051 (vc
->setmode_ready
!= 0),
1052 msecs_to_jiffies(S2255_SETMODE_TIMEOUT
));
1053 if (vc
->setmode_ready
!= 1) {
1054 dprintk(dev
, 0, "s2255: no set mode response\n");
1058 /* clear the restart flag */
1059 vc
->mode
.restart
= 0;
1060 dprintk(dev
, 1, "%s chn %d, result: %d\n", __func__
, vc
->idx
, res
);
1061 mutex_unlock(&dev
->cmdlock
);
1065 static int s2255_cmd_status(struct s2255_vc
*vc
, u32
*pstatus
)
1069 struct s2255_dev
*dev
= to_s2255_dev(vc
->vdev
.v4l2_dev
);
1070 __le32
*buffer
= dev
->cmdbuf
;
1072 mutex_lock(&dev
->cmdlock
);
1073 chn_rev
= G_chnmap
[vc
->idx
];
1074 dprintk(dev
, 4, "%s chan %d\n", __func__
, vc
->idx
);
1075 /* form the get vid status command */
1076 buffer
[0] = IN_DATA_TOKEN
;
1077 buffer
[1] = (__le32
) cpu_to_le32(chn_rev
);
1078 buffer
[2] = CMD_STATUS
;
1080 vc
->vidstatus_ready
= 0;
1081 res
= s2255_write_config(dev
->udev
, (unsigned char *)buffer
, 512);
1082 wait_event_timeout(vc
->wait_vidstatus
,
1083 (vc
->vidstatus_ready
!= 0),
1084 msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT
));
1085 if (vc
->vidstatus_ready
!= 1) {
1086 dprintk(dev
, 0, "s2255: no vidstatus response\n");
1089 *pstatus
= vc
->vidstatus
;
1090 dprintk(dev
, 4, "%s, vid status %d\n", __func__
, *pstatus
);
1091 mutex_unlock(&dev
->cmdlock
);
1095 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
1097 struct s2255_vc
*vc
= vb2_get_drv_priv(vq
);
1100 vc
->last_frame
= -1;
1101 vc
->bad_payload
= 0;
1103 vc
->frame_count
= 0;
1104 for (j
= 0; j
< SYS_FRAMES
; j
++) {
1105 vc
->buffer
.frame
[j
].ulState
= S2255_READ_IDLE
;
1106 vc
->buffer
.frame
[j
].cur_size
= 0;
1108 return s2255_start_acquire(vc
);
1111 /* abort streaming and wait for last buffer */
1112 static void stop_streaming(struct vb2_queue
*vq
)
1114 struct s2255_vc
*vc
= vb2_get_drv_priv(vq
);
1115 struct s2255_buffer
*buf
, *node
;
1116 unsigned long flags
;
1117 (void) s2255_stop_acquire(vc
);
1118 spin_lock_irqsave(&vc
->qlock
, flags
);
1119 list_for_each_entry_safe(buf
, node
, &vc
->buf_list
, list
) {
1120 list_del(&buf
->list
);
1121 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
1122 dprintk(vc
->dev
, 2, "[%p/%d] done\n",
1123 buf
, buf
->vb
.v4l2_buf
.index
);
1125 spin_unlock_irqrestore(&vc
->qlock
, flags
);
1128 static int vidioc_s_std(struct file
*file
, void *priv
, v4l2_std_id i
)
1130 struct s2255_vc
*vc
= video_drvdata(file
);
1131 struct s2255_mode mode
;
1132 struct vb2_queue
*q
= &vc
->vb_vidq
;
1135 * Changing the standard implies a format change, which is not allowed
1136 * while buffers for use with streaming have already been allocated.
1142 if (i
& V4L2_STD_525_60
) {
1143 dprintk(vc
->dev
, 4, "%s 60 Hz\n", __func__
);
1144 /* if changing format, reset frame decimation/intervals */
1145 if (mode
.format
!= FORMAT_NTSC
) {
1147 mode
.format
= FORMAT_NTSC
;
1149 vc
->width
= LINE_SZ_4CIFS_NTSC
;
1150 vc
->height
= NUM_LINES_4CIFS_NTSC
* 2;
1152 } else if (i
& V4L2_STD_625_50
) {
1153 dprintk(vc
->dev
, 4, "%s 50 Hz\n", __func__
);
1154 if (mode
.format
!= FORMAT_PAL
) {
1156 mode
.format
= FORMAT_PAL
;
1158 vc
->width
= LINE_SZ_4CIFS_PAL
;
1159 vc
->height
= NUM_LINES_4CIFS_PAL
* 2;
1165 s2255_set_mode(vc
, &mode
);
1169 static int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*i
)
1171 struct s2255_vc
*vc
= video_drvdata(file
);
1177 /* Sensoray 2255 is a multiple channel capture device.
1178 It does not have a "crossbar" of inputs.
1179 We use one V4L device per channel. The user must
1180 be aware that certain combinations are not allowed.
1181 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1182 at once in color(you can do full fps on 4 channels with greyscale.
1184 static int vidioc_enum_input(struct file
*file
, void *priv
,
1185 struct v4l2_input
*inp
)
1187 struct s2255_vc
*vc
= video_drvdata(file
);
1188 struct s2255_dev
*dev
= vc
->dev
;
1191 if (inp
->index
!= 0)
1193 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
1194 inp
->std
= S2255_NORMS
;
1196 if (dev
->dsp_fw_ver
>= S2255_MIN_DSP_STATUS
) {
1198 rc
= s2255_cmd_status(vc
, &status
);
1199 dprintk(dev
, 4, "s2255_cmd_status rc: %d status %x\n",
1202 inp
->status
= (status
& 0x01) ? 0
1203 : V4L2_IN_ST_NO_SIGNAL
;
1208 strlcpy(inp
->name
, "Composite", sizeof(inp
->name
));
1211 strlcpy(inp
->name
, (vc
->idx
< 2) ? "Composite" : "S-Video",
1218 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1223 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
1230 static int s2255_s_ctrl(struct v4l2_ctrl
*ctrl
)
1232 struct s2255_vc
*vc
=
1233 container_of(ctrl
->handler
, struct s2255_vc
, hdl
);
1234 struct s2255_mode mode
;
1236 /* update the mode to the corresponding value */
1238 case V4L2_CID_BRIGHTNESS
:
1239 mode
.bright
= ctrl
->val
;
1241 case V4L2_CID_CONTRAST
:
1242 mode
.contrast
= ctrl
->val
;
1245 mode
.hue
= ctrl
->val
;
1247 case V4L2_CID_SATURATION
:
1248 mode
.saturation
= ctrl
->val
;
1250 case V4L2_CID_S2255_COLORFILTER
:
1251 mode
.color
&= ~MASK_INPUT_TYPE
;
1252 mode
.color
|= !ctrl
->val
<< 16;
1254 case V4L2_CID_JPEG_COMPRESSION_QUALITY
:
1255 vc
->jpegqual
= ctrl
->val
;
1261 /* set mode here. Note: stream does not need restarted.
1262 some V4L programs restart stream unnecessarily
1265 s2255_set_mode(vc
, &mode
);
1269 static int vidioc_g_jpegcomp(struct file
*file
, void *priv
,
1270 struct v4l2_jpegcompression
*jc
)
1272 struct s2255_vc
*vc
= video_drvdata(file
);
1274 memset(jc
, 0, sizeof(*jc
));
1275 jc
->quality
= vc
->jpegqual
;
1276 dprintk(vc
->dev
, 2, "%s: quality %d\n", __func__
, jc
->quality
);
1280 static int vidioc_s_jpegcomp(struct file
*file
, void *priv
,
1281 const struct v4l2_jpegcompression
*jc
)
1283 struct s2255_vc
*vc
= video_drvdata(file
);
1285 if (jc
->quality
< 0 || jc
->quality
> 100)
1287 v4l2_ctrl_s_ctrl(vc
->jpegqual_ctrl
, jc
->quality
);
1288 dprintk(vc
->dev
, 2, "%s: quality %d\n", __func__
, jc
->quality
);
1292 static int vidioc_g_parm(struct file
*file
, void *priv
,
1293 struct v4l2_streamparm
*sp
)
1295 __u32 def_num
, def_dem
;
1296 struct s2255_vc
*vc
= video_drvdata(file
);
1298 if (sp
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1300 sp
->parm
.capture
.capability
= V4L2_CAP_TIMEPERFRAME
;
1301 sp
->parm
.capture
.capturemode
= vc
->cap_parm
.capturemode
;
1302 sp
->parm
.capture
.readbuffers
= S2255_MIN_BUFS
;
1303 def_num
= (vc
->mode
.format
== FORMAT_NTSC
) ? 1001 : 1000;
1304 def_dem
= (vc
->mode
.format
== FORMAT_NTSC
) ? 30000 : 25000;
1305 sp
->parm
.capture
.timeperframe
.denominator
= def_dem
;
1306 switch (vc
->mode
.fdec
) {
1309 sp
->parm
.capture
.timeperframe
.numerator
= def_num
;
1312 sp
->parm
.capture
.timeperframe
.numerator
= def_num
* 2;
1315 sp
->parm
.capture
.timeperframe
.numerator
= def_num
* 3;
1318 sp
->parm
.capture
.timeperframe
.numerator
= def_num
* 5;
1321 dprintk(vc
->dev
, 4, "%s capture mode, %d timeperframe %d/%d\n",
1323 sp
->parm
.capture
.capturemode
,
1324 sp
->parm
.capture
.timeperframe
.numerator
,
1325 sp
->parm
.capture
.timeperframe
.denominator
);
1329 static int vidioc_s_parm(struct file
*file
, void *priv
,
1330 struct v4l2_streamparm
*sp
)
1332 struct s2255_vc
*vc
= video_drvdata(file
);
1333 struct s2255_mode mode
;
1335 __u32 def_num
, def_dem
;
1336 if (sp
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1339 /* high quality capture mode requires a stream restart */
1340 if ((vc
->cap_parm
.capturemode
!= sp
->parm
.capture
.capturemode
)
1341 && vb2_is_streaming(&vc
->vb_vidq
))
1343 def_num
= (mode
.format
== FORMAT_NTSC
) ? 1001 : 1000;
1344 def_dem
= (mode
.format
== FORMAT_NTSC
) ? 30000 : 25000;
1345 if (def_dem
!= sp
->parm
.capture
.timeperframe
.denominator
)
1346 sp
->parm
.capture
.timeperframe
.numerator
= def_num
;
1347 else if (sp
->parm
.capture
.timeperframe
.numerator
<= def_num
)
1348 sp
->parm
.capture
.timeperframe
.numerator
= def_num
;
1349 else if (sp
->parm
.capture
.timeperframe
.numerator
<= (def_num
* 2)) {
1350 sp
->parm
.capture
.timeperframe
.numerator
= def_num
* 2;
1352 } else if (sp
->parm
.capture
.timeperframe
.numerator
<= (def_num
* 3)) {
1353 sp
->parm
.capture
.timeperframe
.numerator
= def_num
* 3;
1356 sp
->parm
.capture
.timeperframe
.numerator
= def_num
* 5;
1360 sp
->parm
.capture
.timeperframe
.denominator
= def_dem
;
1361 sp
->parm
.capture
.readbuffers
= S2255_MIN_BUFS
;
1362 s2255_set_mode(vc
, &mode
);
1363 dprintk(vc
->dev
, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1365 sp
->parm
.capture
.capturemode
,
1366 sp
->parm
.capture
.timeperframe
.numerator
,
1367 sp
->parm
.capture
.timeperframe
.denominator
, fdec
);
1371 #define NUM_SIZE_ENUMS 3
1372 static const struct v4l2_frmsize_discrete ntsc_sizes
[] = {
1377 static const struct v4l2_frmsize_discrete pal_sizes
[] = {
1383 static int vidioc_enum_framesizes(struct file
*file
, void *priv
,
1384 struct v4l2_frmsizeenum
*fe
)
1386 struct s2255_vc
*vc
= video_drvdata(file
);
1387 int is_ntsc
= vc
->std
& V4L2_STD_525_60
;
1388 const struct s2255_fmt
*fmt
;
1390 if (fe
->index
>= NUM_SIZE_ENUMS
)
1393 fmt
= format_by_fourcc(fe
->pixel_format
);
1396 fe
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1397 fe
->discrete
= is_ntsc
? ntsc_sizes
[fe
->index
] : pal_sizes
[fe
->index
];
1401 static int vidioc_enum_frameintervals(struct file
*file
, void *priv
,
1402 struct v4l2_frmivalenum
*fe
)
1404 struct s2255_vc
*vc
= video_drvdata(file
);
1405 const struct s2255_fmt
*fmt
;
1406 const struct v4l2_frmsize_discrete
*sizes
;
1407 int is_ntsc
= vc
->std
& V4L2_STD_525_60
;
1408 #define NUM_FRAME_ENUMS 4
1409 int frm_dec
[NUM_FRAME_ENUMS
] = {1, 2, 3, 5};
1412 if (fe
->index
>= NUM_FRAME_ENUMS
)
1415 fmt
= format_by_fourcc(fe
->pixel_format
);
1419 sizes
= is_ntsc
? ntsc_sizes
: pal_sizes
;
1420 for (i
= 0; i
< NUM_SIZE_ENUMS
; i
++, sizes
++)
1421 if (fe
->width
== sizes
->width
&&
1422 fe
->height
== sizes
->height
)
1424 if (i
== NUM_SIZE_ENUMS
)
1427 fe
->type
= V4L2_FRMIVAL_TYPE_DISCRETE
;
1428 fe
->discrete
.denominator
= is_ntsc
? 30000 : 25000;
1429 fe
->discrete
.numerator
= (is_ntsc
? 1001 : 1000) * frm_dec
[fe
->index
];
1430 dprintk(vc
->dev
, 4, "%s discrete %d/%d\n", __func__
,
1431 fe
->discrete
.numerator
,
1432 fe
->discrete
.denominator
);
1436 static int s2255_open(struct file
*file
)
1438 struct s2255_vc
*vc
= video_drvdata(file
);
1439 struct s2255_dev
*dev
= vc
->dev
;
1443 rc
= v4l2_fh_open(file
);
1447 dprintk(dev
, 1, "s2255: %s\n", __func__
);
1448 state
= atomic_read(&dev
->fw_data
->fw_state
);
1450 case S2255_FW_DISCONNECTING
:
1452 case S2255_FW_FAILED
:
1453 s2255_dev_err(&dev
->udev
->dev
,
1454 "firmware load failed. retrying.\n");
1455 s2255_fwload_start(dev
, 1);
1456 wait_event_timeout(dev
->fw_data
->wait_fw
,
1457 ((atomic_read(&dev
->fw_data
->fw_state
)
1458 == S2255_FW_SUCCESS
) ||
1459 (atomic_read(&dev
->fw_data
->fw_state
)
1460 == S2255_FW_DISCONNECTING
)),
1461 msecs_to_jiffies(S2255_LOAD_TIMEOUT
));
1462 /* state may have changed, re-read */
1463 state
= atomic_read(&dev
->fw_data
->fw_state
);
1465 case S2255_FW_NOTLOADED
:
1466 case S2255_FW_LOADED_DSPWAIT
:
1467 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1468 driver loaded and then device immediately opened */
1469 pr_info("%s waiting for firmware load\n", __func__
);
1470 wait_event_timeout(dev
->fw_data
->wait_fw
,
1471 ((atomic_read(&dev
->fw_data
->fw_state
)
1472 == S2255_FW_SUCCESS
) ||
1473 (atomic_read(&dev
->fw_data
->fw_state
)
1474 == S2255_FW_DISCONNECTING
)),
1475 msecs_to_jiffies(S2255_LOAD_TIMEOUT
));
1476 /* state may have changed, re-read */
1477 state
= atomic_read(&dev
->fw_data
->fw_state
);
1479 case S2255_FW_SUCCESS
:
1483 /* state may have changed in above switch statement */
1485 case S2255_FW_SUCCESS
:
1487 case S2255_FW_FAILED
:
1488 pr_info("2255 firmware load failed.\n");
1490 case S2255_FW_DISCONNECTING
:
1491 pr_info("%s: disconnecting\n", __func__
);
1493 case S2255_FW_LOADED_DSPWAIT
:
1494 case S2255_FW_NOTLOADED
:
1495 pr_info("%s: firmware not loaded, please retry\n",
1498 * Timeout on firmware load means device unusable.
1499 * Set firmware failure state.
1500 * On next s2255_open the firmware will be reloaded.
1502 atomic_set(&dev
->fw_data
->fw_state
,
1506 pr_info("%s: unknown state\n", __func__
);
1509 if (!vc
->configured
) {
1510 /* configure channel to default state */
1511 vc
->fmt
= &formats
[0];
1512 s2255_set_mode(vc
, &vc
->mode
);
1518 static void s2255_destroy(struct s2255_dev
*dev
)
1520 dprintk(dev
, 1, "%s", __func__
);
1521 /* board shutdown stops the read pipe if it is running */
1522 s2255_board_shutdown(dev
);
1523 /* make sure firmware still not trying to load */
1524 del_timer(&dev
->timer
); /* only started in .probe and .open */
1525 if (dev
->fw_data
->fw_urb
) {
1526 usb_kill_urb(dev
->fw_data
->fw_urb
);
1527 usb_free_urb(dev
->fw_data
->fw_urb
);
1528 dev
->fw_data
->fw_urb
= NULL
;
1530 release_firmware(dev
->fw_data
->fw
);
1531 kfree(dev
->fw_data
->pfw_data
);
1532 kfree(dev
->fw_data
);
1533 /* reset the DSP so firmware can be reloaded next time */
1534 s2255_reset_dsppower(dev
);
1535 mutex_destroy(&dev
->lock
);
1536 usb_put_dev(dev
->udev
);
1537 v4l2_device_unregister(&dev
->v4l2_dev
);
1542 static const struct v4l2_file_operations s2255_fops_v4l
= {
1543 .owner
= THIS_MODULE
,
1545 .release
= vb2_fop_release
,
1546 .poll
= vb2_fop_poll
,
1547 .unlocked_ioctl
= video_ioctl2
, /* V4L2 ioctl handler */
1548 .mmap
= vb2_fop_mmap
,
1549 .read
= vb2_fop_read
,
1552 static const struct v4l2_ioctl_ops s2255_ioctl_ops
= {
1553 .vidioc_querycap
= vidioc_querycap
,
1554 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1555 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1556 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1557 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1558 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1559 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1560 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1561 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1562 .vidioc_s_std
= vidioc_s_std
,
1563 .vidioc_g_std
= vidioc_g_std
,
1564 .vidioc_enum_input
= vidioc_enum_input
,
1565 .vidioc_g_input
= vidioc_g_input
,
1566 .vidioc_s_input
= vidioc_s_input
,
1567 .vidioc_streamon
= vb2_ioctl_streamon
,
1568 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1569 .vidioc_s_jpegcomp
= vidioc_s_jpegcomp
,
1570 .vidioc_g_jpegcomp
= vidioc_g_jpegcomp
,
1571 .vidioc_s_parm
= vidioc_s_parm
,
1572 .vidioc_g_parm
= vidioc_g_parm
,
1573 .vidioc_enum_framesizes
= vidioc_enum_framesizes
,
1574 .vidioc_enum_frameintervals
= vidioc_enum_frameintervals
,
1575 .vidioc_log_status
= v4l2_ctrl_log_status
,
1576 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1577 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1580 static void s2255_video_device_release(struct video_device
*vdev
)
1582 struct s2255_dev
*dev
= to_s2255_dev(vdev
->v4l2_dev
);
1583 struct s2255_vc
*vc
=
1584 container_of(vdev
, struct s2255_vc
, vdev
);
1586 dprintk(dev
, 4, "%s, chnls: %d\n", __func__
,
1587 atomic_read(&dev
->num_channels
));
1589 v4l2_ctrl_handler_free(&vc
->hdl
);
1591 if (atomic_dec_and_test(&dev
->num_channels
))
1596 static struct video_device
template = {
1598 .fops
= &s2255_fops_v4l
,
1599 .ioctl_ops
= &s2255_ioctl_ops
,
1600 .release
= s2255_video_device_release
,
1601 .tvnorms
= S2255_NORMS
,
1604 static const struct v4l2_ctrl_ops s2255_ctrl_ops
= {
1605 .s_ctrl
= s2255_s_ctrl
,
1608 static const struct v4l2_ctrl_config color_filter_ctrl
= {
1609 .ops
= &s2255_ctrl_ops
,
1610 .name
= "Color Filter",
1611 .id
= V4L2_CID_S2255_COLORFILTER
,
1612 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1618 static int s2255_probe_v4l(struct s2255_dev
*dev
)
1622 int cur_nr
= video_nr
;
1623 struct s2255_vc
*vc
;
1624 struct vb2_queue
*q
;
1626 ret
= v4l2_device_register(&dev
->interface
->dev
, &dev
->v4l2_dev
);
1629 /* initialize all video 4 linux */
1630 /* register 4 video devices */
1631 for (i
= 0; i
< MAX_CHANNELS
; i
++) {
1633 INIT_LIST_HEAD(&vc
->buf_list
);
1635 v4l2_ctrl_handler_init(&vc
->hdl
, 6);
1636 v4l2_ctrl_new_std(&vc
->hdl
, &s2255_ctrl_ops
,
1637 V4L2_CID_BRIGHTNESS
, -127, 127, 1, DEF_BRIGHT
);
1638 v4l2_ctrl_new_std(&vc
->hdl
, &s2255_ctrl_ops
,
1639 V4L2_CID_CONTRAST
, 0, 255, 1, DEF_CONTRAST
);
1640 v4l2_ctrl_new_std(&vc
->hdl
, &s2255_ctrl_ops
,
1641 V4L2_CID_SATURATION
, 0, 255, 1, DEF_SATURATION
);
1642 v4l2_ctrl_new_std(&vc
->hdl
, &s2255_ctrl_ops
,
1643 V4L2_CID_HUE
, 0, 255, 1, DEF_HUE
);
1644 vc
->jpegqual_ctrl
= v4l2_ctrl_new_std(&vc
->hdl
,
1646 V4L2_CID_JPEG_COMPRESSION_QUALITY
,
1647 0, 100, 1, S2255_DEF_JPEG_QUAL
);
1648 if (dev
->dsp_fw_ver
>= S2255_MIN_DSP_COLORFILTER
&&
1649 (dev
->pid
!= 0x2257 || vc
->idx
<= 1))
1650 v4l2_ctrl_new_custom(&vc
->hdl
, &color_filter_ctrl
,
1652 if (vc
->hdl
.error
) {
1653 ret
= vc
->hdl
.error
;
1654 v4l2_ctrl_handler_free(&vc
->hdl
);
1655 dev_err(&dev
->udev
->dev
, "couldn't register control\n");
1659 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1660 q
->io_modes
= VB2_MMAP
| VB2_READ
| VB2_USERPTR
;
1662 q
->lock
= &vc
->vb_lock
;
1663 q
->buf_struct_size
= sizeof(struct s2255_buffer
);
1664 q
->mem_ops
= &vb2_vmalloc_memops
;
1665 q
->ops
= &s2255_video_qops
;
1666 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1667 ret
= vb2_queue_init(q
);
1669 dev_err(&dev
->udev
->dev
,
1670 "%s vb2_queue_init 0x%x\n", __func__
, ret
);
1673 /* register video devices */
1674 vc
->vdev
= template;
1676 vc
->vdev
.ctrl_handler
= &vc
->hdl
;
1677 vc
->vdev
.lock
= &dev
->lock
;
1678 vc
->vdev
.v4l2_dev
= &dev
->v4l2_dev
;
1679 set_bit(V4L2_FL_USE_FH_PRIO
, &vc
->vdev
.flags
);
1680 video_set_drvdata(&vc
->vdev
, vc
);
1682 ret
= video_register_device(&vc
->vdev
,
1686 ret
= video_register_device(&vc
->vdev
,
1691 dev_err(&dev
->udev
->dev
,
1692 "failed to register video device!\n");
1695 atomic_inc(&dev
->num_channels
);
1696 v4l2_info(&dev
->v4l2_dev
, "V4L2 device registered as %s\n",
1697 video_device_node_name(&vc
->vdev
));
1700 pr_info("Sensoray 2255 V4L driver Revision: %s\n",
1702 /* if no channels registered, return error and probe will fail*/
1703 if (atomic_read(&dev
->num_channels
) == 0) {
1704 v4l2_device_unregister(&dev
->v4l2_dev
);
1707 if (atomic_read(&dev
->num_channels
) != MAX_CHANNELS
)
1708 pr_warn("s2255: Not all channels available.\n");
1712 /* this function moves the usb stream read pipe data
1713 * into the system buffers.
1714 * returns 0 on success, EAGAIN if more data to process( call this
1717 * Received frame structure:
1718 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1719 * bytes 4-7: channel: 0-3
1720 * bytes 8-11: payload size: size of the frame
1721 * bytes 12-payloadsize+12: frame data
1723 static int save_frame(struct s2255_dev
*dev
, struct s2255_pipeinfo
*pipe_info
)
1729 unsigned long copy_size
;
1732 struct s2255_framei
*frm
;
1733 unsigned char *pdata
;
1734 struct s2255_vc
*vc
;
1735 dprintk(dev
, 100, "buffer to user\n");
1736 vc
= &dev
->vc
[dev
->cc
];
1737 idx
= vc
->cur_frame
;
1738 frm
= &vc
->buffer
.frame
[idx
];
1739 if (frm
->ulState
== S2255_READ_IDLE
) {
1742 __le32
*pdword
; /*data from dsp is little endian */
1744 /* search for marker codes */
1745 pdata
= (unsigned char *)pipe_info
->transfer_buffer
;
1746 pdword
= (__le32
*)pdata
;
1747 for (jj
= 0; jj
< (pipe_info
->cur_transfer_size
- 12); jj
++) {
1749 case S2255_MARKER_FRAME
:
1750 dprintk(dev
, 4, "marker @ offset: %d [%x %x]\n",
1751 jj
, pdata
[0], pdata
[1]);
1752 offset
= jj
+ PREFIX_SIZE
;
1754 cc
= le32_to_cpu(pdword
[1]);
1755 if (cc
>= MAX_CHANNELS
) {
1761 dev
->cc
= G_chnmap
[cc
];
1762 vc
= &dev
->vc
[dev
->cc
];
1763 payload
= le32_to_cpu(pdword
[3]);
1764 if (payload
> vc
->req_image_size
) {
1766 /* discard the bad frame */
1769 vc
->pkt_size
= payload
;
1770 vc
->jpg_size
= le32_to_cpu(pdword
[4]);
1772 case S2255_MARKER_RESPONSE
:
1774 pdata
+= DEF_USB_BLOCK
;
1775 jj
+= DEF_USB_BLOCK
;
1776 if (le32_to_cpu(pdword
[1]) >= MAX_CHANNELS
)
1778 cc
= G_chnmap
[le32_to_cpu(pdword
[1])];
1779 if (cc
>= MAX_CHANNELS
)
1782 switch (pdword
[2]) {
1783 case S2255_RESPONSE_SETMODE
:
1784 /* check if channel valid */
1785 /* set mode ready */
1786 vc
->setmode_ready
= 1;
1787 wake_up(&vc
->wait_setmode
);
1788 dprintk(dev
, 5, "setmode rdy %d\n", cc
);
1790 case S2255_RESPONSE_FW
:
1791 dev
->chn_ready
|= (1 << cc
);
1792 if ((dev
->chn_ready
& 0x0f) != 0x0f)
1794 /* all channels ready */
1795 pr_info("s2255: fw loaded\n");
1796 atomic_set(&dev
->fw_data
->fw_state
,
1798 wake_up(&dev
->fw_data
->wait_fw
);
1800 case S2255_RESPONSE_STATUS
:
1801 vc
->vidstatus
= le32_to_cpu(pdword
[3]);
1802 vc
->vidstatus_ready
= 1;
1803 wake_up(&vc
->wait_vidstatus
);
1804 dprintk(dev
, 5, "vstat %x chan %d\n",
1805 le32_to_cpu(pdword
[3]), cc
);
1808 pr_info("s2255 unknown resp\n");
1820 vc
= &dev
->vc
[dev
->cc
];
1821 idx
= vc
->cur_frame
;
1822 frm
= &vc
->buffer
.frame
[idx
];
1823 /* search done. now find out if should be acquiring on this channel */
1824 if (!vb2_is_streaming(&vc
->vb_vidq
)) {
1825 /* we found a frame, but this channel is turned off */
1826 frm
->ulState
= S2255_READ_IDLE
;
1830 if (frm
->ulState
== S2255_READ_IDLE
) {
1831 frm
->ulState
= S2255_READ_FRAME
;
1835 /* skip the marker 512 bytes (and offset if out of sync) */
1836 psrc
= (u8
*)pipe_info
->transfer_buffer
+ offset
;
1839 if (frm
->lpvbits
== NULL
) {
1840 dprintk(dev
, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1841 frm
, dev
, dev
->cc
, idx
);
1845 pdest
= frm
->lpvbits
+ frm
->cur_size
;
1847 copy_size
= (pipe_info
->cur_transfer_size
- offset
);
1849 size
= vc
->pkt_size
- PREFIX_SIZE
;
1851 /* sanity check on pdest */
1852 if ((copy_size
+ frm
->cur_size
) < vc
->req_image_size
)
1853 memcpy(pdest
, psrc
, copy_size
);
1855 frm
->cur_size
+= copy_size
;
1856 dprintk(dev
, 4, "cur_size: %lu, size: %lu\n", frm
->cur_size
, size
);
1858 if (frm
->cur_size
>= size
) {
1859 dprintk(dev
, 2, "******[%d]Buffer[%d]full*******\n",
1861 vc
->last_frame
= vc
->cur_frame
;
1863 /* end of system frame ring buffer, start at zero */
1864 if ((vc
->cur_frame
== SYS_FRAMES
) ||
1865 (vc
->cur_frame
== vc
->buffer
.dwFrames
))
1868 if (vb2_is_streaming(&vc
->vb_vidq
))
1869 s2255_got_frame(vc
, vc
->jpg_size
);
1871 frm
->ulState
= S2255_READ_IDLE
;
1875 /* done successfully */
1879 static void s2255_read_video_callback(struct s2255_dev
*dev
,
1880 struct s2255_pipeinfo
*pipe_info
)
1883 dprintk(dev
, 50, "callback read video\n");
1885 if (dev
->cc
>= MAX_CHANNELS
) {
1887 dev_err(&dev
->udev
->dev
, "invalid channel\n");
1890 /* otherwise copy to the system buffers */
1891 res
= save_frame(dev
, pipe_info
);
1893 dprintk(dev
, 4, "s2255: read callback failed\n");
1895 dprintk(dev
, 50, "callback read video done\n");
1899 static long s2255_vendor_req(struct s2255_dev
*dev
, unsigned char Request
,
1900 u16 Index
, u16 Value
, void *TransferBuffer
,
1901 s32 TransferBufferLength
, int bOut
)
1905 r
= usb_control_msg(dev
->udev
, usb_rcvctrlpipe(dev
->udev
, 0),
1907 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
|
1909 Value
, Index
, TransferBuffer
,
1910 TransferBufferLength
, HZ
* 5);
1912 r
= usb_control_msg(dev
->udev
, usb_sndctrlpipe(dev
->udev
, 0),
1913 Request
, USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
1914 Value
, Index
, TransferBuffer
,
1915 TransferBufferLength
, HZ
* 5);
1921 * retrieve FX2 firmware version. future use.
1922 * @param dev pointer to device extension
1923 * @return -1 for fail, else returns firmware version as an int(16 bits)
1925 static int s2255_get_fx2fw(struct s2255_dev
*dev
)
1929 unsigned char transBuffer
[64];
1930 ret
= s2255_vendor_req(dev
, S2255_VR_FW
, 0, 0, transBuffer
, 2,
1933 dprintk(dev
, 2, "get fw error: %x\n", ret
);
1934 fw
= transBuffer
[0] + (transBuffer
[1] << 8);
1935 dprintk(dev
, 2, "Get FW %x %x\n", transBuffer
[0], transBuffer
[1]);
1940 * Create the system ring buffer to copy frames into from the
1943 static int s2255_create_sys_buffers(struct s2255_vc
*vc
)
1946 unsigned long reqsize
;
1947 vc
->buffer
.dwFrames
= SYS_FRAMES
;
1948 /* always allocate maximum size(PAL) for system buffers */
1949 reqsize
= SYS_FRAMES_MAXSIZE
;
1951 if (reqsize
> SYS_FRAMES_MAXSIZE
)
1952 reqsize
= SYS_FRAMES_MAXSIZE
;
1954 for (i
= 0; i
< SYS_FRAMES
; i
++) {
1955 /* allocate the frames */
1956 vc
->buffer
.frame
[i
].lpvbits
= vmalloc(reqsize
);
1957 vc
->buffer
.frame
[i
].size
= reqsize
;
1958 if (vc
->buffer
.frame
[i
].lpvbits
== NULL
) {
1959 pr_info("out of memory. using less frames\n");
1960 vc
->buffer
.dwFrames
= i
;
1965 /* make sure internal states are set */
1966 for (i
= 0; i
< SYS_FRAMES
; i
++) {
1967 vc
->buffer
.frame
[i
].ulState
= 0;
1968 vc
->buffer
.frame
[i
].cur_size
= 0;
1972 vc
->last_frame
= -1;
1976 static int s2255_release_sys_buffers(struct s2255_vc
*vc
)
1979 for (i
= 0; i
< SYS_FRAMES
; i
++) {
1980 if (vc
->buffer
.frame
[i
].lpvbits
)
1981 vfree(vc
->buffer
.frame
[i
].lpvbits
);
1982 vc
->buffer
.frame
[i
].lpvbits
= NULL
;
1987 static int s2255_board_init(struct s2255_dev
*dev
)
1989 struct s2255_mode mode_def
= DEF_MODEI_NTSC_CONT
;
1992 struct s2255_pipeinfo
*pipe
= &dev
->pipe
;
1993 dprintk(dev
, 4, "board init: %p", dev
);
1994 memset(pipe
, 0, sizeof(*pipe
));
1996 pipe
->cur_transfer_size
= S2255_USB_XFER_SIZE
;
1997 pipe
->max_transfer_size
= S2255_USB_XFER_SIZE
;
1999 pipe
->transfer_buffer
= kzalloc(pipe
->max_transfer_size
,
2001 if (pipe
->transfer_buffer
== NULL
) {
2002 dprintk(dev
, 1, "out of memory!\n");
2005 /* query the firmware */
2006 fw_ver
= s2255_get_fx2fw(dev
);
2008 pr_info("s2255: usb firmware version %d.%d\n",
2009 (fw_ver
>> 8) & 0xff,
2012 if (fw_ver
< S2255_CUR_USB_FWVER
)
2013 pr_info("s2255: newer USB firmware available\n");
2015 for (j
= 0; j
< MAX_CHANNELS
; j
++) {
2016 struct s2255_vc
*vc
= &dev
->vc
[j
];
2017 vc
->mode
= mode_def
;
2018 if (dev
->pid
== 0x2257 && j
> 1)
2019 vc
->mode
.color
|= (1 << 16);
2020 vc
->jpegqual
= S2255_DEF_JPEG_QUAL
;
2021 vc
->width
= LINE_SZ_4CIFS_NTSC
;
2022 vc
->height
= NUM_LINES_4CIFS_NTSC
* 2;
2023 vc
->std
= V4L2_STD_NTSC_M
;
2024 vc
->fmt
= &formats
[0];
2025 vc
->mode
.restart
= 1;
2026 vc
->req_image_size
= get_transfer_size(&mode_def
);
2027 vc
->frame_count
= 0;
2028 /* create the system buffers */
2029 s2255_create_sys_buffers(vc
);
2031 /* start read pipe */
2032 s2255_start_readpipe(dev
);
2033 dprintk(dev
, 1, "%s: success\n", __func__
);
2037 static int s2255_board_shutdown(struct s2255_dev
*dev
)
2040 dprintk(dev
, 1, "%s: dev: %p", __func__
, dev
);
2042 for (i
= 0; i
< MAX_CHANNELS
; i
++) {
2043 if (vb2_is_streaming(&dev
->vc
[i
].vb_vidq
))
2044 s2255_stop_acquire(&dev
->vc
[i
]);
2046 s2255_stop_readpipe(dev
);
2047 for (i
= 0; i
< MAX_CHANNELS
; i
++)
2048 s2255_release_sys_buffers(&dev
->vc
[i
]);
2049 /* release transfer buffer */
2050 kfree(dev
->pipe
.transfer_buffer
);
2054 static void read_pipe_completion(struct urb
*purb
)
2056 struct s2255_pipeinfo
*pipe_info
;
2057 struct s2255_dev
*dev
;
2060 pipe_info
= purb
->context
;
2061 if (pipe_info
== NULL
) {
2062 dev_err(&purb
->dev
->dev
, "no context!\n");
2065 dev
= pipe_info
->dev
;
2067 dev_err(&purb
->dev
->dev
, "no context!\n");
2070 status
= purb
->status
;
2071 /* if shutting down, do not resubmit, exit immediately */
2072 if (status
== -ESHUTDOWN
) {
2073 dprintk(dev
, 2, "%s: err shutdown\n", __func__
);
2074 pipe_info
->err_count
++;
2078 if (pipe_info
->state
== 0) {
2079 dprintk(dev
, 2, "%s: exiting USB pipe", __func__
);
2084 s2255_read_video_callback(dev
, pipe_info
);
2086 pipe_info
->err_count
++;
2087 dprintk(dev
, 1, "%s: failed URB %d\n", __func__
, status
);
2090 pipe
= usb_rcvbulkpipe(dev
->udev
, dev
->read_endpoint
);
2092 usb_fill_bulk_urb(pipe_info
->stream_urb
, dev
->udev
,
2094 pipe_info
->transfer_buffer
,
2095 pipe_info
->cur_transfer_size
,
2096 read_pipe_completion
, pipe_info
);
2098 if (pipe_info
->state
!= 0) {
2099 if (usb_submit_urb(pipe_info
->stream_urb
, GFP_ATOMIC
))
2100 dev_err(&dev
->udev
->dev
, "error submitting urb\n");
2102 dprintk(dev
, 2, "%s :complete state 0\n", __func__
);
2107 static int s2255_start_readpipe(struct s2255_dev
*dev
)
2111 struct s2255_pipeinfo
*pipe_info
= &dev
->pipe
;
2112 pipe
= usb_rcvbulkpipe(dev
->udev
, dev
->read_endpoint
);
2113 dprintk(dev
, 2, "%s: IN %d\n", __func__
, dev
->read_endpoint
);
2114 pipe_info
->state
= 1;
2115 pipe_info
->err_count
= 0;
2116 pipe_info
->stream_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2117 if (!pipe_info
->stream_urb
) {
2118 dev_err(&dev
->udev
->dev
,
2119 "ReadStream: Unable to alloc URB\n");
2122 /* transfer buffer allocated in board_init */
2123 usb_fill_bulk_urb(pipe_info
->stream_urb
, dev
->udev
,
2125 pipe_info
->transfer_buffer
,
2126 pipe_info
->cur_transfer_size
,
2127 read_pipe_completion
, pipe_info
);
2128 retval
= usb_submit_urb(pipe_info
->stream_urb
, GFP_KERNEL
);
2130 pr_err("s2255: start read pipe failed\n");
2136 /* starts acquisition process */
2137 static int s2255_start_acquire(struct s2255_vc
*vc
)
2140 unsigned long chn_rev
;
2142 struct s2255_dev
*dev
= to_s2255_dev(vc
->vdev
.v4l2_dev
);
2143 __le32
*buffer
= dev
->cmdbuf
;
2145 mutex_lock(&dev
->cmdlock
);
2146 chn_rev
= G_chnmap
[vc
->idx
];
2147 vc
->last_frame
= -1;
2148 vc
->bad_payload
= 0;
2150 for (j
= 0; j
< SYS_FRAMES
; j
++) {
2151 vc
->buffer
.frame
[j
].ulState
= 0;
2152 vc
->buffer
.frame
[j
].cur_size
= 0;
2155 /* send the start command */
2156 buffer
[0] = IN_DATA_TOKEN
;
2157 buffer
[1] = (__le32
) cpu_to_le32(chn_rev
);
2158 buffer
[2] = CMD_START
;
2159 res
= s2255_write_config(dev
->udev
, (unsigned char *)buffer
, 512);
2161 dev_err(&dev
->udev
->dev
, "CMD_START error\n");
2163 dprintk(dev
, 2, "start acquire exit[%d] %d\n", vc
->idx
, res
);
2164 mutex_unlock(&dev
->cmdlock
);
2168 static int s2255_stop_acquire(struct s2255_vc
*vc
)
2171 unsigned long chn_rev
;
2172 struct s2255_dev
*dev
= to_s2255_dev(vc
->vdev
.v4l2_dev
);
2173 __le32
*buffer
= dev
->cmdbuf
;
2175 mutex_lock(&dev
->cmdlock
);
2176 chn_rev
= G_chnmap
[vc
->idx
];
2177 /* send the stop command */
2178 buffer
[0] = IN_DATA_TOKEN
;
2179 buffer
[1] = (__le32
) cpu_to_le32(chn_rev
);
2180 buffer
[2] = CMD_STOP
;
2182 res
= s2255_write_config(dev
->udev
, (unsigned char *)buffer
, 512);
2184 dev_err(&dev
->udev
->dev
, "CMD_STOP error\n");
2186 dprintk(dev
, 4, "%s: chn %d, res %d\n", __func__
, vc
->idx
, res
);
2187 mutex_unlock(&dev
->cmdlock
);
2191 static void s2255_stop_readpipe(struct s2255_dev
*dev
)
2193 struct s2255_pipeinfo
*pipe
= &dev
->pipe
;
2196 if (pipe
->stream_urb
) {
2198 usb_kill_urb(pipe
->stream_urb
);
2199 usb_free_urb(pipe
->stream_urb
);
2200 pipe
->stream_urb
= NULL
;
2202 dprintk(dev
, 4, "%s", __func__
);
2206 static void s2255_fwload_start(struct s2255_dev
*dev
, int reset
)
2209 s2255_reset_dsppower(dev
);
2210 dev
->fw_data
->fw_size
= dev
->fw_data
->fw
->size
;
2211 atomic_set(&dev
->fw_data
->fw_state
, S2255_FW_NOTLOADED
);
2212 memcpy(dev
->fw_data
->pfw_data
,
2213 dev
->fw_data
->fw
->data
, CHUNK_SIZE
);
2214 dev
->fw_data
->fw_loaded
= CHUNK_SIZE
;
2215 usb_fill_bulk_urb(dev
->fw_data
->fw_urb
, dev
->udev
,
2216 usb_sndbulkpipe(dev
->udev
, 2),
2217 dev
->fw_data
->pfw_data
,
2218 CHUNK_SIZE
, s2255_fwchunk_complete
,
2220 mod_timer(&dev
->timer
, jiffies
+ HZ
);
2223 /* standard usb probe function */
2224 static int s2255_probe(struct usb_interface
*interface
,
2225 const struct usb_device_id
*id
)
2227 struct s2255_dev
*dev
= NULL
;
2228 struct usb_host_interface
*iface_desc
;
2229 struct usb_endpoint_descriptor
*endpoint
;
2231 int retval
= -ENOMEM
;
2235 /* allocate memory for our device state and initialize it to zero */
2236 dev
= kzalloc(sizeof(struct s2255_dev
), GFP_KERNEL
);
2238 s2255_dev_err(&interface
->dev
, "out of memory\n");
2242 dev
->cmdbuf
= kzalloc(S2255_CMDBUF_SIZE
, GFP_KERNEL
);
2243 if (dev
->cmdbuf
== NULL
) {
2244 s2255_dev_err(&interface
->dev
, "out of memory\n");
2248 atomic_set(&dev
->num_channels
, 0);
2249 dev
->pid
= le16_to_cpu(id
->idProduct
);
2250 dev
->fw_data
= kzalloc(sizeof(struct s2255_fw
), GFP_KERNEL
);
2253 mutex_init(&dev
->lock
);
2254 mutex_init(&dev
->cmdlock
);
2255 /* grab usb_device and save it */
2256 dev
->udev
= usb_get_dev(interface_to_usbdev(interface
));
2257 if (dev
->udev
== NULL
) {
2258 dev_err(&interface
->dev
, "null usb device\n");
2262 dev_dbg(&interface
->dev
, "dev: %p, udev %p interface %p\n",
2263 dev
, dev
->udev
, interface
);
2264 dev
->interface
= interface
;
2265 /* set up the endpoint information */
2266 iface_desc
= interface
->cur_altsetting
;
2267 dev_dbg(&interface
->dev
, "num EP: %d\n",
2268 iface_desc
->desc
.bNumEndpoints
);
2269 for (i
= 0; i
< iface_desc
->desc
.bNumEndpoints
; ++i
) {
2270 endpoint
= &iface_desc
->endpoint
[i
].desc
;
2271 if (!dev
->read_endpoint
&& usb_endpoint_is_bulk_in(endpoint
)) {
2272 /* we found the bulk in endpoint */
2273 dev
->read_endpoint
= endpoint
->bEndpointAddress
;
2277 if (!dev
->read_endpoint
) {
2278 dev_err(&interface
->dev
, "Could not find bulk-in endpoint\n");
2281 init_timer(&dev
->timer
);
2282 dev
->timer
.function
= s2255_timer
;
2283 dev
->timer
.data
= (unsigned long)dev
->fw_data
;
2284 init_waitqueue_head(&dev
->fw_data
->wait_fw
);
2285 for (i
= 0; i
< MAX_CHANNELS
; i
++) {
2286 struct s2255_vc
*vc
= &dev
->vc
[i
];
2289 init_waitqueue_head(&vc
->wait_setmode
);
2290 init_waitqueue_head(&vc
->wait_vidstatus
);
2291 spin_lock_init(&vc
->qlock
);
2292 mutex_init(&vc
->vb_lock
);
2295 dev
->fw_data
->fw_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2296 if (!dev
->fw_data
->fw_urb
) {
2297 dev_err(&interface
->dev
, "out of memory!\n");
2301 dev
->fw_data
->pfw_data
= kzalloc(CHUNK_SIZE
, GFP_KERNEL
);
2302 if (!dev
->fw_data
->pfw_data
) {
2303 dev_err(&interface
->dev
, "out of memory!\n");
2306 /* load the first chunk */
2307 if (request_firmware(&dev
->fw_data
->fw
,
2308 FIRMWARE_FILE_NAME
, &dev
->udev
->dev
)) {
2309 dev_err(&interface
->dev
, "sensoray 2255 failed to get firmware\n");
2312 /* check the firmware is valid */
2313 fw_size
= dev
->fw_data
->fw
->size
;
2314 pdata
= (__le32
*) &dev
->fw_data
->fw
->data
[fw_size
- 8];
2316 if (*pdata
!= S2255_FW_MARKER
) {
2317 dev_err(&interface
->dev
, "Firmware invalid.\n");
2321 /* make sure firmware is the latest */
2323 pRel
= (__le32
*) &dev
->fw_data
->fw
->data
[fw_size
- 4];
2324 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel
));
2325 dev
->dsp_fw_ver
= le32_to_cpu(*pRel
);
2326 if (dev
->dsp_fw_ver
< S2255_CUR_DSP_FWVER
)
2327 pr_info("s2255: f2255usb.bin out of date.\n");
2328 if (dev
->pid
== 0x2257 &&
2329 dev
->dsp_fw_ver
< S2255_MIN_DSP_COLORFILTER
)
2330 pr_warn("2257 needs firmware %d or above.\n",
2331 S2255_MIN_DSP_COLORFILTER
);
2333 usb_reset_device(dev
->udev
);
2334 /* load 2255 board specific */
2335 retval
= s2255_board_init(dev
);
2337 goto errorBOARDINIT
;
2338 s2255_fwload_start(dev
, 0);
2339 /* loads v4l specific */
2340 retval
= s2255_probe_v4l(dev
);
2342 goto errorBOARDINIT
;
2343 dev_info(&interface
->dev
, "Sensoray 2255 detected\n");
2346 s2255_board_shutdown(dev
);
2348 release_firmware(dev
->fw_data
->fw
);
2350 kfree(dev
->fw_data
->pfw_data
);
2352 usb_free_urb(dev
->fw_data
->fw_urb
);
2354 del_timer(&dev
->timer
);
2356 usb_put_dev(dev
->udev
);
2358 kfree(dev
->fw_data
);
2359 mutex_destroy(&dev
->lock
);
2363 pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval
);
2367 /* disconnect routine. when board is removed physically or with rmmod */
2368 static void s2255_disconnect(struct usb_interface
*interface
)
2370 struct s2255_dev
*dev
= to_s2255_dev(usb_get_intfdata(interface
));
2372 int channels
= atomic_read(&dev
->num_channels
);
2373 mutex_lock(&dev
->lock
);
2374 v4l2_device_disconnect(&dev
->v4l2_dev
);
2375 mutex_unlock(&dev
->lock
);
2376 /*see comments in the uvc_driver.c usb disconnect function */
2377 atomic_inc(&dev
->num_channels
);
2378 /* unregister each video device. */
2379 for (i
= 0; i
< channels
; i
++)
2380 video_unregister_device(&dev
->vc
[i
].vdev
);
2381 /* wake up any of our timers */
2382 atomic_set(&dev
->fw_data
->fw_state
, S2255_FW_DISCONNECTING
);
2383 wake_up(&dev
->fw_data
->wait_fw
);
2384 for (i
= 0; i
< MAX_CHANNELS
; i
++) {
2385 dev
->vc
[i
].setmode_ready
= 1;
2386 wake_up(&dev
->vc
[i
].wait_setmode
);
2387 dev
->vc
[i
].vidstatus_ready
= 1;
2388 wake_up(&dev
->vc
[i
].wait_vidstatus
);
2390 if (atomic_dec_and_test(&dev
->num_channels
))
2392 dev_info(&interface
->dev
, "%s\n", __func__
);
2395 static struct usb_driver s2255_driver
= {
2396 .name
= S2255_DRIVER_NAME
,
2397 .probe
= s2255_probe
,
2398 .disconnect
= s2255_disconnect
,
2399 .id_table
= s2255_table
,
2402 module_usb_driver(s2255_driver
);
2404 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2405 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2406 MODULE_LICENSE("GPL");
2407 MODULE_VERSION(S2255_VERSION
);
2408 MODULE_FIRMWARE(FIRMWARE_FILE_NAME
);