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