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