2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
4 * Copyright (C) 2007-2008 by Sensoray Company Inc.
7 * Some video buffer code based on vivi driver:
9 * Sensoray 2255 device supports 4 simultaneous channels.
10 * The channels are not "crossbar" inputs, they are physically
11 * attached to separate video decoders.
13 * Because of USB2.0 bandwidth limitations. There is only a
14 * certain amount of data which may be transferred at one time.
16 * Example maximum bandwidth utilization:
18 * -full size, color mode YUYV or YUV422P: 2 channels at once
20 * -full or half size Grey scale: all 4 channels at once
22 * -half size, color mode YUYV or YUV422P: all 4 channels at once
24 * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
26 * (TODO: Incorporate videodev2 frame rate(FR) enumeration,
27 * which is currently experimental.)
29 * This program is free software; you can redistribute it and/or modify
30 * it under the terms of the GNU General Public License as published by
31 * the Free Software Foundation; either version 2 of the License, or
32 * (at your option) any later version.
34 * This program is distributed in the hope that it will be useful,
35 * but WITHOUT ANY WARRANTY; without even the implied warranty of
36 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37 * GNU General Public License for more details.
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
44 #include <linux/module.h>
45 #include <linux/firmware.h>
46 #include <linux/kernel.h>
47 #include <linux/mutex.h>
48 #include <linux/videodev2.h>
49 #include <linux/version.h>
50 #include <media/videobuf-vmalloc.h>
51 #include <media/v4l2-common.h>
52 #include <media/v4l2-ioctl.h>
53 #include <linux/vmalloc.h>
54 #include <linux/usb.h>
56 #define FIRMWARE_FILE_NAME "f2255usb.bin"
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 400
70 /* maximum time to wait for firmware to load (ms) */
71 #define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
72 #define S2255_DEF_BUFS 16
73 #define MAX_CHANNELS 4
74 #define FRAME_MARKER 0x2255DA4AL
75 #define MAX_PIPE_USBBLOCK (40 * 1024)
76 #define DEFAULT_PIPE_USBBLOCK (16 * 1024)
77 #define MAX_CHANNELS 4
78 #define MAX_PIPE_BUFFERS 1
80 /* maximum size is PAL full size plus room for the marker header(s) */
81 #define SYS_FRAMES_MAXSIZE (720 * 288 * 2 * 2 + 4096)
82 #define DEF_USB_BLOCK (4096)
83 #define LINE_SZ_4CIFS_NTSC 640
84 #define LINE_SZ_2CIFS_NTSC 640
85 #define LINE_SZ_1CIFS_NTSC 320
86 #define LINE_SZ_4CIFS_PAL 704
87 #define LINE_SZ_2CIFS_PAL 704
88 #define LINE_SZ_1CIFS_PAL 352
89 #define NUM_LINES_4CIFS_NTSC 240
90 #define NUM_LINES_2CIFS_NTSC 240
91 #define NUM_LINES_1CIFS_NTSC 240
92 #define NUM_LINES_4CIFS_PAL 288
93 #define NUM_LINES_2CIFS_PAL 288
94 #define NUM_LINES_1CIFS_PAL 288
95 #define LINE_SZ_DEF 640
96 #define NUM_LINES_DEF 240
99 /* predefined settings */
100 #define FORMAT_NTSC 1
103 #define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
104 #define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
105 #define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
107 #define COLOR_YUVPL 1 /* YUV planar */
108 #define COLOR_YUVPK 2 /* YUV packed */
109 #define COLOR_Y8 4 /* monochrome */
111 /* frame decimation. Not implemented by V4L yet(experimental in V4L) */
112 #define FDEC_1 1 /* capture every frame. default */
113 #define FDEC_2 2 /* capture every 2nd frame */
114 #define FDEC_3 3 /* capture every 3rd frame */
115 #define FDEC_5 5 /* capture every 5th frame */
117 /*-------------------------------------------------------
118 * Default mode parameters.
119 *-------------------------------------------------------*/
120 #define DEF_SCALE SCALE_4CIFS
121 #define DEF_COLOR COLOR_YUVPL
122 #define DEF_FDEC FDEC_1
124 #define DEF_CONTRAST 0x5c
125 #define DEF_SATURATION 0x80
128 /* usb config commands */
129 #define IN_DATA_TOKEN 0x2255c0de
130 #define CMD_2255 0xc2255000
131 #define CMD_SET_MODE (CMD_2255 | 0x10)
132 #define CMD_START (CMD_2255 | 0x20)
133 #define CMD_STOP (CMD_2255 | 0x30)
134 #define CMD_STATUS (CMD_2255 | 0x40)
137 u32 format; /* input video format (NTSC, PAL) */
138 u32 scale; /* output video scale */
139 u32 color; /* output video color format */
140 u32 fdec; /* frame decimation */
141 u32 bright; /* brightness */
142 u32 contrast; /* contrast */
143 u32 saturation; /* saturation */
144 u32 hue; /* hue (NTSC only)*/
145 u32 single; /* capture 1 frame at a time (!=0), continuously (==0)*/
146 u32 usb_block; /* block size. should be 4096 of DEF_USB_BLOCK */
147 u32 restart; /* if DSP requires restart */
150 /* frame structure */
151 #define FRAME_STATE_UNUSED 0
152 #define FRAME_STATE_FILLING 1
153 #define FRAME_STATE_FULL 2
156 struct s2255_framei {
159 unsigned long ulState; /* ulState ==0 unused, 1 being filled, 2 full */
160 void *lpvbits; /* image data */
161 unsigned long cur_size; /* current data copied to it */
164 /* image buffer structure */
165 struct s2255_bufferi {
166 unsigned long dwFrames; /* number of frames in buffer */
167 struct s2255_framei frame[SYS_FRAMES]; /* array of FRAME structures */
170 #define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
171 DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
172 DEF_HUE, 0, DEF_USB_BLOCK, 0}
174 struct s2255_dmaqueue {
175 struct list_head active;
176 /* thread for acquisition */
177 struct task_struct *kthread;
179 struct s2255_dev *dev;
183 /* for firmware loading, fw_state */
184 #define S2255_FW_NOTLOADED 0
185 #define S2255_FW_LOADED_DSPWAIT 1
186 #define S2255_FW_SUCCESS 2
187 #define S2255_FW_FAILED 3
195 wait_queue_head_t wait_fw;
196 struct timer_list dsp_wait;
197 const struct firmware *fw;
200 struct s2255_pipeinfo {
201 u32 max_transfer_size;
202 u32 cur_transfer_size;
209 void *dev; /* back pointer to s2255_dev struct*/
216 struct s2255_fmt; /*forward declaration */
220 int users[MAX_CHANNELS];
222 struct mutex open_lock;
223 int resources[MAX_CHANNELS];
224 struct usb_device *udev;
225 struct usb_interface *interface;
228 struct s2255_dmaqueue vidq[MAX_CHANNELS];
229 struct video_device *vdev[MAX_CHANNELS];
230 struct list_head s2255_devlist;
231 struct timer_list timer;
232 struct s2255_fw *fw_data;
235 struct s2255_pipeinfo pipes[MAX_PIPE_BUFFERS];
236 struct s2255_bufferi buffer[MAX_CHANNELS];
237 struct s2255_mode mode[MAX_CHANNELS];
238 const struct s2255_fmt *cur_fmt[MAX_CHANNELS];
239 int cur_frame[MAX_CHANNELS];
240 int last_frame[MAX_CHANNELS];
241 u32 cc; /* current channel */
242 int b_acquire[MAX_CHANNELS];
243 unsigned long req_image_size[MAX_CHANNELS];
244 int bad_payload[MAX_CHANNELS];
245 unsigned long frame_count[MAX_CHANNELS];
250 #define to_s2255_dev(d) container_of(d, struct s2255_dev, kref)
258 /* buffer for one video frame */
259 struct s2255_buffer {
260 /* common v4l buffer stuff -- must be first */
261 struct videobuf_buffer vb;
262 const struct s2255_fmt *fmt;
266 struct s2255_dev *dev;
267 unsigned int resources;
268 const struct s2255_fmt *fmt;
271 struct videobuf_queue vb_vidq;
272 enum v4l2_buf_type type;
274 /* mode below is the desired mode.
275 mode in s2255_dev is the current mode that was last set */
276 struct s2255_mode mode;
280 * TODO: fixme S2255_MAX_USERS. Do not limit open driver handles.
281 * Limit V4L to one stream at a time.
283 #define S2255_MAX_USERS 1
285 #define CUR_USB_FWVER 774 /* current cypress EEPROM firmware version */
286 #define S2255_MAJOR_VERSION 1
287 #define S2255_MINOR_VERSION 13
288 #define S2255_RELEASE 0
289 #define S2255_VERSION KERNEL_VERSION(S2255_MAJOR_VERSION, \
290 S2255_MINOR_VERSION, \
294 #define USB_S2255_VENDOR_ID 0x1943
295 #define USB_S2255_PRODUCT_ID 0x2255
296 #define S2255_NORMS (V4L2_STD_PAL | V4L2_STD_NTSC)
297 /* frame prefix size (sent once every frame) */
298 #define PREFIX_SIZE 512
300 /* Channels on box are in reverse order */
301 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
303 static LIST_HEAD(s2255_devlist);
306 static int *s2255_debug = &debug;
308 static int s2255_start_readpipe(struct s2255_dev *dev);
309 static void s2255_stop_readpipe(struct s2255_dev *dev);
310 static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn);
311 static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn);
312 static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
314 static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
315 struct s2255_mode *mode);
316 static int s2255_board_shutdown(struct s2255_dev *dev);
317 static void s2255_exit_v4l(struct s2255_dev *dev);
318 static void s2255_fwload_start(struct s2255_dev *dev);
320 #define dprintk(level, fmt, arg...) \
322 if (*s2255_debug >= (level)) { \
323 printk(KERN_DEBUG "s2255: " fmt, ##arg); \
328 static struct usb_driver s2255_driver;
331 /* Declare static vars that will be used as parameters */
332 static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
334 /* start video number */
335 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
337 module_param(debug, int, 0644);
338 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
339 module_param(vid_limit, int, 0644);
340 MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)");
341 module_param(video_nr, int, 0644);
342 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
344 /* USB device table */
345 static struct usb_device_id s2255_table[] = {
346 {USB_DEVICE(USB_S2255_VENDOR_ID, USB_S2255_PRODUCT_ID)},
347 { } /* Terminating entry */
349 MODULE_DEVICE_TABLE(usb, s2255_table);
352 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
354 /* supported controls */
355 static struct v4l2_queryctrl s2255_qctrl[] = {
357 .id = V4L2_CID_BRIGHTNESS,
358 .type = V4L2_CTRL_TYPE_INTEGER,
359 .name = "Brightness",
366 .id = V4L2_CID_CONTRAST,
367 .type = V4L2_CTRL_TYPE_INTEGER,
372 .default_value = DEF_CONTRAST,
375 .id = V4L2_CID_SATURATION,
376 .type = V4L2_CTRL_TYPE_INTEGER,
377 .name = "Saturation",
381 .default_value = DEF_SATURATION,
385 .type = V4L2_CTRL_TYPE_INTEGER,
390 .default_value = DEF_HUE,
395 static int qctl_regs[ARRAY_SIZE(s2255_qctrl)];
398 static const struct s2255_fmt formats[] = {
400 .name = "4:2:2, planar, YUV422P",
401 .fourcc = V4L2_PIX_FMT_YUV422P,
405 .name = "4:2:2, packed, YUYV",
406 .fourcc = V4L2_PIX_FMT_YUYV,
410 .name = "4:2:2, packed, UYVY",
411 .fourcc = V4L2_PIX_FMT_UYVY,
415 .fourcc = V4L2_PIX_FMT_GREY,
420 static int norm_maxw(struct video_device *vdev)
422 return (vdev->current_norm & V4L2_STD_NTSC) ?
423 LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
426 static int norm_maxh(struct video_device *vdev)
428 return (vdev->current_norm & V4L2_STD_NTSC) ?
429 (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
432 static int norm_minw(struct video_device *vdev)
434 return (vdev->current_norm & V4L2_STD_NTSC) ?
435 LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
438 static int norm_minh(struct video_device *vdev)
440 return (vdev->current_norm & V4L2_STD_NTSC) ?
441 (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
446 * TODO: fixme: move YUV reordering to hardware
447 * converts 2255 planar format to yuyv or uyvy
449 static void planar422p_to_yuv_packed(const unsigned char *in,
451 int width, int height,
457 unsigned long size = height * width;
459 pY = (unsigned char *)in;
460 pCr = (unsigned char *)in + height * width;
461 pCb = (unsigned char *)in + height * width + (height * width / 2);
462 for (i = 0; i < size * 2; i += 4) {
463 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
464 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
465 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
466 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
472 /* kickstarts the firmware loading. from probe
474 static void s2255_timer(unsigned long user_data)
476 struct s2255_fw *data = (struct s2255_fw *)user_data;
477 dprintk(100, "s2255 timer\n");
478 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
479 printk(KERN_ERR "s2255: can't submit urb\n");
481 release_firmware(data->fw);
488 /* called when DSP is up and running. DSP is guaranteed to
489 be running after S2255_DSP_BOOTTIME */
490 static void s2255_dsp_running(unsigned long user_data)
492 struct s2255_fw *data = (struct s2255_fw *)user_data;
493 dprintk(1, "dsp running\n");
494 atomic_set(&data->fw_state, S2255_FW_SUCCESS);
495 wake_up(&data->wait_fw);
496 printk(KERN_INFO "s2255: firmware loaded successfully\n");
501 /* this loads the firmware asynchronously.
502 Originally this was done synchroously in probe.
503 But it is better to load it asynchronously here than block
504 inside the probe function. Blocking inside probe affects boot time.
505 FW loading is triggered by the timer in the probe function
507 static void s2255_fwchunk_complete(struct urb *urb)
509 struct s2255_fw *data = urb->context;
510 struct usb_device *udev = urb->dev;
512 dprintk(100, "udev %p urb %p", udev, urb);
513 /* TODO: fixme. reflect change in status */
515 dev_err(&udev->dev, "URB failed with status %d", urb->status);
518 if (data->fw_urb == NULL) {
519 dev_err(&udev->dev, "early disconncect\n");
522 #define CHUNK_SIZE 512
523 /* all USB transfers must be done with continuous kernel memory.
524 can't allocate more than 128k in current linux kernel, so
525 upload the firmware in chunks
527 if (data->fw_loaded < data->fw_size) {
528 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
529 data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
531 if (len < CHUNK_SIZE)
532 memset(data->pfw_data, 0, CHUNK_SIZE);
534 dprintk(100, "completed len %d, loaded %d \n", len,
537 memcpy(data->pfw_data,
538 (char *) data->fw->data + data->fw_loaded, len);
540 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
541 data->pfw_data, CHUNK_SIZE,
542 s2255_fwchunk_complete, data);
543 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
544 dev_err(&udev->dev, "failed submit URB\n");
545 atomic_set(&data->fw_state, S2255_FW_FAILED);
546 /* wake up anything waiting for the firmware */
547 wake_up(&data->wait_fw);
550 data->fw_loaded += len;
552 init_timer(&data->dsp_wait);
553 data->dsp_wait.function = s2255_dsp_running;
554 data->dsp_wait.data = (unsigned long)data;
555 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
556 mod_timer(&data->dsp_wait, msecs_to_jiffies(S2255_DSP_BOOTTIME)
559 dprintk(100, "2255 complete done\n");
564 static int s2255_got_frame(struct s2255_dev *dev, int chn)
566 struct s2255_dmaqueue *dma_q = &dev->vidq[chn];
567 struct s2255_buffer *buf;
568 unsigned long flags = 0;
570 dprintk(2, "wakeup: %p channel: %d\n", &dma_q, chn);
571 spin_lock_irqsave(&dev->slock, flags);
573 if (list_empty(&dma_q->active)) {
574 dprintk(1, "No active queue to serve\n");
578 buf = list_entry(dma_q->active.next,
579 struct s2255_buffer, vb.queue);
581 if (!waitqueue_active(&buf->vb.done)) {
586 list_del(&buf->vb.queue);
587 do_gettimeofday(&buf->vb.ts);
588 dprintk(100, "[%p/%d] wakeup\n", buf, buf->vb.i);
590 s2255_fillbuff(dev, buf, dma_q->channel);
591 wake_up(&buf->vb.done);
592 dprintk(2, "wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
594 spin_unlock_irqrestore(&dev->slock, flags);
599 static const struct s2255_fmt *format_by_fourcc(int fourcc)
603 for (i = 0; i < ARRAY_SIZE(formats); i++) {
604 if (-1 == formats[i].fourcc)
606 if (formats[i].fourcc == fourcc)
615 /* video buffer vmalloc implementation based partly on VIVI driver which is
616 * Copyright (c) 2006 by
617 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
618 * Ted Walther <ted--a.t--enumera.com>
619 * John Sokol <sokol--a.t--videotechnology.com>
620 * http://v4l.videotechnology.com/
623 static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
629 char *vbuf = videobuf_to_vmalloc(&buf->vb);
630 unsigned long last_frame;
631 struct s2255_framei *frm;
636 last_frame = dev->last_frame[chn];
637 if (last_frame != -1) {
638 frm = &dev->buffer[chn].frame[last_frame];
640 (const char *)dev->buffer[chn].frame[last_frame].lpvbits;
641 switch (buf->fmt->fourcc) {
642 case V4L2_PIX_FMT_YUYV:
643 case V4L2_PIX_FMT_UYVY:
644 planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
649 case V4L2_PIX_FMT_GREY:
650 memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
652 case V4L2_PIX_FMT_YUV422P:
654 buf->vb.width * buf->vb.height * 2);
657 printk(KERN_DEBUG "s2255: unknown format?\n");
659 dev->last_frame[chn] = -1;
660 /* done with the frame, free it */
662 dprintk(4, "freeing buffer\n");
664 printk(KERN_ERR "s2255: =======no frame\n");
668 dprintk(2, "s2255fill at : Buffer 0x%08lx size= %d\n",
669 (unsigned long)vbuf, pos);
670 /* tell v4l buffer was filled */
672 buf->vb.field_count++;
673 do_gettimeofday(&ts);
675 buf->vb.state = VIDEOBUF_DONE;
679 /* ------------------------------------------------------------------
681 ------------------------------------------------------------------*/
683 static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
686 struct s2255_fh *fh = vq->priv_data;
688 *size = fh->width * fh->height * (fh->fmt->depth >> 3);
691 *count = S2255_DEF_BUFS;
693 while (*size * (*count) > vid_limit * 1024 * 1024)
699 static void free_buffer(struct videobuf_queue *vq, struct s2255_buffer *buf)
701 dprintk(4, "%s\n", __func__);
703 videobuf_waiton(&buf->vb, 0, 0);
704 videobuf_vmalloc_free(&buf->vb);
705 buf->vb.state = VIDEOBUF_NEEDS_INIT;
708 static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
709 enum v4l2_field field)
711 struct s2255_fh *fh = vq->priv_data;
712 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
714 dprintk(4, "%s, field=%d\n", __func__, field);
718 if ((fh->width < norm_minw(fh->dev->vdev[fh->channel])) ||
719 (fh->width > norm_maxw(fh->dev->vdev[fh->channel])) ||
720 (fh->height < norm_minh(fh->dev->vdev[fh->channel])) ||
721 (fh->height > norm_maxh(fh->dev->vdev[fh->channel]))) {
722 dprintk(4, "invalid buffer prepare\n");
726 buf->vb.size = fh->width * fh->height * (fh->fmt->depth >> 3);
728 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
729 dprintk(4, "invalid buffer prepare\n");
734 buf->vb.width = fh->width;
735 buf->vb.height = fh->height;
736 buf->vb.field = field;
739 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
740 rc = videobuf_iolock(vq, &buf->vb, NULL);
745 buf->vb.state = VIDEOBUF_PREPARED;
748 free_buffer(vq, buf);
752 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
754 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
755 struct s2255_fh *fh = vq->priv_data;
756 struct s2255_dev *dev = fh->dev;
757 struct s2255_dmaqueue *vidq = &dev->vidq[fh->channel];
759 dprintk(1, "%s\n", __func__);
761 buf->vb.state = VIDEOBUF_QUEUED;
762 list_add_tail(&buf->vb.queue, &vidq->active);
765 static void buffer_release(struct videobuf_queue *vq,
766 struct videobuf_buffer *vb)
768 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
769 struct s2255_fh *fh = vq->priv_data;
770 dprintk(4, "%s %d\n", __func__, fh->channel);
771 free_buffer(vq, buf);
774 static struct videobuf_queue_ops s2255_video_qops = {
775 .buf_setup = buffer_setup,
776 .buf_prepare = buffer_prepare,
777 .buf_queue = buffer_queue,
778 .buf_release = buffer_release,
782 static int res_get(struct s2255_dev *dev, struct s2255_fh *fh)
785 mutex_lock(&dev->lock);
786 if (dev->resources[fh->channel]) {
787 /* no, someone else uses it */
788 mutex_unlock(&dev->lock);
791 /* it's free, grab it */
792 dev->resources[fh->channel] = 1;
793 dprintk(1, "res: get\n");
794 mutex_unlock(&dev->lock);
798 static int res_locked(struct s2255_dev *dev, struct s2255_fh *fh)
800 return dev->resources[fh->channel];
803 static void res_free(struct s2255_dev *dev, struct s2255_fh *fh)
805 dev->resources[fh->channel] = 0;
806 dprintk(1, "res: put\n");
810 static int vidioc_querycap(struct file *file, void *priv,
811 struct v4l2_capability *cap)
813 struct s2255_fh *fh = file->private_data;
814 struct s2255_dev *dev = fh->dev;
815 strlcpy(cap->driver, "s2255", sizeof(cap->driver));
816 strlcpy(cap->card, "s2255", sizeof(cap->card));
817 strlcpy(cap->bus_info, dev_name(&dev->udev->dev),
818 sizeof(cap->bus_info));
819 cap->version = S2255_VERSION;
820 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
824 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
825 struct v4l2_fmtdesc *f)
831 if (index >= ARRAY_SIZE(formats))
834 dprintk(4, "name %s\n", formats[index].name);
835 strlcpy(f->description, formats[index].name, sizeof(f->description));
836 f->pixelformat = formats[index].fourcc;
840 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
841 struct v4l2_format *f)
843 struct s2255_fh *fh = priv;
845 f->fmt.pix.width = fh->width;
846 f->fmt.pix.height = fh->height;
847 f->fmt.pix.field = fh->vb_vidq.field;
848 f->fmt.pix.pixelformat = fh->fmt->fourcc;
849 f->fmt.pix.bytesperline = f->fmt.pix.width * (fh->fmt->depth >> 3);
850 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
854 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
855 struct v4l2_format *f)
857 const struct s2255_fmt *fmt;
858 enum v4l2_field field;
860 struct s2255_fh *fh = priv;
861 struct s2255_dev *dev = fh->dev;
865 (dev->vdev[fh->channel]->current_norm & V4L2_STD_NTSC) ? 1 : 0;
867 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
872 field = f->fmt.pix.field;
873 if (field == V4L2_FIELD_ANY)
876 dprintk(4, "try format %d \n", is_ntsc);
877 /* supports 3 sizes. see s2255drv.h */
878 dprintk(50, "width test %d, height %d\n",
879 f->fmt.pix.width, f->fmt.pix.height);
882 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
883 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
885 field = V4L2_FIELD_SEQ_TB;
886 } else if (!((field == V4L2_FIELD_INTERLACED) ||
887 (field == V4L2_FIELD_SEQ_TB) ||
888 (field == V4L2_FIELD_INTERLACED_TB))) {
889 dprintk(1, "unsupported field setting\n");
893 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
895 field = V4L2_FIELD_TOP;
896 } else if (!((field == V4L2_FIELD_TOP) ||
897 (field == V4L2_FIELD_BOTTOM))) {
898 dprintk(1, "unsupported field setting\n");
903 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
904 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
905 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
906 f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
907 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
908 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
910 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
913 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
914 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
916 field = V4L2_FIELD_SEQ_TB;
917 } else if (!((field == V4L2_FIELD_INTERLACED) ||
918 (field == V4L2_FIELD_SEQ_TB) ||
919 (field == V4L2_FIELD_INTERLACED_TB))) {
920 dprintk(1, "unsupported field setting\n");
924 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
926 field = V4L2_FIELD_TOP;
927 } else if (!((field == V4L2_FIELD_TOP) ||
928 (field == V4L2_FIELD_BOTTOM))) {
929 dprintk(1, "unsupported field setting\n");
933 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) {
934 dprintk(50, "pal 704\n");
935 f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
936 field = V4L2_FIELD_SEQ_TB;
937 } else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL) {
938 dprintk(50, "pal 352A\n");
939 f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
940 field = V4L2_FIELD_TOP;
941 } else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL) {
942 dprintk(50, "pal 352B\n");
943 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
944 field = V4L2_FIELD_TOP;
946 dprintk(50, "pal 352C\n");
947 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
948 field = V4L2_FIELD_TOP;
952 dprintk(50, "width %d height %d field %d \n", f->fmt.pix.width,
953 f->fmt.pix.height, f->fmt.pix.field);
954 f->fmt.pix.field = field;
955 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
956 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
960 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
961 struct v4l2_format *f)
963 struct s2255_fh *fh = priv;
964 const struct s2255_fmt *fmt;
965 struct videobuf_queue *q = &fh->vb_vidq;
969 ret = vidioc_try_fmt_vid_cap(file, fh, f);
974 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
979 mutex_lock(&q->vb_lock);
981 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
982 dprintk(1, "queue busy\n");
987 if (res_locked(fh->dev, fh)) {
988 dprintk(1, "can't change format after started\n");
994 fh->width = f->fmt.pix.width;
995 fh->height = f->fmt.pix.height;
996 fh->vb_vidq.field = f->fmt.pix.field;
998 norm = norm_minw(fh->dev->vdev[fh->channel]);
999 if (fh->width > norm_minw(fh->dev->vdev[fh->channel])) {
1000 if (fh->height > norm_minh(fh->dev->vdev[fh->channel]))
1001 fh->mode.scale = SCALE_4CIFS;
1003 fh->mode.scale = SCALE_2CIFS;
1006 fh->mode.scale = SCALE_1CIFS;
1010 switch (fh->fmt->fourcc) {
1011 case V4L2_PIX_FMT_GREY:
1012 fh->mode.color = COLOR_Y8;
1014 case V4L2_PIX_FMT_YUV422P:
1015 fh->mode.color = COLOR_YUVPL;
1017 case V4L2_PIX_FMT_YUYV:
1018 case V4L2_PIX_FMT_UYVY:
1020 fh->mode.color = COLOR_YUVPK;
1025 mutex_unlock(&q->vb_lock);
1029 static int vidioc_reqbufs(struct file *file, void *priv,
1030 struct v4l2_requestbuffers *p)
1033 struct s2255_fh *fh = priv;
1034 rc = videobuf_reqbufs(&fh->vb_vidq, p);
1038 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1041 struct s2255_fh *fh = priv;
1042 rc = videobuf_querybuf(&fh->vb_vidq, p);
1046 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1049 struct s2255_fh *fh = priv;
1050 rc = videobuf_qbuf(&fh->vb_vidq, p);
1054 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1057 struct s2255_fh *fh = priv;
1058 rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
1062 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1063 static int vidioc_cgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1065 struct s2255_fh *fh = priv;
1067 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1071 /* write to the configuration pipe, synchronously */
1072 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1079 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
1080 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
1085 static u32 get_transfer_size(struct s2255_mode *mode)
1087 int linesPerFrame = LINE_SZ_DEF;
1088 int pixelsPerLine = NUM_LINES_DEF;
1091 unsigned int mask_mult;
1096 if (mode->format == FORMAT_NTSC) {
1097 switch (mode->scale) {
1099 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
1100 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
1103 linesPerFrame = NUM_LINES_2CIFS_NTSC;
1104 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
1107 linesPerFrame = NUM_LINES_1CIFS_NTSC;
1108 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
1113 } else if (mode->format == FORMAT_PAL) {
1114 switch (mode->scale) {
1116 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
1117 pixelsPerLine = LINE_SZ_4CIFS_PAL;
1120 linesPerFrame = NUM_LINES_2CIFS_PAL;
1121 pixelsPerLine = LINE_SZ_2CIFS_PAL;
1124 linesPerFrame = NUM_LINES_1CIFS_PAL;
1125 pixelsPerLine = LINE_SZ_1CIFS_PAL;
1131 outImageSize = linesPerFrame * pixelsPerLine;
1132 if (mode->color != COLOR_Y8) {
1133 /* 2 bytes/pixel if not monochrome */
1137 /* total bytes to send including prefix and 4K padding;
1138 must be a multiple of USB_READ_SIZE */
1139 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
1140 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
1141 /* if size not a multiple of USB_READ_SIZE */
1142 if (usbInSize & ~mask_mult)
1143 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
1147 static void dump_verify_mode(struct s2255_dev *sdev, struct s2255_mode *mode)
1149 struct device *dev = &sdev->udev->dev;
1150 dev_info(dev, "------------------------------------------------\n");
1151 dev_info(dev, "verify mode\n");
1152 dev_info(dev, "format: %d\n", mode->format);
1153 dev_info(dev, "scale: %d\n", mode->scale);
1154 dev_info(dev, "fdec: %d\n", mode->fdec);
1155 dev_info(dev, "color: %d\n", mode->color);
1156 dev_info(dev, "bright: 0x%x\n", mode->bright);
1157 dev_info(dev, "restart: 0x%x\n", mode->restart);
1158 dev_info(dev, "usb_block: 0x%x\n", mode->usb_block);
1159 dev_info(dev, "single: 0x%x\n", mode->single);
1160 dev_info(dev, "------------------------------------------------\n");
1164 * set mode is the function which controls the DSP.
1165 * the restart parameter in struct s2255_mode should be set whenever
1166 * the image size could change via color format, video system or image
1168 * When the restart parameter is set, we sleep for ONE frame to allow the
1169 * DSP time to get the new frame
1171 static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
1172 struct s2255_mode *mode)
1176 unsigned long chn_rev;
1178 chn_rev = G_chnmap[chn];
1179 dprintk(3, "mode scale [%ld] %p %d\n", chn, mode, mode->scale);
1180 dprintk(3, "mode scale [%ld] %p %d\n", chn, &dev->mode[chn],
1181 dev->mode[chn].scale);
1182 dprintk(2, "mode contrast %x\n", mode->contrast);
1185 dev->mode[chn] = *mode;
1186 dev->req_image_size[chn] = get_transfer_size(mode);
1187 dprintk(1, "transfer size %ld\n", dev->req_image_size[chn]);
1189 buffer = kzalloc(512, GFP_KERNEL);
1190 if (buffer == NULL) {
1191 dev_err(&dev->udev->dev, "out of mem\n");
1196 buffer[0] = IN_DATA_TOKEN;
1197 buffer[1] = (u32) chn_rev;
1198 buffer[2] = CMD_SET_MODE;
1199 memcpy(&buffer[3], &dev->mode[chn], sizeof(struct s2255_mode));
1200 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1202 dump_verify_mode(dev, mode);
1204 dprintk(1, "set mode done chn %lu, %d\n", chn, res);
1206 /* wait at least 3 frames before continuing */
1210 /* clear the restart flag */
1211 dev->mode[chn].restart = 0;
1216 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1219 struct s2255_fh *fh = priv;
1220 struct s2255_dev *dev = fh->dev;
1221 struct s2255_mode *new_mode;
1222 struct s2255_mode *old_mode;
1225 dprintk(4, "%s\n", __func__);
1226 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1227 dev_err(&dev->udev->dev, "invalid fh type0\n");
1230 if (i != fh->type) {
1231 dev_err(&dev->udev->dev, "invalid fh type1\n");
1235 if (!res_get(dev, fh)) {
1236 dev_err(&dev->udev->dev, "res get busy\n");
1240 /* send a set mode command everytime with restart.
1241 in case we switch resolutions or other parameters */
1243 new_mode = &fh->mode;
1244 old_mode = &fh->dev->mode[chn];
1246 if (new_mode->color != old_mode->color)
1247 new_mode->restart = 1;
1248 else if (new_mode->scale != old_mode->scale)
1249 new_mode->restart = 1;
1250 else if (new_mode->format != old_mode->format)
1251 new_mode->restart = 1;
1253 s2255_set_mode(dev, chn, new_mode);
1254 new_mode->restart = 0;
1255 *old_mode = *new_mode;
1256 dev->cur_fmt[chn] = fh->fmt;
1257 dprintk(1, "%s[%d]\n", __func__, chn);
1258 dev->last_frame[chn] = -1;
1259 dev->bad_payload[chn] = 0;
1260 dev->cur_frame[chn] = 0;
1261 for (j = 0; j < SYS_FRAMES; j++) {
1262 dev->buffer[chn].frame[j].ulState = 0;
1263 dev->buffer[chn].frame[j].cur_size = 0;
1265 res = videobuf_streamon(&fh->vb_vidq);
1267 s2255_start_acquire(dev, chn);
1268 dev->b_acquire[chn] = 1;
1275 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1278 struct s2255_fh *fh = priv;
1279 struct s2255_dev *dev = fh->dev;
1281 dprintk(4, "%s\n, channel: %d", __func__, fh->channel);
1282 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1283 printk(KERN_ERR "invalid fh type0\n");
1286 if (i != fh->type) {
1287 printk(KERN_ERR "invalid type i\n");
1290 s2255_stop_acquire(dev, fh->channel);
1291 res = videobuf_streamoff(&fh->vb_vidq);
1296 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1298 struct s2255_fh *fh = priv;
1299 struct s2255_mode *mode;
1300 struct videobuf_queue *q = &fh->vb_vidq;
1303 mutex_lock(&q->vb_lock);
1304 if (videobuf_queue_is_busy(q)) {
1305 dprintk(1, "queue busy\n");
1310 if (res_locked(fh->dev, fh)) {
1311 dprintk(1, "can't change standard after started\n");
1317 if (*i & V4L2_STD_NTSC) {
1318 dprintk(4, "vidioc_s_std NTSC\n");
1319 mode->format = FORMAT_NTSC;
1320 } else if (*i & V4L2_STD_PAL) {
1321 dprintk(4, "vidioc_s_std PAL\n");
1322 mode->format = FORMAT_PAL;
1327 mutex_unlock(&q->vb_lock);
1331 /* Sensoray 2255 is a multiple channel capture device.
1332 It does not have a "crossbar" of inputs.
1333 We use one V4L device per channel. The user must
1334 be aware that certain combinations are not allowed.
1335 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1336 at once in color(you can do full fps on 4 channels with greyscale.
1338 static int vidioc_enum_input(struct file *file, void *priv,
1339 struct v4l2_input *inp)
1341 if (inp->index != 0)
1344 inp->type = V4L2_INPUT_TYPE_CAMERA;
1345 inp->std = S2255_NORMS;
1346 strlcpy(inp->name, "Camera", sizeof(inp->name));
1350 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1355 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1362 /* --- controls ---------------------------------------------- */
1363 static int vidioc_queryctrl(struct file *file, void *priv,
1364 struct v4l2_queryctrl *qc)
1368 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1369 if (qc->id && qc->id == s2255_qctrl[i].id) {
1370 memcpy(qc, &(s2255_qctrl[i]), sizeof(*qc));
1374 dprintk(4, "query_ctrl -EINVAL %d\n", qc->id);
1378 static int vidioc_g_ctrl(struct file *file, void *priv,
1379 struct v4l2_control *ctrl)
1383 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1384 if (ctrl->id == s2255_qctrl[i].id) {
1385 ctrl->value = qctl_regs[i];
1388 dprintk(4, "g_ctrl -EINVAL\n");
1393 static int vidioc_s_ctrl(struct file *file, void *priv,
1394 struct v4l2_control *ctrl)
1397 struct s2255_fh *fh = priv;
1398 struct s2255_dev *dev = fh->dev;
1399 struct s2255_mode *mode;
1401 dprintk(4, "vidioc_s_ctrl\n");
1402 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++) {
1403 if (ctrl->id == s2255_qctrl[i].id) {
1404 if (ctrl->value < s2255_qctrl[i].minimum ||
1405 ctrl->value > s2255_qctrl[i].maximum)
1408 qctl_regs[i] = ctrl->value;
1409 /* update the mode to the corresponding value */
1411 case V4L2_CID_BRIGHTNESS:
1412 mode->bright = ctrl->value;
1414 case V4L2_CID_CONTRAST:
1415 mode->contrast = ctrl->value;
1418 mode->hue = ctrl->value;
1420 case V4L2_CID_SATURATION:
1421 mode->saturation = ctrl->value;
1425 /* set mode here. Note: stream does not need restarted.
1426 some V4L programs restart stream unnecessarily
1429 s2255_set_mode(dev, fh->channel, mode);
1436 static int s2255_open(struct inode *inode, struct file *file)
1438 int minor = iminor(inode);
1439 struct s2255_dev *h, *dev = NULL;
1440 struct s2255_fh *fh;
1441 struct list_head *list;
1442 enum v4l2_buf_type type = 0;
1444 int cur_channel = -1;
1445 dprintk(1, "s2255: open called (minor=%d)\n", minor);
1447 list_for_each(list, &s2255_devlist) {
1448 h = list_entry(list, struct s2255_dev, s2255_devlist);
1449 for (i = 0; i < MAX_CHANNELS; i++) {
1450 if (h->vdev[i]->minor == minor) {
1453 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1458 if ((NULL == dev) || (cur_channel == -1)) {
1459 dprintk(1, "s2255: openv4l no dev\n");
1463 mutex_lock(&dev->open_lock);
1465 dev->users[cur_channel]++;
1466 if (dev->users[cur_channel] > S2255_MAX_USERS) {
1467 dev->users[cur_channel]--;
1468 mutex_unlock(&dev->open_lock);
1469 printk(KERN_INFO "s2255drv: too many open handles!\n");
1473 if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_FAILED) {
1474 err("2255 firmware load failed. retrying.\n");
1475 s2255_fwload_start(dev);
1476 wait_event_timeout(dev->fw_data->wait_fw,
1477 (atomic_read(&dev->fw_data->fw_state)
1478 != S2255_FW_NOTLOADED),
1479 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1480 if (atomic_read(&dev->fw_data->fw_state)
1481 != S2255_FW_SUCCESS) {
1482 printk(KERN_INFO "2255 FW load failed after 2 tries\n");
1483 mutex_unlock(&dev->open_lock);
1486 } else if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_NOTLOADED) {
1487 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1488 driver loaded and then device immediately opened */
1489 printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1490 wait_event_timeout(dev->fw_data->wait_fw,
1491 (atomic_read(&dev->fw_data->fw_state)
1492 != S2255_FW_NOTLOADED),
1493 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1494 if (atomic_read(&dev->fw_data->fw_state)
1495 != S2255_FW_SUCCESS) {
1496 printk(KERN_INFO "2255 firmware not loaded"
1498 mutex_unlock(&dev->open_lock);
1503 /* allocate + initialize per filehandle data */
1504 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1506 mutex_unlock(&dev->open_lock);
1510 file->private_data = fh;
1512 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1513 fh->mode = dev->mode[cur_channel];
1514 fh->fmt = dev->cur_fmt[cur_channel];
1515 /* default 4CIF NTSC */
1516 fh->width = LINE_SZ_4CIFS_NTSC;
1517 fh->height = NUM_LINES_4CIFS_NTSC * 2;
1518 fh->channel = cur_channel;
1520 /* Put all controls at a sane state */
1521 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1522 qctl_regs[i] = s2255_qctrl[i].default_value;
1524 dprintk(1, "s2255drv: open minor=%d type=%s users=%d\n",
1525 minor, v4l2_type_names[type], dev->users[cur_channel]);
1526 dprintk(2, "s2255drv: open: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n",
1527 (unsigned long)fh, (unsigned long)dev,
1528 (unsigned long)&dev->vidq[cur_channel]);
1529 dprintk(4, "s2255drv: open: list_empty active=%d\n",
1530 list_empty(&dev->vidq[cur_channel].active));
1532 videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1535 V4L2_FIELD_INTERLACED,
1536 sizeof(struct s2255_buffer), fh);
1538 kref_get(&dev->kref);
1539 mutex_unlock(&dev->open_lock);
1544 static unsigned int s2255_poll(struct file *file,
1545 struct poll_table_struct *wait)
1547 struct s2255_fh *fh = file->private_data;
1549 dprintk(100, "%s\n", __func__);
1551 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1554 rc = videobuf_poll_stream(file, &fh->vb_vidq, wait);
1558 static void s2255_destroy(struct kref *kref)
1560 struct s2255_dev *dev = to_s2255_dev(kref);
1562 printk(KERN_ERR "s2255drv: kref problem\n");
1565 /* prevent s2255_disconnect from racing s2255_open */
1566 mutex_lock(&dev->open_lock);
1567 s2255_exit_v4l(dev);
1568 /* device unregistered so no longer possible to open. open_mutex
1570 mutex_unlock(&dev->open_lock);
1572 /* board shutdown stops the read pipe if it is running */
1573 s2255_board_shutdown(dev);
1575 /* make sure firmware still not trying to load */
1576 if (dev->fw_data->fw_urb) {
1577 dprintk(2, "kill fw_urb\n");
1578 usb_kill_urb(dev->fw_data->fw_urb);
1579 usb_free_urb(dev->fw_data->fw_urb);
1580 dev->fw_data->fw_urb = NULL;
1583 * TODO: fixme(above, below): potentially leaving timers alive.
1584 * do not ignore timeout below if
1588 /* make sure we aren't waiting for the DSP */
1589 if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_LOADED_DSPWAIT) {
1590 /* if we are, wait for the wakeup for fw_success or timeout */
1591 wait_event_timeout(dev->fw_data->wait_fw,
1592 (atomic_read(&dev->fw_data->fw_state)
1593 == S2255_FW_SUCCESS),
1594 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1598 if (dev->fw_data->fw)
1599 release_firmware(dev->fw_data->fw);
1600 kfree(dev->fw_data->pfw_data);
1601 kfree(dev->fw_data);
1604 usb_put_dev(dev->udev);
1605 dprintk(1, "%s", __func__);
1609 static int s2255_close(struct inode *inode, struct file *file)
1611 struct s2255_fh *fh = file->private_data;
1612 struct s2255_dev *dev = fh->dev;
1613 int minor = iminor(inode);
1617 mutex_lock(&dev->open_lock);
1619 if (dev->b_acquire[fh->channel])
1620 s2255_stop_acquire(dev, fh->channel);
1622 videobuf_mmap_free(&fh->vb_vidq);
1624 dev->users[fh->channel]--;
1625 mutex_unlock(&dev->open_lock);
1627 kref_put(&dev->kref, s2255_destroy);
1628 dprintk(1, "s2255: close called (minor=%d, users=%d)\n",
1629 minor, dev->users[fh->channel]);
1633 static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1635 struct s2255_fh *fh = file->private_data;
1640 dprintk(4, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1642 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1644 dprintk(4, "vma start=0x%08lx, size=%ld, ret=%d\n",
1645 (unsigned long)vma->vm_start,
1646 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1651 static const struct file_operations s2255_fops_v4l = {
1652 .owner = THIS_MODULE,
1654 .release = s2255_close,
1656 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
1657 .compat_ioctl = v4l_compat_ioctl32,
1658 .mmap = s2255_mmap_v4l,
1659 .llseek = no_llseek,
1662 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1663 .vidioc_querycap = vidioc_querycap,
1664 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1665 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1666 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1667 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1668 .vidioc_reqbufs = vidioc_reqbufs,
1669 .vidioc_querybuf = vidioc_querybuf,
1670 .vidioc_qbuf = vidioc_qbuf,
1671 .vidioc_dqbuf = vidioc_dqbuf,
1672 .vidioc_s_std = vidioc_s_std,
1673 .vidioc_enum_input = vidioc_enum_input,
1674 .vidioc_g_input = vidioc_g_input,
1675 .vidioc_s_input = vidioc_s_input,
1676 .vidioc_queryctrl = vidioc_queryctrl,
1677 .vidioc_g_ctrl = vidioc_g_ctrl,
1678 .vidioc_s_ctrl = vidioc_s_ctrl,
1679 .vidioc_streamon = vidioc_streamon,
1680 .vidioc_streamoff = vidioc_streamoff,
1681 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1682 .vidiocgmbuf = vidioc_cgmbuf,
1686 static struct video_device template = {
1688 .type = VID_TYPE_CAPTURE,
1689 .fops = &s2255_fops_v4l,
1690 .ioctl_ops = &s2255_ioctl_ops,
1692 .release = video_device_release,
1693 .tvnorms = S2255_NORMS,
1694 .current_norm = V4L2_STD_NTSC_M,
1697 static int s2255_probe_v4l(struct s2255_dev *dev)
1701 int cur_nr = video_nr;
1703 /* initialize all video 4 linux */
1704 list_add_tail(&dev->s2255_devlist, &s2255_devlist);
1705 /* register 4 video devices */
1706 for (i = 0; i < MAX_CHANNELS; i++) {
1707 INIT_LIST_HEAD(&dev->vidq[i].active);
1708 dev->vidq[i].dev = dev;
1709 dev->vidq[i].channel = i;
1710 dev->vidq[i].kthread = NULL;
1711 /* register 4 video devices */
1712 dev->vdev[i] = video_device_alloc();
1713 memcpy(dev->vdev[i], &template, sizeof(struct video_device));
1714 dev->vdev[i]->parent = &dev->interface->dev;
1716 ret = video_register_device(dev->vdev[i],
1720 ret = video_register_device(dev->vdev[i],
1723 dev->vdev[i]->priv = dev;
1726 dev_err(&dev->udev->dev,
1727 "failed to register video device!\n");
1731 printk(KERN_INFO "Sensoray 2255 V4L driver\n");
1735 static void s2255_exit_v4l(struct s2255_dev *dev)
1737 struct list_head *list;
1739 /* unregister the video devices */
1740 while (!list_empty(&s2255_devlist)) {
1741 list = s2255_devlist.next;
1744 for (i = 0; i < MAX_CHANNELS; i++) {
1745 if (-1 != dev->vdev[i]->minor)
1746 video_unregister_device(dev->vdev[i]);
1748 video_device_release(dev->vdev[i]);
1752 /* this function moves the usb stream read pipe data
1753 * into the system buffers.
1754 * returns 0 on success, EAGAIN if more data to process( call this
1757 * Received frame structure:
1758 * bytes 0-3: marker : 0x2255DA4AL (FRAME_MARKER)
1759 * bytes 4-7: channel: 0-3
1760 * bytes 8-11: payload size: size of the frame
1761 * bytes 12-payloadsize+12: frame data
1763 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1765 static int dbgsync; /* = 0; */
1771 unsigned long copy_size;
1774 struct s2255_framei *frm;
1775 unsigned char *pdata;
1776 unsigned long cur_size;
1778 struct s2255_bufferi *buf;
1779 dprintk(100, "buffer to user\n");
1781 idx = dev->cur_frame[dev->cc];
1782 buf = &dev->buffer[dev->cc];
1783 frm = &buf->frame[idx];
1785 if (frm->ulState == 0) {
1789 } else if (frm->ulState == 2) {
1790 /* system frame was not freed */
1791 dprintk(2, "sys frame not free. overrun ringbuf\n");
1798 if (*(s32 *) pipe_info->transfer_buffer != FRAME_MARKER) {
1801 dprintk(3, "not synched, discarding all packets"
1806 pdata = (unsigned char *)pipe_info->transfer_buffer;
1807 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12);
1809 if (*(s32 *) pdata == FRAME_MARKER) {
1812 "found frame marker at offset:"
1813 " %d [%x %x]\n", jj, pdata[0],
1817 cc = *(u32 *) (pdata + sizeof(u32));
1818 if (cc >= MAX_CHANNELS) {
1824 dev->cc = G_chnmap[cc];
1837 pword = (u32 *) pipe_info->transfer_buffer;
1840 if (cc >= MAX_CHANNELS) {
1841 printk("invalid channel found. "
1842 "throwing out data!\n");
1845 dev->cc = G_chnmap[cc];
1847 if (payload != dev->req_image_size[dev->cc]) {
1848 dprintk(1, "[%d][%d]unexpected payload: %d"
1849 "required: %lu \n", cc, dev->cc,
1850 payload, dev->req_image_size[dev->cc]);
1851 dev->bad_payload[dev->cc]++;
1852 /* discard the bad frame */
1858 /* search done. now find out if should be acquiring
1860 if (!dev->b_acquire[dev->cc]) {
1865 idx = dev->cur_frame[dev->cc];
1866 frm = &dev->buffer[dev->cc].frame[idx];
1868 if (frm->ulState == 0) {
1871 } else if (frm->ulState == 2) {
1872 /* system frame ring buffer overrun */
1873 dprintk(2, "sys frame overrun. overwriting frame %d %d\n",
1880 /* skip the marker 512 bytes (and offset if out of sync) */
1881 psrc = (u8 *)pipe_info->transfer_buffer + offset + PREFIX_SIZE;
1883 psrc = (u8 *)pipe_info->transfer_buffer;
1886 if (frm->lpvbits == NULL) {
1887 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
1888 frm, dev, dev->cc, idx);
1892 pdest = frm->lpvbits + frm->cur_size;
1896 (pipe_info->cur_transfer_size - offset) - PREFIX_SIZE;
1897 if (copy_size > pipe_info->cur_transfer_size) {
1898 printk("invalid copy size, overflow!\n");
1902 copy_size = pipe_info->cur_transfer_size;
1905 cur_size = frm->cur_size;
1906 size = dev->req_image_size[dev->cc];
1908 if ((copy_size + cur_size) > size) {
1909 copy_size = size - cur_size;
1913 memcpy(pdest, psrc, copy_size);
1914 cur_size += copy_size;
1915 frm->cur_size += copy_size;
1916 dprintk(50, "cur_size size %lu size %lu \n", cur_size, size);
1918 if (cur_size >= (size - PREFIX_SIZE)) {
1921 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
1923 dev->last_frame[cc] = dev->cur_frame[cc];
1924 dev->cur_frame[cc]++;
1925 /* end of system frame ring buffer, start at zero */
1926 if ((dev->cur_frame[cc] == SYS_FRAMES) ||
1927 (dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
1928 dev->cur_frame[cc] = 0;
1930 /* signal the semaphore for this channel */
1931 if (dev->b_acquire[cc])
1932 s2255_got_frame(dev, cc);
1933 dev->frame_count[cc]++;
1935 /* frame was truncated */
1937 /* return more data to process */
1940 /* done successfully */
1944 static void s2255_read_video_callback(struct s2255_dev *dev,
1945 struct s2255_pipeinfo *pipe_info)
1948 dprintk(50, "callback read video \n");
1950 if (dev->cc >= MAX_CHANNELS) {
1952 dev_err(&dev->udev->dev, "invalid channel\n");
1955 /* otherwise copy to the system buffers */
1956 res = save_frame(dev, pipe_info);
1958 save_frame(dev, pipe_info);
1960 dprintk(50, "callback read video done\n");
1964 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1965 u16 Index, u16 Value, void *TransferBuffer,
1966 s32 TransferBufferLength, int bOut)
1970 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1972 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1974 Value, Index, TransferBuffer,
1975 TransferBufferLength, HZ * 5);
1977 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1978 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1979 Value, Index, TransferBuffer,
1980 TransferBufferLength, HZ * 5);
1986 * retrieve FX2 firmware version. future use.
1987 * @param dev pointer to device extension
1988 * @return -1 for fail, else returns firmware version as an int(16 bits)
1990 static int s2255_get_fx2fw(struct s2255_dev *dev)
1994 unsigned char transBuffer[64];
1995 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
1998 dprintk(2, "get fw error: %x\n", ret);
1999 fw = transBuffer[0] + (transBuffer[1] << 8);
2000 dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2005 * Create the system ring buffer to copy frames into from the
2008 static int s2255_create_sys_buffers(struct s2255_dev *dev, unsigned long chn)
2011 unsigned long reqsize;
2012 dprintk(1, "create sys buffers\n");
2013 if (chn >= MAX_CHANNELS)
2016 dev->buffer[chn].dwFrames = SYS_FRAMES;
2018 /* always allocate maximum size(PAL) for system buffers */
2019 reqsize = SYS_FRAMES_MAXSIZE;
2021 if (reqsize > SYS_FRAMES_MAXSIZE)
2022 reqsize = SYS_FRAMES_MAXSIZE;
2024 for (i = 0; i < SYS_FRAMES; i++) {
2025 /* allocate the frames */
2026 dev->buffer[chn].frame[i].lpvbits = vmalloc(reqsize);
2028 dprintk(1, "valloc %p chan %lu, idx %lu, pdata %p\n",
2029 &dev->buffer[chn].frame[i], chn, i,
2030 dev->buffer[chn].frame[i].lpvbits);
2031 dev->buffer[chn].frame[i].size = reqsize;
2032 if (dev->buffer[chn].frame[i].lpvbits == NULL) {
2033 printk(KERN_INFO "out of memory. using less frames\n");
2034 dev->buffer[chn].dwFrames = i;
2039 /* make sure internal states are set */
2040 for (i = 0; i < SYS_FRAMES; i++) {
2041 dev->buffer[chn].frame[i].ulState = 0;
2042 dev->buffer[chn].frame[i].cur_size = 0;
2045 dev->cur_frame[chn] = 0;
2046 dev->last_frame[chn] = -1;
2050 static int s2255_release_sys_buffers(struct s2255_dev *dev,
2051 unsigned long channel)
2054 dprintk(1, "release sys buffers\n");
2055 for (i = 0; i < SYS_FRAMES; i++) {
2056 if (dev->buffer[channel].frame[i].lpvbits) {
2057 dprintk(1, "vfree %p\n",
2058 dev->buffer[channel].frame[i].lpvbits);
2059 vfree(dev->buffer[channel].frame[i].lpvbits);
2061 dev->buffer[channel].frame[i].lpvbits = NULL;
2066 static int s2255_board_init(struct s2255_dev *dev)
2069 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2071 dprintk(4, "board init: %p", dev);
2073 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2074 struct s2255_pipeinfo *pipe = &dev->pipes[j];
2076 memset(pipe, 0, sizeof(*pipe));
2078 pipe->cur_transfer_size = DEFAULT_PIPE_USBBLOCK;
2079 pipe->max_transfer_size = MAX_PIPE_USBBLOCK;
2081 if (pipe->cur_transfer_size > pipe->max_transfer_size)
2082 pipe->cur_transfer_size = pipe->max_transfer_size;
2083 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2085 if (pipe->transfer_buffer == NULL) {
2086 dprintk(1, "out of memory!\n");
2092 /* query the firmware */
2093 fw_ver = s2255_get_fx2fw(dev);
2095 printk(KERN_INFO "2255 usb firmware version %d \n", fw_ver);
2096 if (fw_ver < CUR_USB_FWVER)
2097 err("usb firmware not up to date %d\n", fw_ver);
2099 for (j = 0; j < MAX_CHANNELS; j++) {
2100 dev->b_acquire[j] = 0;
2101 dev->mode[j] = mode_def;
2102 dev->cur_fmt[j] = &formats[0];
2103 dev->mode[j].restart = 1;
2104 dev->req_image_size[j] = get_transfer_size(&mode_def);
2105 dev->frame_count[j] = 0;
2106 /* create the system buffers */
2107 s2255_create_sys_buffers(dev, j);
2109 /* start read pipe */
2110 s2255_start_readpipe(dev);
2112 dprintk(1, "S2255: board initialized\n");
2116 static int s2255_board_shutdown(struct s2255_dev *dev)
2120 dprintk(1, "S2255: board shutdown: %p", dev);
2122 for (i = 0; i < MAX_CHANNELS; i++) {
2123 if (dev->b_acquire[i])
2124 s2255_stop_acquire(dev, i);
2127 s2255_stop_readpipe(dev);
2129 for (i = 0; i < MAX_CHANNELS; i++)
2130 s2255_release_sys_buffers(dev, i);
2132 /* release transfer buffers */
2133 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2134 struct s2255_pipeinfo *pipe = &dev->pipes[i];
2135 kfree(pipe->transfer_buffer);
2140 static void read_pipe_completion(struct urb *purb)
2142 struct s2255_pipeinfo *pipe_info;
2143 struct s2255_dev *dev;
2147 pipe_info = purb->context;
2148 dprintk(100, "read pipe completion %p, status %d\n", purb,
2150 if (pipe_info == NULL) {
2151 err("no context !");
2155 dev = pipe_info->dev;
2157 err("no context !");
2160 status = purb->status;
2162 dprintk(2, "read_pipe_completion: err\n");
2166 if (pipe_info->state == 0) {
2167 dprintk(2, "exiting USB pipe");
2171 s2255_read_video_callback(dev, pipe_info);
2173 pipe_info->err_count = 0;
2174 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2176 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2178 pipe_info->transfer_buffer,
2179 pipe_info->cur_transfer_size,
2180 read_pipe_completion, pipe_info);
2182 if (pipe_info->state != 0) {
2183 if (usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL)) {
2184 dev_err(&dev->udev->dev, "error submitting urb\n");
2185 usb_free_urb(pipe_info->stream_urb);
2188 dprintk(2, "read pipe complete state 0\n");
2193 static int s2255_start_readpipe(struct s2255_dev *dev)
2198 struct s2255_pipeinfo *pipe_info = dev->pipes;
2199 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2200 dprintk(2, "start pipe IN %d\n", dev->read_endpoint);
2202 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2203 pipe_info->state = 1;
2204 pipe_info->buf_index = (u32) i;
2205 pipe_info->priority_set = 0;
2206 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2207 if (!pipe_info->stream_urb) {
2208 dev_err(&dev->udev->dev,
2209 "ReadStream: Unable to alloc URB");
2212 /* transfer buffer allocated in board_init */
2213 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2215 pipe_info->transfer_buffer,
2216 pipe_info->cur_transfer_size,
2217 read_pipe_completion, pipe_info);
2219 pipe_info->urb_size = sizeof(pipe_info->stream_urb);
2220 dprintk(4, "submitting URB %p\n", pipe_info->stream_urb);
2221 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2223 printk(KERN_ERR "s2255: start read pipe failed\n");
2231 /* starts acquisition process */
2232 static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn)
2234 unsigned char *buffer;
2236 unsigned long chn_rev;
2238 if (chn >= MAX_CHANNELS) {
2239 dprintk(2, "start acquire failed, bad channel %lu\n", chn);
2243 chn_rev = G_chnmap[chn];
2244 dprintk(1, "S2255: start acquire %lu \n", chn);
2246 buffer = kzalloc(512, GFP_KERNEL);
2247 if (buffer == NULL) {
2248 dev_err(&dev->udev->dev, "out of mem\n");
2252 dev->last_frame[chn] = -1;
2253 dev->bad_payload[chn] = 0;
2254 dev->cur_frame[chn] = 0;
2255 for (j = 0; j < SYS_FRAMES; j++) {
2256 dev->buffer[chn].frame[j].ulState = 0;
2257 dev->buffer[chn].frame[j].cur_size = 0;
2260 /* send the start command */
2261 *(u32 *) buffer = IN_DATA_TOKEN;
2262 *((u32 *) buffer + 1) = (u32) chn_rev;
2263 *((u32 *) buffer + 2) = (u32) CMD_START;
2264 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2266 dev_err(&dev->udev->dev, "CMD_START error\n");
2268 dprintk(2, "start acquire exit[%lu] %d \n", chn, res);
2273 static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
2275 unsigned char *buffer;
2277 unsigned long chn_rev;
2279 if (chn >= MAX_CHANNELS) {
2280 dprintk(2, "stop acquire failed, bad channel %lu\n", chn);
2283 chn_rev = G_chnmap[chn];
2285 buffer = kzalloc(512, GFP_KERNEL);
2286 if (buffer == NULL) {
2287 dev_err(&dev->udev->dev, "out of mem\n");
2291 /* send the stop command */
2292 dprintk(4, "stop acquire %lu\n", chn);
2293 *(u32 *) buffer = IN_DATA_TOKEN;
2294 *((u32 *) buffer + 1) = (u32) chn_rev;
2295 *((u32 *) buffer + 2) = CMD_STOP;
2296 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2299 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2301 dprintk(4, "stop acquire: releasing states \n");
2304 dev->b_acquire[chn] = 0;
2309 static void s2255_stop_readpipe(struct s2255_dev *dev)
2314 err("s2255: invalid device");
2317 dprintk(4, "stop read pipe\n");
2318 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2319 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2321 if (pipe_info->state == 0)
2323 pipe_info->state = 0;
2324 pipe_info->prev_state = 1;
2329 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2330 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2331 if (pipe_info->stream_urb) {
2333 usb_kill_urb(pipe_info->stream_urb);
2334 usb_free_urb(pipe_info->stream_urb);
2335 pipe_info->stream_urb = NULL;
2338 dprintk(2, "s2255 stop read pipe: %d\n", j);
2342 static void s2255_fwload_start(struct s2255_dev *dev)
2344 dev->fw_data->fw_size = dev->fw_data->fw->size;
2345 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2346 memcpy(dev->fw_data->pfw_data,
2347 dev->fw_data->fw->data, CHUNK_SIZE);
2348 dev->fw_data->fw_loaded = CHUNK_SIZE;
2349 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2350 usb_sndbulkpipe(dev->udev, 2),
2351 dev->fw_data->pfw_data,
2352 CHUNK_SIZE, s2255_fwchunk_complete,
2354 mod_timer(&dev->timer, jiffies + HZ);
2357 /* standard usb probe function */
2358 static int s2255_probe(struct usb_interface *interface,
2359 const struct usb_device_id *id)
2361 struct s2255_dev *dev = NULL;
2362 struct usb_host_interface *iface_desc;
2363 struct usb_endpoint_descriptor *endpoint;
2365 int retval = -ENOMEM;
2367 dprintk(2, "s2255: probe\n");
2369 /* allocate memory for our device state and initialize it to zero */
2370 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2372 err("s2255: out of memory");
2376 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2380 mutex_init(&dev->lock);
2381 mutex_init(&dev->open_lock);
2383 /* grab usb_device and save it */
2384 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2385 if (dev->udev == NULL) {
2386 dev_err(&interface->dev, "null usb device\n");
2390 kref_init(&dev->kref);
2391 dprintk(1, "dev: %p, kref: %p udev %p interface %p\n", dev, &dev->kref,
2392 dev->udev, interface);
2393 dev->interface = interface;
2394 /* set up the endpoint information */
2395 iface_desc = interface->cur_altsetting;
2396 dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2397 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2398 endpoint = &iface_desc->endpoint[i].desc;
2399 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2400 /* we found the bulk in endpoint */
2401 dev->read_endpoint = endpoint->bEndpointAddress;
2405 if (!dev->read_endpoint) {
2406 dev_err(&interface->dev, "Could not find bulk-in endpoint");
2411 usb_set_intfdata(interface, dev);
2413 dprintk(100, "after intfdata %p\n", dev);
2415 init_timer(&dev->timer);
2416 dev->timer.function = s2255_timer;
2417 dev->timer.data = (unsigned long)dev->fw_data;
2419 init_waitqueue_head(&dev->fw_data->wait_fw);
2422 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2424 if (!dev->fw_data->fw_urb) {
2425 dev_err(&interface->dev, "out of memory!\n");
2428 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2429 if (!dev->fw_data->pfw_data) {
2430 dev_err(&interface->dev, "out of memory!\n");
2433 /* load the first chunk */
2434 if (request_firmware(&dev->fw_data->fw,
2435 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2436 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2440 /* loads v4l specific */
2441 s2255_probe_v4l(dev);
2442 /* load 2255 board specific */
2443 s2255_board_init(dev);
2445 dprintk(4, "before probe done %p\n", dev);
2446 spin_lock_init(&dev->slock);
2448 s2255_fwload_start(dev);
2449 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2455 /* disconnect routine. when board is removed physically or with rmmod */
2456 static void s2255_disconnect(struct usb_interface *interface)
2458 struct s2255_dev *dev = NULL;
2459 dprintk(1, "s2255: disconnect interface %p\n", interface);
2460 dev = usb_get_intfdata(interface);
2462 kref_put(&dev->kref, s2255_destroy);
2463 dprintk(1, "s2255drv: disconnect\n");
2464 dev_info(&interface->dev, "s2255usb now disconnected\n");
2466 usb_set_intfdata(interface, NULL);
2469 static struct usb_driver s2255_driver = {
2471 .probe = s2255_probe,
2472 .disconnect = s2255_disconnect,
2473 .id_table = s2255_table,
2476 static int __init usb_s2255_init(void)
2480 /* register this driver with the USB subsystem */
2481 result = usb_register(&s2255_driver);
2484 err("usb_register failed. Error number %d", result);
2486 dprintk(2, "s2255_init: done\n");
2490 static void __exit usb_s2255_exit(void)
2492 usb_deregister(&s2255_driver);
2495 module_init(usb_s2255_init);
2496 module_exit(usb_s2255_exit);
2498 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2499 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2500 MODULE_LICENSE("GPL");