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