?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / media / usb / s2255 / s2255drv.c
blob6bc9b8e19e20d889d225fdc1864f15b881b18184
1 /*
2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
3 *
4 * Copyright (C) 2007-2013 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.23.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 (res_locked(fh)) {
1307 dprintk(1, "can't change standard after started\n");
1308 ret = -EBUSY;
1309 goto out_s_std;
1310 }
1311 mode = fh->channel->mode;
1312 if (i & V4L2_STD_525_60) {
1313 dprintk(4, "%s 60 Hz\n", __func__);
1314 /* if changing format, reset frame decimation/intervals */
1315 if (mode.format != FORMAT_NTSC) {
1316 mode.restart = 1;
1317 mode.format = FORMAT_NTSC;
1318 mode.fdec = FDEC_1;
1319 channel->width = LINE_SZ_4CIFS_NTSC;
1320 channel->height = NUM_LINES_4CIFS_NTSC * 2;
1321 }
1322 } else if (i & V4L2_STD_625_50) {
1323 dprintk(4, "%s 50 Hz\n", __func__);
1324 if (mode.format != FORMAT_PAL) {
1325 mode.restart = 1;
1326 mode.format = FORMAT_PAL;
1327 mode.fdec = FDEC_1;
1328 channel->width = LINE_SZ_4CIFS_PAL;
1329 channel->height = NUM_LINES_4CIFS_PAL * 2;
1330 }
1331 } else {
1332 ret = -EINVAL;
1333 goto out_s_std;
1334 }
1335 fh->channel->std = i;
1336 if (mode.restart)
1337 s2255_set_mode(fh->channel, &mode);
1338 out_s_std:
1339 mutex_unlock(&q->vb_lock);
1340 return ret;
1341 }
1342
1343 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i)
1344 {
1345 struct s2255_fh *fh = priv;
1346
1347 *i = fh->channel->std;
1348 return 0;
1349 }
1350
1351 /* Sensoray 2255 is a multiple channel capture device.
1352 It does not have a "crossbar" of inputs.
1353 We use one V4L device per channel. The user must
1354 be aware that certain combinations are not allowed.
1355 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1356 at once in color(you can do full fps on 4 channels with greyscale.
1357 */
1358 static int vidioc_enum_input(struct file *file, void *priv,
1359 struct v4l2_input *inp)
1360 {
1361 struct s2255_fh *fh = priv;
1362 struct s2255_dev *dev = fh->dev;
1363 struct s2255_channel *channel = fh->channel;
1364 u32 status = 0;
1365 if (inp->index != 0)
1366 return -EINVAL;
1367 inp->type = V4L2_INPUT_TYPE_CAMERA;
1368 inp->std = S2255_NORMS;
1369 inp->status = 0;
1370 if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1371 int rc;
1372 rc = s2255_cmd_status(fh->channel, &status);
1373 dprintk(4, "s2255_cmd_status rc: %d status %x\n", rc, status);
1374 if (rc == 0)
1375 inp->status = (status & 0x01) ? 0
1376 : V4L2_IN_ST_NO_SIGNAL;
1377 }
1378 switch (dev->pid) {
1379 case 0x2255:
1380 default:
1381 strlcpy(inp->name, "Composite", sizeof(inp->name));
1382 break;
1383 case 0x2257:
1384 strlcpy(inp->name, (channel->idx < 2) ? "Composite" : "S-Video",
1385 sizeof(inp->name));
1386 break;
1387 }
1388 return 0;
1389 }
1390
1391 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1392 {
1393 *i = 0;
1394 return 0;
1395 }
1396 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1397 {
1398 if (i > 0)
1399 return -EINVAL;
1400 return 0;
1401 }
1402
1403 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
1404 {
1405 struct s2255_channel *channel =
1406 container_of(ctrl->handler, struct s2255_channel, hdl);
1407 struct s2255_mode mode;
1408
1409 mode = channel->mode;
1410 dprintk(4, "%s\n", __func__);
1411
1412 /* update the mode to the corresponding value */
1413 switch (ctrl->id) {
1414 case V4L2_CID_BRIGHTNESS:
1415 mode.bright = ctrl->val;
1416 break;
1417 case V4L2_CID_CONTRAST:
1418 mode.contrast = ctrl->val;
1419 break;
1420 case V4L2_CID_HUE:
1421 mode.hue = ctrl->val;
1422 break;
1423 case V4L2_CID_SATURATION:
1424 mode.saturation = ctrl->val;
1425 break;
1426 case V4L2_CID_S2255_COLORFILTER:
1427 mode.color &= ~MASK_INPUT_TYPE;
1428 mode.color |= !ctrl->val << 16;
1429 break;
1430 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1431 channel->jpegqual = ctrl->val;
1432 return 0;
1433 default:
1434 return -EINVAL;
1435 }
1436 mode.restart = 0;
1437 /* set mode here. Note: stream does not need restarted.
1438 some V4L programs restart stream unnecessarily
1439 after a s_crtl.
1440 */
1441 s2255_set_mode(channel, &mode);
1442 return 0;
1443 }
1444
1445 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1446 struct v4l2_jpegcompression *jc)
1447 {
1448 struct s2255_fh *fh = priv;
1449 struct s2255_channel *channel = fh->channel;
1450
1451 memset(jc, 0, sizeof(*jc));
1452 jc->quality = channel->jpegqual;
1453 dprintk(2, "%s: quality %d\n", __func__, jc->quality);
1454 return 0;
1455 }
1456
1457 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1458 const struct v4l2_jpegcompression *jc)
1459 {
1460 struct s2255_fh *fh = priv;
1461 struct s2255_channel *channel = fh->channel;
1462 if (jc->quality < 0 || jc->quality > 100)
1463 return -EINVAL;
1464 v4l2_ctrl_s_ctrl(channel->jpegqual_ctrl, jc->quality);
1465 dprintk(2, "%s: quality %d\n", __func__, jc->quality);
1466 return 0;
1467 }
1468
1469 static int vidioc_g_parm(struct file *file, void *priv,
1470 struct v4l2_streamparm *sp)
1471 {
1472 struct s2255_fh *fh = priv;
1473 __u32 def_num, def_dem;
1474 struct s2255_channel *channel = fh->channel;
1475 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1476 return -EINVAL;
1477 sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1478 sp->parm.capture.capturemode = channel->cap_parm.capturemode;
1479 def_num = (channel->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1480 def_dem = (channel->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1481 sp->parm.capture.timeperframe.denominator = def_dem;
1482 switch (channel->mode.fdec) {
1483 default:
1484 case FDEC_1:
1485 sp->parm.capture.timeperframe.numerator = def_num;
1486 break;
1487 case FDEC_2:
1488 sp->parm.capture.timeperframe.numerator = def_num * 2;
1489 break;
1490 case FDEC_3:
1491 sp->parm.capture.timeperframe.numerator = def_num * 3;
1492 break;
1493 case FDEC_5:
1494 sp->parm.capture.timeperframe.numerator = def_num * 5;
1495 break;
1496 }
1497 dprintk(4, "%s capture mode, %d timeperframe %d/%d\n", __func__,
1498 sp->parm.capture.capturemode,
1499 sp->parm.capture.timeperframe.numerator,
1500 sp->parm.capture.timeperframe.denominator);
1501 return 0;
1502 }
1503
1504 static int vidioc_s_parm(struct file *file, void *priv,
1505 struct v4l2_streamparm *sp)
1506 {
1507 struct s2255_fh *fh = priv;
1508 struct s2255_channel *channel = fh->channel;
1509 struct s2255_mode mode;
1510 int fdec = FDEC_1;
1511 __u32 def_num, def_dem;
1512 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1513 return -EINVAL;
1514 mode = channel->mode;
1515 /* high quality capture mode requires a stream restart */
1516 if (channel->cap_parm.capturemode
1517 != sp->parm.capture.capturemode && res_locked(fh))
1518 return -EBUSY;
1519 def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1520 def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1521 if (def_dem != sp->parm.capture.timeperframe.denominator)
1522 sp->parm.capture.timeperframe.numerator = def_num;
1523 else if (sp->parm.capture.timeperframe.numerator <= def_num)
1524 sp->parm.capture.timeperframe.numerator = def_num;
1525 else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1526 sp->parm.capture.timeperframe.numerator = def_num * 2;
1527 fdec = FDEC_2;
1528 } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1529 sp->parm.capture.timeperframe.numerator = def_num * 3;
1530 fdec = FDEC_3;
1531 } else {
1532 sp->parm.capture.timeperframe.numerator = def_num * 5;
1533 fdec = FDEC_5;
1534 }
1535 mode.fdec = fdec;
1536 sp->parm.capture.timeperframe.denominator = def_dem;
1537 s2255_set_mode(channel, &mode);
1538 dprintk(4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1539 __func__,
1540 sp->parm.capture.capturemode,
1541 sp->parm.capture.timeperframe.numerator,
1542 sp->parm.capture.timeperframe.denominator, fdec);
1543 return 0;
1544 }
1545
1546 #define NUM_SIZE_ENUMS 3
1547 static const struct v4l2_frmsize_discrete ntsc_sizes[] = {
1548 { 640, 480 },
1549 { 640, 240 },
1550 { 320, 240 },
1551 };
1552 static const struct v4l2_frmsize_discrete pal_sizes[] = {
1553 { 704, 576 },
1554 { 704, 288 },
1555 { 352, 288 },
1556 };
1557
1558 static int vidioc_enum_framesizes(struct file *file, void *priv,
1559 struct v4l2_frmsizeenum *fe)
1560 {
1561 struct s2255_fh *fh = priv;
1562 struct s2255_channel *channel = fh->channel;
1563 int is_ntsc = channel->std & V4L2_STD_525_60;
1564 const struct s2255_fmt *fmt;
1565
1566 if (fe->index >= NUM_SIZE_ENUMS)
1567 return -EINVAL;
1568
1569 fmt = format_by_fourcc(fe->pixel_format);
1570 if (fmt == NULL)
1571 return -EINVAL;
1572 fe->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1573 fe->discrete = is_ntsc ? ntsc_sizes[fe->index] : pal_sizes[fe->index];
1574 return 0;
1575 }
1576
1577 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1578 struct v4l2_frmivalenum *fe)
1579 {
1580 struct s2255_fh *fh = priv;
1581 struct s2255_channel *channel = fh->channel;
1582 const struct s2255_fmt *fmt;
1583 const struct v4l2_frmsize_discrete *sizes;
1584 int is_ntsc = channel->std & V4L2_STD_525_60;
1585 #define NUM_FRAME_ENUMS 4
1586 int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1587 int i;
1588
1589 if (fe->index >= NUM_FRAME_ENUMS)
1590 return -EINVAL;
1591
1592 fmt = format_by_fourcc(fe->pixel_format);
1593 if (fmt == NULL)
1594 return -EINVAL;
1595
1596 sizes = is_ntsc ? ntsc_sizes : pal_sizes;
1597 for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++)
1598 if (fe->width == sizes->width &&
1599 fe->height == sizes->height)
1600 break;
1601 if (i == NUM_SIZE_ENUMS)
1602 return -EINVAL;
1603
1604 fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1605 fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1606 fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1607 dprintk(4, "%s discrete %d/%d\n", __func__, fe->discrete.numerator,
1608 fe->discrete.denominator);
1609 return 0;
1610 }
1611
1612 static int __s2255_open(struct file *file)
1613 {
1614 struct video_device *vdev = video_devdata(file);
1615 struct s2255_channel *channel = video_drvdata(file);
1616 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1617 struct s2255_fh *fh;
1618 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1619 int state;
1620 dprintk(1, "s2255: open called (dev=%s)\n",
1621 video_device_node_name(vdev));
1622 state = atomic_read(&dev->fw_data->fw_state);
1623 switch (state) {
1624 case S2255_FW_DISCONNECTING:
1625 return -ENODEV;
1626 case S2255_FW_FAILED:
1627 s2255_dev_err(&dev->udev->dev,
1628 "firmware load failed. retrying.\n");
1629 s2255_fwload_start(dev, 1);
1630 wait_event_timeout(dev->fw_data->wait_fw,
1631 ((atomic_read(&dev->fw_data->fw_state)
1632 == S2255_FW_SUCCESS) ||
1633 (atomic_read(&dev->fw_data->fw_state)
1634 == S2255_FW_DISCONNECTING)),
1635 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1636 /* state may have changed, re-read */
1637 state = atomic_read(&dev->fw_data->fw_state);
1638 break;
1639 case S2255_FW_NOTLOADED:
1640 case S2255_FW_LOADED_DSPWAIT:
1641 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1642 driver loaded and then device immediately opened */
1643 printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1644 wait_event_timeout(dev->fw_data->wait_fw,
1645 ((atomic_read(&dev->fw_data->fw_state)
1646 == S2255_FW_SUCCESS) ||
1647 (atomic_read(&dev->fw_data->fw_state)
1648 == S2255_FW_DISCONNECTING)),
1649 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1650 /* state may have changed, re-read */
1651 state = atomic_read(&dev->fw_data->fw_state);
1652 break;
1653 case S2255_FW_SUCCESS:
1654 default:
1655 break;
1656 }
1657 /* state may have changed in above switch statement */
1658 switch (state) {
1659 case S2255_FW_SUCCESS:
1660 break;
1661 case S2255_FW_FAILED:
1662 printk(KERN_INFO "2255 firmware load failed.\n");
1663 return -ENODEV;
1664 case S2255_FW_DISCONNECTING:
1665 printk(KERN_INFO "%s: disconnecting\n", __func__);
1666 return -ENODEV;
1667 case S2255_FW_LOADED_DSPWAIT:
1668 case S2255_FW_NOTLOADED:
1669 printk(KERN_INFO "%s: firmware not loaded yet"
1670 "please try again later\n",
1671 __func__);
1672 /*
1673 * Timeout on firmware load means device unusable.
1674 * Set firmware failure state.
1675 * On next s2255_open the firmware will be reloaded.
1676 */
1677 atomic_set(&dev->fw_data->fw_state,
1678 S2255_FW_FAILED);
1679 return -EAGAIN;
1680 default:
1681 printk(KERN_INFO "%s: unknown state\n", __func__);
1682 return -EFAULT;
1683 }
1684 /* allocate + initialize per filehandle data */
1685 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1686 if (NULL == fh)
1687 return -ENOMEM;
1688 v4l2_fh_init(&fh->fh, vdev);
1689 v4l2_fh_add(&fh->fh);
1690 file->private_data = &fh->fh;
1691 fh->dev = dev;
1692 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1693 fh->channel = channel;
1694 if (!channel->configured) {
1695 /* configure channel to default state */
1696 channel->fmt = &formats[0];
1697 s2255_set_mode(channel, &channel->mode);
1698 channel->configured = 1;
1699 }
1700 dprintk(1, "%s: dev=%s type=%s\n", __func__,
1701 video_device_node_name(vdev), v4l2_type_names[type]);
1702 dprintk(2, "%s: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n", __func__,
1703 (unsigned long)fh, (unsigned long)dev,
1704 (unsigned long)&channel->vidq);
1705 dprintk(4, "%s: list_empty active=%d\n", __func__,
1706 list_empty(&channel->vidq.active));
1707 videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1708 NULL, &dev->slock,
1709 fh->type,
1710 V4L2_FIELD_INTERLACED,
1711 sizeof(struct s2255_buffer),
1712 fh, vdev->lock);
1713 return 0;
1714 }
1715
1716 static int s2255_open(struct file *file)
1717 {
1718 struct video_device *vdev = video_devdata(file);
1719 int ret;
1720
1721 if (mutex_lock_interruptible(vdev->lock))
1722 return -ERESTARTSYS;
1723 ret = __s2255_open(file);
1724 mutex_unlock(vdev->lock);
1725 return ret;
1726 }
1727
1728 static unsigned int s2255_poll(struct file *file,
1729 struct poll_table_struct *wait)
1730 {
1731 struct s2255_fh *fh = file->private_data;
1732 struct s2255_dev *dev = fh->dev;
1733 int rc = v4l2_ctrl_poll(file, wait);
1734
1735 dprintk(100, "%s\n", __func__);
1736 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1737 return POLLERR;
1738 mutex_lock(&dev->lock);
1739 rc |= videobuf_poll_stream(file, &fh->vb_vidq, wait);
1740 mutex_unlock(&dev->lock);
1741 return rc;
1742 }
1743
1744 static void s2255_destroy(struct s2255_dev *dev)
1745 {
1746 /* board shutdown stops the read pipe if it is running */
1747 s2255_board_shutdown(dev);
1748 /* make sure firmware still not trying to load */
1749 del_timer(&dev->timer); /* only started in .probe and .open */
1750 if (dev->fw_data->fw_urb) {
1751 usb_kill_urb(dev->fw_data->fw_urb);
1752 usb_free_urb(dev->fw_data->fw_urb);
1753 dev->fw_data->fw_urb = NULL;
1754 }
1755 release_firmware(dev->fw_data->fw);
1756 kfree(dev->fw_data->pfw_data);
1757 kfree(dev->fw_data);
1758 /* reset the DSP so firmware can be reloaded next time */
1759 s2255_reset_dsppower(dev);
1760 mutex_destroy(&dev->lock);
1761 usb_put_dev(dev->udev);
1762 v4l2_device_unregister(&dev->v4l2_dev);
1763 dprintk(1, "%s", __func__);
1764 kfree(dev);
1765 }
1766
1767 static int s2255_release(struct file *file)
1768 {
1769 struct s2255_fh *fh = file->private_data;
1770 struct s2255_dev *dev = fh->dev;
1771 struct video_device *vdev = video_devdata(file);
1772 struct s2255_channel *channel = fh->channel;
1773 if (!dev)
1774 return -ENODEV;
1775 mutex_lock(&dev->lock);
1776 /* turn off stream */
1777 if (res_check(fh)) {
1778 if (channel->b_acquire)
1779 s2255_stop_acquire(fh->channel);
1780 videobuf_streamoff(&fh->vb_vidq);
1781 res_free(fh);
1782 }
1783 videobuf_mmap_free(&fh->vb_vidq);
1784 mutex_unlock(&dev->lock);
1785 dprintk(1, "%s (dev=%s)\n", __func__, video_device_node_name(vdev));
1786 v4l2_fh_del(&fh->fh);
1787 v4l2_fh_exit(&fh->fh);
1788 kfree(fh);
1789 return 0;
1790 }
1791
1792 static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1793 {
1794 struct s2255_fh *fh = file->private_data;
1795 struct s2255_dev *dev;
1796 int ret;
1797
1798 if (!fh)
1799 return -ENODEV;
1800 dev = fh->dev;
1801 dprintk(4, "%s, vma=0x%08lx\n", __func__, (unsigned long)vma);
1802 if (mutex_lock_interruptible(&dev->lock))
1803 return -ERESTARTSYS;
1804 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1805 mutex_unlock(&dev->lock);
1806 dprintk(4, "%s vma start=0x%08lx, size=%ld, ret=%d\n", __func__,
1807 (unsigned long)vma->vm_start,
1808 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1809 return ret;
1810 }
1811
1812 static const struct v4l2_file_operations s2255_fops_v4l = {
1813 .owner = THIS_MODULE,
1814 .open = s2255_open,
1815 .release = s2255_release,
1816 .poll = s2255_poll,
1817 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1818 .mmap = s2255_mmap_v4l,
1819 };
1820
1821 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1822 .vidioc_querycap = vidioc_querycap,
1823 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1824 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1825 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1826 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1827 .vidioc_reqbufs = vidioc_reqbufs,
1828 .vidioc_querybuf = vidioc_querybuf,
1829 .vidioc_qbuf = vidioc_qbuf,
1830 .vidioc_dqbuf = vidioc_dqbuf,
1831 .vidioc_s_std = vidioc_s_std,
1832 .vidioc_g_std = vidioc_g_std,
1833 .vidioc_enum_input = vidioc_enum_input,
1834 .vidioc_g_input = vidioc_g_input,
1835 .vidioc_s_input = vidioc_s_input,
1836 .vidioc_streamon = vidioc_streamon,
1837 .vidioc_streamoff = vidioc_streamoff,
1838 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1839 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1840 .vidioc_s_parm = vidioc_s_parm,
1841 .vidioc_g_parm = vidioc_g_parm,
1842 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1843 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1844 .vidioc_log_status = v4l2_ctrl_log_status,
1845 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1846 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1847 };
1848
1849 static void s2255_video_device_release(struct video_device *vdev)
1850 {
1851 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1852 struct s2255_channel *channel =
1853 container_of(vdev, struct s2255_channel, vdev);
1854
1855 v4l2_ctrl_handler_free(&channel->hdl);
1856 dprintk(4, "%s, chnls: %d\n", __func__,
1857 atomic_read(&dev->num_channels));
1858
1859 if (atomic_dec_and_test(&dev->num_channels))
1860 s2255_destroy(dev);
1861 return;
1862 }
1863
1864 static struct video_device template = {
1865 .name = "s2255v",
1866 .fops = &s2255_fops_v4l,
1867 .ioctl_ops = &s2255_ioctl_ops,
1868 .release = s2255_video_device_release,
1869 .tvnorms = S2255_NORMS,
1870 };
1871
1872 static const struct v4l2_ctrl_ops s2255_ctrl_ops = {
1873 .s_ctrl = s2255_s_ctrl,
1874 };
1875
1876 static const struct v4l2_ctrl_config color_filter_ctrl = {
1877 .ops = &s2255_ctrl_ops,
1878 .name = "Color Filter",
1879 .id = V4L2_CID_S2255_COLORFILTER,
1880 .type = V4L2_CTRL_TYPE_BOOLEAN,
1881 .max = 1,
1882 .step = 1,
1883 .def = 1,
1884 };
1885
1886 static int s2255_probe_v4l(struct s2255_dev *dev)
1887 {
1888 int ret;
1889 int i;
1890 int cur_nr = video_nr;
1891 struct s2255_channel *channel;
1892 ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1893 if (ret)
1894 return ret;
1895 /* initialize all video 4 linux */
1896 /* register 4 video devices */
1897 for (i = 0; i < MAX_CHANNELS; i++) {
1898 channel = &dev->channel[i];
1899 INIT_LIST_HEAD(&channel->vidq.active);
1900
1901 v4l2_ctrl_handler_init(&channel->hdl, 6);
1902 v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
1903 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
1904 v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
1905 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
1906 v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
1907 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
1908 v4l2_ctrl_new_std(&channel->hdl, &s2255_ctrl_ops,
1909 V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
1910 channel->jpegqual_ctrl = v4l2_ctrl_new_std(&channel->hdl,
1911 &s2255_ctrl_ops,
1912 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1913 0, 100, 1, S2255_DEF_JPEG_QUAL);
1914 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1915 (dev->pid != 0x2257 || channel->idx <= 1))
1916 v4l2_ctrl_new_custom(&channel->hdl, &color_filter_ctrl, NULL);
1917 if (channel->hdl.error) {
1918 ret = channel->hdl.error;
1919 v4l2_ctrl_handler_free(&channel->hdl);
1920 dev_err(&dev->udev->dev, "couldn't register control\n");
1921 break;
1922 }
1923 channel->vidq.dev = dev;
1924 /* register 4 video devices */
1925 channel->vdev = template;
1926 channel->vdev.ctrl_handler = &channel->hdl;
1927 channel->vdev.lock = &dev->lock;
1928 channel->vdev.v4l2_dev = &dev->v4l2_dev;
1929 set_bit(V4L2_FL_USE_FH_PRIO, &channel->vdev.flags);
1930 video_set_drvdata(&channel->vdev, channel);
1931 if (video_nr == -1)
1932 ret = video_register_device(&channel->vdev,
1933 VFL_TYPE_GRABBER,
1934 video_nr);
1935 else
1936 ret = video_register_device(&channel->vdev,
1937 VFL_TYPE_GRABBER,
1938 cur_nr + i);
1939
1940 if (ret) {
1941 dev_err(&dev->udev->dev,
1942 "failed to register video device!\n");
1943 break;
1944 }
1945 atomic_inc(&dev->num_channels);
1946 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1947 video_device_node_name(&channel->vdev));
1948
1949 }
1950 printk(KERN_INFO "Sensoray 2255 V4L driver Revision: %s\n",
1951 S2255_VERSION);
1952 /* if no channels registered, return error and probe will fail*/
1953 if (atomic_read(&dev->num_channels) == 0) {
1954 v4l2_device_unregister(&dev->v4l2_dev);
1955 return ret;
1956 }
1957 if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1958 printk(KERN_WARNING "s2255: Not all channels available.\n");
1959 return 0;
1960 }
1961
1962 /* this function moves the usb stream read pipe data
1963 * into the system buffers.
1964 * returns 0 on success, EAGAIN if more data to process( call this
1965 * function again).
1966 *
1967 * Received frame structure:
1968 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1969 * bytes 4-7: channel: 0-3
1970 * bytes 8-11: payload size: size of the frame
1971 * bytes 12-payloadsize+12: frame data
1972 */
1973 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1974 {
1975 char *pdest;
1976 u32 offset = 0;
1977 int bframe = 0;
1978 char *psrc;
1979 unsigned long copy_size;
1980 unsigned long size;
1981 s32 idx = -1;
1982 struct s2255_framei *frm;
1983 unsigned char *pdata;
1984 struct s2255_channel *channel;
1985 dprintk(100, "buffer to user\n");
1986 channel = &dev->channel[dev->cc];
1987 idx = channel->cur_frame;
1988 frm = &channel->buffer.frame[idx];
1989 if (frm->ulState == S2255_READ_IDLE) {
1990 int jj;
1991 unsigned int cc;
1992 __le32 *pdword; /*data from dsp is little endian */
1993 int payload;
1994 /* search for marker codes */
1995 pdata = (unsigned char *)pipe_info->transfer_buffer;
1996 pdword = (__le32 *)pdata;
1997 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1998 switch (*pdword) {
1999 case S2255_MARKER_FRAME:
2000 dprintk(4, "found frame marker at offset:"
2001 " %d [%x %x]\n", jj, pdata[0],
2002 pdata[1]);
2003 offset = jj + PREFIX_SIZE;
2004 bframe = 1;
2005 cc = le32_to_cpu(pdword[1]);
2006 if (cc >= MAX_CHANNELS) {
2007 printk(KERN_ERR
2008 "bad channel\n");
2009 return -EINVAL;
2010 }
2011 /* reverse it */
2012 dev->cc = G_chnmap[cc];
2013 channel = &dev->channel[dev->cc];
2014 payload = le32_to_cpu(pdword[3]);
2015 if (payload > channel->req_image_size) {
2016 channel->bad_payload++;
2017 /* discard the bad frame */
2018 return -EINVAL;
2019 }
2020 channel->pkt_size = payload;
2021 channel->jpg_size = le32_to_cpu(pdword[4]);
2022 break;
2023 case S2255_MARKER_RESPONSE:
2024
2025 pdata += DEF_USB_BLOCK;
2026 jj += DEF_USB_BLOCK;
2027 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
2028 break;
2029 cc = G_chnmap[le32_to_cpu(pdword[1])];
2030 if (cc >= MAX_CHANNELS)
2031 break;
2032 channel = &dev->channel[cc];
2033 switch (pdword[2]) {
2034 case S2255_RESPONSE_SETMODE:
2035 /* check if channel valid */
2036 /* set mode ready */
2037 channel->setmode_ready = 1;
2038 wake_up(&channel->wait_setmode);
2039 dprintk(5, "setmode ready %d\n", cc);
2040 break;
2041 case S2255_RESPONSE_FW:
2042 dev->chn_ready |= (1 << cc);
2043 if ((dev->chn_ready & 0x0f) != 0x0f)
2044 break;
2045 /* all channels ready */
2046 printk(KERN_INFO "s2255: fw loaded\n");
2047 atomic_set(&dev->fw_data->fw_state,
2048 S2255_FW_SUCCESS);
2049 wake_up(&dev->fw_data->wait_fw);
2050 break;
2051 case S2255_RESPONSE_STATUS:
2052 channel->vidstatus = le32_to_cpu(pdword[3]);
2053 channel->vidstatus_ready = 1;
2054 wake_up(&channel->wait_vidstatus);
2055 dprintk(5, "got vidstatus %x chan %d\n",
2056 le32_to_cpu(pdword[3]), cc);
2057 break;
2058 default:
2059 printk(KERN_INFO "s2255 unknown resp\n");
2060 }
2061 default:
2062 pdata++;
2063 break;
2064 }
2065 if (bframe)
2066 break;
2067 } /* for */
2068 if (!bframe)
2069 return -EINVAL;
2070 }
2071 channel = &dev->channel[dev->cc];
2072 idx = channel->cur_frame;
2073 frm = &channel->buffer.frame[idx];
2074 /* search done. now find out if should be acquiring on this channel */
2075 if (!channel->b_acquire) {
2076 /* we found a frame, but this channel is turned off */
2077 frm->ulState = S2255_READ_IDLE;
2078 return -EINVAL;
2079 }
2080
2081 if (frm->ulState == S2255_READ_IDLE) {
2082 frm->ulState = S2255_READ_FRAME;
2083 frm->cur_size = 0;
2084 }
2085
2086 /* skip the marker 512 bytes (and offset if out of sync) */
2087 psrc = (u8 *)pipe_info->transfer_buffer + offset;
2088
2089
2090 if (frm->lpvbits == NULL) {
2091 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
2092 frm, dev, dev->cc, idx);
2093 return -ENOMEM;
2094 }
2095
2096 pdest = frm->lpvbits + frm->cur_size;
2097
2098 copy_size = (pipe_info->cur_transfer_size - offset);
2099
2100 size = channel->pkt_size - PREFIX_SIZE;
2101
2102 /* sanity check on pdest */
2103 if ((copy_size + frm->cur_size) < channel->req_image_size)
2104 memcpy(pdest, psrc, copy_size);
2105
2106 frm->cur_size += copy_size;
2107 dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
2108
2109 if (frm->cur_size >= size) {
2110 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
2111 dev->cc, idx);
2112 channel->last_frame = channel->cur_frame;
2113 channel->cur_frame++;
2114 /* end of system frame ring buffer, start at zero */
2115 if ((channel->cur_frame == SYS_FRAMES) ||
2116 (channel->cur_frame == channel->buffer.dwFrames))
2117 channel->cur_frame = 0;
2118 /* frame ready */
2119 if (channel->b_acquire)
2120 s2255_got_frame(channel, channel->jpg_size);
2121 channel->frame_count++;
2122 frm->ulState = S2255_READ_IDLE;
2123 frm->cur_size = 0;
2124
2125 }
2126 /* done successfully */
2127 return 0;
2128 }
2129
2130 static void s2255_read_video_callback(struct s2255_dev *dev,
2131 struct s2255_pipeinfo *pipe_info)
2132 {
2133 int res;
2134 dprintk(50, "callback read video \n");
2135
2136 if (dev->cc >= MAX_CHANNELS) {
2137 dev->cc = 0;
2138 dev_err(&dev->udev->dev, "invalid channel\n");
2139 return;
2140 }
2141 /* otherwise copy to the system buffers */
2142 res = save_frame(dev, pipe_info);
2143 if (res != 0)
2144 dprintk(4, "s2255: read callback failed\n");
2145
2146 dprintk(50, "callback read video done\n");
2147 return;
2148 }
2149
2150 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
2151 u16 Index, u16 Value, void *TransferBuffer,
2152 s32 TransferBufferLength, int bOut)
2153 {
2154 int r;
2155 if (!bOut) {
2156 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2157 Request,
2158 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
2159 USB_DIR_IN,
2160 Value, Index, TransferBuffer,
2161 TransferBufferLength, HZ * 5);
2162 } else {
2163 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2164 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2165 Value, Index, TransferBuffer,
2166 TransferBufferLength, HZ * 5);
2167 }
2168 return r;
2169 }
2170
2171 /*
2172 * retrieve FX2 firmware version. future use.
2173 * @param dev pointer to device extension
2174 * @return -1 for fail, else returns firmware version as an int(16 bits)
2175 */
2176 static int s2255_get_fx2fw(struct s2255_dev *dev)
2177 {
2178 int fw;
2179 int ret;
2180 unsigned char transBuffer[64];
2181 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2182 S2255_VR_IN);
2183 if (ret < 0)
2184 dprintk(2, "get fw error: %x\n", ret);
2185 fw = transBuffer[0] + (transBuffer[1] << 8);
2186 dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2187 return fw;
2188 }
2189
2190 /*
2191 * Create the system ring buffer to copy frames into from the
2192 * usb read pipe.
2193 */
2194 static int s2255_create_sys_buffers(struct s2255_channel *channel)
2195 {
2196 unsigned long i;
2197 unsigned long reqsize;
2198 dprintk(1, "create sys buffers\n");
2199 channel->buffer.dwFrames = SYS_FRAMES;
2200 /* always allocate maximum size(PAL) for system buffers */
2201 reqsize = SYS_FRAMES_MAXSIZE;
2202
2203 if (reqsize > SYS_FRAMES_MAXSIZE)
2204 reqsize = SYS_FRAMES_MAXSIZE;
2205
2206 for (i = 0; i < SYS_FRAMES; i++) {
2207 /* allocate the frames */
2208 channel->buffer.frame[i].lpvbits = vmalloc(reqsize);
2209 dprintk(1, "valloc %p chan %d, idx %lu, pdata %p\n",
2210 &channel->buffer.frame[i], channel->idx, i,
2211 channel->buffer.frame[i].lpvbits);
2212 channel->buffer.frame[i].size = reqsize;
2213 if (channel->buffer.frame[i].lpvbits == NULL) {
2214 printk(KERN_INFO "out of memory. using less frames\n");
2215 channel->buffer.dwFrames = i;
2216 break;
2217 }
2218 }
2219
2220 /* make sure internal states are set */
2221 for (i = 0; i < SYS_FRAMES; i++) {
2222 channel->buffer.frame[i].ulState = 0;
2223 channel->buffer.frame[i].cur_size = 0;
2224 }
2225
2226 channel->cur_frame = 0;
2227 channel->last_frame = -1;
2228 return 0;
2229 }
2230
2231 static int s2255_release_sys_buffers(struct s2255_channel *channel)
2232 {
2233 unsigned long i;
2234 dprintk(1, "release sys buffers\n");
2235 for (i = 0; i < SYS_FRAMES; i++) {
2236 if (channel->buffer.frame[i].lpvbits) {
2237 dprintk(1, "vfree %p\n",
2238 channel->buffer.frame[i].lpvbits);
2239 vfree(channel->buffer.frame[i].lpvbits);
2240 }
2241 channel->buffer.frame[i].lpvbits = NULL;
2242 }
2243 return 0;
2244 }
2245
2246 static int s2255_board_init(struct s2255_dev *dev)
2247 {
2248 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2249 int fw_ver;
2250 int j;
2251 struct s2255_pipeinfo *pipe = &dev->pipe;
2252 dprintk(4, "board init: %p", dev);
2253 memset(pipe, 0, sizeof(*pipe));
2254 pipe->dev = dev;
2255 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2256 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
2257
2258 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2259 GFP_KERNEL);
2260 if (pipe->transfer_buffer == NULL) {
2261 dprintk(1, "out of memory!\n");
2262 return -ENOMEM;
2263 }
2264 /* query the firmware */
2265 fw_ver = s2255_get_fx2fw(dev);
2266
2267 printk(KERN_INFO "s2255: usb firmware version %d.%d\n",
2268 (fw_ver >> 8) & 0xff,
2269 fw_ver & 0xff);
2270
2271 if (fw_ver < S2255_CUR_USB_FWVER)
2272 printk(KERN_INFO "s2255: newer USB firmware available\n");
2273
2274 for (j = 0; j < MAX_CHANNELS; j++) {
2275 struct s2255_channel *channel = &dev->channel[j];
2276 channel->b_acquire = 0;
2277 channel->mode = mode_def;
2278 if (dev->pid == 0x2257 && j > 1)
2279 channel->mode.color |= (1 << 16);
2280 channel->jpegqual = S2255_DEF_JPEG_QUAL;
2281 channel->width = LINE_SZ_4CIFS_NTSC;
2282 channel->height = NUM_LINES_4CIFS_NTSC * 2;
2283 channel->std = V4L2_STD_NTSC_M;
2284 channel->fmt = &formats[0];
2285 channel->mode.restart = 1;
2286 channel->req_image_size = get_transfer_size(&mode_def);
2287 channel->frame_count = 0;
2288 /* create the system buffers */
2289 s2255_create_sys_buffers(channel);
2290 }
2291 /* start read pipe */
2292 s2255_start_readpipe(dev);
2293 dprintk(1, "%s: success\n", __func__);
2294 return 0;
2295 }
2296
2297 static int s2255_board_shutdown(struct s2255_dev *dev)
2298 {
2299 u32 i;
2300 dprintk(1, "%s: dev: %p", __func__, dev);
2301
2302 for (i = 0; i < MAX_CHANNELS; i++) {
2303 if (dev->channel[i].b_acquire)
2304 s2255_stop_acquire(&dev->channel[i]);
2305 }
2306 s2255_stop_readpipe(dev);
2307 for (i = 0; i < MAX_CHANNELS; i++)
2308 s2255_release_sys_buffers(&dev->channel[i]);
2309 /* release transfer buffer */
2310 kfree(dev->pipe.transfer_buffer);
2311 return 0;
2312 }
2313
2314 static void read_pipe_completion(struct urb *purb)
2315 {
2316 struct s2255_pipeinfo *pipe_info;
2317 struct s2255_dev *dev;
2318 int status;
2319 int pipe;
2320 pipe_info = purb->context;
2321 dprintk(100, "%s: urb:%p, status %d\n", __func__, purb,
2322 purb->status);
2323 if (pipe_info == NULL) {
2324 dev_err(&purb->dev->dev, "no context!\n");
2325 return;
2326 }
2327
2328 dev = pipe_info->dev;
2329 if (dev == NULL) {
2330 dev_err(&purb->dev->dev, "no context!\n");
2331 return;
2332 }
2333 status = purb->status;
2334 /* if shutting down, do not resubmit, exit immediately */
2335 if (status == -ESHUTDOWN) {
2336 dprintk(2, "%s: err shutdown\n", __func__);
2337 pipe_info->err_count++;
2338 return;
2339 }
2340
2341 if (pipe_info->state == 0) {
2342 dprintk(2, "%s: exiting USB pipe", __func__);
2343 return;
2344 }
2345
2346 if (status == 0)
2347 s2255_read_video_callback(dev, pipe_info);
2348 else {
2349 pipe_info->err_count++;
2350 dprintk(1, "%s: failed URB %d\n", __func__, status);
2351 }
2352
2353 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2354 /* reuse urb */
2355 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2356 pipe,
2357 pipe_info->transfer_buffer,
2358 pipe_info->cur_transfer_size,
2359 read_pipe_completion, pipe_info);
2360
2361 if (pipe_info->state != 0) {
2362 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC)) {
2363 dev_err(&dev->udev->dev, "error submitting urb\n");
2364 }
2365 } else {
2366 dprintk(2, "%s :complete state 0\n", __func__);
2367 }
2368 return;
2369 }
2370
2371 static int s2255_start_readpipe(struct s2255_dev *dev)
2372 {
2373 int pipe;
2374 int retval;
2375 struct s2255_pipeinfo *pipe_info = &dev->pipe;
2376 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2377 dprintk(2, "%s: IN %d\n", __func__, dev->read_endpoint);
2378 pipe_info->state = 1;
2379 pipe_info->err_count = 0;
2380 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2381 if (!pipe_info->stream_urb) {
2382 dev_err(&dev->udev->dev,
2383 "ReadStream: Unable to alloc URB\n");
2384 return -ENOMEM;
2385 }
2386 /* transfer buffer allocated in board_init */
2387 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2388 pipe,
2389 pipe_info->transfer_buffer,
2390 pipe_info->cur_transfer_size,
2391 read_pipe_completion, pipe_info);
2392 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2393 if (retval) {
2394 printk(KERN_ERR "s2255: start read pipe failed\n");
2395 return retval;
2396 }
2397 return 0;
2398 }
2399
2400 /* starts acquisition process */
2401 static int s2255_start_acquire(struct s2255_channel *channel)
2402 {
2403 unsigned char *buffer;
2404 int res;
2405 unsigned long chn_rev;
2406 int j;
2407 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
2408 chn_rev = G_chnmap[channel->idx];
2409 buffer = kzalloc(512, GFP_KERNEL);
2410 if (buffer == NULL) {
2411 dev_err(&dev->udev->dev, "out of mem\n");
2412 return -ENOMEM;
2413 }
2414
2415 channel->last_frame = -1;
2416 channel->bad_payload = 0;
2417 channel->cur_frame = 0;
2418 for (j = 0; j < SYS_FRAMES; j++) {
2419 channel->buffer.frame[j].ulState = 0;
2420 channel->buffer.frame[j].cur_size = 0;
2421 }
2422
2423 /* send the start command */
2424 *(__le32 *) buffer = IN_DATA_TOKEN;
2425 *((__le32 *) buffer + 1) = (__le32) cpu_to_le32(chn_rev);
2426 *((__le32 *) buffer + 2) = CMD_START;
2427 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2428 if (res != 0)
2429 dev_err(&dev->udev->dev, "CMD_START error\n");
2430
2431 dprintk(2, "start acquire exit[%d] %d \n", channel->idx, res);
2432 kfree(buffer);
2433 return 0;
2434 }
2435
2436 static int s2255_stop_acquire(struct s2255_channel *channel)
2437 {
2438 unsigned char *buffer;
2439 int res;
2440 unsigned long chn_rev;
2441 struct s2255_dev *dev = to_s2255_dev(channel->vdev.v4l2_dev);
2442 chn_rev = G_chnmap[channel->idx];
2443 buffer = kzalloc(512, GFP_KERNEL);
2444 if (buffer == NULL) {
2445 dev_err(&dev->udev->dev, "out of mem\n");
2446 return -ENOMEM;
2447 }
2448 /* send the stop command */
2449 *(__le32 *) buffer = IN_DATA_TOKEN;
2450 *((__le32 *) buffer + 1) = (__le32) cpu_to_le32(chn_rev);
2451 *((__le32 *) buffer + 2) = CMD_STOP;
2452 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2453 if (res != 0)
2454 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2455 kfree(buffer);
2456 channel->b_acquire = 0;
2457 dprintk(4, "%s: chn %d, res %d\n", __func__, channel->idx, res);
2458 return res;
2459 }
2460
2461 static void s2255_stop_readpipe(struct s2255_dev *dev)
2462 {
2463 struct s2255_pipeinfo *pipe = &dev->pipe;
2464
2465 pipe->state = 0;
2466 if (pipe->stream_urb) {
2467 /* cancel urb */
2468 usb_kill_urb(pipe->stream_urb);
2469 usb_free_urb(pipe->stream_urb);
2470 pipe->stream_urb = NULL;
2471 }
2472 dprintk(4, "%s", __func__);
2473 return;
2474 }
2475
2476 static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2477 {
2478 if (reset)
2479 s2255_reset_dsppower(dev);
2480 dev->fw_data->fw_size = dev->fw_data->fw->size;
2481 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2482 memcpy(dev->fw_data->pfw_data,
2483 dev->fw_data->fw->data, CHUNK_SIZE);
2484 dev->fw_data->fw_loaded = CHUNK_SIZE;
2485 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2486 usb_sndbulkpipe(dev->udev, 2),
2487 dev->fw_data->pfw_data,
2488 CHUNK_SIZE, s2255_fwchunk_complete,
2489 dev->fw_data);
2490 mod_timer(&dev->timer, jiffies + HZ);
2491 }
2492
2493 /* standard usb probe function */
2494 static int s2255_probe(struct usb_interface *interface,
2495 const struct usb_device_id *id)
2496 {
2497 struct s2255_dev *dev = NULL;
2498 struct usb_host_interface *iface_desc;
2499 struct usb_endpoint_descriptor *endpoint;
2500 int i;
2501 int retval = -ENOMEM;
2502 __le32 *pdata;
2503 int fw_size;
2504 dprintk(2, "%s\n", __func__);
2505 /* allocate memory for our device state and initialize it to zero */
2506 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2507 if (dev == NULL) {
2508 s2255_dev_err(&interface->dev, "out of memory\n");
2509 return -ENOMEM;
2510 }
2511 atomic_set(&dev->num_channels, 0);
2512 dev->pid = le16_to_cpu(id->idProduct);
2513 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2514 if (!dev->fw_data)
2515 goto errorFWDATA1;
2516 mutex_init(&dev->lock);
2517 /* grab usb_device and save it */
2518 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2519 if (dev->udev == NULL) {
2520 dev_err(&interface->dev, "null usb device\n");
2521 retval = -ENODEV;
2522 goto errorUDEV;
2523 }
2524 dprintk(1, "dev: %p, udev %p interface %p\n", dev,
2525 dev->udev, interface);
2526 dev->interface = interface;
2527 /* set up the endpoint information */
2528 iface_desc = interface->cur_altsetting;
2529 dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2530 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2531 endpoint = &iface_desc->endpoint[i].desc;
2532 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2533 /* we found the bulk in endpoint */
2534 dev->read_endpoint = endpoint->bEndpointAddress;
2535 }
2536 }
2537
2538 if (!dev->read_endpoint) {
2539 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2540 goto errorEP;
2541 }
2542 init_timer(&dev->timer);
2543 dev->timer.function = s2255_timer;
2544 dev->timer.data = (unsigned long)dev->fw_data;
2545 init_waitqueue_head(&dev->fw_data->wait_fw);
2546 for (i = 0; i < MAX_CHANNELS; i++) {
2547 struct s2255_channel *channel = &dev->channel[i];
2548 dev->channel[i].idx = i;
2549 init_waitqueue_head(&channel->wait_setmode);
2550 init_waitqueue_head(&channel->wait_vidstatus);
2551 }
2552
2553 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2554 if (!dev->fw_data->fw_urb) {
2555 dev_err(&interface->dev, "out of memory!\n");
2556 goto errorFWURB;
2557 }
2558
2559 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2560 if (!dev->fw_data->pfw_data) {
2561 dev_err(&interface->dev, "out of memory!\n");
2562 goto errorFWDATA2;
2563 }
2564 /* load the first chunk */
2565 if (request_firmware(&dev->fw_data->fw,
2566 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2567 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2568 goto errorREQFW;
2569 }
2570 /* check the firmware is valid */
2571 fw_size = dev->fw_data->fw->size;
2572 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2573
2574 if (*pdata != S2255_FW_MARKER) {
2575 printk(KERN_INFO "Firmware invalid.\n");
2576 retval = -ENODEV;
2577 goto errorFWMARKER;
2578 } else {
2579 /* make sure firmware is the latest */
2580 __le32 *pRel;
2581 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2582 printk(KERN_INFO "s2255 dsp fw version %x\n", le32_to_cpu(*pRel));
2583 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2584 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2585 printk(KERN_INFO "s2255: f2255usb.bin out of date.\n");
2586 if (dev->pid == 0x2257 &&
2587 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2588 printk(KERN_WARNING "s2255: 2257 requires firmware %d"
2589 " or above.\n", S2255_MIN_DSP_COLORFILTER);
2590 }
2591 usb_reset_device(dev->udev);
2592 /* load 2255 board specific */
2593 retval = s2255_board_init(dev);
2594 if (retval)
2595 goto errorBOARDINIT;
2596 spin_lock_init(&dev->slock);
2597 s2255_fwload_start(dev, 0);
2598 /* loads v4l specific */
2599 retval = s2255_probe_v4l(dev);
2600 if (retval)
2601 goto errorBOARDINIT;
2602 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2603 return 0;
2604 errorBOARDINIT:
2605 s2255_board_shutdown(dev);
2606 errorFWMARKER:
2607 release_firmware(dev->fw_data->fw);
2608 errorREQFW:
2609 kfree(dev->fw_data->pfw_data);
2610 errorFWDATA2:
2611 usb_free_urb(dev->fw_data->fw_urb);
2612 errorFWURB:
2613 del_timer(&dev->timer);
2614 errorEP:
2615 usb_put_dev(dev->udev);
2616 errorUDEV:
2617 kfree(dev->fw_data);
2618 mutex_destroy(&dev->lock);
2619 errorFWDATA1:
2620 kfree(dev);
2621 printk(KERN_WARNING "Sensoray 2255 driver load failed: 0x%x\n", retval);
2622 return retval;
2623 }
2624
2625 /* disconnect routine. when board is removed physically or with rmmod */
2626 static void s2255_disconnect(struct usb_interface *interface)
2627 {
2628 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2629 int i;
2630 int channels = atomic_read(&dev->num_channels);
2631 mutex_lock(&dev->lock);
2632 v4l2_device_disconnect(&dev->v4l2_dev);
2633 mutex_unlock(&dev->lock);
2634 /*see comments in the uvc_driver.c usb disconnect function */
2635 atomic_inc(&dev->num_channels);
2636 /* unregister each video device. */
2637 for (i = 0; i < channels; i++)
2638 video_unregister_device(&dev->channel[i].vdev);
2639 /* wake up any of our timers */
2640 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2641 wake_up(&dev->fw_data->wait_fw);
2642 for (i = 0; i < MAX_CHANNELS; i++) {
2643 dev->channel[i].setmode_ready = 1;
2644 wake_up(&dev->channel[i].wait_setmode);
2645 dev->channel[i].vidstatus_ready = 1;
2646 wake_up(&dev->channel[i].wait_vidstatus);
2647 }
2648 if (atomic_dec_and_test(&dev->num_channels))
2649 s2255_destroy(dev);
2650 dev_info(&interface->dev, "%s\n", __func__);
2651 }
2652
2653 static struct usb_driver s2255_driver = {
2654 .name = S2255_DRIVER_NAME,
2655 .probe = s2255_probe,
2656 .disconnect = s2255_disconnect,
2657 .id_table = s2255_table,
2658 };
2659
2660 module_usb_driver(s2255_driver);
2661
2662 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2663 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2664 MODULE_LICENSE("GPL");
2665 MODULE_VERSION(S2255_VERSION);
2666 MODULE_FIRMWARE(FIRMWARE_FILE_NAME);
Linux with added FPC-III support