2
* s2255drv.c - a driver for the Sensoray 2255 USB video capture device
4
* Copyright (C) 2007-2010 by Sensoray Company Inc.
7
* Some video buffer code based on vivi driver:
9
* Sensoray 2255 device supports 4 simultaneous channels.
10
* The channels are not "crossbar" inputs, they are physically
11
* attached to separate video decoders.
13
* Because of USB2.0 bandwidth limitations. There is only a
14
* certain amount of data which may be transferred at one time.
16
* Example maximum bandwidth utilization:
18
* -full size, color mode YUYV or YUV422P: 2 channels at once
19
* -full or half size Grey scale: all 4 channels at once
20
* -half size, color mode YUYV or YUV422P: all 4 channels at once
21
* -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
24
* This program is free software; you can redistribute it and/or modify
25
* it under the terms of the GNU General Public License as published by
26
* the Free Software Foundation; either version 2 of the License, or
27
* (at your option) any later version.
29
* This program is distributed in the hope that it will be useful,
30
* but WITHOUT ANY WARRANTY; without even the implied warranty of
31
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32
* GNU General Public License for more details.
34
* You should have received a copy of the GNU General Public License
35
* along with this program; if not, write to the Free Software
36
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
39
#include <linux/module.h>
40
#include <linux/firmware.h>
41
#include <linux/kernel.h>
42
#include <linux/mutex.h>
43
#include <linux/slab.h>
44
#include <linux/videodev2.h>
46
#include <media/videobuf-vmalloc.h>
47
#include <media/v4l2-common.h>
48
#include <media/v4l2-device.h>
49
#include <media/v4l2-ioctl.h>
50
#include <linux/vmalloc.h>
51
#include <linux/usb.h>
53
#define S2255_VERSION "1.22.1"
54
#define FIRMWARE_FILE_NAME "f2255usb.bin"
56
/* default JPEG quality */
57
#define S2255_DEF_JPEG_QUAL 50
58
/* vendor request in */
60
/* vendor request out */
61
#define S2255_VR_OUT 1
63
#define S2255_VR_FW 0x30
64
/* USB endpoint number for configuring the device */
65
#define S2255_CONFIG_EP 2
66
/* maximum time for DSP to start responding after last FW word loaded(ms) */
67
#define S2255_DSP_BOOTTIME 800
68
/* maximum time to wait for firmware to load (ms) */
69
#define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
70
#define S2255_DEF_BUFS 16
71
#define S2255_SETMODE_TIMEOUT 500
72
#define S2255_VIDSTATUS_TIMEOUT 350
73
#define S2255_MARKER_FRAME cpu_to_le32(0x2255DA4AL)
74
#define S2255_MARKER_RESPONSE cpu_to_le32(0x2255ACACL)
75
#define S2255_RESPONSE_SETMODE cpu_to_le32(0x01)
76
#define S2255_RESPONSE_FW cpu_to_le32(0x10)
77
#define S2255_RESPONSE_STATUS cpu_to_le32(0x20)
78
#define S2255_USB_XFER_SIZE (16 * 1024)
79
#define MAX_CHANNELS 4
81
/* maximum size is PAL full size plus room for the marker header(s) */
82
#define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
83
#define DEF_USB_BLOCK S2255_USB_XFER_SIZE
84
#define LINE_SZ_4CIFS_NTSC 640
85
#define LINE_SZ_2CIFS_NTSC 640
86
#define LINE_SZ_1CIFS_NTSC 320
87
#define LINE_SZ_4CIFS_PAL 704
88
#define LINE_SZ_2CIFS_PAL 704
89
#define LINE_SZ_1CIFS_PAL 352
90
#define NUM_LINES_4CIFS_NTSC 240
91
#define NUM_LINES_2CIFS_NTSC 240
92
#define NUM_LINES_1CIFS_NTSC 240
93
#define NUM_LINES_4CIFS_PAL 288
94
#define NUM_LINES_2CIFS_PAL 288
95
#define NUM_LINES_1CIFS_PAL 288
96
#define LINE_SZ_DEF 640
97
#define NUM_LINES_DEF 240
100
/* predefined settings */
101
#define FORMAT_NTSC 1
104
#define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
105
#define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
106
#define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
107
/* SCALE_4CIFSI is the 2 fields interpolated into one */
108
#define SCALE_4CIFSI 4 /* 640x480(NTSC) or 704x576(PAL) high quality */
110
#define COLOR_YUVPL 1 /* YUV planar */
111
#define COLOR_YUVPK 2 /* YUV packed */
112
#define COLOR_Y8 4 /* monochrome */
113
#define COLOR_JPG 5 /* JPEG */
115
#define MASK_COLOR 0x000000ff
116
#define MASK_JPG_QUALITY 0x0000ff00
117
#define MASK_INPUT_TYPE 0x000f0000
118
/* frame decimation. */
119
#define FDEC_1 1 /* capture every frame. default */
120
#define FDEC_2 2 /* capture every 2nd frame */
121
#define FDEC_3 3 /* capture every 3rd frame */
122
#define FDEC_5 5 /* capture every 5th frame */
124
/*-------------------------------------------------------
125
* Default mode parameters.
126
*-------------------------------------------------------*/
127
#define DEF_SCALE SCALE_4CIFS
128
#define DEF_COLOR COLOR_YUVPL
129
#define DEF_FDEC FDEC_1
131
#define DEF_CONTRAST 0x5c
132
#define DEF_SATURATION 0x80
135
/* usb config commands */
136
#define IN_DATA_TOKEN cpu_to_le32(0x2255c0de)
137
#define CMD_2255 cpu_to_le32(0xc2255000)
138
#define CMD_SET_MODE cpu_to_le32((CMD_2255 | 0x10))
139
#define CMD_START cpu_to_le32((CMD_2255 | 0x20))
140
#define CMD_STOP cpu_to_le32((CMD_2255 | 0x30))
141
#define CMD_STATUS cpu_to_le32((CMD_2255 | 0x40))
144
u32 format; /* input video format (NTSC, PAL) */
145
u32 scale; /* output video scale */
146
u32 color; /* output video color format */
147
u32 fdec; /* frame decimation */
148
u32 bright; /* brightness */
149
u32 contrast; /* contrast */
150
u32 saturation; /* saturation */
151
u32 hue; /* hue (NTSC only)*/
152
u32 single; /* capture 1 frame at a time (!=0), continuously (==0)*/
153
u32 usb_block; /* block size. should be 4096 of DEF_USB_BLOCK */
154
u32 restart; /* if DSP requires restart */
158
#define S2255_READ_IDLE 0
159
#define S2255_READ_FRAME 1
161
/* frame structure */
162
struct s2255_framei {
164
unsigned long ulState; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
165
void *lpvbits; /* image data */
166
unsigned long cur_size; /* current data copied to it */
169
/* image buffer structure */
170
struct s2255_bufferi {
171
unsigned long dwFrames; /* number of frames in buffer */
172
struct s2255_framei frame[SYS_FRAMES]; /* array of FRAME structures */
175
#define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
176
DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
177
DEF_HUE, 0, DEF_USB_BLOCK, 0}
179
struct s2255_dmaqueue {
180
struct list_head active;
181
struct s2255_dev *dev;
184
/* for firmware loading, fw_state */
185
#define S2255_FW_NOTLOADED 0
186
#define S2255_FW_LOADED_DSPWAIT 1
187
#define S2255_FW_SUCCESS 2
188
#define S2255_FW_FAILED 3
189
#define S2255_FW_DISCONNECTING 4
190
#define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
191
/* 2255 read states */
192
#define S2255_READ_IDLE 0
193
#define S2255_READ_FRAME 1
200
wait_queue_head_t wait_fw;
201
const struct firmware *fw;
204
struct s2255_pipeinfo {
205
u32 max_transfer_size;
206
u32 cur_transfer_size;
210
void *dev; /* back pointer to s2255_dev struct*/
215
struct s2255_fmt; /*forward declaration */
218
struct s2255_channel {
219
struct video_device vdev;
221
struct s2255_dmaqueue vidq;
222
struct s2255_bufferi buffer;
223
struct s2255_mode mode;
224
/* jpeg compression */
225
struct v4l2_jpegcompression jc;
226
/* capture parameters (for high quality mode full size) */
227
struct v4l2_captureparm cap_parm;
232
/* allocated image size */
233
unsigned long req_image_size;
234
/* received packet size */
235
unsigned long pkt_size;
237
unsigned long frame_count;
240
/* if channel configured to default state */
242
wait_queue_head_t wait_setmode;
244
/* video status items */
246
wait_queue_head_t wait_vidstatus;
250
const struct s2255_fmt *fmt;
251
int idx; /* channel number on device, 0-3 */
256
struct s2255_channel channel[MAX_CHANNELS];
257
struct v4l2_device v4l2_dev;
258
atomic_t num_channels;
260
struct mutex lock; /* channels[].vdev.lock */
261
struct mutex open_lock;
262
struct usb_device *udev;
263
struct usb_interface *interface;
265
struct timer_list timer;
266
struct s2255_fw *fw_data;
267
struct s2255_pipeinfo pipe;
268
u32 cc; /* current channel */
272
/* dsp firmware version (f2255usb.bin) */
274
u16 pid; /* product id */
277
static inline struct s2255_dev *to_s2255_dev(struct v4l2_device *v4l2_dev)
279
return container_of(v4l2_dev, struct s2255_dev, v4l2_dev);
288
/* buffer for one video frame */
289
struct s2255_buffer {
290
/* common v4l buffer stuff -- must be first */
291
struct videobuf_buffer vb;
292
const struct s2255_fmt *fmt;
296
struct s2255_dev *dev;
297
struct videobuf_queue vb_vidq;
298
enum v4l2_buf_type type;
299
struct s2255_channel *channel;
303
/* current cypress EEPROM firmware version */
304
#define S2255_CUR_USB_FWVER ((3 << 8) | 12)
305
/* current DSP FW version */
306
#define S2255_CUR_DSP_FWVER 10104
307
/* Need DSP version 5+ for video status feature */
308
#define S2255_MIN_DSP_STATUS 5
309
#define S2255_MIN_DSP_COLORFILTER 8
310
#define S2255_NORMS (V4L2_STD_PAL | V4L2_STD_NTSC)
312
/* private V4L2 controls */
315
* The following chart displays how COLORFILTER should be set
316
* =========================================================
317
* = fourcc = COLORFILTER =
318
* = ===============================
320
* =========================================================
321
* = V4L2_PIX_FMT_GREY(Y8) = monochrome from = monochrome=
322
* = = s-video or = composite =
323
* = = B/W camera = input =
324
* =========================================================
325
* = other = color, svideo = color, =
327
* =========================================================
330
* channels 0-3 on 2255 are composite
331
* channels 0-1 on 2257 are composite, 2-3 are s-video
332
* If COLORFILTER is 0 with a composite color camera connected,
333
* the output will appear monochrome but hatching
335
* COLORFILTER is different from "color killer" and "color effects"
338
#define S2255_V4L2_YC_ON 1
339
#define S2255_V4L2_YC_OFF 0
340
#define V4L2_CID_PRIVATE_COLORFILTER (V4L2_CID_PRIVATE_BASE + 0)
342
/* frame prefix size (sent once every frame) */
343
#define PREFIX_SIZE 512
345
/* Channels on box are in reverse order */
346
static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
349
static int *s2255_debug = &debug;
351
static int s2255_start_readpipe(struct s2255_dev *dev);
352
static void s2255_stop_readpipe(struct s2255_dev *dev);
353
static int s2255_start_acquire(struct s2255_channel *channel);
354
static int s2255_stop_acquire(struct s2255_channel *channel);
355
static void s2255_fillbuff(struct s2255_channel *chn, struct s2255_buffer *buf,
357
static int s2255_set_mode(struct s2255_channel *chan, struct s2255_mode *mode);
358
static int s2255_board_shutdown(struct s2255_dev *dev);
359
static void s2255_fwload_start(struct s2255_dev *dev, int reset);
360
static void s2255_destroy(struct s2255_dev *dev);
361
static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
362
u16 index, u16 value, void *buf,
363
s32 buf_len, int bOut);
365
/* dev_err macro with driver name */
366
#define S2255_DRIVER_NAME "s2255"
367
#define s2255_dev_err(dev, fmt, arg...) \
368
dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
370
#define dprintk(level, fmt, arg...) \
372
if (*s2255_debug >= (level)) { \
373
printk(KERN_DEBUG S2255_DRIVER_NAME \
378
static struct usb_driver s2255_driver;
380
/* Declare static vars that will be used as parameters */
381
static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
383
/* start video number */
384
static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
386
/* Enable jpeg capture. */
387
static int jpeg_enable = 1;
389
module_param(debug, int, 0644);
390
MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
391
module_param(vid_limit, int, 0644);
392
MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)");
393
module_param(video_nr, int, 0644);
394
MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
395
module_param(jpeg_enable, int, 0644);
396
MODULE_PARM_DESC(jpeg_enable, "Jpeg enable(1-on 0-off) default 1");
398
/* USB device table */
399
#define USB_SENSORAY_VID 0x1943
400
static struct usb_device_id s2255_table[] = {
401
{USB_DEVICE(USB_SENSORAY_VID, 0x2255)},
402
{USB_DEVICE(USB_SENSORAY_VID, 0x2257)}, /*same family as 2255*/
403
{ } /* Terminating entry */
405
MODULE_DEVICE_TABLE(usb, s2255_table);
407
#define BUFFER_TIMEOUT msecs_to_jiffies(400)
410
/* JPEG formats must be defined last to support jpeg_enable parameter */
411
static const struct s2255_fmt formats[] = {
413
.name = "4:2:2, planar, YUV422P",
414
.fourcc = V4L2_PIX_FMT_YUV422P,
418
.name = "4:2:2, packed, YUYV",
419
.fourcc = V4L2_PIX_FMT_YUYV,
423
.name = "4:2:2, packed, UYVY",
424
.fourcc = V4L2_PIX_FMT_UYVY,
428
.fourcc = V4L2_PIX_FMT_GREY,
432
.fourcc = V4L2_PIX_FMT_JPEG,
436
.fourcc = V4L2_PIX_FMT_MJPEG,
441
static int norm_maxw(struct video_device *vdev)
443
return (vdev->current_norm & V4L2_STD_NTSC) ?
444
LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
447
static int norm_maxh(struct video_device *vdev)
449
return (vdev->current_norm & V4L2_STD_NTSC) ?
450
(NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
453
static int norm_minw(struct video_device *vdev)
455
return (vdev->current_norm & V4L2_STD_NTSC) ?
456
LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
459
static int norm_minh(struct video_device *vdev)
461
return (vdev->current_norm & V4L2_STD_NTSC) ?
462
(NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
467
* TODO: fixme: move YUV reordering to hardware
468
* converts 2255 planar format to yuyv or uyvy
470
static void planar422p_to_yuv_packed(const unsigned char *in,
472
int width, int height,
478
unsigned long size = height * width;
480
pY = (unsigned char *)in;
481
pCr = (unsigned char *)in + height * width;
482
pCb = (unsigned char *)in + height * width + (height * width / 2);
483
for (i = 0; i < size * 2; i += 4) {
484
out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
485
out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
486
out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
487
out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
492
static void s2255_reset_dsppower(struct s2255_dev *dev)
494
s2255_vendor_req(dev, 0x40, 0x0000, 0x0001, NULL, 0, 1);
496
s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
498
s2255_vendor_req(dev, 0x10, 0x0000, 0x0000, NULL, 0, 1);
502
/* kickstarts the firmware loading. from probe
504
static void s2255_timer(unsigned long user_data)
506
struct s2255_fw *data = (struct s2255_fw *)user_data;
507
dprintk(100, "%s\n", __func__);
508
if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
509
printk(KERN_ERR "s2255: can't submit urb\n");
510
atomic_set(&data->fw_state, S2255_FW_FAILED);
511
/* wake up anything waiting for the firmware */
512
wake_up(&data->wait_fw);
518
/* this loads the firmware asynchronously.
519
Originally this was done synchroously in probe.
520
But it is better to load it asynchronously here than block
521
inside the probe function. Blocking inside probe affects boot time.
522
FW loading is triggered by the timer in the probe function
524
static void s2255_fwchunk_complete(struct urb *urb)
526
struct s2255_fw *data = urb->context;
527
struct usb_device *udev = urb->dev;
529
dprintk(100, "%s: udev %p urb %p", __func__, udev, urb);
531
dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
532
atomic_set(&data->fw_state, S2255_FW_FAILED);
533
/* wake up anything waiting for the firmware */
534
wake_up(&data->wait_fw);
537
if (data->fw_urb == NULL) {
538
s2255_dev_err(&udev->dev, "disconnected\n");
539
atomic_set(&data->fw_state, S2255_FW_FAILED);
540
/* wake up anything waiting for the firmware */
541
wake_up(&data->wait_fw);
544
#define CHUNK_SIZE 512
545
/* all USB transfers must be done with continuous kernel memory.
546
can't allocate more than 128k in current linux kernel, so
547
upload the firmware in chunks
549
if (data->fw_loaded < data->fw_size) {
550
len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
551
data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
553
if (len < CHUNK_SIZE)
554
memset(data->pfw_data, 0, CHUNK_SIZE);
556
dprintk(100, "completed len %d, loaded %d \n", len,
559
memcpy(data->pfw_data,
560
(char *) data->fw->data + data->fw_loaded, len);
562
usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
563
data->pfw_data, CHUNK_SIZE,
564
s2255_fwchunk_complete, data);
565
if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
566
dev_err(&udev->dev, "failed submit URB\n");
567
atomic_set(&data->fw_state, S2255_FW_FAILED);
568
/* wake up anything waiting for the firmware */
569
wake_up(&data->wait_fw);
572
data->fw_loaded += len;
574
atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
575
dprintk(100, "%s: firmware upload complete\n", __func__);
581
static int s2255_got_frame(struct s2255_channel *channel, int jpgsize)
583
struct s2255_dmaqueue *dma_q = &channel->vidq;
584
struct s2255_buffer *buf;
585
struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
586
unsigned long flags = 0;
588
spin_lock_irqsave(&dev->slock, flags);
589
if (list_empty(&dma_q->active)) {
590
dprintk(1, "No active queue to serve\n");
594
buf = list_entry(dma_q->active.next,
595
struct s2255_buffer, vb.queue);
596
list_del(&buf->vb.queue);
597
do_gettimeofday(&buf->vb.ts);
598
s2255_fillbuff(channel, buf, jpgsize);
599
wake_up(&buf->vb.done);
600
dprintk(2, "%s: [buf/i] [%p/%d]\n", __func__, buf, buf->vb.i);
602
spin_unlock_irqrestore(&dev->slock, flags);
606
static const struct s2255_fmt *format_by_fourcc(int fourcc)
609
for (i = 0; i < ARRAY_SIZE(formats); i++) {
610
if (-1 == formats[i].fourcc)
612
if (!jpeg_enable && ((formats[i].fourcc == V4L2_PIX_FMT_JPEG) ||
613
(formats[i].fourcc == V4L2_PIX_FMT_MJPEG)))
615
if (formats[i].fourcc == fourcc)
621
/* video buffer vmalloc implementation based partly on VIVI driver which is
622
* Copyright (c) 2006 by
623
* Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
624
* Ted Walther <ted--a.t--enumera.com>
625
* John Sokol <sokol--a.t--videotechnology.com>
626
* http://v4l.videotechnology.com/
629
static void s2255_fillbuff(struct s2255_channel *channel,
630
struct s2255_buffer *buf, int jpgsize)
635
char *vbuf = videobuf_to_vmalloc(&buf->vb);
636
unsigned long last_frame;
637
struct s2255_framei *frm;
641
last_frame = channel->last_frame;
642
if (last_frame != -1) {
643
frm = &channel->buffer.frame[last_frame];
645
(const char *)channel->buffer.frame[last_frame].lpvbits;
646
switch (buf->fmt->fourcc) {
647
case V4L2_PIX_FMT_YUYV:
648
case V4L2_PIX_FMT_UYVY:
649
planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
654
case V4L2_PIX_FMT_GREY:
655
memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
657
case V4L2_PIX_FMT_JPEG:
658
case V4L2_PIX_FMT_MJPEG:
659
buf->vb.size = jpgsize;
660
memcpy(vbuf, tmpbuf, buf->vb.size);
662
case V4L2_PIX_FMT_YUV422P:
664
buf->vb.width * buf->vb.height * 2);
667
printk(KERN_DEBUG "s2255: unknown format?\n");
669
channel->last_frame = -1;
671
printk(KERN_ERR "s2255: =======no frame\n");
675
dprintk(2, "s2255fill at : Buffer 0x%08lx size= %d\n",
676
(unsigned long)vbuf, pos);
677
/* tell v4l buffer was filled */
679
buf->vb.field_count = channel->frame_count * 2;
680
do_gettimeofday(&ts);
682
buf->vb.state = VIDEOBUF_DONE;
686
/* ------------------------------------------------------------------
688
------------------------------------------------------------------*/
690
static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
693
struct s2255_fh *fh = vq->priv_data;
694
struct s2255_channel *channel = fh->channel;
695
*size = channel->width * channel->height * (channel->fmt->depth >> 3);
698
*count = S2255_DEF_BUFS;
700
if (*size * *count > vid_limit * 1024 * 1024)
701
*count = (vid_limit * 1024 * 1024) / *size;
706
static void free_buffer(struct videobuf_queue *vq, struct s2255_buffer *buf)
708
dprintk(4, "%s\n", __func__);
710
videobuf_vmalloc_free(&buf->vb);
711
buf->vb.state = VIDEOBUF_NEEDS_INIT;
714
static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
715
enum v4l2_field field)
717
struct s2255_fh *fh = vq->priv_data;
718
struct s2255_channel *channel = fh->channel;
719
struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
721
int w = channel->width;
722
int h = channel->height;
723
dprintk(4, "%s, field=%d\n", __func__, field);
724
if (channel->fmt == NULL)
727
if ((w < norm_minw(&channel->vdev)) ||
728
(w > norm_maxw(&channel->vdev)) ||
729
(h < norm_minh(&channel->vdev)) ||
730
(h > norm_maxh(&channel->vdev))) {
731
dprintk(4, "invalid buffer prepare\n");
734
buf->vb.size = w * h * (channel->fmt->depth >> 3);
735
if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
736
dprintk(4, "invalid buffer prepare\n");
740
buf->fmt = channel->fmt;
743
buf->vb.field = field;
745
if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
746
rc = videobuf_iolock(vq, &buf->vb, NULL);
751
buf->vb.state = VIDEOBUF_PREPARED;
754
free_buffer(vq, buf);
758
static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
760
struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
761
struct s2255_fh *fh = vq->priv_data;
762
struct s2255_channel *channel = fh->channel;
763
struct s2255_dmaqueue *vidq = &channel->vidq;
764
dprintk(1, "%s\n", __func__);
765
buf->vb.state = VIDEOBUF_QUEUED;
766
list_add_tail(&buf->vb.queue, &vidq->active);
769
static void buffer_release(struct videobuf_queue *vq,
770
struct videobuf_buffer *vb)
772
struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
773
struct s2255_fh *fh = vq->priv_data;
774
dprintk(4, "%s %d\n", __func__, fh->channel->idx);
775
free_buffer(vq, buf);
778
static struct videobuf_queue_ops s2255_video_qops = {
779
.buf_setup = buffer_setup,
780
.buf_prepare = buffer_prepare,
781
.buf_queue = buffer_queue,
782
.buf_release = buffer_release,
786
static int res_get(struct s2255_fh *fh)
788
struct s2255_channel *channel = fh->channel;
790
if (channel->resources)
791
return 0; /* no, someone else uses it */
792
/* it's free, grab it */
793
channel->resources = 1;
795
dprintk(1, "s2255: res: get\n");
799
static int res_locked(struct s2255_fh *fh)
801
return fh->channel->resources;
804
static int res_check(struct s2255_fh *fh)
806
return fh->resources;
810
static void res_free(struct s2255_fh *fh)
812
struct s2255_channel *channel = fh->channel;
813
channel->resources = 0;
815
dprintk(1, "res: put\n");
818
static int vidioc_querymenu(struct file *file, void *priv,
819
struct v4l2_querymenu *qmenu)
821
static const char *colorfilter[] = {
826
if (qmenu->id == V4L2_CID_PRIVATE_COLORFILTER) {
828
const char **menu_items = colorfilter;
829
for (i = 0; i < qmenu->index && menu_items[i]; i++)
830
; /* do nothing (from v4l2-common.c) */
831
if (menu_items[i] == NULL || menu_items[i][0] == '\0')
833
strlcpy(qmenu->name, menu_items[qmenu->index],
834
sizeof(qmenu->name));
837
return v4l2_ctrl_query_menu(qmenu, NULL, NULL);
840
static int vidioc_querycap(struct file *file, void *priv,
841
struct v4l2_capability *cap)
843
struct s2255_fh *fh = file->private_data;
844
struct s2255_dev *dev = fh->dev;
845
strlcpy(cap->driver, "s2255", sizeof(cap->driver));
846
strlcpy(cap->card, "s2255", sizeof(cap->card));
847
usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
848
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
852
static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
853
struct v4l2_fmtdesc *f)
859
if (index >= ARRAY_SIZE(formats))
861
if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
862
(formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
864
dprintk(4, "name %s\n", formats[index].name);
865
strlcpy(f->description, formats[index].name, sizeof(f->description));
866
f->pixelformat = formats[index].fourcc;
870
static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
871
struct v4l2_format *f)
873
struct s2255_fh *fh = priv;
874
struct s2255_channel *channel = fh->channel;
876
f->fmt.pix.width = channel->width;
877
f->fmt.pix.height = channel->height;
878
f->fmt.pix.field = fh->vb_vidq.field;
879
f->fmt.pix.pixelformat = channel->fmt->fourcc;
880
f->fmt.pix.bytesperline = f->fmt.pix.width * (channel->fmt->depth >> 3);
881
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
885
static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
886
struct v4l2_format *f)
888
const struct s2255_fmt *fmt;
889
enum v4l2_field field;
891
struct s2255_fh *fh = priv;
892
struct s2255_channel *channel = fh->channel;
895
(channel->vdev.current_norm & V4L2_STD_NTSC) ? 1 : 0;
897
fmt = format_by_fourcc(f->fmt.pix.pixelformat);
902
field = f->fmt.pix.field;
903
if (field == V4L2_FIELD_ANY)
906
dprintk(50, "%s NTSC: %d suggested width: %d, height: %d\n",
907
__func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
910
if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
911
f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
913
field = V4L2_FIELD_SEQ_TB;
914
} else if (!((field == V4L2_FIELD_INTERLACED) ||
915
(field == V4L2_FIELD_SEQ_TB) ||
916
(field == V4L2_FIELD_INTERLACED_TB))) {
917
dprintk(1, "unsupported field setting\n");
921
f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
923
field = V4L2_FIELD_TOP;
924
} else if (!((field == V4L2_FIELD_TOP) ||
925
(field == V4L2_FIELD_BOTTOM))) {
926
dprintk(1, "unsupported field setting\n");
931
if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
932
f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
933
else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
934
f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
935
else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
936
f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
938
f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
941
if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
942
f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
944
field = V4L2_FIELD_SEQ_TB;
945
} else if (!((field == V4L2_FIELD_INTERLACED) ||
946
(field == V4L2_FIELD_SEQ_TB) ||
947
(field == V4L2_FIELD_INTERLACED_TB))) {
948
dprintk(1, "unsupported field setting\n");
952
f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
954
field = V4L2_FIELD_TOP;
955
} else if (!((field == V4L2_FIELD_TOP) ||
956
(field == V4L2_FIELD_BOTTOM))) {
957
dprintk(1, "unsupported field setting\n");
961
if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) {
962
f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
963
field = V4L2_FIELD_SEQ_TB;
964
} else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL) {
965
f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
966
field = V4L2_FIELD_TOP;
967
} else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL) {
968
f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
969
field = V4L2_FIELD_TOP;
971
f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
972
field = V4L2_FIELD_TOP;
975
f->fmt.pix.field = field;
976
f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
977
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
978
dprintk(50, "%s: set width %d height %d field %d\n", __func__,
979
f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
983
static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
984
struct v4l2_format *f)
986
struct s2255_fh *fh = priv;
987
struct s2255_channel *channel = fh->channel;
988
const struct s2255_fmt *fmt;
989
struct videobuf_queue *q = &fh->vb_vidq;
990
struct s2255_mode mode;
994
ret = vidioc_try_fmt_vid_cap(file, fh, f);
999
fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1004
mutex_lock(&q->vb_lock);
1006
if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1007
dprintk(1, "queue busy\n");
1012
if (res_locked(fh)) {
1013
dprintk(1, "%s: channel busy\n", __func__);
1017
mode = channel->mode;
1019
channel->width = f->fmt.pix.width;
1020
channel->height = f->fmt.pix.height;
1021
fh->vb_vidq.field = f->fmt.pix.field;
1023
norm = norm_minw(&channel->vdev);
1024
if (channel->width > norm_minw(&channel->vdev)) {
1025
if (channel->height > norm_minh(&channel->vdev)) {
1026
if (channel->cap_parm.capturemode &
1027
V4L2_MODE_HIGHQUALITY)
1028
mode.scale = SCALE_4CIFSI;
1030
mode.scale = SCALE_4CIFS;
1032
mode.scale = SCALE_2CIFS;
1035
mode.scale = SCALE_1CIFS;
1038
switch (channel->fmt->fourcc) {
1039
case V4L2_PIX_FMT_GREY:
1040
mode.color &= ~MASK_COLOR;
1041
mode.color |= COLOR_Y8;
1043
case V4L2_PIX_FMT_JPEG:
1044
case V4L2_PIX_FMT_MJPEG:
1045
mode.color &= ~MASK_COLOR;
1046
mode.color |= COLOR_JPG;
1047
mode.color |= (channel->jc.quality << 8);
1049
case V4L2_PIX_FMT_YUV422P:
1050
mode.color &= ~MASK_COLOR;
1051
mode.color |= COLOR_YUVPL;
1053
case V4L2_PIX_FMT_YUYV:
1054
case V4L2_PIX_FMT_UYVY:
1056
mode.color &= ~MASK_COLOR;
1057
mode.color |= COLOR_YUVPK;
1060
if ((mode.color & MASK_COLOR) != (channel->mode.color & MASK_COLOR))
1062
else if (mode.scale != channel->mode.scale)
1064
else if (mode.format != channel->mode.format)
1066
channel->mode = mode;
1067
(void) s2255_set_mode(channel, &mode);
1070
mutex_unlock(&q->vb_lock);
1074
static int vidioc_reqbufs(struct file *file, void *priv,
1075
struct v4l2_requestbuffers *p)
1078
struct s2255_fh *fh = priv;
1079
rc = videobuf_reqbufs(&fh->vb_vidq, p);
1083
static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1086
struct s2255_fh *fh = priv;
1087
rc = videobuf_querybuf(&fh->vb_vidq, p);
1091
static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1094
struct s2255_fh *fh = priv;
1095
rc = videobuf_qbuf(&fh->vb_vidq, p);
1099
static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1102
struct s2255_fh *fh = priv;
1103
rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
1107
/* write to the configuration pipe, synchronously */
1108
static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1115
pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
1116
retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
1121
static u32 get_transfer_size(struct s2255_mode *mode)
1123
int linesPerFrame = LINE_SZ_DEF;
1124
int pixelsPerLine = NUM_LINES_DEF;
1127
unsigned int mask_mult;
1132
if (mode->format == FORMAT_NTSC) {
1133
switch (mode->scale) {
1136
linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
1137
pixelsPerLine = LINE_SZ_4CIFS_NTSC;
1140
linesPerFrame = NUM_LINES_2CIFS_NTSC;
1141
pixelsPerLine = LINE_SZ_2CIFS_NTSC;
1144
linesPerFrame = NUM_LINES_1CIFS_NTSC;
1145
pixelsPerLine = LINE_SZ_1CIFS_NTSC;
1150
} else if (mode->format == FORMAT_PAL) {
1151
switch (mode->scale) {
1154
linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
1155
pixelsPerLine = LINE_SZ_4CIFS_PAL;
1158
linesPerFrame = NUM_LINES_2CIFS_PAL;
1159
pixelsPerLine = LINE_SZ_2CIFS_PAL;
1162
linesPerFrame = NUM_LINES_1CIFS_PAL;
1163
pixelsPerLine = LINE_SZ_1CIFS_PAL;
1169
outImageSize = linesPerFrame * pixelsPerLine;
1170
if ((mode->color & MASK_COLOR) != COLOR_Y8) {
1171
/* 2 bytes/pixel if not monochrome */
1175
/* total bytes to send including prefix and 4K padding;
1176
must be a multiple of USB_READ_SIZE */
1177
usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
1178
mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
1179
/* if size not a multiple of USB_READ_SIZE */
1180
if (usbInSize & ~mask_mult)
1181
usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
1185
static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
1187
struct device *dev = &sdev->udev->dev;
1188
dev_info(dev, "------------------------------------------------\n");
1189
dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
1190
dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
1191
dev_info(dev, "bright: 0x%x\n", mode->bright);
1192
dev_info(dev, "------------------------------------------------\n");
1196
* set mode is the function which controls the DSP.
1197
* the restart parameter in struct s2255_mode should be set whenever
1198
* the image size could change via color format, video system or image
1200
* When the restart parameter is set, we sleep for ONE frame to allow the
1201
* DSP time to get the new frame
1203
static int s2255_set_mode(struct s2255_channel *channel,
1204
struct s2255_mode *mode)
1208
unsigned long chn_rev;
1209
struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
1210
chn_rev = G_chnmap[channel->idx];
1211
dprintk(3, "%s channel: %d\n", __func__, channel->idx);
1212
/* if JPEG, set the quality */
1213
if ((mode->color & MASK_COLOR) == COLOR_JPG) {
1214
mode->color &= ~MASK_COLOR;
1215
mode->color |= COLOR_JPG;
1216
mode->color &= ~MASK_JPG_QUALITY;
1217
mode->color |= (channel->jc.quality << 8);
1220
channel->mode = *mode;
1221
channel->req_image_size = get_transfer_size(mode);
1222
dprintk(1, "%s: reqsize %ld\n", __func__, channel->req_image_size);
1223
buffer = kzalloc(512, GFP_KERNEL);
1224
if (buffer == NULL) {
1225
dev_err(&dev->udev->dev, "out of mem\n");
1229
buffer[0] = IN_DATA_TOKEN;
1230
buffer[1] = (__le32) cpu_to_le32(chn_rev);
1231
buffer[2] = CMD_SET_MODE;
1232
memcpy(&buffer[3], &channel->mode, sizeof(struct s2255_mode));
1233
channel->setmode_ready = 0;
1234
res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1236
s2255_print_cfg(dev, mode);
1238
/* wait at least 3 frames before continuing */
1239
if (mode->restart) {
1240
wait_event_timeout(channel->wait_setmode,
1241
(channel->setmode_ready != 0),
1242
msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1243
if (channel->setmode_ready != 1) {
1244
printk(KERN_DEBUG "s2255: no set mode response\n");
1248
/* clear the restart flag */
1249
channel->mode.restart = 0;
1250
dprintk(1, "%s chn %d, result: %d\n", __func__, channel->idx, res);
1254
static int s2255_cmd_status(struct s2255_channel *channel, u32 *pstatus)
1259
struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
1260
chn_rev = G_chnmap[channel->idx];
1261
dprintk(4, "%s chan %d\n", __func__, channel->idx);
1262
buffer = kzalloc(512, GFP_KERNEL);
1263
if (buffer == NULL) {
1264
dev_err(&dev->udev->dev, "out of mem\n");
1267
/* form the get vid status command */
1268
buffer[0] = IN_DATA_TOKEN;
1269
buffer[1] = (__le32) cpu_to_le32(chn_rev);
1270
buffer[2] = CMD_STATUS;
1272
channel->vidstatus_ready = 0;
1273
res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1275
wait_event_timeout(channel->wait_vidstatus,
1276
(channel->vidstatus_ready != 0),
1277
msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1278
if (channel->vidstatus_ready != 1) {
1279
printk(KERN_DEBUG "s2255: no vidstatus response\n");
1282
*pstatus = channel->vidstatus;
1283
dprintk(4, "%s, vid status %d\n", __func__, *pstatus);
1287
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1290
struct s2255_fh *fh = priv;
1291
struct s2255_dev *dev = fh->dev;
1292
struct s2255_channel *channel = fh->channel;
1294
dprintk(4, "%s\n", __func__);
1295
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1296
dev_err(&dev->udev->dev, "invalid fh type0\n");
1299
if (i != fh->type) {
1300
dev_err(&dev->udev->dev, "invalid fh type1\n");
1305
s2255_dev_err(&dev->udev->dev, "stream busy\n");
1308
channel->last_frame = -1;
1309
channel->bad_payload = 0;
1310
channel->cur_frame = 0;
1311
channel->frame_count = 0;
1312
for (j = 0; j < SYS_FRAMES; j++) {
1313
channel->buffer.frame[j].ulState = S2255_READ_IDLE;
1314
channel->buffer.frame[j].cur_size = 0;
1316
res = videobuf_streamon(&fh->vb_vidq);
1318
s2255_start_acquire(channel);
1319
channel->b_acquire = 1;
1326
static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1328
struct s2255_fh *fh = priv;
1329
dprintk(4, "%s\n, channel: %d", __func__, fh->channel->idx);
1330
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1331
printk(KERN_ERR "invalid fh type0\n");
1334
if (i != fh->type) {
1335
printk(KERN_ERR "invalid type i\n");
1338
s2255_stop_acquire(fh->channel);
1339
videobuf_streamoff(&fh->vb_vidq);
1344
static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1346
struct s2255_fh *fh = priv;
1347
struct s2255_mode mode;
1348
struct videobuf_queue *q = &fh->vb_vidq;
1350
mutex_lock(&q->vb_lock);
1351
if (videobuf_queue_is_busy(q)) {
1352
dprintk(1, "queue busy\n");
1356
if (res_locked(fh)) {
1357
dprintk(1, "can't change standard after started\n");
1361
mode = fh->channel->mode;
1362
if (*i & V4L2_STD_NTSC) {
1363
dprintk(4, "%s NTSC\n", __func__);
1364
/* if changing format, reset frame decimation/intervals */
1365
if (mode.format != FORMAT_NTSC) {
1367
mode.format = FORMAT_NTSC;
1370
} else if (*i & V4L2_STD_PAL) {
1371
dprintk(4, "%s PAL\n", __func__);
1372
if (mode.format != FORMAT_PAL) {
1374
mode.format = FORMAT_PAL;
1381
s2255_set_mode(fh->channel, &mode);
1383
mutex_unlock(&q->vb_lock);
1387
/* Sensoray 2255 is a multiple channel capture device.
1388
It does not have a "crossbar" of inputs.
1389
We use one V4L device per channel. The user must
1390
be aware that certain combinations are not allowed.
1391
For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1392
at once in color(you can do full fps on 4 channels with greyscale.
1394
static int vidioc_enum_input(struct file *file, void *priv,
1395
struct v4l2_input *inp)
1397
struct s2255_fh *fh = priv;
1398
struct s2255_dev *dev = fh->dev;
1399
struct s2255_channel *channel = fh->channel;
1401
if (inp->index != 0)
1403
inp->type = V4L2_INPUT_TYPE_CAMERA;
1404
inp->std = S2255_NORMS;
1406
if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1408
rc = s2255_cmd_status(fh->channel, &status);
1409
dprintk(4, "s2255_cmd_status rc: %d status %x\n", rc, status);
1411
inp->status = (status & 0x01) ? 0
1412
: V4L2_IN_ST_NO_SIGNAL;
1417
strlcpy(inp->name, "Composite", sizeof(inp->name));
1420
strlcpy(inp->name, (channel->idx < 2) ? "Composite" : "S-Video",
1427
static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1432
static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1439
/* --- controls ---------------------------------------------- */
1440
static int vidioc_queryctrl(struct file *file, void *priv,
1441
struct v4l2_queryctrl *qc)
1443
struct s2255_fh *fh = priv;
1444
struct s2255_channel *channel = fh->channel;
1445
struct s2255_dev *dev = fh->dev;
1447
case V4L2_CID_BRIGHTNESS:
1448
v4l2_ctrl_query_fill(qc, -127, 127, 1, DEF_BRIGHT);
1450
case V4L2_CID_CONTRAST:
1451
v4l2_ctrl_query_fill(qc, 0, 255, 1, DEF_CONTRAST);
1453
case V4L2_CID_SATURATION:
1454
v4l2_ctrl_query_fill(qc, 0, 255, 1, DEF_SATURATION);
1457
v4l2_ctrl_query_fill(qc, 0, 255, 1, DEF_HUE);
1459
case V4L2_CID_PRIVATE_COLORFILTER:
1460
if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
1462
if ((dev->pid == 0x2257) && (channel->idx > 1))
1464
strlcpy(qc->name, "Color Filter", sizeof(qc->name));
1465
qc->type = V4L2_CTRL_TYPE_MENU;
1469
qc->default_value = 1;
1475
dprintk(4, "%s, id %d\n", __func__, qc->id);
1479
static int vidioc_g_ctrl(struct file *file, void *priv,
1480
struct v4l2_control *ctrl)
1482
struct s2255_fh *fh = priv;
1483
struct s2255_dev *dev = fh->dev;
1484
struct s2255_channel *channel = fh->channel;
1486
case V4L2_CID_BRIGHTNESS:
1487
ctrl->value = channel->mode.bright;
1489
case V4L2_CID_CONTRAST:
1490
ctrl->value = channel->mode.contrast;
1492
case V4L2_CID_SATURATION:
1493
ctrl->value = channel->mode.saturation;
1496
ctrl->value = channel->mode.hue;
1498
case V4L2_CID_PRIVATE_COLORFILTER:
1499
if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
1501
if ((dev->pid == 0x2257) && (channel->idx > 1))
1503
ctrl->value = !((channel->mode.color & MASK_INPUT_TYPE) >> 16);
1508
dprintk(4, "%s, id %d val %d\n", __func__, ctrl->id, ctrl->value);
1512
static int vidioc_s_ctrl(struct file *file, void *priv,
1513
struct v4l2_control *ctrl)
1515
struct s2255_fh *fh = priv;
1516
struct s2255_channel *channel = fh->channel;
1517
struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
1518
struct s2255_mode mode;
1519
mode = channel->mode;
1520
dprintk(4, "%s\n", __func__);
1521
/* update the mode to the corresponding value */
1523
case V4L2_CID_BRIGHTNESS:
1524
mode.bright = ctrl->value;
1526
case V4L2_CID_CONTRAST:
1527
mode.contrast = ctrl->value;
1530
mode.hue = ctrl->value;
1532
case V4L2_CID_SATURATION:
1533
mode.saturation = ctrl->value;
1535
case V4L2_CID_PRIVATE_COLORFILTER:
1536
if (dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
1538
if ((dev->pid == 0x2257) && (channel->idx > 1))
1540
mode.color &= ~MASK_INPUT_TYPE;
1541
mode.color |= ((ctrl->value ? 0 : 1) << 16);
1547
/* set mode here. Note: stream does not need restarted.
1548
some V4L programs restart stream unnecessarily
1551
s2255_set_mode(fh->channel, &mode);
1555
static int vidioc_g_jpegcomp(struct file *file, void *priv,
1556
struct v4l2_jpegcompression *jc)
1558
struct s2255_fh *fh = priv;
1559
struct s2255_channel *channel = fh->channel;
1561
dprintk(2, "%s: quality %d\n", __func__, jc->quality);
1565
static int vidioc_s_jpegcomp(struct file *file, void *priv,
1566
struct v4l2_jpegcompression *jc)
1568
struct s2255_fh *fh = priv;
1569
struct s2255_channel *channel = fh->channel;
1570
if (jc->quality < 0 || jc->quality > 100)
1572
channel->jc.quality = jc->quality;
1573
dprintk(2, "%s: quality %d\n", __func__, jc->quality);
1577
static int vidioc_g_parm(struct file *file, void *priv,
1578
struct v4l2_streamparm *sp)
1580
struct s2255_fh *fh = priv;
1581
__u32 def_num, def_dem;
1582
struct s2255_channel *channel = fh->channel;
1583
if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1585
memset(sp, 0, sizeof(struct v4l2_streamparm));
1586
sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1587
sp->parm.capture.capturemode = channel->cap_parm.capturemode;
1588
def_num = (channel->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1589
def_dem = (channel->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1590
sp->parm.capture.timeperframe.denominator = def_dem;
1591
switch (channel->mode.fdec) {
1594
sp->parm.capture.timeperframe.numerator = def_num;
1597
sp->parm.capture.timeperframe.numerator = def_num * 2;
1600
sp->parm.capture.timeperframe.numerator = def_num * 3;
1603
sp->parm.capture.timeperframe.numerator = def_num * 5;
1606
dprintk(4, "%s capture mode, %d timeperframe %d/%d\n", __func__,
1607
sp->parm.capture.capturemode,
1608
sp->parm.capture.timeperframe.numerator,
1609
sp->parm.capture.timeperframe.denominator);
1613
static int vidioc_s_parm(struct file *file, void *priv,
1614
struct v4l2_streamparm *sp)
1616
struct s2255_fh *fh = priv;
1617
struct s2255_channel *channel = fh->channel;
1618
struct s2255_mode mode;
1620
__u32 def_num, def_dem;
1621
if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1623
mode = channel->mode;
1624
/* high quality capture mode requires a stream restart */
1625
if (channel->cap_parm.capturemode
1626
!= sp->parm.capture.capturemode && res_locked(fh))
1628
def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1629
def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1630
if (def_dem != sp->parm.capture.timeperframe.denominator)
1631
sp->parm.capture.timeperframe.numerator = def_num;
1632
else if (sp->parm.capture.timeperframe.numerator <= def_num)
1633
sp->parm.capture.timeperframe.numerator = def_num;
1634
else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1635
sp->parm.capture.timeperframe.numerator = def_num * 2;
1637
} else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1638
sp->parm.capture.timeperframe.numerator = def_num * 3;
1641
sp->parm.capture.timeperframe.numerator = def_num * 5;
1645
sp->parm.capture.timeperframe.denominator = def_dem;
1646
s2255_set_mode(channel, &mode);
1647
dprintk(4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1649
sp->parm.capture.capturemode,
1650
sp->parm.capture.timeperframe.numerator,
1651
sp->parm.capture.timeperframe.denominator, fdec);
1655
static int vidioc_enum_frameintervals(struct file *file, void *priv,
1656
struct v4l2_frmivalenum *fe)
1659
#define NUM_FRAME_ENUMS 4
1660
int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1661
if (fe->index < 0 || fe->index >= NUM_FRAME_ENUMS)
1663
switch (fe->width) {
1665
if (fe->height != 240 && fe->height != 480)
1670
if (fe->height != 240)
1675
if (fe->height != 288 && fe->height != 576)
1679
if (fe->height != 288)
1685
fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1686
fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1687
fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1688
dprintk(4, "%s discrete %d/%d\n", __func__, fe->discrete.numerator,
1689
fe->discrete.denominator);
1693
static int s2255_open(struct file *file)
1695
struct video_device *vdev = video_devdata(file);
1696
struct s2255_channel *channel = video_drvdata(file);
1697
struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1698
struct s2255_fh *fh;
1699
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1701
dprintk(1, "s2255: open called (dev=%s)\n",
1702
video_device_node_name(vdev));
1704
* open lock necessary to prevent multiple instances
1705
* of v4l-conf (or other programs) from simultaneously
1706
* reloading firmware.
1708
mutex_lock(&dev->open_lock);
1709
state = atomic_read(&dev->fw_data->fw_state);
1711
case S2255_FW_DISCONNECTING:
1712
mutex_unlock(&dev->open_lock);
1714
case S2255_FW_FAILED:
1715
s2255_dev_err(&dev->udev->dev,
1716
"firmware load failed. retrying.\n");
1717
s2255_fwload_start(dev, 1);
1718
wait_event_timeout(dev->fw_data->wait_fw,
1719
((atomic_read(&dev->fw_data->fw_state)
1720
== S2255_FW_SUCCESS) ||
1721
(atomic_read(&dev->fw_data->fw_state)
1722
== S2255_FW_DISCONNECTING)),
1723
msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1724
/* state may have changed, re-read */
1725
state = atomic_read(&dev->fw_data->fw_state);
1727
case S2255_FW_NOTLOADED:
1728
case S2255_FW_LOADED_DSPWAIT:
1729
/* give S2255_LOAD_TIMEOUT time for firmware to load in case
1730
driver loaded and then device immediately opened */
1731
printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1732
wait_event_timeout(dev->fw_data->wait_fw,
1733
((atomic_read(&dev->fw_data->fw_state)
1734
== S2255_FW_SUCCESS) ||
1735
(atomic_read(&dev->fw_data->fw_state)
1736
== S2255_FW_DISCONNECTING)),
1737
msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1738
/* state may have changed, re-read */
1739
state = atomic_read(&dev->fw_data->fw_state);
1741
case S2255_FW_SUCCESS:
1745
/* state may have changed in above switch statement */
1747
case S2255_FW_SUCCESS:
1749
case S2255_FW_FAILED:
1750
printk(KERN_INFO "2255 firmware load failed.\n");
1751
mutex_unlock(&dev->open_lock);
1753
case S2255_FW_DISCONNECTING:
1754
printk(KERN_INFO "%s: disconnecting\n", __func__);
1755
mutex_unlock(&dev->open_lock);
1757
case S2255_FW_LOADED_DSPWAIT:
1758
case S2255_FW_NOTLOADED:
1759
printk(KERN_INFO "%s: firmware not loaded yet"
1760
"please try again later\n",
1763
* Timeout on firmware load means device unusable.
1764
* Set firmware failure state.
1765
* On next s2255_open the firmware will be reloaded.
1767
atomic_set(&dev->fw_data->fw_state,
1769
mutex_unlock(&dev->open_lock);
1772
printk(KERN_INFO "%s: unknown state\n", __func__);
1773
mutex_unlock(&dev->open_lock);
1776
mutex_unlock(&dev->open_lock);
1777
/* allocate + initialize per filehandle data */
1778
fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1781
file->private_data = fh;
1783
fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1784
fh->channel = channel;
1785
if (!channel->configured) {
1786
/* configure channel to default state */
1787
channel->fmt = &formats[0];
1788
s2255_set_mode(channel, &channel->mode);
1789
channel->configured = 1;
1791
dprintk(1, "%s: dev=%s type=%s\n", __func__,
1792
video_device_node_name(vdev), v4l2_type_names[type]);
1793
dprintk(2, "%s: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n", __func__,
1794
(unsigned long)fh, (unsigned long)dev,
1795
(unsigned long)&channel->vidq);
1796
dprintk(4, "%s: list_empty active=%d\n", __func__,
1797
list_empty(&channel->vidq.active));
1798
videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1801
V4L2_FIELD_INTERLACED,
1802
sizeof(struct s2255_buffer),
1808
static unsigned int s2255_poll(struct file *file,
1809
struct poll_table_struct *wait)
1811
struct s2255_fh *fh = file->private_data;
1813
dprintk(100, "%s\n", __func__);
1814
if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1816
rc = videobuf_poll_stream(file, &fh->vb_vidq, wait);
1820
static void s2255_destroy(struct s2255_dev *dev)
1822
/* board shutdown stops the read pipe if it is running */
1823
s2255_board_shutdown(dev);
1824
/* make sure firmware still not trying to load */
1825
del_timer(&dev->timer); /* only started in .probe and .open */
1826
if (dev->fw_data->fw_urb) {
1827
usb_kill_urb(dev->fw_data->fw_urb);
1828
usb_free_urb(dev->fw_data->fw_urb);
1829
dev->fw_data->fw_urb = NULL;
1831
if (dev->fw_data->fw)
1832
release_firmware(dev->fw_data->fw);
1833
kfree(dev->fw_data->pfw_data);
1834
kfree(dev->fw_data);
1835
/* reset the DSP so firmware can be reloaded next time */
1836
s2255_reset_dsppower(dev);
1837
mutex_destroy(&dev->open_lock);
1838
mutex_destroy(&dev->lock);
1839
usb_put_dev(dev->udev);
1840
v4l2_device_unregister(&dev->v4l2_dev);
1841
dprintk(1, "%s", __func__);
1845
static int s2255_release(struct file *file)
1847
struct s2255_fh *fh = file->private_data;
1848
struct s2255_dev *dev = fh->dev;
1849
struct video_device *vdev = video_devdata(file);
1850
struct s2255_channel *channel = fh->channel;
1853
/* turn off stream */
1854
if (res_check(fh)) {
1855
if (channel->b_acquire)
1856
s2255_stop_acquire(fh->channel);
1857
videobuf_streamoff(&fh->vb_vidq);
1860
videobuf_mmap_free(&fh->vb_vidq);
1861
dprintk(1, "%s (dev=%s)\n", __func__, video_device_node_name(vdev));
1866
static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1868
struct s2255_fh *fh = file->private_data;
1873
dprintk(4, "%s, vma=0x%08lx\n", __func__, (unsigned long)vma);
1874
ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1875
dprintk(4, "%s vma start=0x%08lx, size=%ld, ret=%d\n", __func__,
1876
(unsigned long)vma->vm_start,
1877
(unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1881
static const struct v4l2_file_operations s2255_fops_v4l = {
1882
.owner = THIS_MODULE,
1884
.release = s2255_release,
1886
.unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1887
.mmap = s2255_mmap_v4l,
1890
static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1891
.vidioc_querymenu = vidioc_querymenu,
1892
.vidioc_querycap = vidioc_querycap,
1893
.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1894
.vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1895
.vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1896
.vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1897
.vidioc_reqbufs = vidioc_reqbufs,
1898
.vidioc_querybuf = vidioc_querybuf,
1899
.vidioc_qbuf = vidioc_qbuf,
1900
.vidioc_dqbuf = vidioc_dqbuf,
1901
.vidioc_s_std = vidioc_s_std,
1902
.vidioc_enum_input = vidioc_enum_input,
1903
.vidioc_g_input = vidioc_g_input,
1904
.vidioc_s_input = vidioc_s_input,
1905
.vidioc_queryctrl = vidioc_queryctrl,
1906
.vidioc_g_ctrl = vidioc_g_ctrl,
1907
.vidioc_s_ctrl = vidioc_s_ctrl,
1908
.vidioc_streamon = vidioc_streamon,
1909
.vidioc_streamoff = vidioc_streamoff,
1910
.vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1911
.vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1912
.vidioc_s_parm = vidioc_s_parm,
1913
.vidioc_g_parm = vidioc_g_parm,
1914
.vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1917
static void s2255_video_device_release(struct video_device *vdev)
1919
struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1920
dprintk(4, "%s, chnls: %d \n", __func__,
1921
atomic_read(&dev->num_channels));
1922
if (atomic_dec_and_test(&dev->num_channels))
1927
static struct video_device template = {
1929
.fops = &s2255_fops_v4l,
1930
.ioctl_ops = &s2255_ioctl_ops,
1931
.release = s2255_video_device_release,
1932
.tvnorms = S2255_NORMS,
1933
.current_norm = V4L2_STD_NTSC_M,
1936
static int s2255_probe_v4l(struct s2255_dev *dev)
1940
int cur_nr = video_nr;
1941
struct s2255_channel *channel;
1942
ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1945
/* initialize all video 4 linux */
1946
/* register 4 video devices */
1947
for (i = 0; i < MAX_CHANNELS; i++) {
1948
channel = &dev->channel[i];
1949
INIT_LIST_HEAD(&channel->vidq.active);
1950
channel->vidq.dev = dev;
1951
/* register 4 video devices */
1952
channel->vdev = template;
1953
channel->vdev.lock = &dev->lock;
1954
channel->vdev.v4l2_dev = &dev->v4l2_dev;
1955
video_set_drvdata(&channel->vdev, channel);
1957
ret = video_register_device(&channel->vdev,
1961
ret = video_register_device(&channel->vdev,
1966
dev_err(&dev->udev->dev,
1967
"failed to register video device!\n");
1970
atomic_inc(&dev->num_channels);
1971
v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1972
video_device_node_name(&channel->vdev));
1975
printk(KERN_INFO "Sensoray 2255 V4L driver Revision: %s\n",
1977
/* if no channels registered, return error and probe will fail*/
1978
if (atomic_read(&dev->num_channels) == 0) {
1979
v4l2_device_unregister(&dev->v4l2_dev);
1982
if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1983
printk(KERN_WARNING "s2255: Not all channels available.\n");
1987
/* this function moves the usb stream read pipe data
1988
* into the system buffers.
1989
* returns 0 on success, EAGAIN if more data to process( call this
1992
* Received frame structure:
1993
* bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1994
* bytes 4-7: channel: 0-3
1995
* bytes 8-11: payload size: size of the frame
1996
* bytes 12-payloadsize+12: frame data
1998
static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
2004
unsigned long copy_size;
2007
struct s2255_framei *frm;
2008
unsigned char *pdata;
2009
struct s2255_channel *channel;
2010
dprintk(100, "buffer to user\n");
2011
channel = &dev->channel[dev->cc];
2012
idx = channel->cur_frame;
2013
frm = &channel->buffer.frame[idx];
2014
if (frm->ulState == S2255_READ_IDLE) {
2017
__le32 *pdword; /*data from dsp is little endian */
2019
/* search for marker codes */
2020
pdata = (unsigned char *)pipe_info->transfer_buffer;
2021
pdword = (__le32 *)pdata;
2022
for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
2024
case S2255_MARKER_FRAME:
2025
dprintk(4, "found frame marker at offset:"
2026
" %d [%x %x]\n", jj, pdata[0],
2028
offset = jj + PREFIX_SIZE;
2031
if (cc >= MAX_CHANNELS) {
2037
dev->cc = G_chnmap[cc];
2038
channel = &dev->channel[dev->cc];
2039
payload = pdword[3];
2040
if (payload > channel->req_image_size) {
2041
channel->bad_payload++;
2042
/* discard the bad frame */
2045
channel->pkt_size = payload;
2046
channel->jpg_size = pdword[4];
2048
case S2255_MARKER_RESPONSE:
2050
pdata += DEF_USB_BLOCK;
2051
jj += DEF_USB_BLOCK;
2052
if (pdword[1] >= MAX_CHANNELS)
2054
cc = G_chnmap[pdword[1]];
2055
if (cc >= MAX_CHANNELS)
2057
channel = &dev->channel[cc];
2058
switch (pdword[2]) {
2059
case S2255_RESPONSE_SETMODE:
2060
/* check if channel valid */
2061
/* set mode ready */
2062
channel->setmode_ready = 1;
2063
wake_up(&channel->wait_setmode);
2064
dprintk(5, "setmode ready %d\n", cc);
2066
case S2255_RESPONSE_FW:
2067
dev->chn_ready |= (1 << cc);
2068
if ((dev->chn_ready & 0x0f) != 0x0f)
2070
/* all channels ready */
2071
printk(KERN_INFO "s2255: fw loaded\n");
2072
atomic_set(&dev->fw_data->fw_state,
2074
wake_up(&dev->fw_data->wait_fw);
2076
case S2255_RESPONSE_STATUS:
2077
channel->vidstatus = pdword[3];
2078
channel->vidstatus_ready = 1;
2079
wake_up(&channel->wait_vidstatus);
2080
dprintk(5, "got vidstatus %x chan %d\n",
2084
printk(KERN_INFO "s2255 unknown resp\n");
2096
channel = &dev->channel[dev->cc];
2097
idx = channel->cur_frame;
2098
frm = &channel->buffer.frame[idx];
2099
/* search done. now find out if should be acquiring on this channel */
2100
if (!channel->b_acquire) {
2101
/* we found a frame, but this channel is turned off */
2102
frm->ulState = S2255_READ_IDLE;
2106
if (frm->ulState == S2255_READ_IDLE) {
2107
frm->ulState = S2255_READ_FRAME;
2111
/* skip the marker 512 bytes (and offset if out of sync) */
2112
psrc = (u8 *)pipe_info->transfer_buffer + offset;
2115
if (frm->lpvbits == NULL) {
2116
dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
2117
frm, dev, dev->cc, idx);
2121
pdest = frm->lpvbits + frm->cur_size;
2123
copy_size = (pipe_info->cur_transfer_size - offset);
2125
size = channel->pkt_size - PREFIX_SIZE;
2127
/* sanity check on pdest */
2128
if ((copy_size + frm->cur_size) < channel->req_image_size)
2129
memcpy(pdest, psrc, copy_size);
2131
frm->cur_size += copy_size;
2132
dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
2134
if (frm->cur_size >= size) {
2135
dprintk(2, "****************[%d]Buffer[%d]full*************\n",
2137
channel->last_frame = channel->cur_frame;
2138
channel->cur_frame++;
2139
/* end of system frame ring buffer, start at zero */
2140
if ((channel->cur_frame == SYS_FRAMES) ||
2141
(channel->cur_frame == channel->buffer.dwFrames))
2142
channel->cur_frame = 0;
2144
if (channel->b_acquire)
2145
s2255_got_frame(channel, channel->jpg_size);
2146
channel->frame_count++;
2147
frm->ulState = S2255_READ_IDLE;
2151
/* done successfully */
2155
static void s2255_read_video_callback(struct s2255_dev *dev,
2156
struct s2255_pipeinfo *pipe_info)
2159
dprintk(50, "callback read video \n");
2161
if (dev->cc >= MAX_CHANNELS) {
2163
dev_err(&dev->udev->dev, "invalid channel\n");
2166
/* otherwise copy to the system buffers */
2167
res = save_frame(dev, pipe_info);
2169
dprintk(4, "s2255: read callback failed\n");
2171
dprintk(50, "callback read video done\n");
2175
static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
2176
u16 Index, u16 Value, void *TransferBuffer,
2177
s32 TransferBufferLength, int bOut)
2181
r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2183
USB_TYPE_VENDOR | USB_RECIP_DEVICE |
2185
Value, Index, TransferBuffer,
2186
TransferBufferLength, HZ * 5);
2188
r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2189
Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2190
Value, Index, TransferBuffer,
2191
TransferBufferLength, HZ * 5);
2197
* retrieve FX2 firmware version. future use.
2198
* @param dev pointer to device extension
2199
* @return -1 for fail, else returns firmware version as an int(16 bits)
2201
static int s2255_get_fx2fw(struct s2255_dev *dev)
2205
unsigned char transBuffer[64];
2206
ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2209
dprintk(2, "get fw error: %x\n", ret);
2210
fw = transBuffer[0] + (transBuffer[1] << 8);
2211
dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2216
* Create the system ring buffer to copy frames into from the
2219
static int s2255_create_sys_buffers(struct s2255_channel *channel)
2222
unsigned long reqsize;
2223
dprintk(1, "create sys buffers\n");
2224
channel->buffer.dwFrames = SYS_FRAMES;
2225
/* always allocate maximum size(PAL) for system buffers */
2226
reqsize = SYS_FRAMES_MAXSIZE;
2228
if (reqsize > SYS_FRAMES_MAXSIZE)
2229
reqsize = SYS_FRAMES_MAXSIZE;
2231
for (i = 0; i < SYS_FRAMES; i++) {
2232
/* allocate the frames */
2233
channel->buffer.frame[i].lpvbits = vmalloc(reqsize);
2234
dprintk(1, "valloc %p chan %d, idx %lu, pdata %p\n",
2235
&channel->buffer.frame[i], channel->idx, i,
2236
channel->buffer.frame[i].lpvbits);
2237
channel->buffer.frame[i].size = reqsize;
2238
if (channel->buffer.frame[i].lpvbits == NULL) {
2239
printk(KERN_INFO "out of memory. using less frames\n");
2240
channel->buffer.dwFrames = i;
2245
/* make sure internal states are set */
2246
for (i = 0; i < SYS_FRAMES; i++) {
2247
channel->buffer.frame[i].ulState = 0;
2248
channel->buffer.frame[i].cur_size = 0;
2251
channel->cur_frame = 0;
2252
channel->last_frame = -1;
2256
static int s2255_release_sys_buffers(struct s2255_channel *channel)
2259
dprintk(1, "release sys buffers\n");
2260
for (i = 0; i < SYS_FRAMES; i++) {
2261
if (channel->buffer.frame[i].lpvbits) {
2262
dprintk(1, "vfree %p\n",
2263
channel->buffer.frame[i].lpvbits);
2264
vfree(channel->buffer.frame[i].lpvbits);
2266
channel->buffer.frame[i].lpvbits = NULL;
2271
static int s2255_board_init(struct s2255_dev *dev)
2273
struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2276
struct s2255_pipeinfo *pipe = &dev->pipe;
2277
dprintk(4, "board init: %p", dev);
2278
memset(pipe, 0, sizeof(*pipe));
2280
pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2281
pipe->max_transfer_size = S2255_USB_XFER_SIZE;
2283
pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2285
if (pipe->transfer_buffer == NULL) {
2286
dprintk(1, "out of memory!\n");
2289
/* query the firmware */
2290
fw_ver = s2255_get_fx2fw(dev);
2292
printk(KERN_INFO "s2255: usb firmware version %d.%d\n",
2293
(fw_ver >> 8) & 0xff,
2296
if (fw_ver < S2255_CUR_USB_FWVER)
2297
printk(KERN_INFO "s2255: newer USB firmware available\n");
2299
for (j = 0; j < MAX_CHANNELS; j++) {
2300
struct s2255_channel *channel = &dev->channel[j];
2301
channel->b_acquire = 0;
2302
channel->mode = mode_def;
2303
if (dev->pid == 0x2257 && j > 1)
2304
channel->mode.color |= (1 << 16);
2305
channel->jc.quality = S2255_DEF_JPEG_QUAL;
2306
channel->width = LINE_SZ_4CIFS_NTSC;
2307
channel->height = NUM_LINES_4CIFS_NTSC * 2;
2308
channel->fmt = &formats[0];
2309
channel->mode.restart = 1;
2310
channel->req_image_size = get_transfer_size(&mode_def);
2311
channel->frame_count = 0;
2312
/* create the system buffers */
2313
s2255_create_sys_buffers(channel);
2315
/* start read pipe */
2316
s2255_start_readpipe(dev);
2317
dprintk(1, "%s: success\n", __func__);
2321
static int s2255_board_shutdown(struct s2255_dev *dev)
2324
dprintk(1, "%s: dev: %p", __func__, dev);
2326
for (i = 0; i < MAX_CHANNELS; i++) {
2327
if (dev->channel[i].b_acquire)
2328
s2255_stop_acquire(&dev->channel[i]);
2330
s2255_stop_readpipe(dev);
2331
for (i = 0; i < MAX_CHANNELS; i++)
2332
s2255_release_sys_buffers(&dev->channel[i]);
2333
/* release transfer buffer */
2334
kfree(dev->pipe.transfer_buffer);
2338
static void read_pipe_completion(struct urb *purb)
2340
struct s2255_pipeinfo *pipe_info;
2341
struct s2255_dev *dev;
2344
pipe_info = purb->context;
2345
dprintk(100, "%s: urb:%p, status %d\n", __func__, purb,
2347
if (pipe_info == NULL) {
2348
dev_err(&purb->dev->dev, "no context!\n");
2352
dev = pipe_info->dev;
2354
dev_err(&purb->dev->dev, "no context!\n");
2357
status = purb->status;
2358
/* if shutting down, do not resubmit, exit immediately */
2359
if (status == -ESHUTDOWN) {
2360
dprintk(2, "%s: err shutdown\n", __func__);
2361
pipe_info->err_count++;
2365
if (pipe_info->state == 0) {
2366
dprintk(2, "%s: exiting USB pipe", __func__);
2371
s2255_read_video_callback(dev, pipe_info);
2373
pipe_info->err_count++;
2374
dprintk(1, "%s: failed URB %d\n", __func__, status);
2377
pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2379
usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2381
pipe_info->transfer_buffer,
2382
pipe_info->cur_transfer_size,
2383
read_pipe_completion, pipe_info);
2385
if (pipe_info->state != 0) {
2386
if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC)) {
2387
dev_err(&dev->udev->dev, "error submitting urb\n");
2390
dprintk(2, "%s :complete state 0\n", __func__);
2395
static int s2255_start_readpipe(struct s2255_dev *dev)
2399
struct s2255_pipeinfo *pipe_info = &dev->pipe;
2400
pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2401
dprintk(2, "%s: IN %d\n", __func__, dev->read_endpoint);
2402
pipe_info->state = 1;
2403
pipe_info->err_count = 0;
2404
pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2405
if (!pipe_info->stream_urb) {
2406
dev_err(&dev->udev->dev,
2407
"ReadStream: Unable to alloc URB\n");
2410
/* transfer buffer allocated in board_init */
2411
usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2413
pipe_info->transfer_buffer,
2414
pipe_info->cur_transfer_size,
2415
read_pipe_completion, pipe_info);
2416
retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2418
printk(KERN_ERR "s2255: start read pipe failed\n");
2424
/* starts acquisition process */
2425
static int s2255_start_acquire(struct s2255_channel *channel)
2427
unsigned char *buffer;
2429
unsigned long chn_rev;
2431
struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
2432
chn_rev = G_chnmap[channel->idx];
2433
buffer = kzalloc(512, GFP_KERNEL);
2434
if (buffer == NULL) {
2435
dev_err(&dev->udev->dev, "out of mem\n");
2439
channel->last_frame = -1;
2440
channel->bad_payload = 0;
2441
channel->cur_frame = 0;
2442
for (j = 0; j < SYS_FRAMES; j++) {
2443
channel->buffer.frame[j].ulState = 0;
2444
channel->buffer.frame[j].cur_size = 0;
2447
/* send the start command */
2448
*(__le32 *) buffer = IN_DATA_TOKEN;
2449
*((__le32 *) buffer + 1) = (__le32) cpu_to_le32(chn_rev);
2450
*((__le32 *) buffer + 2) = CMD_START;
2451
res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2453
dev_err(&dev->udev->dev, "CMD_START error\n");
2455
dprintk(2, "start acquire exit[%d] %d \n", channel->idx, res);
2460
static int s2255_stop_acquire(struct s2255_channel *channel)
2462
unsigned char *buffer;
2464
unsigned long chn_rev;
2465
struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
2466
chn_rev = G_chnmap[channel->idx];
2467
buffer = kzalloc(512, GFP_KERNEL);
2468
if (buffer == NULL) {
2469
dev_err(&dev->udev->dev, "out of mem\n");
2472
/* send the stop command */
2473
*(__le32 *) buffer = IN_DATA_TOKEN;
2474
*((__le32 *) buffer + 1) = (__le32) cpu_to_le32(chn_rev);
2475
*((__le32 *) buffer + 2) = CMD_STOP;
2476
res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2478
dev_err(&dev->udev->dev, "CMD_STOP error\n");
2480
channel->b_acquire = 0;
2481
dprintk(4, "%s: chn %d, res %d\n", __func__, channel->idx, res);
2485
static void s2255_stop_readpipe(struct s2255_dev *dev)
2487
struct s2255_pipeinfo *pipe = &dev->pipe;
2490
if (pipe->stream_urb) {
2492
usb_kill_urb(pipe->stream_urb);
2493
usb_free_urb(pipe->stream_urb);
2494
pipe->stream_urb = NULL;
2496
dprintk(4, "%s", __func__);
2500
static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2503
s2255_reset_dsppower(dev);
2504
dev->fw_data->fw_size = dev->fw_data->fw->size;
2505
atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2506
memcpy(dev->fw_data->pfw_data,
2507
dev->fw_data->fw->data, CHUNK_SIZE);
2508
dev->fw_data->fw_loaded = CHUNK_SIZE;
2509
usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2510
usb_sndbulkpipe(dev->udev, 2),
2511
dev->fw_data->pfw_data,
2512
CHUNK_SIZE, s2255_fwchunk_complete,
2514
mod_timer(&dev->timer, jiffies + HZ);
2517
/* standard usb probe function */
2518
static int s2255_probe(struct usb_interface *interface,
2519
const struct usb_device_id *id)
2521
struct s2255_dev *dev = NULL;
2522
struct usb_host_interface *iface_desc;
2523
struct usb_endpoint_descriptor *endpoint;
2525
int retval = -ENOMEM;
2528
dprintk(2, "%s\n", __func__);
2529
/* allocate memory for our device state and initialize it to zero */
2530
dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2532
s2255_dev_err(&interface->dev, "out of memory\n");
2535
atomic_set(&dev->num_channels, 0);
2536
dev->pid = id->idProduct;
2537
dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2540
mutex_init(&dev->lock);
2541
mutex_init(&dev->open_lock);
2542
/* grab usb_device and save it */
2543
dev->udev = usb_get_dev(interface_to_usbdev(interface));
2544
if (dev->udev == NULL) {
2545
dev_err(&interface->dev, "null usb device\n");
2549
dprintk(1, "dev: %p, udev %p interface %p\n", dev,
2550
dev->udev, interface);
2551
dev->interface = interface;
2552
/* set up the endpoint information */
2553
iface_desc = interface->cur_altsetting;
2554
dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2555
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2556
endpoint = &iface_desc->endpoint[i].desc;
2557
if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2558
/* we found the bulk in endpoint */
2559
dev->read_endpoint = endpoint->bEndpointAddress;
2563
if (!dev->read_endpoint) {
2564
dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2567
init_timer(&dev->timer);
2568
dev->timer.function = s2255_timer;
2569
dev->timer.data = (unsigned long)dev->fw_data;
2570
init_waitqueue_head(&dev->fw_data->wait_fw);
2571
for (i = 0; i < MAX_CHANNELS; i++) {
2572
struct s2255_channel *channel = &dev->channel[i];
2573
dev->channel[i].idx = i;
2574
init_waitqueue_head(&channel->wait_setmode);
2575
init_waitqueue_head(&channel->wait_vidstatus);
2578
dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2579
if (!dev->fw_data->fw_urb) {
2580
dev_err(&interface->dev, "out of memory!\n");
2584
dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2585
if (!dev->fw_data->pfw_data) {
2586
dev_err(&interface->dev, "out of memory!\n");
2589
/* load the first chunk */
2590
if (request_firmware(&dev->fw_data->fw,
2591
FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2592
printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2595
/* check the firmware is valid */
2596
fw_size = dev->fw_data->fw->size;
2597
pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2599
if (*pdata != S2255_FW_MARKER) {
2600
printk(KERN_INFO "Firmware invalid.\n");
2604
/* make sure firmware is the latest */
2606
pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2607
printk(KERN_INFO "s2255 dsp fw version %x\n", *pRel);
2608
dev->dsp_fw_ver = *pRel;
2609
if (*pRel < S2255_CUR_DSP_FWVER)
2610
printk(KERN_INFO "s2255: f2255usb.bin out of date.\n");
2611
if (dev->pid == 0x2257 && *pRel < S2255_MIN_DSP_COLORFILTER)
2612
printk(KERN_WARNING "s2255: 2257 requires firmware %d"
2613
" or above.\n", S2255_MIN_DSP_COLORFILTER);
2615
usb_reset_device(dev->udev);
2616
/* load 2255 board specific */
2617
retval = s2255_board_init(dev);
2619
goto errorBOARDINIT;
2620
spin_lock_init(&dev->slock);
2621
s2255_fwload_start(dev, 0);
2622
/* loads v4l specific */
2623
retval = s2255_probe_v4l(dev);
2625
goto errorBOARDINIT;
2626
dev_info(&interface->dev, "Sensoray 2255 detected\n");
2629
s2255_board_shutdown(dev);
2631
release_firmware(dev->fw_data->fw);
2633
kfree(dev->fw_data->pfw_data);
2635
usb_free_urb(dev->fw_data->fw_urb);
2637
del_timer(&dev->timer);
2639
usb_put_dev(dev->udev);
2641
kfree(dev->fw_data);
2642
mutex_destroy(&dev->open_lock);
2643
mutex_destroy(&dev->lock);
2646
printk(KERN_WARNING "Sensoray 2255 driver load failed: 0x%x\n", retval);
2650
/* disconnect routine. when board is removed physically or with rmmod */
2651
static void s2255_disconnect(struct usb_interface *interface)
2653
struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2655
int channels = atomic_read(&dev->num_channels);
2656
mutex_lock(&dev->lock);
2657
v4l2_device_disconnect(&dev->v4l2_dev);
2658
mutex_unlock(&dev->lock);
2659
/*see comments in the uvc_driver.c usb disconnect function */
2660
atomic_inc(&dev->num_channels);
2661
/* unregister each video device. */
2662
for (i = 0; i < channels; i++)
2663
video_unregister_device(&dev->channel[i].vdev);
2664
/* wake up any of our timers */
2665
atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2666
wake_up(&dev->fw_data->wait_fw);
2667
for (i = 0; i < MAX_CHANNELS; i++) {
2668
dev->channel[i].setmode_ready = 1;
2669
wake_up(&dev->channel[i].wait_setmode);
2670
dev->channel[i].vidstatus_ready = 1;
2671
wake_up(&dev->channel[i].wait_vidstatus);
2673
if (atomic_dec_and_test(&dev->num_channels))
2675
dev_info(&interface->dev, "%s\n", __func__);
2678
static struct usb_driver s2255_driver = {
2679
.name = S2255_DRIVER_NAME,
2680
.probe = s2255_probe,
2681
.disconnect = s2255_disconnect,
2682
.id_table = s2255_table,
2685
static int __init usb_s2255_init(void)
2688
/* register this driver with the USB subsystem */
2689
result = usb_register(&s2255_driver);
2691
pr_err(KBUILD_MODNAME
2692
": usb_register failed. Error number %d\n", result);
2693
dprintk(2, "%s\n", __func__);
2697
static void __exit usb_s2255_exit(void)
2699
usb_deregister(&s2255_driver);
2702
module_init(usb_s2255_init);
2703
module_exit(usb_s2255_exit);
2705
MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2706
MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2707
MODULE_LICENSE("GPL");
2708
MODULE_VERSION(S2255_VERSION);