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