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