]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/media/video/s2255drv.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (10135): v4l2: introduce v4l2_file_operations.
[mirror_ubuntu-artful-kernel.git] / drivers / media / video / s2255drv.c
CommitLineData
38f993ad
DA		 1/*
2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
3 *
4 * Copyright (C) 2007-2008 by Sensoray Company Inc.
5 * Dean Anderson
6 *
7 * Some video buffer code based on vivi driver:
8 *
9 * Sensoray 2255 device supports 4 simultaneous channels.
10 * The channels are not "crossbar" inputs, they are physically
11 * attached to separate video decoders.
12 *
13 * Because of USB2.0 bandwidth limitations. There is only a
14 * certain amount of data which may be transferred at one time.
15 *
16 * Example maximum bandwidth utilization:
17 *
18 * -full size, color mode YUYV or YUV422P: 2 channels at once
19 *
20 * -full or half size Grey scale: all 4 channels at once
21 *
22 * -half size, color mode YUYV or YUV422P: all 4 channels at once
23 *
24 * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
25 * at once.
26 * (TODO: Incorporate videodev2 frame rate(FR) enumeration,
27 * which is currently experimental.)
28 *
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.
33 *
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.
38 *
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.
42 */
43
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>
feb75f07 50#include <linux/mm.h>
38f993ad
DA		 51#include <media/videobuf-vmalloc.h>
52#include <media/v4l2-common.h>
35ea11ff 53#include <media/v4l2-ioctl.h>
38f993ad
DA		 54#include <linux/vmalloc.h>
55#include <linux/usb.h>
56
57#define FIRMWARE_FILE_NAME "f2255usb.bin"
58
59
60
22b88d48
DA		 61/* default JPEG quality */
62#define S2255_DEF_JPEG_QUAL 50
38f993ad
DA		 63/* vendor request in */
64#define S2255_VR_IN 0
65/* vendor request out */
66#define S2255_VR_OUT 1
67/* firmware query */
68#define S2255_VR_FW 0x30
69/* USB endpoint number for configuring the device */
70#define S2255_CONFIG_EP 2
71/* maximum time for DSP to start responding after last FW word loaded(ms) */
14d96260 72#define S2255_DSP_BOOTTIME 800
38f993ad 73/* maximum time to wait for firmware to load (ms) */
3f8d6f73 74#define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
38f993ad 75#define S2255_DEF_BUFS 16
14d96260 76#define S2255_SETMODE_TIMEOUT 500
38f993ad 77#define MAX_CHANNELS 4
14d96260
DA		 78#define S2255_MARKER_FRAME 0x2255DA4AL
79#define S2255_MARKER_RESPONSE 0x2255ACACL
80#define S2255_USB_XFER_SIZE (16 * 1024)
38f993ad
DA		 81#define MAX_CHANNELS 4
82#define MAX_PIPE_BUFFERS 1
83#define SYS_FRAMES 4
84/* maximum size is PAL full size plus room for the marker header(s) */
14d96260
DA		 85#define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
86#define DEF_USB_BLOCK S2255_USB_XFER_SIZE
38f993ad
DA		 87#define LINE_SZ_4CIFS_NTSC 640
88#define LINE_SZ_2CIFS_NTSC 640
89#define LINE_SZ_1CIFS_NTSC 320
90#define LINE_SZ_4CIFS_PAL 704
91#define LINE_SZ_2CIFS_PAL 704
92#define LINE_SZ_1CIFS_PAL 352
93#define NUM_LINES_4CIFS_NTSC 240
94#define NUM_LINES_2CIFS_NTSC 240
95#define NUM_LINES_1CIFS_NTSC 240
96#define NUM_LINES_4CIFS_PAL 288
97#define NUM_LINES_2CIFS_PAL 288
98#define NUM_LINES_1CIFS_PAL 288
99#define LINE_SZ_DEF 640
100#define NUM_LINES_DEF 240
101
102
103/* predefined settings */
104#define FORMAT_NTSC 1
105#define FORMAT_PAL 2
106
107#define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
108#define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
109#define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
110
111#define COLOR_YUVPL 1 /* YUV planar */
112#define COLOR_YUVPK 2 /* YUV packed */
113#define COLOR_Y8 4 /* monochrome */
14d96260
DA		 114#define COLOR_JPG 5 /* JPEG */
115#define MASK_COLOR 0xff
116#define MASK_JPG_QUALITY 0xff00
38f993ad
DA		 117
118/* frame decimation. Not implemented by V4L yet(experimental in V4L) */
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 */
123
124/*-------------------------------------------------------
125 * Default mode parameters.
126 *-------------------------------------------------------*/
127#define DEF_SCALE SCALE_4CIFS
128#define DEF_COLOR COLOR_YUVPL
129#define DEF_FDEC FDEC_1
130#define DEF_BRIGHT 0
131#define DEF_CONTRAST 0x5c
132#define DEF_SATURATION 0x80
133#define DEF_HUE 0
134
135/* usb config commands */
136#define IN_DATA_TOKEN 0x2255c0de
137#define CMD_2255 0xc2255000
138#define CMD_SET_MODE (CMD_2255 | 0x10)
139#define CMD_START (CMD_2255 | 0x20)
140#define CMD_STOP (CMD_2255 | 0x30)
141#define CMD_STATUS (CMD_2255 | 0x40)
142
143struct s2255_mode {
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 */
155};
156
38f993ad 157
14d96260
DA		 158#define S2255_READ_IDLE 0
159#define S2255_READ_FRAME 1
38f993ad 160
14d96260 161/* frame structure */
38f993ad
DA		 162struct s2255_framei {
163 unsigned long size;
14d96260 164 unsigned long ulState; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
38f993ad
DA		 165 void *lpvbits; /* image data */
166 unsigned long cur_size; /* current data copied to it */
167};
168
169/* image buffer structure */
170struct s2255_bufferi {
171 unsigned long dwFrames; /* number of frames in buffer */
172 struct s2255_framei frame[SYS_FRAMES]; /* array of FRAME structures */
173};
174
175#define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
176 DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
3f8d6f73 177 DEF_HUE, 0, DEF_USB_BLOCK, 0}
38f993ad
DA		 178
179struct s2255_dmaqueue {
180 struct list_head active;
181 /* thread for acquisition */
182 struct task_struct *kthread;
183 int frame;
184 struct s2255_dev *dev;
185 int channel;
186};
187
188/* for firmware loading, fw_state */
189#define S2255_FW_NOTLOADED 0
190#define S2255_FW_LOADED_DSPWAIT 1
191#define S2255_FW_SUCCESS 2
192#define S2255_FW_FAILED 3
f78d92c9 193#define S2255_FW_DISCONNECTING 4
38f993ad 194
deaf53e3 195#define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
14d96260
DA		 196/* 2255 read states */
197#define S2255_READ_IDLE 0
198#define S2255_READ_FRAME 1
38f993ad
DA		 199struct s2255_fw {
200 int fw_loaded;
201 int fw_size;
202 struct urb *fw_urb;
203 atomic_t fw_state;
204 void *pfw_data;
205 wait_queue_head_t wait_fw;
38f993ad
DA		 206 const struct firmware *fw;
207};
208
209struct s2255_pipeinfo {
210 u32 max_transfer_size;
211 u32 cur_transfer_size;
212 u8 *transfer_buffer;
213 u32 transfer_flags;;
214 u32 state;
215 u32 prev_state;
216 u32 urb_size;
217 void *stream_urb;
218 void *dev; /* back pointer to s2255_dev struct*/
219 u32 err_count;
220 u32 buf_index;
221 u32 idx;
222 u32 priority_set;
223};
224
225struct s2255_fmt; /*forward declaration */
226
227struct s2255_dev {
228 int frames;
229 int users[MAX_CHANNELS];
230 struct mutex lock;
231 struct mutex open_lock;
232 int resources[MAX_CHANNELS];
233 struct usb_device *udev;
234 struct usb_interface *interface;
235 u8 read_endpoint;
236
237 struct s2255_dmaqueue vidq[MAX_CHANNELS];
238 struct video_device *vdev[MAX_CHANNELS];
239 struct list_head s2255_devlist;
240 struct timer_list timer;
241 struct s2255_fw *fw_data;
242 int board_num;
243 int is_open;
244 struct s2255_pipeinfo pipes[MAX_PIPE_BUFFERS];
245 struct s2255_bufferi buffer[MAX_CHANNELS];
246 struct s2255_mode mode[MAX_CHANNELS];
22b88d48
DA		 247 /* jpeg compression */
248 struct v4l2_jpegcompression jc[MAX_CHANNELS];
38f993ad
DA		 249 const struct s2255_fmt *cur_fmt[MAX_CHANNELS];
250 int cur_frame[MAX_CHANNELS];
251 int last_frame[MAX_CHANNELS];
252 u32 cc; /* current channel */
253 int b_acquire[MAX_CHANNELS];
14d96260 254 /* allocated image size */
38f993ad 255 unsigned long req_image_size[MAX_CHANNELS];
14d96260
DA		 256 /* received packet size */
257 unsigned long pkt_size[MAX_CHANNELS];
38f993ad
DA		 258 int bad_payload[MAX_CHANNELS];
259 unsigned long frame_count[MAX_CHANNELS];
260 int frame_ready;
14d96260
DA		 261 /* if JPEG image */
262 int jpg_size[MAX_CHANNELS];
263 /* if channel configured to default state */
264 int chn_configured[MAX_CHANNELS];
265 wait_queue_head_t wait_setmode[MAX_CHANNELS];
266 int setmode_ready[MAX_CHANNELS];
267 int chn_ready;
38f993ad
DA		 268 struct kref kref;
269 spinlock_t slock;
270};
271#define to_s2255_dev(d) container_of(d, struct s2255_dev, kref)
272
273struct s2255_fmt {
274 char *name;
275 u32 fourcc;
276 int depth;
277};
278
279/* buffer for one video frame */
280struct s2255_buffer {
281 /* common v4l buffer stuff -- must be first */
282 struct videobuf_buffer vb;
283 const struct s2255_fmt *fmt;
284};
285
286struct s2255_fh {
287 struct s2255_dev *dev;
38f993ad
DA		 288 const struct s2255_fmt *fmt;
289 unsigned int width;
290 unsigned int height;
291 struct videobuf_queue vb_vidq;
292 enum v4l2_buf_type type;
293 int channel;
294 /* mode below is the desired mode.
295 mode in s2255_dev is the current mode that was last set */
296 struct s2255_mode mode;
f78d92c9 297 int resources[MAX_CHANNELS];
38f993ad
DA		 298};
299
38f993ad
DA		 300#define CUR_USB_FWVER 774 /* current cypress EEPROM firmware version */
301#define S2255_MAJOR_VERSION 1
302#define S2255_MINOR_VERSION 13
303#define S2255_RELEASE 0
304#define S2255_VERSION KERNEL_VERSION(S2255_MAJOR_VERSION, \
305 S2255_MINOR_VERSION, \
306 S2255_RELEASE)
307
308/* vendor ids */
309#define USB_S2255_VENDOR_ID 0x1943
310#define USB_S2255_PRODUCT_ID 0x2255
311#define S2255_NORMS (V4L2_STD_PAL | V4L2_STD_NTSC)
312/* frame prefix size (sent once every frame) */
313#define PREFIX_SIZE 512
314
315/* Channels on box are in reverse order */
3f8d6f73 316static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
38f993ad
DA		 317
318static LIST_HEAD(s2255_devlist);
319
320static int debug;
321static int *s2255_debug = &debug;
322
323static int s2255_start_readpipe(struct s2255_dev *dev);
324static void s2255_stop_readpipe(struct s2255_dev *dev);
325static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn);
326static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn);
327static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
14d96260 328 int chn, int jpgsize);
38f993ad
DA		 329static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
330 struct s2255_mode *mode);
331static int s2255_board_shutdown(struct s2255_dev *dev);
332static void s2255_exit_v4l(struct s2255_dev *dev);
14d96260
DA		 333static void s2255_fwload_start(struct s2255_dev *dev, int reset);
334static void s2255_destroy(struct kref *kref);
335static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
336 u16 index, u16 value, void *buf,
337 s32 buf_len, int bOut);
38f993ad
DA		 338
339#define dprintk(level, fmt, arg...) \
340 do { \
341 if (*s2255_debug >= (level)) { \
342 printk(KERN_DEBUG "s2255: " fmt, ##arg); \
343 } \
344 } while (0)
345
346
347static struct usb_driver s2255_driver;
348
349
350/* Declare static vars that will be used as parameters */
351static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
352
353/* start video number */
354static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
355
3f8d6f73 356module_param(debug, int, 0644);
38f993ad 357MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
3f8d6f73 358module_param(vid_limit, int, 0644);
38f993ad 359MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)");
3f8d6f73 360module_param(video_nr, int, 0644);
38f993ad
DA		 361MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
362
363/* USB device table */
364static struct usb_device_id s2255_table[] = {
365 {USB_DEVICE(USB_S2255_VENDOR_ID, USB_S2255_PRODUCT_ID)},
366 { } /* Terminating entry */
367};
368MODULE_DEVICE_TABLE(usb, s2255_table);
369
370
371#define BUFFER_TIMEOUT msecs_to_jiffies(400)
372
373/* supported controls */
374static struct v4l2_queryctrl s2255_qctrl[] = {
375 {
376 .id = V4L2_CID_BRIGHTNESS,
377 .type = V4L2_CTRL_TYPE_INTEGER,
378 .name = "Brightness",
379 .minimum = -127,
380 .maximum = 128,
381 .step = 1,
382 .default_value = 0,
383 .flags = 0,
384 }, {
385 .id = V4L2_CID_CONTRAST,
386 .type = V4L2_CTRL_TYPE_INTEGER,
387 .name = "Contrast",
388 .minimum = 0,
389 .maximum = 255,
390 .step = 0x1,
391 .default_value = DEF_CONTRAST,
392 .flags = 0,
393 }, {
394 .id = V4L2_CID_SATURATION,
395 .type = V4L2_CTRL_TYPE_INTEGER,
396 .name = "Saturation",
397 .minimum = 0,
398 .maximum = 255,
399 .step = 0x1,
400 .default_value = DEF_SATURATION,
401 .flags = 0,
402 }, {
403 .id = V4L2_CID_HUE,
404 .type = V4L2_CTRL_TYPE_INTEGER,
405 .name = "Hue",
406 .minimum = 0,
407 .maximum = 255,
408 .step = 0x1,
409 .default_value = DEF_HUE,
410 .flags = 0,
411 }
412};
413
414static int qctl_regs[ARRAY_SIZE(s2255_qctrl)];
415
416/* image formats. */
417static const struct s2255_fmt formats[] = {
418 {
419 .name = "4:2:2, planar, YUV422P",
420 .fourcc = V4L2_PIX_FMT_YUV422P,
421 .depth = 16
422
423 }, {
424 .name = "4:2:2, packed, YUYV",
425 .fourcc = V4L2_PIX_FMT_YUYV,
426 .depth = 16
427
428 }, {
429 .name = "4:2:2, packed, UYVY",
430 .fourcc = V4L2_PIX_FMT_UYVY,
431 .depth = 16
14d96260
DA		 432 }, {
433 .name = "JPG",
434 .fourcc = V4L2_PIX_FMT_JPEG,
435 .depth = 24
38f993ad
DA		 436 }, {
437 .name = "8bpp GREY",
438 .fourcc = V4L2_PIX_FMT_GREY,
439 .depth = 8
440 }
441};
442
443static int norm_maxw(struct video_device *vdev)
444{
445 return (vdev->current_norm & V4L2_STD_NTSC) ?
446 LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
447}
448
449static int norm_maxh(struct video_device *vdev)
450{
451 return (vdev->current_norm & V4L2_STD_NTSC) ?
452 (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
453}
454
455static int norm_minw(struct video_device *vdev)
456{
457 return (vdev->current_norm & V4L2_STD_NTSC) ?
458 LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
459}
460
461static int norm_minh(struct video_device *vdev)
462{
463 return (vdev->current_norm & V4L2_STD_NTSC) ?
464 (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
465}
466
467
3f8d6f73
DA		 468/*
469 * TODO: fixme: move YUV reordering to hardware
470 * converts 2255 planar format to yuyv or uyvy
471 */
38f993ad
DA		 472static void planar422p_to_yuv_packed(const unsigned char *in,
473 unsigned char *out,
474 int width, int height,
475 int fmt)
476{
477 unsigned char *pY;
478 unsigned char *pCb;
479 unsigned char *pCr;
480 unsigned long size = height * width;
481 unsigned int i;
482 pY = (unsigned char *)in;
483 pCr = (unsigned char *)in + height * width;
484 pCb = (unsigned char *)in + height * width + (height * width / 2);
485 for (i = 0; i < size * 2; i += 4) {
486 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
487 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
488 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
489 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
490 }
491 return;
492}
493
d45b9b8a 494static void s2255_reset_dsppower(struct s2255_dev *dev)
14d96260
DA		 495{
496 s2255_vendor_req(dev, 0x40, 0x0b0b, 0x0b0b, NULL, 0, 1);
497 msleep(10);
498 s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
499 return;
500}
38f993ad
DA		 501
502/* kickstarts the firmware loading. from probe
503 */
504static void s2255_timer(unsigned long user_data)
505{
506 struct s2255_fw *data = (struct s2255_fw *)user_data;
507 dprintk(100, "s2255 timer\n");
508 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
509 printk(KERN_ERR "s2255: can't submit urb\n");
f78d92c9
DA		 510 atomic_set(&data->fw_state, S2255_FW_FAILED);
511 /* wake up anything waiting for the firmware */
512 wake_up(&data->wait_fw);
38f993ad
DA		 513 return;
514 }
515}
516
38f993ad
DA		 517
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
523*/
524static void s2255_fwchunk_complete(struct urb *urb)
525{
526 struct s2255_fw *data = urb->context;
527 struct usb_device *udev = urb->dev;
528 int len;
529 dprintk(100, "udev %p urb %p", udev, urb);
38f993ad
DA		 530 if (urb->status) {
531 dev_err(&udev->dev, "URB failed with status %d", urb->status);
f78d92c9
DA		 532 atomic_set(&data->fw_state, S2255_FW_FAILED);
533 /* wake up anything waiting for the firmware */
534 wake_up(&data->wait_fw);
38f993ad
DA		 535 return;
536 }
537 if (data->fw_urb == NULL) {
f78d92c9
DA		 538 dev_err(&udev->dev, "s2255 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);
38f993ad
DA		 542 return;
543 }
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
548 */
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;
552
553 if (len < CHUNK_SIZE)
554 memset(data->pfw_data, 0, CHUNK_SIZE);
555
556 dprintk(100, "completed len %d, loaded %d \n", len,
557 data->fw_loaded);
558
559 memcpy(data->pfw_data,
560 (char *) data->fw->data + data->fw_loaded, len);
561
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);
570 return;
571 }
572 data->fw_loaded += len;
573 } else {
38f993ad 574 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
38f993ad
DA		 575 }
576 dprintk(100, "2255 complete done\n");
577 return;
578
579}
580
14d96260 581static int s2255_got_frame(struct s2255_dev *dev, int chn, int jpgsize)
38f993ad
DA		 582{
583 struct s2255_dmaqueue *dma_q = &dev->vidq[chn];
584 struct s2255_buffer *buf;
585 unsigned long flags = 0;
586 int rc = 0;
587 dprintk(2, "wakeup: %p channel: %d\n", &dma_q, chn);
588 spin_lock_irqsave(&dev->slock, flags);
589
590 if (list_empty(&dma_q->active)) {
591 dprintk(1, "No active queue to serve\n");
592 rc = -1;
593 goto unlock;
594 }
595 buf = list_entry(dma_q->active.next,
596 struct s2255_buffer, vb.queue);
597
598 if (!waitqueue_active(&buf->vb.done)) {
599 /* no one active */
600 rc = -1;
601 goto unlock;
602 }
603 list_del(&buf->vb.queue);
604 do_gettimeofday(&buf->vb.ts);
605 dprintk(100, "[%p/%d] wakeup\n", buf, buf->vb.i);
14d96260 606 s2255_fillbuff(dev, buf, dma_q->channel, jpgsize);
38f993ad
DA		 607 wake_up(&buf->vb.done);
608 dprintk(2, "wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
609unlock:
610 spin_unlock_irqrestore(&dev->slock, flags);
611 return 0;
612}
613
614
615static const struct s2255_fmt *format_by_fourcc(int fourcc)
616{
617 unsigned int i;
618
619 for (i = 0; i < ARRAY_SIZE(formats); i++) {
620 if (-1 == formats[i].fourcc)
621 continue;
622 if (formats[i].fourcc == fourcc)
623 return formats + i;
624 }
625 return NULL;
626}
627
628
629
630
631/* video buffer vmalloc implementation based partly on VIVI driver which is
632 * Copyright (c) 2006 by
633 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
634 * Ted Walther <ted--a.t--enumera.com>
635 * John Sokol <sokol--a.t--videotechnology.com>
636 * http://v4l.videotechnology.com/
637 *
638 */
639static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
14d96260 640 int chn, int jpgsize)
38f993ad
DA		 641{
642 int pos = 0;
643 struct timeval ts;
644 const char *tmpbuf;
645 char *vbuf = videobuf_to_vmalloc(&buf->vb);
646 unsigned long last_frame;
647 struct s2255_framei *frm;
648
649 if (!vbuf)
650 return;
651
652 last_frame = dev->last_frame[chn];
653 if (last_frame != -1) {
654 frm = &dev->buffer[chn].frame[last_frame];
655 tmpbuf =
656 (const char *)dev->buffer[chn].frame[last_frame].lpvbits;
657 switch (buf->fmt->fourcc) {
658 case V4L2_PIX_FMT_YUYV:
659 case V4L2_PIX_FMT_UYVY:
660 planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
661 vbuf, buf->vb.width,
662 buf->vb.height,
663 buf->fmt->fourcc);
664 break;
665 case V4L2_PIX_FMT_GREY:
666 memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
667 break;
14d96260
DA		 668 case V4L2_PIX_FMT_JPEG:
669 buf->vb.size = jpgsize;
670 memcpy(vbuf, tmpbuf, buf->vb.size);
671 break;
38f993ad
DA		 672 case V4L2_PIX_FMT_YUV422P:
673 memcpy(vbuf, tmpbuf,
674 buf->vb.width * buf->vb.height * 2);
675 break;
676 default:
677 printk(KERN_DEBUG "s2255: unknown format?\n");
678 }
679 dev->last_frame[chn] = -1;
38f993ad
DA		 680 } else {
681 printk(KERN_ERR "s2255: =======no frame\n");
682 return;
683
684 }
685 dprintk(2, "s2255fill at : Buffer 0x%08lx size= %d\n",
686 (unsigned long)vbuf, pos);
687 /* tell v4l buffer was filled */
688
a1c4530e 689 buf->vb.field_count = dev->frame_count[chn] * 2;
38f993ad
DA		 690 do_gettimeofday(&ts);
691 buf->vb.ts = ts;
692 buf->vb.state = VIDEOBUF_DONE;
693}
694
695
696/* ------------------------------------------------------------------
697 Videobuf operations
698 ------------------------------------------------------------------*/
699
700static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
701 unsigned int *size)
702{
703 struct s2255_fh *fh = vq->priv_data;
704
705 *size = fh->width * fh->height * (fh->fmt->depth >> 3);
706
707 if (0 == *count)
708 *count = S2255_DEF_BUFS;
709
3f8d6f73 710 while (*size * (*count) > vid_limit * 1024 * 1024)
38f993ad
DA		 711 (*count)--;
712
713 return 0;
714}
715
716static void free_buffer(struct videobuf_queue *vq, struct s2255_buffer *buf)
717{
718 dprintk(4, "%s\n", __func__);
719
720 videobuf_waiton(&buf->vb, 0, 0);
721 videobuf_vmalloc_free(&buf->vb);
722 buf->vb.state = VIDEOBUF_NEEDS_INIT;
723}
724
725static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
726 enum v4l2_field field)
727{
728 struct s2255_fh *fh = vq->priv_data;
729 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
730 int rc;
731 dprintk(4, "%s, field=%d\n", __func__, field);
732 if (fh->fmt == NULL)
733 return -EINVAL;
734
735 if ((fh->width < norm_minw(fh->dev->vdev[fh->channel])) ||
736 (fh->width > norm_maxw(fh->dev->vdev[fh->channel])) ||
737 (fh->height < norm_minh(fh->dev->vdev[fh->channel])) ||
738 (fh->height > norm_maxh(fh->dev->vdev[fh->channel]))) {
739 dprintk(4, "invalid buffer prepare\n");
740 return -EINVAL;
741 }
742
743 buf->vb.size = fh->width * fh->height * (fh->fmt->depth >> 3);
744
745 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
746 dprintk(4, "invalid buffer prepare\n");
747 return -EINVAL;
748 }
749
750 buf->fmt = fh->fmt;
751 buf->vb.width = fh->width;
752 buf->vb.height = fh->height;
753 buf->vb.field = field;
754
755
756 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
757 rc = videobuf_iolock(vq, &buf->vb, NULL);
758 if (rc < 0)
759 goto fail;
760 }
761
762 buf->vb.state = VIDEOBUF_PREPARED;
763 return 0;
764fail:
765 free_buffer(vq, buf);
766 return rc;
767}
768
769static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
770{
771 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
772 struct s2255_fh *fh = vq->priv_data;
773 struct s2255_dev *dev = fh->dev;
774 struct s2255_dmaqueue *vidq = &dev->vidq[fh->channel];
775
776 dprintk(1, "%s\n", __func__);
777
778 buf->vb.state = VIDEOBUF_QUEUED;
779 list_add_tail(&buf->vb.queue, &vidq->active);
780}
781
782static void buffer_release(struct videobuf_queue *vq,
783 struct videobuf_buffer *vb)
784{
785 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
786 struct s2255_fh *fh = vq->priv_data;
787 dprintk(4, "%s %d\n", __func__, fh->channel);
788 free_buffer(vq, buf);
789}
790
791static struct videobuf_queue_ops s2255_video_qops = {
792 .buf_setup = buffer_setup,
793 .buf_prepare = buffer_prepare,
794 .buf_queue = buffer_queue,
795 .buf_release = buffer_release,
796};
797
798
799static int res_get(struct s2255_dev *dev, struct s2255_fh *fh)
800{
801 /* is it free? */
802 mutex_lock(&dev->lock);
803 if (dev->resources[fh->channel]) {
804 /* no, someone else uses it */
805 mutex_unlock(&dev->lock);
806 return 0;
807 }
808 /* it's free, grab it */
809 dev->resources[fh->channel] = 1;
f78d92c9
DA		 810 fh->resources[fh->channel] = 1;
811 dprintk(1, "s2255: res: get\n");
38f993ad
DA		 812 mutex_unlock(&dev->lock);
813 return 1;
814}
815
816static int res_locked(struct s2255_dev *dev, struct s2255_fh *fh)
817{
3f8d6f73 818 return dev->resources[fh->channel];
38f993ad
DA		 819}
820
f78d92c9
DA		 821static int res_check(struct s2255_fh *fh)
822{
823 return fh->resources[fh->channel];
824}
825
826
38f993ad
DA		 827static void res_free(struct s2255_dev *dev, struct s2255_fh *fh)
828{
f78d92c9 829 mutex_lock(&dev->lock);
38f993ad 830 dev->resources[fh->channel] = 0;
f78d92c9
DA		 831 fh->resources[fh->channel] = 0;
832 mutex_unlock(&dev->lock);
38f993ad
DA		 833 dprintk(1, "res: put\n");
834}
835
836
837static int vidioc_querycap(struct file *file, void *priv,
838 struct v4l2_capability *cap)
839{
840 struct s2255_fh *fh = file->private_data;
841 struct s2255_dev *dev = fh->dev;
842 strlcpy(cap->driver, "s2255", sizeof(cap->driver));
843 strlcpy(cap->card, "s2255", sizeof(cap->card));
3f8d6f73
DA		 844 strlcpy(cap->bus_info, dev_name(&dev->udev->dev),
845 sizeof(cap->bus_info));
38f993ad
DA		 846 cap->version = S2255_VERSION;
847 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
848 return 0;
849}
850
851static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
852 struct v4l2_fmtdesc *f)
853{
854 int index = 0;
855 if (f)
856 index = f->index;
857
858 if (index >= ARRAY_SIZE(formats))
859 return -EINVAL;
860
861 dprintk(4, "name %s\n", formats[index].name);
862 strlcpy(f->description, formats[index].name, sizeof(f->description));
863 f->pixelformat = formats[index].fourcc;
864 return 0;
865}
866
867static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
868 struct v4l2_format *f)
869{
870 struct s2255_fh *fh = priv;
871
872 f->fmt.pix.width = fh->width;
873 f->fmt.pix.height = fh->height;
874 f->fmt.pix.field = fh->vb_vidq.field;
875 f->fmt.pix.pixelformat = fh->fmt->fourcc;
876 f->fmt.pix.bytesperline = f->fmt.pix.width * (fh->fmt->depth >> 3);
877 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
3f8d6f73 878 return 0;
38f993ad
DA		 879}
880
881static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
882 struct v4l2_format *f)
883{
884 const struct s2255_fmt *fmt;
885 enum v4l2_field field;
886 int b_any_field = 0;
887 struct s2255_fh *fh = priv;
888 struct s2255_dev *dev = fh->dev;
889 int is_ntsc;
890
891 is_ntsc =
892 (dev->vdev[fh->channel]->current_norm & V4L2_STD_NTSC) ? 1 : 0;
893
894 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
895
896 if (fmt == NULL)
897 return -EINVAL;
898
899 field = f->fmt.pix.field;
900 if (field == V4L2_FIELD_ANY)
901 b_any_field = 1;
902
903 dprintk(4, "try format %d \n", is_ntsc);
904 /* supports 3 sizes. see s2255drv.h */
905 dprintk(50, "width test %d, height %d\n",
906 f->fmt.pix.width, f->fmt.pix.height);
907 if (is_ntsc) {
908 /* NTSC */
909 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
910 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
911 if (b_any_field) {
912 field = V4L2_FIELD_SEQ_TB;
913 } else if (!((field == V4L2_FIELD_INTERLACED) ||
914 (field == V4L2_FIELD_SEQ_TB) ||
915 (field == V4L2_FIELD_INTERLACED_TB))) {
916 dprintk(1, "unsupported field setting\n");
917 return -EINVAL;
918 }
919 } else {
920 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
921 if (b_any_field) {
922 field = V4L2_FIELD_TOP;
923 } else if (!((field == V4L2_FIELD_TOP) ||
924 (field == V4L2_FIELD_BOTTOM))) {
925 dprintk(1, "unsupported field setting\n");
926 return -EINVAL;
927 }
928
929 }
930 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
931 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
932 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
933 f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
934 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
935 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
936 else
937 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
938 } else {
939 /* PAL */
940 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
941 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
942 if (b_any_field) {
943 field = V4L2_FIELD_SEQ_TB;
944 } else if (!((field == V4L2_FIELD_INTERLACED) ||
945 (field == V4L2_FIELD_SEQ_TB) ||
946 (field == V4L2_FIELD_INTERLACED_TB))) {
947 dprintk(1, "unsupported field setting\n");
948 return -EINVAL;
949 }
950 } else {
951 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
952 if (b_any_field) {
953 field = V4L2_FIELD_TOP;
954 } else if (!((field == V4L2_FIELD_TOP) ||
955 (field == V4L2_FIELD_BOTTOM))) {
956 dprintk(1, "unsupported field setting\n");
957 return -EINVAL;
958 }
959 }
960 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) {
961 dprintk(50, "pal 704\n");
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 dprintk(50, "pal 352A\n");
966 f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
967 field = V4L2_FIELD_TOP;
968 } else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL) {
969 dprintk(50, "pal 352B\n");
970 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
971 field = V4L2_FIELD_TOP;
972 } else {
973 dprintk(50, "pal 352C\n");
974 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
975 field = V4L2_FIELD_TOP;
976 }
977 }
978
979 dprintk(50, "width %d height %d field %d \n", f->fmt.pix.width,
980 f->fmt.pix.height, f->fmt.pix.field);
981 f->fmt.pix.field = field;
982 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
983 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
984 return 0;
985}
986
987static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
988 struct v4l2_format *f)
989{
990 struct s2255_fh *fh = priv;
991 const struct s2255_fmt *fmt;
992 struct videobuf_queue *q = &fh->vb_vidq;
993 int ret;
994 int norm;
995
996 ret = vidioc_try_fmt_vid_cap(file, fh, f);
997
998 if (ret < 0)
3f8d6f73 999 return ret;
38f993ad
DA		 1000
1001 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1002
1003 if (fmt == NULL)
1004 return -EINVAL;
1005
1006 mutex_lock(&q->vb_lock);
1007
1008 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1009 dprintk(1, "queue busy\n");
1010 ret = -EBUSY;
1011 goto out_s_fmt;
1012 }
1013
1014 if (res_locked(fh->dev, fh)) {
1015 dprintk(1, "can't change format after started\n");
1016 ret = -EBUSY;
1017 goto out_s_fmt;
1018 }
1019
1020 fh->fmt = fmt;
1021 fh->width = f->fmt.pix.width;
1022 fh->height = f->fmt.pix.height;
1023 fh->vb_vidq.field = f->fmt.pix.field;
1024 fh->type = f->type;
1025 norm = norm_minw(fh->dev->vdev[fh->channel]);
1026 if (fh->width > norm_minw(fh->dev->vdev[fh->channel])) {
1027 if (fh->height > norm_minh(fh->dev->vdev[fh->channel]))
1028 fh->mode.scale = SCALE_4CIFS;
1029 else
1030 fh->mode.scale = SCALE_2CIFS;
1031
1032 } else {
1033 fh->mode.scale = SCALE_1CIFS;
1034 }
1035
1036 /* color mode */
1037 switch (fh->fmt->fourcc) {
1038 case V4L2_PIX_FMT_GREY:
1039 fh->mode.color = COLOR_Y8;
1040 break;
14d96260 1041 case V4L2_PIX_FMT_JPEG:
22b88d48
DA		 1042 fh->mode.color = COLOR_JPG |
1043 (fh->dev->jc[fh->channel].quality << 8);
14d96260 1044 break;
38f993ad
DA		 1045 case V4L2_PIX_FMT_YUV422P:
1046 fh->mode.color = COLOR_YUVPL;
1047 break;
1048 case V4L2_PIX_FMT_YUYV:
1049 case V4L2_PIX_FMT_UYVY:
1050 default:
1051 fh->mode.color = COLOR_YUVPK;
1052 break;
1053 }
1054 ret = 0;
1055out_s_fmt:
1056 mutex_unlock(&q->vb_lock);
1057 return ret;
1058}
1059
1060static int vidioc_reqbufs(struct file *file, void *priv,
1061 struct v4l2_requestbuffers *p)
1062{
1063 int rc;
1064 struct s2255_fh *fh = priv;
1065 rc = videobuf_reqbufs(&fh->vb_vidq, p);
1066 return rc;
1067}
1068
1069static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1070{
1071 int rc;
1072 struct s2255_fh *fh = priv;
1073 rc = videobuf_querybuf(&fh->vb_vidq, p);
1074 return rc;
1075}
1076
1077static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1078{
1079 int rc;
1080 struct s2255_fh *fh = priv;
1081 rc = videobuf_qbuf(&fh->vb_vidq, p);
1082 return rc;
1083}
1084
1085static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1086{
1087 int rc;
1088 struct s2255_fh *fh = priv;
1089 rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
1090 return rc;
1091}
1092
1093#ifdef CONFIG_VIDEO_V4L1_COMPAT
1094static int vidioc_cgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1095{
1096 struct s2255_fh *fh = priv;
1097
1098 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1099}
1100#endif
1101
1102/* write to the configuration pipe, synchronously */
1103static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1104 int size)
1105{
1106 int pipe;
1107 int done;
1108 long retval = -1;
1109 if (udev) {
1110 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
1111 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
1112 }
1113 return retval;
1114}
1115
1116static u32 get_transfer_size(struct s2255_mode *mode)
1117{
1118 int linesPerFrame = LINE_SZ_DEF;
1119 int pixelsPerLine = NUM_LINES_DEF;
1120 u32 outImageSize;
1121 u32 usbInSize;
1122 unsigned int mask_mult;
1123
1124 if (mode == NULL)
1125 return 0;
1126
1127 if (mode->format == FORMAT_NTSC) {
1128 switch (mode->scale) {
1129 case SCALE_4CIFS:
1130 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
1131 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
1132 break;
1133 case SCALE_2CIFS:
1134 linesPerFrame = NUM_LINES_2CIFS_NTSC;
1135 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
1136 break;
1137 case SCALE_1CIFS:
1138 linesPerFrame = NUM_LINES_1CIFS_NTSC;
1139 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
1140 break;
1141 default:
1142 break;
1143 }
1144 } else if (mode->format == FORMAT_PAL) {
1145 switch (mode->scale) {
1146 case SCALE_4CIFS:
1147 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
1148 pixelsPerLine = LINE_SZ_4CIFS_PAL;
1149 break;
1150 case SCALE_2CIFS:
1151 linesPerFrame = NUM_LINES_2CIFS_PAL;
1152 pixelsPerLine = LINE_SZ_2CIFS_PAL;
1153 break;
1154 case SCALE_1CIFS:
1155 linesPerFrame = NUM_LINES_1CIFS_PAL;
1156 pixelsPerLine = LINE_SZ_1CIFS_PAL;
1157 break;
1158 default:
1159 break;
1160 }
1161 }
1162 outImageSize = linesPerFrame * pixelsPerLine;
14d96260 1163 if ((mode->color & MASK_COLOR) != COLOR_Y8) {
38f993ad
DA		 1164 /* 2 bytes/pixel if not monochrome */
1165 outImageSize *= 2;
1166 }
1167
1168 /* total bytes to send including prefix and 4K padding;
1169 must be a multiple of USB_READ_SIZE */
1170 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
1171 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
1172 /* if size not a multiple of USB_READ_SIZE */
1173 if (usbInSize & ~mask_mult)
1174 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
1175 return usbInSize;
1176}
1177
1178static void dump_verify_mode(struct s2255_dev *sdev, struct s2255_mode *mode)
1179{
1180 struct device *dev = &sdev->udev->dev;
1181 dev_info(dev, "------------------------------------------------\n");
1182 dev_info(dev, "verify mode\n");
1183 dev_info(dev, "format: %d\n", mode->format);
1184 dev_info(dev, "scale: %d\n", mode->scale);
1185 dev_info(dev, "fdec: %d\n", mode->fdec);
1186 dev_info(dev, "color: %d\n", mode->color);
1187 dev_info(dev, "bright: 0x%x\n", mode->bright);
1188 dev_info(dev, "restart: 0x%x\n", mode->restart);
1189 dev_info(dev, "usb_block: 0x%x\n", mode->usb_block);
1190 dev_info(dev, "single: 0x%x\n", mode->single);
1191 dev_info(dev, "------------------------------------------------\n");
1192}
1193
1194/*
1195 * set mode is the function which controls the DSP.
1196 * the restart parameter in struct s2255_mode should be set whenever
1197 * the image size could change via color format, video system or image
1198 * size.
1199 * When the restart parameter is set, we sleep for ONE frame to allow the
1200 * DSP time to get the new frame
1201 */
1202static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
1203 struct s2255_mode *mode)
1204{
1205 int res;
1206 u32 *buffer;
1207 unsigned long chn_rev;
1208
14d96260 1209 mutex_lock(&dev->lock);
38f993ad
DA		 1210 chn_rev = G_chnmap[chn];
1211 dprintk(3, "mode scale [%ld] %p %d\n", chn, mode, mode->scale);
1212 dprintk(3, "mode scale [%ld] %p %d\n", chn, &dev->mode[chn],
1213 dev->mode[chn].scale);
1214 dprintk(2, "mode contrast %x\n", mode->contrast);
1215
22b88d48
DA		 1216 /* if JPEG, set the quality */
1217 if ((mode->color & MASK_COLOR) == COLOR_JPG)
1218 mode->color = (dev->jc[chn].quality << 8) | COLOR_JPG;
1219
38f993ad
DA		 1220 /* save the mode */
1221 dev->mode[chn] = *mode;
1222 dev->req_image_size[chn] = get_transfer_size(mode);
1223 dprintk(1, "transfer size %ld\n", dev->req_image_size[chn]);
1224
1225 buffer = kzalloc(512, GFP_KERNEL);
1226 if (buffer == NULL) {
1227 dev_err(&dev->udev->dev, "out of mem\n");
14d96260 1228 mutex_unlock(&dev->lock);
38f993ad
DA		 1229 return -ENOMEM;
1230 }
1231
1232 /* set the mode */
1233 buffer[0] = IN_DATA_TOKEN;
1234 buffer[1] = (u32) chn_rev;
1235 buffer[2] = CMD_SET_MODE;
1236 memcpy(&buffer[3], &dev->mode[chn], sizeof(struct s2255_mode));
1237 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1238 if (debug)
1239 dump_verify_mode(dev, mode);
1240 kfree(buffer);
1241 dprintk(1, "set mode done chn %lu, %d\n", chn, res);
1242
1243 /* wait at least 3 frames before continuing */
14d96260
DA		 1244 if (mode->restart) {
1245 dev->setmode_ready[chn] = 0;
1246 wait_event_timeout(dev->wait_setmode[chn],
1247 (dev->setmode_ready[chn] != 0),
1248 msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1249 if (dev->setmode_ready[chn] != 1) {
1250 printk(KERN_DEBUG "s2255: no set mode response\n");
1251 res = -EFAULT;
1252 }
1253 }
38f993ad
DA		 1254
1255 /* clear the restart flag */
1256 dev->mode[chn].restart = 0;
14d96260 1257 mutex_unlock(&dev->lock);
38f993ad
DA		 1258 return res;
1259}
1260
1261static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1262{
1263 int res;
1264 struct s2255_fh *fh = priv;
1265 struct s2255_dev *dev = fh->dev;
1266 struct s2255_mode *new_mode;
1267 struct s2255_mode *old_mode;
1268 int chn;
1269 int j;
1270 dprintk(4, "%s\n", __func__);
1271 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1272 dev_err(&dev->udev->dev, "invalid fh type0\n");
1273 return -EINVAL;
1274 }
1275 if (i != fh->type) {
1276 dev_err(&dev->udev->dev, "invalid fh type1\n");
1277 return -EINVAL;
1278 }
1279
1280 if (!res_get(dev, fh)) {
f78d92c9 1281 dev_err(&dev->udev->dev, "s2255: stream busy\n");
38f993ad
DA		 1282 return -EBUSY;
1283 }
1284
1285 /* send a set mode command everytime with restart.
1286 in case we switch resolutions or other parameters */
1287 chn = fh->channel;
1288 new_mode = &fh->mode;
1289 old_mode = &fh->dev->mode[chn];
1290
1291 if (new_mode->color != old_mode->color)
1292 new_mode->restart = 1;
1293 else if (new_mode->scale != old_mode->scale)
1294 new_mode->restart = 1;
1295 else if (new_mode->format != old_mode->format)
1296 new_mode->restart = 1;
1297
1298 s2255_set_mode(dev, chn, new_mode);
1299 new_mode->restart = 0;
1300 *old_mode = *new_mode;
1301 dev->cur_fmt[chn] = fh->fmt;
1302 dprintk(1, "%s[%d]\n", __func__, chn);
1303 dev->last_frame[chn] = -1;
1304 dev->bad_payload[chn] = 0;
1305 dev->cur_frame[chn] = 0;
a1c4530e 1306 dev->frame_count[chn] = 0;
38f993ad 1307 for (j = 0; j < SYS_FRAMES; j++) {
14d96260 1308 dev->buffer[chn].frame[j].ulState = S2255_READ_IDLE;
38f993ad
DA		 1309 dev->buffer[chn].frame[j].cur_size = 0;
1310 }
1311 res = videobuf_streamon(&fh->vb_vidq);
1312 if (res == 0) {
1313 s2255_start_acquire(dev, chn);
1314 dev->b_acquire[chn] = 1;
1315 } else {
1316 res_free(dev, fh);
1317 }
1318 return res;
1319}
1320
1321static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1322{
1323 int res;
1324 struct s2255_fh *fh = priv;
1325 struct s2255_dev *dev = fh->dev;
1326
1327 dprintk(4, "%s\n, channel: %d", __func__, fh->channel);
1328 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1329 printk(KERN_ERR "invalid fh type0\n");
1330 return -EINVAL;
1331 }
1332 if (i != fh->type) {
1333 printk(KERN_ERR "invalid type i\n");
1334 return -EINVAL;
1335 }
1336 s2255_stop_acquire(dev, fh->channel);
1337 res = videobuf_streamoff(&fh->vb_vidq);
f78d92c9
DA		 1338 if (res < 0)
1339 return res;
38f993ad 1340 res_free(dev, fh);
f78d92c9 1341 return 0;
38f993ad
DA		 1342}
1343
1344static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1345{
1346 struct s2255_fh *fh = priv;
1347 struct s2255_mode *mode;
1348 struct videobuf_queue *q = &fh->vb_vidq;
1349 int ret = 0;
1350
1351 mutex_lock(&q->vb_lock);
1352 if (videobuf_queue_is_busy(q)) {
1353 dprintk(1, "queue busy\n");
1354 ret = -EBUSY;
1355 goto out_s_std;
1356 }
1357
1358 if (res_locked(fh->dev, fh)) {
1359 dprintk(1, "can't change standard after started\n");
1360 ret = -EBUSY;
1361 goto out_s_std;
1362 }
1363 mode = &fh->mode;
1364
1365 if (*i & V4L2_STD_NTSC) {
1366 dprintk(4, "vidioc_s_std NTSC\n");
1367 mode->format = FORMAT_NTSC;
1368 } else if (*i & V4L2_STD_PAL) {
1369 dprintk(4, "vidioc_s_std PAL\n");
1370 mode->format = FORMAT_PAL;
1371 } else {
1372 ret = -EINVAL;
1373 }
1374out_s_std:
1375 mutex_unlock(&q->vb_lock);
1376 return ret;
1377}
1378
1379/* Sensoray 2255 is a multiple channel capture device.
1380 It does not have a "crossbar" of inputs.
1381 We use one V4L device per channel. The user must
1382 be aware that certain combinations are not allowed.
1383 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1384 at once in color(you can do full fps on 4 channels with greyscale.
1385*/
1386static int vidioc_enum_input(struct file *file, void *priv,
1387 struct v4l2_input *inp)
1388{
1389 if (inp->index != 0)
1390 return -EINVAL;
1391
1392 inp->type = V4L2_INPUT_TYPE_CAMERA;
1393 inp->std = S2255_NORMS;
1394 strlcpy(inp->name, "Camera", sizeof(inp->name));
3f8d6f73 1395 return 0;
38f993ad
DA		 1396}
1397
1398static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1399{
1400 *i = 0;
1401 return 0;
1402}
1403static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1404{
1405 if (i > 0)
1406 return -EINVAL;
1407 return 0;
1408}
1409
1410/* --- controls ---------------------------------------------- */
1411static int vidioc_queryctrl(struct file *file, void *priv,
1412 struct v4l2_queryctrl *qc)
1413{
1414 int i;
1415
1416 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1417 if (qc->id && qc->id == s2255_qctrl[i].id) {
1418 memcpy(qc, &(s2255_qctrl[i]), sizeof(*qc));
3f8d6f73 1419 return 0;
38f993ad
DA		 1420 }
1421
1422 dprintk(4, "query_ctrl -EINVAL %d\n", qc->id);
1423 return -EINVAL;
1424}
1425
1426static int vidioc_g_ctrl(struct file *file, void *priv,
1427 struct v4l2_control *ctrl)
1428{
1429 int i;
1430
1431 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1432 if (ctrl->id == s2255_qctrl[i].id) {
1433 ctrl->value = qctl_regs[i];
3f8d6f73 1434 return 0;
38f993ad
DA		 1435 }
1436 dprintk(4, "g_ctrl -EINVAL\n");
1437
1438 return -EINVAL;
1439}
1440
1441static int vidioc_s_ctrl(struct file *file, void *priv,
1442 struct v4l2_control *ctrl)
1443{
1444 int i;
1445 struct s2255_fh *fh = priv;
1446 struct s2255_dev *dev = fh->dev;
1447 struct s2255_mode *mode;
1448 mode = &fh->mode;
1449 dprintk(4, "vidioc_s_ctrl\n");
1450 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++) {
1451 if (ctrl->id == s2255_qctrl[i].id) {
1452 if (ctrl->value < s2255_qctrl[i].minimum ||
1453 ctrl->value > s2255_qctrl[i].maximum)
3f8d6f73 1454 return -ERANGE;
38f993ad
DA		 1455
1456 qctl_regs[i] = ctrl->value;
1457 /* update the mode to the corresponding value */
1458 switch (ctrl->id) {
1459 case V4L2_CID_BRIGHTNESS:
1460 mode->bright = ctrl->value;
1461 break;
1462 case V4L2_CID_CONTRAST:
1463 mode->contrast = ctrl->value;
1464 break;
1465 case V4L2_CID_HUE:
1466 mode->hue = ctrl->value;
1467 break;
1468 case V4L2_CID_SATURATION:
1469 mode->saturation = ctrl->value;
1470 break;
1471 }
1472 mode->restart = 0;
1473 /* set mode here. Note: stream does not need restarted.
1474 some V4L programs restart stream unnecessarily
1475 after a s_crtl.
1476 */
1477 s2255_set_mode(dev, fh->channel, mode);
1478 return 0;
1479 }
1480 }
1481 return -EINVAL;
1482}
1483
22b88d48
DA		 1484static int vidioc_g_jpegcomp(struct file *file, void *priv,
1485 struct v4l2_jpegcompression *jc)
1486{
1487 struct s2255_fh *fh = priv;
1488 struct s2255_dev *dev = fh->dev;
1489 *jc = dev->jc[fh->channel];
1490 dprintk(2, "getting jpegcompression, quality %d\n", jc->quality);
1491 return 0;
1492}
1493
1494static int vidioc_s_jpegcomp(struct file *file, void *priv,
1495 struct v4l2_jpegcompression *jc)
1496{
1497 struct s2255_fh *fh = priv;
1498 struct s2255_dev *dev = fh->dev;
1499 if (jc->quality < 0 || jc->quality > 100)
1500 return -EINVAL;
1501 dev->jc[fh->channel].quality = jc->quality;
1502 dprintk(2, "setting jpeg quality %d\n", jc->quality);
1503 return 0;
1504}
bec43661 1505static int s2255_open(struct file *file)
38f993ad 1506{
bec43661 1507 int minor = video_devdata(file)->minor;
38f993ad
DA		 1508 struct s2255_dev *h, *dev = NULL;
1509 struct s2255_fh *fh;
1510 struct list_head *list;
1511 enum v4l2_buf_type type = 0;
1512 int i = 0;
1513 int cur_channel = -1;
14d96260 1514 int state;
38f993ad
DA		 1515 dprintk(1, "s2255: open called (minor=%d)\n", minor);
1516
d56dc612 1517 lock_kernel();
38f993ad
DA		 1518 list_for_each(list, &s2255_devlist) {
1519 h = list_entry(list, struct s2255_dev, s2255_devlist);
1520 for (i = 0; i < MAX_CHANNELS; i++) {
1521 if (h->vdev[i]->minor == minor) {
1522 cur_channel = i;
1523 dev = h;
1524 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1525 }
1526 }
1527 }
1528
1529 if ((NULL == dev) || (cur_channel == -1)) {
d56dc612 1530 unlock_kernel();
14d96260 1531 printk(KERN_INFO "s2255: openv4l no dev\n");
38f993ad
DA		 1532 return -ENODEV;
1533 }
1534
14d96260
DA		 1535 if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_DISCONNECTING) {
1536 unlock_kernel();
1537 printk(KERN_INFO "disconnecting\n");
1538 return -ENODEV;
1539 }
1540 kref_get(&dev->kref);
38f993ad
DA		 1541 mutex_lock(&dev->open_lock);
1542
1543 dev->users[cur_channel]++;
f78d92c9 1544 dprintk(4, "s2255: open_handles %d\n", dev->users[cur_channel]);
38f993ad 1545
14d96260
DA		 1546 switch (atomic_read(&dev->fw_data->fw_state)) {
1547 case S2255_FW_FAILED:
38f993ad 1548 err("2255 firmware load failed. retrying.\n");
14d96260 1549 s2255_fwload_start(dev, 1);
38f993ad 1550 wait_event_timeout(dev->fw_data->wait_fw,
14d96260
DA		 1551 ((atomic_read(&dev->fw_data->fw_state)
1552 == S2255_FW_SUCCESS) ||
1553 (atomic_read(&dev->fw_data->fw_state)
1554 == S2255_FW_DISCONNECTING)),
38f993ad 1555 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
14d96260
DA		 1556 break;
1557 case S2255_FW_NOTLOADED:
1558 case S2255_FW_LOADED_DSPWAIT:
38f993ad
DA		 1559 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1560 driver loaded and then device immediately opened */
1561 printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1562 wait_event_timeout(dev->fw_data->wait_fw,
14d96260
DA		 1563 ((atomic_read(&dev->fw_data->fw_state)
1564 == S2255_FW_SUCCESS) ||
1565 (atomic_read(&dev->fw_data->fw_state)
1566 == S2255_FW_DISCONNECTING)),
1567 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1568 break;
1569 case S2255_FW_SUCCESS:
1570 default:
1571 break;
1572 }
1573 state = atomic_read(&dev->fw_data->fw_state);
1574 if (state != S2255_FW_SUCCESS) {
1575 int rc;
1576 switch (state) {
1577 case S2255_FW_FAILED:
1578 printk(KERN_INFO "2255 FW load failed. %d\n", state);
1579 rc = -ENODEV;
1580 break;
1581 case S2255_FW_DISCONNECTING:
1582 printk(KERN_INFO "%s: disconnecting\n", __func__);
1583 rc = -ENODEV;
1584 break;
1585 case S2255_FW_LOADED_DSPWAIT:
1586 case S2255_FW_NOTLOADED:
1587 printk(KERN_INFO "%s: firmware not loaded yet"
1588 "please try again later\n",
1589 __func__);
1590 rc = -EAGAIN;
1591 break;
1592 default:
1593 printk(KERN_INFO "%s: unknown state\n", __func__);
1594 rc = -EFAULT;
1595 break;
38f993ad 1596 }
14d96260
DA		 1597 dev->users[cur_channel]--;
1598 mutex_unlock(&dev->open_lock);
1599 kref_put(&dev->kref, s2255_destroy);
1600 unlock_kernel();
1601 return rc;
38f993ad
DA		 1602 }
1603
1604 /* allocate + initialize per filehandle data */
1605 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1606 if (NULL == fh) {
f78d92c9 1607 dev->users[cur_channel]--;
38f993ad 1608 mutex_unlock(&dev->open_lock);
14d96260 1609 kref_put(&dev->kref, s2255_destroy);
d56dc612 1610 unlock_kernel();
38f993ad
DA		 1611 return -ENOMEM;
1612 }
1613
1614 file->private_data = fh;
1615 fh->dev = dev;
1616 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1617 fh->mode = dev->mode[cur_channel];
1618 fh->fmt = dev->cur_fmt[cur_channel];
1619 /* default 4CIF NTSC */
1620 fh->width = LINE_SZ_4CIFS_NTSC;
1621 fh->height = NUM_LINES_4CIFS_NTSC * 2;
1622 fh->channel = cur_channel;
1623
14d96260
DA		 1624 /* configure channel to default state */
1625 if (!dev->chn_configured[cur_channel]) {
1626 s2255_set_mode(dev, cur_channel, &fh->mode);
1627 dev->chn_configured[cur_channel] = 1;
1628 }
1629
1630
38f993ad
DA		 1631 /* Put all controls at a sane state */
1632 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1633 qctl_regs[i] = s2255_qctrl[i].default_value;
1634
1635 dprintk(1, "s2255drv: open minor=%d type=%s users=%d\n",
1636 minor, v4l2_type_names[type], dev->users[cur_channel]);
1637 dprintk(2, "s2255drv: open: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n",
1638 (unsigned long)fh, (unsigned long)dev,
1639 (unsigned long)&dev->vidq[cur_channel]);
1640 dprintk(4, "s2255drv: open: list_empty active=%d\n",
1641 list_empty(&dev->vidq[cur_channel].active));
1642
1643 videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1644 NULL, &dev->slock,
1645 fh->type,
1646 V4L2_FIELD_INTERLACED,
1647 sizeof(struct s2255_buffer), fh);
1648
38f993ad 1649 mutex_unlock(&dev->open_lock);
d56dc612 1650 unlock_kernel();
38f993ad
DA		 1651 return 0;
1652}
1653
1654
1655static unsigned int s2255_poll(struct file *file,
1656 struct poll_table_struct *wait)
1657{
1658 struct s2255_fh *fh = file->private_data;
1659 int rc;
1660 dprintk(100, "%s\n", __func__);
1661
1662 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1663 return POLLERR;
1664
1665 rc = videobuf_poll_stream(file, &fh->vb_vidq, wait);
1666 return rc;
1667}
1668
1669static void s2255_destroy(struct kref *kref)
1670{
1671 struct s2255_dev *dev = to_s2255_dev(kref);
14d96260
DA		 1672 struct list_head *list;
1673 int i;
38f993ad
DA		 1674 if (!dev) {
1675 printk(KERN_ERR "s2255drv: kref problem\n");
1676 return;
1677 }
f78d92c9
DA		 1678 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
1679 wake_up(&dev->fw_data->wait_fw);
14d96260
DA		 1680 for (i = 0; i < MAX_CHANNELS; i++) {
1681 dev->setmode_ready[i] = 1;
1682 wake_up(&dev->wait_setmode[i]);
1683 }
38f993ad 1684 mutex_lock(&dev->open_lock);
14d96260
DA		 1685 /* reset the DSP so firmware can be reload next time */
1686 s2255_reset_dsppower(dev);
38f993ad 1687 s2255_exit_v4l(dev);
38f993ad
DA		 1688 /* board shutdown stops the read pipe if it is running */
1689 s2255_board_shutdown(dev);
38f993ad 1690 /* make sure firmware still not trying to load */
f78d92c9
DA		 1691 del_timer(&dev->timer); /* only started in .probe and .open */
1692
38f993ad
DA		 1693 if (dev->fw_data->fw_urb) {
1694 dprintk(2, "kill fw_urb\n");
1695 usb_kill_urb(dev->fw_data->fw_urb);
1696 usb_free_urb(dev->fw_data->fw_urb);
1697 dev->fw_data->fw_urb = NULL;
1698 }
f78d92c9
DA		 1699 if (dev->fw_data->fw)
1700 release_firmware(dev->fw_data->fw);
1701 kfree(dev->fw_data->pfw_data);
1702 kfree(dev->fw_data);
38f993ad
DA		 1703 usb_put_dev(dev->udev);
1704 dprintk(1, "%s", __func__);
1705 kfree(dev);
14d96260
DA		 1706
1707 while (!list_empty(&s2255_devlist)) {
1708 list = s2255_devlist.next;
1709 list_del(list);
1710 }
1711 mutex_unlock(&dev->open_lock);
38f993ad
DA		 1712}
1713
bec43661 1714static int s2255_close(struct file *file)
38f993ad
DA		 1715{
1716 struct s2255_fh *fh = file->private_data;
1717 struct s2255_dev *dev = fh->dev;
bec43661 1718 int minor = video_devdata(file)->minor;
38f993ad
DA		 1719 if (!dev)
1720 return -ENODEV;
1721
1722 mutex_lock(&dev->open_lock);
1723
f78d92c9
DA		 1724 /* turn off stream */
1725 if (res_check(fh)) {
1726 if (dev->b_acquire[fh->channel])
1727 s2255_stop_acquire(dev, fh->channel);
1728 videobuf_streamoff(&fh->vb_vidq);
1729 res_free(dev, fh);
1730 }
1731
38f993ad 1732 videobuf_mmap_free(&fh->vb_vidq);
38f993ad 1733 dev->users[fh->channel]--;
f78d92c9 1734
38f993ad
DA		 1735 mutex_unlock(&dev->open_lock);
1736
1737 kref_put(&dev->kref, s2255_destroy);
1738 dprintk(1, "s2255: close called (minor=%d, users=%d)\n",
1739 minor, dev->users[fh->channel]);
f78d92c9 1740 kfree(fh);
38f993ad
DA		 1741 return 0;
1742}
1743
1744static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1745{
1746 struct s2255_fh *fh = file->private_data;
1747 int ret;
1748
1749 if (!fh)
1750 return -ENODEV;
1751 dprintk(4, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1752
1753 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1754
1755 dprintk(4, "vma start=0x%08lx, size=%ld, ret=%d\n",
1756 (unsigned long)vma->vm_start,
1757 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1758
1759 return ret;
1760}
1761
bec43661 1762static const struct v4l2_file_operations s2255_fops_v4l = {
38f993ad
DA		 1763 .owner = THIS_MODULE,
1764 .open = s2255_open,
1765 .release = s2255_close,
1766 .poll = s2255_poll,
1767 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
38f993ad 1768 .mmap = s2255_mmap_v4l,
38f993ad
DA		 1769};
1770
a399810c 1771static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
38f993ad
DA		 1772 .vidioc_querycap = vidioc_querycap,
1773 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1774 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1775 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1776 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1777 .vidioc_reqbufs = vidioc_reqbufs,
1778 .vidioc_querybuf = vidioc_querybuf,
1779 .vidioc_qbuf = vidioc_qbuf,
1780 .vidioc_dqbuf = vidioc_dqbuf,
1781 .vidioc_s_std = vidioc_s_std,
1782 .vidioc_enum_input = vidioc_enum_input,
1783 .vidioc_g_input = vidioc_g_input,
1784 .vidioc_s_input = vidioc_s_input,
1785 .vidioc_queryctrl = vidioc_queryctrl,
1786 .vidioc_g_ctrl = vidioc_g_ctrl,
1787 .vidioc_s_ctrl = vidioc_s_ctrl,
1788 .vidioc_streamon = vidioc_streamon,
1789 .vidioc_streamoff = vidioc_streamoff,
1790#ifdef CONFIG_VIDEO_V4L1_COMPAT
1791 .vidiocgmbuf = vidioc_cgmbuf,
1792#endif
22b88d48
DA		 1793 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1794 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
a399810c
HV		 1795};
1796
1797static struct video_device template = {
1798 .name = "s2255v",
a399810c
HV		 1799 .fops = &s2255_fops_v4l,
1800 .ioctl_ops = &s2255_ioctl_ops,
1801 .minor = -1,
1802 .release = video_device_release,
38f993ad
DA		 1803 .tvnorms = S2255_NORMS,
1804 .current_norm = V4L2_STD_NTSC_M,
1805};
1806
1807static int s2255_probe_v4l(struct s2255_dev *dev)
1808{
1809 int ret;
1810 int i;
1811 int cur_nr = video_nr;
1812
1813 /* initialize all video 4 linux */
1814 list_add_tail(&dev->s2255_devlist, &s2255_devlist);
1815 /* register 4 video devices */
1816 for (i = 0; i < MAX_CHANNELS; i++) {
1817 INIT_LIST_HEAD(&dev->vidq[i].active);
1818 dev->vidq[i].dev = dev;
1819 dev->vidq[i].channel = i;
1820 dev->vidq[i].kthread = NULL;
1821 /* register 4 video devices */
1822 dev->vdev[i] = video_device_alloc();
1823 memcpy(dev->vdev[i], &template, sizeof(struct video_device));
5e85e732 1824 dev->vdev[i]->parent = &dev->interface->dev;
38f993ad
DA		 1825 if (video_nr == -1)
1826 ret = video_register_device(dev->vdev[i],
1827 VFL_TYPE_GRABBER,
1828 video_nr);
1829 else
1830 ret = video_register_device(dev->vdev[i],
1831 VFL_TYPE_GRABBER,
1832 cur_nr + i);
601e9444 1833 video_set_drvdata(dev->vdev[i], dev);
38f993ad
DA		 1834
1835 if (ret != 0) {
1836 dev_err(&dev->udev->dev,
1837 "failed to register video device!\n");
1838 return ret;
1839 }
1840 }
1841 printk(KERN_INFO "Sensoray 2255 V4L driver\n");
1842 return ret;
1843}
1844
1845static void s2255_exit_v4l(struct s2255_dev *dev)
1846{
14d96260 1847
38f993ad 1848 int i;
38f993ad 1849 for (i = 0; i < MAX_CHANNELS; i++) {
14d96260 1850 if (-1 != dev->vdev[i]->minor) {
38f993ad 1851 video_unregister_device(dev->vdev[i]);
14d96260
DA		 1852 printk(KERN_INFO "s2255 unregistered\n");
1853 } else {
38f993ad 1854 video_device_release(dev->vdev[i]);
14d96260
DA		 1855 printk(KERN_INFO "s2255 released\n");
1856 }
38f993ad
DA		 1857 }
1858}
1859
1860/* this function moves the usb stream read pipe data
1861 * into the system buffers.
1862 * returns 0 on success, EAGAIN if more data to process( call this
1863 * function again).
1864 *
1865 * Received frame structure:
14d96260 1866 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
38f993ad
DA		 1867 * bytes 4-7: channel: 0-3
1868 * bytes 8-11: payload size: size of the frame
1869 * bytes 12-payloadsize+12: frame data
1870 */
1871static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1872{
38f993ad
DA		 1873 char *pdest;
1874 u32 offset = 0;
14d96260 1875 int bframe = 0;
38f993ad
DA		 1876 char *psrc;
1877 unsigned long copy_size;
1878 unsigned long size;
1879 s32 idx = -1;
1880 struct s2255_framei *frm;
1881 unsigned char *pdata;
14d96260 1882
38f993ad
DA		 1883 dprintk(100, "buffer to user\n");
1884
1885 idx = dev->cur_frame[dev->cc];
14d96260 1886 frm = &dev->buffer[dev->cc].frame[idx];
38f993ad 1887
14d96260
DA		 1888 if (frm->ulState == S2255_READ_IDLE) {
1889 int jj;
1890 unsigned int cc;
1891 s32 *pdword;
1892 int payload;
1893 /* search for marker codes */
1894 pdata = (unsigned char *)pipe_info->transfer_buffer;
1895 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1896 switch (*(s32 *) pdata) {
1897 case S2255_MARKER_FRAME:
1898 pdword = (s32 *)pdata;
1899 dprintk(4, "found frame marker at offset:"
1900 " %d [%x %x]\n", jj, pdata[0],
1901 pdata[1]);
1902 offset = jj + PREFIX_SIZE;
1903 bframe = 1;
1904 cc = pdword[1];
1905 if (cc >= MAX_CHANNELS) {
1906 printk(KERN_ERR
1907 "bad channel\n");
1908 return -EINVAL;
1909 }
1910 /* reverse it */
1911 dev->cc = G_chnmap[cc];
1912 payload = pdword[3];
1913 if (payload > dev->req_image_size[dev->cc]) {
1914 dev->bad_payload[dev->cc]++;
1915 /* discard the bad frame */
1916 return -EINVAL;
1917 }
1918 dev->pkt_size[dev->cc] = payload;
1919 dev->jpg_size[dev->cc] = pdword[4];
1920 break;
1921 case S2255_MARKER_RESPONSE:
1922 pdword = (s32 *)pdata;
1923 pdata += DEF_USB_BLOCK;
1924 jj += DEF_USB_BLOCK;
1925 if (pdword[1] >= MAX_CHANNELS)
1926 break;
1927 cc = G_chnmap[pdword[1]];
1928 if (!(cc >= 0 && cc < MAX_CHANNELS))
1929 break;
1930 switch (pdword[2]) {
1931 case 0x01:
1932 /* check if channel valid */
1933 /* set mode ready */
1934 dev->setmode_ready[cc] = 1;
1935 wake_up(&dev->wait_setmode[cc]);
1936 dprintk(5, "setmode ready %d\n", cc);
38f993ad 1937 break;
14d96260
DA		 1938 case 0x10:
1939
1940 dev->chn_ready |= (1 << cc);
1941 if ((dev->chn_ready & 0x0f) != 0x0f)
1942 break;
1943 /* all channels ready */
1944 printk(KERN_INFO "s2255: fw loaded\n");
1945 atomic_set(&dev->fw_data->fw_state,
1946 S2255_FW_SUCCESS);
1947 wake_up(&dev->fw_data->wait_fw);
1948 break;
1949 default:
1950 printk(KERN_INFO "s2255 unknwn resp\n");
38f993ad 1951 }
14d96260 1952 default:
38f993ad 1953 pdata++;
14d96260 1954 break;
38f993ad 1955 }
14d96260
DA		 1956 if (bframe)
1957 break;
1958 } /* for */
1959 if (!bframe)
1960 return -EINVAL;
38f993ad
DA		 1961 }
1962
14d96260 1963
38f993ad
DA		 1964 idx = dev->cur_frame[dev->cc];
1965 frm = &dev->buffer[dev->cc].frame[idx];
1966
14d96260
DA		 1967 /* search done. now find out if should be acquiring on this channel */
1968 if (!dev->b_acquire[dev->cc]) {
1969 /* we found a frame, but this channel is turned off */
1970 frm->ulState = S2255_READ_IDLE;
1971 return -EINVAL;
38f993ad
DA		 1972 }
1973
14d96260
DA		 1974 if (frm->ulState == S2255_READ_IDLE) {
1975 frm->ulState = S2255_READ_FRAME;
1976 frm->cur_size = 0;
38f993ad
DA		 1977 }
1978
14d96260
DA		 1979 /* skip the marker 512 bytes (and offset if out of sync) */
1980 psrc = (u8 *)pipe_info->transfer_buffer + offset;
1981
1982
38f993ad
DA		 1983 if (frm->lpvbits == NULL) {
1984 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
1985 frm, dev, dev->cc, idx);
1986 return -ENOMEM;
1987 }
1988
1989 pdest = frm->lpvbits + frm->cur_size;
1990
14d96260 1991 copy_size = (pipe_info->cur_transfer_size - offset);
38f993ad 1992
14d96260 1993 size = dev->pkt_size[dev->cc] - PREFIX_SIZE;
38f993ad 1994
14d96260
DA		 1995 /* sanity check on pdest */
1996 if ((copy_size + frm->cur_size) < dev->req_image_size[dev->cc])
1997 memcpy(pdest, psrc, copy_size);
38f993ad 1998
38f993ad 1999 frm->cur_size += copy_size;
14d96260
DA		 2000 dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
2001
2002 if (frm->cur_size >= size) {
38f993ad 2003
38f993ad 2004 u32 cc = dev->cc;
38f993ad
DA		 2005 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
2006 cc, idx);
2007 dev->last_frame[cc] = dev->cur_frame[cc];
2008 dev->cur_frame[cc]++;
2009 /* end of system frame ring buffer, start at zero */
2010 if ((dev->cur_frame[cc] == SYS_FRAMES) ||
2011 (dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
2012 dev->cur_frame[cc] = 0;
14d96260 2013 /* frame ready */
38f993ad 2014 if (dev->b_acquire[cc])
14d96260 2015 s2255_got_frame(dev, cc, dev->jpg_size[cc]);
38f993ad 2016 dev->frame_count[cc]++;
14d96260
DA		 2017 frm->ulState = S2255_READ_IDLE;
2018 frm->cur_size = 0;
2019
38f993ad
DA		 2020 }
2021 /* done successfully */
2022 return 0;
2023}
2024
2025static void s2255_read_video_callback(struct s2255_dev *dev,
2026 struct s2255_pipeinfo *pipe_info)
2027{
2028 int res;
2029 dprintk(50, "callback read video \n");
2030
2031 if (dev->cc >= MAX_CHANNELS) {
2032 dev->cc = 0;
2033 dev_err(&dev->udev->dev, "invalid channel\n");
2034 return;
2035 }
2036 /* otherwise copy to the system buffers */
2037 res = save_frame(dev, pipe_info);
14d96260
DA		 2038 if (res != 0)
2039 dprintk(4, "s2255: read callback failed\n");
38f993ad
DA		 2040
2041 dprintk(50, "callback read video done\n");
2042 return;
2043}
2044
2045static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
2046 u16 Index, u16 Value, void *TransferBuffer,
2047 s32 TransferBufferLength, int bOut)
2048{
2049 int r;
2050 if (!bOut) {
2051 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2052 Request,
2053 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
2054 USB_DIR_IN,
2055 Value, Index, TransferBuffer,
2056 TransferBufferLength, HZ * 5);
2057 } else {
2058 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2059 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2060 Value, Index, TransferBuffer,
2061 TransferBufferLength, HZ * 5);
2062 }
2063 return r;
2064}
2065
2066/*
2067 * retrieve FX2 firmware version. future use.
2068 * @param dev pointer to device extension
2069 * @return -1 for fail, else returns firmware version as an int(16 bits)
2070 */
2071static int s2255_get_fx2fw(struct s2255_dev *dev)
2072{
2073 int fw;
2074 int ret;
2075 unsigned char transBuffer[64];
2076 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2077 S2255_VR_IN);
2078 if (ret < 0)
2079 dprintk(2, "get fw error: %x\n", ret);
2080 fw = transBuffer[0] + (transBuffer[1] << 8);
2081 dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2082 return fw;
2083}
2084
2085/*
2086 * Create the system ring buffer to copy frames into from the
2087 * usb read pipe.
2088 */
2089static int s2255_create_sys_buffers(struct s2255_dev *dev, unsigned long chn)
2090{
2091 unsigned long i;
2092 unsigned long reqsize;
2093 dprintk(1, "create sys buffers\n");
2094 if (chn >= MAX_CHANNELS)
2095 return -1;
2096
2097 dev->buffer[chn].dwFrames = SYS_FRAMES;
2098
2099 /* always allocate maximum size(PAL) for system buffers */
2100 reqsize = SYS_FRAMES_MAXSIZE;
2101
2102 if (reqsize > SYS_FRAMES_MAXSIZE)
2103 reqsize = SYS_FRAMES_MAXSIZE;
2104
2105 for (i = 0; i < SYS_FRAMES; i++) {
2106 /* allocate the frames */
2107 dev->buffer[chn].frame[i].lpvbits = vmalloc(reqsize);
2108
2109 dprintk(1, "valloc %p chan %lu, idx %lu, pdata %p\n",
2110 &dev->buffer[chn].frame[i], chn, i,
2111 dev->buffer[chn].frame[i].lpvbits);
2112 dev->buffer[chn].frame[i].size = reqsize;
2113 if (dev->buffer[chn].frame[i].lpvbits == NULL) {
2114 printk(KERN_INFO "out of memory. using less frames\n");
2115 dev->buffer[chn].dwFrames = i;
2116 break;
2117 }
2118 }
2119
2120 /* make sure internal states are set */
2121 for (i = 0; i < SYS_FRAMES; i++) {
2122 dev->buffer[chn].frame[i].ulState = 0;
2123 dev->buffer[chn].frame[i].cur_size = 0;
2124 }
2125
2126 dev->cur_frame[chn] = 0;
2127 dev->last_frame[chn] = -1;
2128 return 0;
2129}
2130
2131static int s2255_release_sys_buffers(struct s2255_dev *dev,
2132 unsigned long channel)
2133{
2134 unsigned long i;
2135 dprintk(1, "release sys buffers\n");
2136 for (i = 0; i < SYS_FRAMES; i++) {
2137 if (dev->buffer[channel].frame[i].lpvbits) {
2138 dprintk(1, "vfree %p\n",
2139 dev->buffer[channel].frame[i].lpvbits);
2140 vfree(dev->buffer[channel].frame[i].lpvbits);
2141 }
2142 dev->buffer[channel].frame[i].lpvbits = NULL;
2143 }
2144 return 0;
2145}
2146
2147static int s2255_board_init(struct s2255_dev *dev)
2148{
2149 int j;
2150 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2151 int fw_ver;
2152 dprintk(4, "board init: %p", dev);
2153
2154 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2155 struct s2255_pipeinfo *pipe = &dev->pipes[j];
2156
2157 memset(pipe, 0, sizeof(*pipe));
2158 pipe->dev = dev;
14d96260
DA		 2159 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2160 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
38f993ad 2161
38f993ad
DA		 2162 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2163 GFP_KERNEL);
2164 if (pipe->transfer_buffer == NULL) {
2165 dprintk(1, "out of memory!\n");
2166 return -ENOMEM;
2167 }
2168
2169 }
2170
2171 /* query the firmware */
2172 fw_ver = s2255_get_fx2fw(dev);
2173
2174 printk(KERN_INFO "2255 usb firmware version %d \n", fw_ver);
2175 if (fw_ver < CUR_USB_FWVER)
2176 err("usb firmware not up to date %d\n", fw_ver);
2177
2178 for (j = 0; j < MAX_CHANNELS; j++) {
2179 dev->b_acquire[j] = 0;
2180 dev->mode[j] = mode_def;
22b88d48 2181 dev->jc[j].quality = S2255_DEF_JPEG_QUAL;
38f993ad
DA		 2182 dev->cur_fmt[j] = &formats[0];
2183 dev->mode[j].restart = 1;
2184 dev->req_image_size[j] = get_transfer_size(&mode_def);
2185 dev->frame_count[j] = 0;
2186 /* create the system buffers */
2187 s2255_create_sys_buffers(dev, j);
2188 }
2189 /* start read pipe */
2190 s2255_start_readpipe(dev);
2191
2192 dprintk(1, "S2255: board initialized\n");
2193 return 0;
2194}
2195
2196static int s2255_board_shutdown(struct s2255_dev *dev)
2197{
2198 u32 i;
2199
2200 dprintk(1, "S2255: board shutdown: %p", dev);
2201
2202 for (i = 0; i < MAX_CHANNELS; i++) {
2203 if (dev->b_acquire[i])
2204 s2255_stop_acquire(dev, i);
2205 }
2206
2207 s2255_stop_readpipe(dev);
2208
2209 for (i = 0; i < MAX_CHANNELS; i++)
2210 s2255_release_sys_buffers(dev, i);
2211
2212 /* release transfer buffers */
2213 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2214 struct s2255_pipeinfo *pipe = &dev->pipes[i];
2215 kfree(pipe->transfer_buffer);
2216 }
2217 return 0;
2218}
2219
2220static void read_pipe_completion(struct urb *purb)
2221{
2222 struct s2255_pipeinfo *pipe_info;
2223 struct s2255_dev *dev;
2224 int status;
2225 int pipe;
2226
2227 pipe_info = purb->context;
2228 dprintk(100, "read pipe completion %p, status %d\n", purb,
2229 purb->status);
2230 if (pipe_info == NULL) {
2231 err("no context !");
2232 return;
2233 }
2234
2235 dev = pipe_info->dev;
2236 if (dev == NULL) {
2237 err("no context !");
2238 return;
2239 }
2240 status = purb->status;
2241 if (status != 0) {
2242 dprintk(2, "read_pipe_completion: err\n");
2243 return;
2244 }
2245
2246 if (pipe_info->state == 0) {
2247 dprintk(2, "exiting USB pipe");
2248 return;
2249 }
2250
2251 s2255_read_video_callback(dev, pipe_info);
2252
2253 pipe_info->err_count = 0;
2254 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2255 /* reuse urb */
2256 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2257 pipe,
2258 pipe_info->transfer_buffer,
2259 pipe_info->cur_transfer_size,
2260 read_pipe_completion, pipe_info);
2261
2262 if (pipe_info->state != 0) {
2263 if (usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL)) {
2264 dev_err(&dev->udev->dev, "error submitting urb\n");
2265 usb_free_urb(pipe_info->stream_urb);
2266 }
2267 } else {
2268 dprintk(2, "read pipe complete state 0\n");
2269 }
2270 return;
2271}
2272
2273static int s2255_start_readpipe(struct s2255_dev *dev)
2274{
2275 int pipe;
2276 int retval;
2277 int i;
2278 struct s2255_pipeinfo *pipe_info = dev->pipes;
2279 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2280 dprintk(2, "start pipe IN %d\n", dev->read_endpoint);
2281
2282 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2283 pipe_info->state = 1;
2284 pipe_info->buf_index = (u32) i;
2285 pipe_info->priority_set = 0;
2286 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2287 if (!pipe_info->stream_urb) {
2288 dev_err(&dev->udev->dev,
2289 "ReadStream: Unable to alloc URB");
2290 return -ENOMEM;
2291 }
2292 /* transfer buffer allocated in board_init */
2293 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2294 pipe,
2295 pipe_info->transfer_buffer,
2296 pipe_info->cur_transfer_size,
2297 read_pipe_completion, pipe_info);
2298
2299 pipe_info->urb_size = sizeof(pipe_info->stream_urb);
2300 dprintk(4, "submitting URB %p\n", pipe_info->stream_urb);
2301 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2302 if (retval) {
2303 printk(KERN_ERR "s2255: start read pipe failed\n");
2304 return retval;
2305 }
2306 }
2307
2308 return 0;
2309}
2310
2311/* starts acquisition process */
2312static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn)
2313{
2314 unsigned char *buffer;
2315 int res;
2316 unsigned long chn_rev;
2317 int j;
2318 if (chn >= MAX_CHANNELS) {
2319 dprintk(2, "start acquire failed, bad channel %lu\n", chn);
2320 return -1;
2321 }
2322
2323 chn_rev = G_chnmap[chn];
2324 dprintk(1, "S2255: start acquire %lu \n", chn);
2325
2326 buffer = kzalloc(512, GFP_KERNEL);
2327 if (buffer == NULL) {
2328 dev_err(&dev->udev->dev, "out of mem\n");
2329 return -ENOMEM;
2330 }
2331
2332 dev->last_frame[chn] = -1;
2333 dev->bad_payload[chn] = 0;
2334 dev->cur_frame[chn] = 0;
2335 for (j = 0; j < SYS_FRAMES; j++) {
2336 dev->buffer[chn].frame[j].ulState = 0;
2337 dev->buffer[chn].frame[j].cur_size = 0;
2338 }
2339
2340 /* send the start command */
2341 *(u32 *) buffer = IN_DATA_TOKEN;
2342 *((u32 *) buffer + 1) = (u32) chn_rev;
2343 *((u32 *) buffer + 2) = (u32) CMD_START;
2344 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2345 if (res != 0)
2346 dev_err(&dev->udev->dev, "CMD_START error\n");
2347
2348 dprintk(2, "start acquire exit[%lu] %d \n", chn, res);
2349 kfree(buffer);
2350 return 0;
2351}
2352
2353static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
2354{
2355 unsigned char *buffer;
2356 int res;
2357 unsigned long chn_rev;
2358
2359 if (chn >= MAX_CHANNELS) {
2360 dprintk(2, "stop acquire failed, bad channel %lu\n", chn);
2361 return -1;
2362 }
2363 chn_rev = G_chnmap[chn];
2364
2365 buffer = kzalloc(512, GFP_KERNEL);
2366 if (buffer == NULL) {
2367 dev_err(&dev->udev->dev, "out of mem\n");
2368 return -ENOMEM;
2369 }
2370
2371 /* send the stop command */
2372 dprintk(4, "stop acquire %lu\n", chn);
2373 *(u32 *) buffer = IN_DATA_TOKEN;
2374 *((u32 *) buffer + 1) = (u32) chn_rev;
2375 *((u32 *) buffer + 2) = CMD_STOP;
2376 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2377
2378 if (res != 0)
2379 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2380
2381 dprintk(4, "stop acquire: releasing states \n");
2382
2383 kfree(buffer);
2384 dev->b_acquire[chn] = 0;
2385
14d96260 2386 return res;
38f993ad
DA		 2387}
2388
2389static void s2255_stop_readpipe(struct s2255_dev *dev)
2390{
2391 int j;
2392
2393 if (dev == NULL) {
2394 err("s2255: invalid device");
2395 return;
2396 }
2397 dprintk(4, "stop read pipe\n");
2398 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2399 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2400 if (pipe_info) {
2401 if (pipe_info->state == 0)
2402 continue;
2403 pipe_info->state = 0;
2404 pipe_info->prev_state = 1;
2405
2406 }
2407 }
2408
2409 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2410 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2411 if (pipe_info->stream_urb) {
2412 /* cancel urb */
2413 usb_kill_urb(pipe_info->stream_urb);
2414 usb_free_urb(pipe_info->stream_urb);
2415 pipe_info->stream_urb = NULL;
2416 }
2417 }
2418 dprintk(2, "s2255 stop read pipe: %d\n", j);
2419 return;
2420}
2421
14d96260 2422static void s2255_fwload_start(struct s2255_dev *dev, int reset)
38f993ad 2423{
14d96260
DA		 2424 if (reset)
2425 s2255_reset_dsppower(dev);
38f993ad
DA		 2426 dev->fw_data->fw_size = dev->fw_data->fw->size;
2427 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2428 memcpy(dev->fw_data->pfw_data,
2429 dev->fw_data->fw->data, CHUNK_SIZE);
2430 dev->fw_data->fw_loaded = CHUNK_SIZE;
2431 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2432 usb_sndbulkpipe(dev->udev, 2),
2433 dev->fw_data->pfw_data,
2434 CHUNK_SIZE, s2255_fwchunk_complete,
2435 dev->fw_data);
2436 mod_timer(&dev->timer, jiffies + HZ);
2437}
2438
2439/* standard usb probe function */
2440static int s2255_probe(struct usb_interface *interface,
2441 const struct usb_device_id *id)
2442{
2443 struct s2255_dev *dev = NULL;
2444 struct usb_host_interface *iface_desc;
2445 struct usb_endpoint_descriptor *endpoint;
2446 int i;
2447 int retval = -ENOMEM;
14d96260
DA		 2448 __le32 *pdata;
2449 int fw_size;
38f993ad
DA		 2450
2451 dprintk(2, "s2255: probe\n");
2452
2453 /* allocate memory for our device state and initialize it to zero */
2454 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2455 if (dev == NULL) {
2456 err("s2255: out of memory");
2457 goto error;
2458 }
2459
2460 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2461 if (!dev->fw_data)
2462 goto error;
2463
2464 mutex_init(&dev->lock);
2465 mutex_init(&dev->open_lock);
2466
2467 /* grab usb_device and save it */
2468 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2469 if (dev->udev == NULL) {
2470 dev_err(&interface->dev, "null usb device\n");
2471 retval = -ENODEV;
2472 goto error;
2473 }
2474 kref_init(&dev->kref);
2475 dprintk(1, "dev: %p, kref: %p udev %p interface %p\n", dev, &dev->kref,
2476 dev->udev, interface);
2477 dev->interface = interface;
2478 /* set up the endpoint information */
2479 iface_desc = interface->cur_altsetting;
2480 dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2481 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2482 endpoint = &iface_desc->endpoint[i].desc;
2483 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2484 /* we found the bulk in endpoint */
2485 dev->read_endpoint = endpoint->bEndpointAddress;
2486 }
2487 }
2488
2489 if (!dev->read_endpoint) {
2490 dev_err(&interface->dev, "Could not find bulk-in endpoint");
2491 goto error;
2492 }
2493
2494 /* set intfdata */
2495 usb_set_intfdata(interface, dev);
2496
2497 dprintk(100, "after intfdata %p\n", dev);
2498
2499 init_timer(&dev->timer);
2500 dev->timer.function = s2255_timer;
2501 dev->timer.data = (unsigned long)dev->fw_data;
2502
2503 init_waitqueue_head(&dev->fw_data->wait_fw);
14d96260
DA		 2504 for (i = 0; i < MAX_CHANNELS; i++)
2505 init_waitqueue_head(&dev->wait_setmode[i]);
38f993ad
DA		 2506
2507
2508 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2509
2510 if (!dev->fw_data->fw_urb) {
2511 dev_err(&interface->dev, "out of memory!\n");
2512 goto error;
2513 }
2514 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2515 if (!dev->fw_data->pfw_data) {
2516 dev_err(&interface->dev, "out of memory!\n");
2517 goto error;
2518 }
2519 /* load the first chunk */
2520 if (request_firmware(&dev->fw_data->fw,
2521 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2522 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2523 goto error;
2524 }
14d96260
DA		 2525 /* check the firmware is valid */
2526 fw_size = dev->fw_data->fw->size;
2527 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
38f993ad 2528
14d96260
DA		 2529 if (*pdata != S2255_FW_MARKER) {
2530 printk(KERN_INFO "Firmware invalid.\n");
2531 retval = -ENODEV;
2532 goto error;
2533 } else {
2534 /* make sure firmware is the latest */
2535 __le32 *pRel;
2536 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2537 printk(KERN_INFO "s2255 dsp fw version %x\n", *pRel);
2538 }
38f993ad
DA		 2539 /* loads v4l specific */
2540 s2255_probe_v4l(dev);
14d96260 2541 usb_reset_device(dev->udev);
38f993ad
DA		 2542 /* load 2255 board specific */
2543 s2255_board_init(dev);
2544
2545 dprintk(4, "before probe done %p\n", dev);
2546 spin_lock_init(&dev->slock);
2547
14d96260 2548 s2255_fwload_start(dev, 0);
38f993ad
DA		 2549 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2550 return 0;
2551error:
2552 return retval;
2553}
2554
2555/* disconnect routine. when board is removed physically or with rmmod */
2556static void s2255_disconnect(struct usb_interface *interface)
2557{
2558 struct s2255_dev *dev = NULL;
14d96260 2559 int i;
38f993ad
DA		 2560 dprintk(1, "s2255: disconnect interface %p\n", interface);
2561 dev = usb_get_intfdata(interface);
14d96260
DA		 2562
2563 /*
2564 * wake up any of the timers to allow open_lock to be
2565 * acquired sooner
2566 */
2567 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2568 wake_up(&dev->fw_data->wait_fw);
2569 for (i = 0; i < MAX_CHANNELS; i++) {
2570 dev->setmode_ready[i] = 1;
2571 wake_up(&dev->wait_setmode[i]);
2572 }
2573
2574 mutex_lock(&dev->open_lock);
2575 usb_set_intfdata(interface, NULL);
2576 mutex_unlock(&dev->open_lock);
2577
38f993ad
DA		 2578 if (dev) {
2579 kref_put(&dev->kref, s2255_destroy);
2580 dprintk(1, "s2255drv: disconnect\n");
2581 dev_info(&interface->dev, "s2255usb now disconnected\n");
2582 }
38f993ad
DA		 2583}
2584
2585static struct usb_driver s2255_driver = {
2586 .name = "s2255",
2587 .probe = s2255_probe,
2588 .disconnect = s2255_disconnect,
2589 .id_table = s2255_table,
2590};
2591
2592static int __init usb_s2255_init(void)
2593{
2594 int result;
2595
2596 /* register this driver with the USB subsystem */
2597 result = usb_register(&s2255_driver);
2598
2599 if (result)
2600 err("usb_register failed. Error number %d", result);
2601
2602 dprintk(2, "s2255_init: done\n");
2603 return result;
2604}
2605
2606static void __exit usb_s2255_exit(void)
2607{
2608 usb_deregister(&s2255_driver);
2609}
2610
2611module_init(usb_s2255_init);
2612module_exit(usb_s2255_exit);
2613
2614MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2615MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2616MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror