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