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