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