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