?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
printf: Remove unused 'bprintf'
[drm/drm-misc.git] / drivers / media / usb / s2255 / s2255drv.c
blob899a7a67e2baf16012719006c7cbbf0504462608
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 refcount_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 };
708
709 static int vidioc_querycap(struct file *file, void *priv,
710 struct v4l2_capability *cap)
711 {
712 struct s2255_vc *vc = video_drvdata(file);
713 struct s2255_dev *dev = vc->dev;
714
715 strscpy(cap->driver, "s2255", sizeof(cap->driver));
716 strscpy(cap->card, "s2255", sizeof(cap->card));
717 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
718 return 0;
719 }
720
721 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
722 struct v4l2_fmtdesc *f)
723 {
724 int index = f->index;
725
726 if (index >= ARRAY_SIZE(formats))
727 return -EINVAL;
728 if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
729 (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
730 return -EINVAL;
731 f->pixelformat = formats[index].fourcc;
732 return 0;
733 }
734
735 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
736 struct v4l2_format *f)
737 {
738 struct s2255_vc *vc = video_drvdata(file);
739 int is_ntsc = vc->std & V4L2_STD_525_60;
740
741 f->fmt.pix.width = vc->width;
742 f->fmt.pix.height = vc->height;
743 if (f->fmt.pix.height >=
744 (is_ntsc ? NUM_LINES_1CIFS_NTSC : NUM_LINES_1CIFS_PAL) * 2)
745 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
746 else
747 f->fmt.pix.field = V4L2_FIELD_TOP;
748 f->fmt.pix.pixelformat = vc->fmt->fourcc;
749 f->fmt.pix.bytesperline = f->fmt.pix.width * (vc->fmt->depth >> 3);
750 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
751 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
752 return 0;
753 }
754
755 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
756 struct v4l2_format *f)
757 {
758 const struct s2255_fmt *fmt;
759 enum v4l2_field field;
760 struct s2255_vc *vc = video_drvdata(file);
761 int is_ntsc = vc->std & V4L2_STD_525_60;
762
763 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
764
765 if (fmt == NULL)
766 return -EINVAL;
767
768 dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
769 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
770 if (is_ntsc) {
771 /* NTSC */
772 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
773 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
774 field = V4L2_FIELD_INTERLACED;
775 } else {
776 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
777 field = V4L2_FIELD_TOP;
778 }
779 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
780 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
781 else
782 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
783 } else {
784 /* PAL */
785 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
786 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
787 field = V4L2_FIELD_INTERLACED;
788 } else {
789 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
790 field = V4L2_FIELD_TOP;
791 }
792 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL)
793 f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
794 else
795 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
796 }
797 f->fmt.pix.field = field;
798 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
799 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
800 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
801 dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__,
802 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
803 return 0;
804 }
805
806 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
807 struct v4l2_format *f)
808 {
809 struct s2255_vc *vc = video_drvdata(file);
810 const struct s2255_fmt *fmt;
811 struct vb2_queue *q = &vc->vb_vidq;
812 struct s2255_mode mode;
813 int ret;
814
815 ret = vidioc_try_fmt_vid_cap(file, vc, f);
816
817 if (ret < 0)
818 return ret;
819
820 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
821
822 if (fmt == NULL)
823 return -EINVAL;
824
825 if (vb2_is_busy(q)) {
826 dprintk(vc->dev, 1, "queue busy\n");
827 return -EBUSY;
828 }
829
830 mode = vc->mode;
831 vc->fmt = fmt;
832 vc->width = f->fmt.pix.width;
833 vc->height = f->fmt.pix.height;
834 vc->field = f->fmt.pix.field;
835 if (vc->width > norm_minw(vc)) {
836 if (vc->height > norm_minh(vc)) {
837 if (vc->cap_parm.capturemode &
838 V4L2_MODE_HIGHQUALITY)
839 mode.scale = SCALE_4CIFSI;
840 else
841 mode.scale = SCALE_4CIFS;
842 } else
843 mode.scale = SCALE_2CIFS;
844
845 } else {
846 mode.scale = SCALE_1CIFS;
847 }
848 /* color mode */
849 switch (vc->fmt->fourcc) {
850 case V4L2_PIX_FMT_GREY:
851 mode.color &= ~MASK_COLOR;
852 mode.color |= COLOR_Y8;
853 break;
854 case V4L2_PIX_FMT_JPEG:
855 case V4L2_PIX_FMT_MJPEG:
856 mode.color &= ~MASK_COLOR;
857 mode.color |= COLOR_JPG;
858 mode.color |= (vc->jpegqual << 8);
859 break;
860 case V4L2_PIX_FMT_YUV422P:
861 mode.color &= ~MASK_COLOR;
862 mode.color |= COLOR_YUVPL;
863 break;
864 case V4L2_PIX_FMT_YUYV:
865 case V4L2_PIX_FMT_UYVY:
866 default:
867 mode.color &= ~MASK_COLOR;
868 mode.color |= COLOR_YUVPK;
869 break;
870 }
871 if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR))
872 mode.restart = 1;
873 else if (mode.scale != vc->mode.scale)
874 mode.restart = 1;
875 else if (mode.format != vc->mode.format)
876 mode.restart = 1;
877 vc->mode = mode;
878 (void) s2255_set_mode(vc, &mode);
879 return 0;
880 }
881
882
883 /* write to the configuration pipe, synchronously */
884 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
885 int size)
886 {
887 int pipe;
888 int done;
889 long retval = -1;
890 if (udev) {
891 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
892 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
893 }
894 return retval;
895 }
896
897 static u32 get_transfer_size(struct s2255_mode *mode)
898 {
899 int linesPerFrame = LINE_SZ_DEF;
900 int pixelsPerLine = NUM_LINES_DEF;
901 u32 outImageSize;
902 u32 usbInSize;
903 unsigned int mask_mult;
904
905 if (mode == NULL)
906 return 0;
907
908 if (mode->format == FORMAT_NTSC) {
909 switch (mode->scale) {
910 case SCALE_4CIFS:
911 case SCALE_4CIFSI:
912 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
913 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
914 break;
915 case SCALE_2CIFS:
916 linesPerFrame = NUM_LINES_2CIFS_NTSC;
917 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
918 break;
919 case SCALE_1CIFS:
920 linesPerFrame = NUM_LINES_1CIFS_NTSC;
921 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
922 break;
923 default:
924 break;
925 }
926 } else if (mode->format == FORMAT_PAL) {
927 switch (mode->scale) {
928 case SCALE_4CIFS:
929 case SCALE_4CIFSI:
930 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
931 pixelsPerLine = LINE_SZ_4CIFS_PAL;
932 break;
933 case SCALE_2CIFS:
934 linesPerFrame = NUM_LINES_2CIFS_PAL;
935 pixelsPerLine = LINE_SZ_2CIFS_PAL;
936 break;
937 case SCALE_1CIFS:
938 linesPerFrame = NUM_LINES_1CIFS_PAL;
939 pixelsPerLine = LINE_SZ_1CIFS_PAL;
940 break;
941 default:
942 break;
943 }
944 }
945 outImageSize = linesPerFrame * pixelsPerLine;
946 if ((mode->color & MASK_COLOR) != COLOR_Y8) {
947 /* 2 bytes/pixel if not monochrome */
948 outImageSize *= 2;
949 }
950
951 /* total bytes to send including prefix and 4K padding;
952 must be a multiple of USB_READ_SIZE */
953 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
954 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
955 /* if size not a multiple of USB_READ_SIZE */
956 if (usbInSize & ~mask_mult)
957 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
958 return usbInSize;
959 }
960
961 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
962 {
963 struct device *dev = &sdev->udev->dev;
964 dev_info(dev, "------------------------------------------------\n");
965 dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
966 dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
967 dev_info(dev, "bright: 0x%x\n", mode->bright);
968 dev_info(dev, "------------------------------------------------\n");
969 }
970
971 /*
972 * set mode is the function which controls the DSP.
973 * the restart parameter in struct s2255_mode should be set whenever
974 * the image size could change via color format, video system or image
975 * size.
976 * When the restart parameter is set, we sleep for ONE frame to allow the
977 * DSP time to get the new frame
978 */
979 static int s2255_set_mode(struct s2255_vc *vc,
980 struct s2255_mode *mode)
981 {
982 int res;
983 unsigned long chn_rev;
984 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
985 int i;
986 __le32 *buffer = dev->cmdbuf;
987
988 mutex_lock(&dev->cmdlock);
989 chn_rev = G_chnmap[vc->idx];
990 dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
991 /* if JPEG, set the quality */
992 if ((mode->color & MASK_COLOR) == COLOR_JPG) {
993 mode->color &= ~MASK_COLOR;
994 mode->color |= COLOR_JPG;
995 mode->color &= ~MASK_JPG_QUALITY;
996 mode->color |= (vc->jpegqual << 8);
997 }
998 /* save the mode */
999 vc->mode = *mode;
1000 vc->req_image_size = get_transfer_size(mode);
1001 dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
1002 /* set the mode */
1003 buffer[0] = IN_DATA_TOKEN;
1004 buffer[1] = (__le32) cpu_to_le32(chn_rev);
1005 buffer[2] = CMD_SET_MODE;
1006 for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++)
1007 buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]);
1008 vc->setmode_ready = 0;
1009 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1010 if (debug)
1011 s2255_print_cfg(dev, mode);
1012 /* wait at least 3 frames before continuing */
1013 if (mode->restart) {
1014 wait_event_timeout(vc->wait_setmode,
1015 (vc->setmode_ready != 0),
1016 msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1017 if (vc->setmode_ready != 1) {
1018 dprintk(dev, 0, "s2255: no set mode response\n");
1019 res = -EFAULT;
1020 }
1021 }
1022 /* clear the restart flag */
1023 vc->mode.restart = 0;
1024 dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
1025 mutex_unlock(&dev->cmdlock);
1026 return res;
1027 }
1028
1029 static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus)
1030 {
1031 int res;
1032 u32 chn_rev;
1033 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1034 __le32 *buffer = dev->cmdbuf;
1035
1036 mutex_lock(&dev->cmdlock);
1037 chn_rev = G_chnmap[vc->idx];
1038 dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
1039 /* form the get vid status command */
1040 buffer[0] = IN_DATA_TOKEN;
1041 buffer[1] = (__le32) cpu_to_le32(chn_rev);
1042 buffer[2] = CMD_STATUS;
1043 *pstatus = 0;
1044 vc->vidstatus_ready = 0;
1045 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1046 wait_event_timeout(vc->wait_vidstatus,
1047 (vc->vidstatus_ready != 0),
1048 msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1049 if (vc->vidstatus_ready != 1) {
1050 dprintk(dev, 0, "s2255: no vidstatus response\n");
1051 res = -EFAULT;
1052 }
1053 *pstatus = vc->vidstatus;
1054 dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
1055 mutex_unlock(&dev->cmdlock);
1056 return res;
1057 }
1058
1059 static int start_streaming(struct vb2_queue *vq, unsigned int count)
1060 {
1061 struct s2255_vc *vc = vb2_get_drv_priv(vq);
1062 int j;
1063
1064 vc->last_frame = -1;
1065 vc->bad_payload = 0;
1066 vc->cur_frame = 0;
1067 vc->frame_count = 0;
1068 for (j = 0; j < SYS_FRAMES; j++) {
1069 vc->buffer.frame[j].ulState = S2255_READ_IDLE;
1070 vc->buffer.frame[j].cur_size = 0;
1071 }
1072 return s2255_start_acquire(vc);
1073 }
1074
1075 /* abort streaming and wait for last buffer */
1076 static void stop_streaming(struct vb2_queue *vq)
1077 {
1078 struct s2255_vc *vc = vb2_get_drv_priv(vq);
1079 struct s2255_buffer *buf, *node;
1080 unsigned long flags;
1081 (void) s2255_stop_acquire(vc);
1082 spin_lock_irqsave(&vc->qlock, flags);
1083 list_for_each_entry_safe(buf, node, &vc->buf_list, list) {
1084 list_del(&buf->list);
1085 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1086 dprintk(vc->dev, 2, "[%p/%d] done\n",
1087 buf, buf->vb.vb2_buf.index);
1088 }
1089 spin_unlock_irqrestore(&vc->qlock, flags);
1090 }
1091
1092 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id i)
1093 {
1094 struct s2255_vc *vc = video_drvdata(file);
1095 struct s2255_mode mode;
1096 struct vb2_queue *q = &vc->vb_vidq;
1097
1098 /*
1099 * Changing the standard implies a format change, which is not allowed
1100 * while buffers for use with streaming have already been allocated.
1101 */
1102 if (vb2_is_busy(q))
1103 return -EBUSY;
1104
1105 mode = vc->mode;
1106 if (i & V4L2_STD_525_60) {
1107 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
1108 /* if changing format, reset frame decimation/intervals */
1109 if (mode.format != FORMAT_NTSC) {
1110 mode.restart = 1;
1111 mode.format = FORMAT_NTSC;
1112 mode.fdec = FDEC_1;
1113 vc->width = LINE_SZ_4CIFS_NTSC;
1114 vc->height = NUM_LINES_4CIFS_NTSC * 2;
1115 }
1116 } else if (i & V4L2_STD_625_50) {
1117 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
1118 if (mode.format != FORMAT_PAL) {
1119 mode.restart = 1;
1120 mode.format = FORMAT_PAL;
1121 mode.fdec = FDEC_1;
1122 vc->width = LINE_SZ_4CIFS_PAL;
1123 vc->height = NUM_LINES_4CIFS_PAL * 2;
1124 }
1125 } else
1126 return -EINVAL;
1127 vc->std = i;
1128 if (mode.restart)
1129 s2255_set_mode(vc, &mode);
1130 return 0;
1131 }
1132
1133 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i)
1134 {
1135 struct s2255_vc *vc = video_drvdata(file);
1136
1137 *i = vc->std;
1138 return 0;
1139 }
1140
1141 /* Sensoray 2255 is a multiple channel capture device.
1142 It does not have a "crossbar" of inputs.
1143 We use one V4L device per channel. The user must
1144 be aware that certain combinations are not allowed.
1145 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1146 at once in color(you can do full fps on 4 channels with greyscale.
1147 */
1148 static int vidioc_enum_input(struct file *file, void *priv,
1149 struct v4l2_input *inp)
1150 {
1151 struct s2255_vc *vc = video_drvdata(file);
1152 struct s2255_dev *dev = vc->dev;
1153 u32 status = 0;
1154
1155 if (inp->index != 0)
1156 return -EINVAL;
1157 inp->type = V4L2_INPUT_TYPE_CAMERA;
1158 inp->std = S2255_NORMS;
1159 inp->status = 0;
1160 if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1161 int rc;
1162 rc = s2255_cmd_status(vc, &status);
1163 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
1164 rc, status);
1165 if (rc == 0)
1166 inp->status = (status & 0x01) ? 0
1167 : V4L2_IN_ST_NO_SIGNAL;
1168 }
1169 switch (dev->pid) {
1170 case 0x2255:
1171 default:
1172 strscpy(inp->name, "Composite", sizeof(inp->name));
1173 break;
1174 case 0x2257:
1175 strscpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video",
1176 sizeof(inp->name));
1177 break;
1178 }
1179 return 0;
1180 }
1181
1182 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1183 {
1184 *i = 0;
1185 return 0;
1186 }
1187 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1188 {
1189 if (i > 0)
1190 return -EINVAL;
1191 return 0;
1192 }
1193
1194 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
1195 {
1196 struct s2255_vc *vc =
1197 container_of(ctrl->handler, struct s2255_vc, hdl);
1198 struct s2255_mode mode;
1199 mode = vc->mode;
1200 /* update the mode to the corresponding value */
1201 switch (ctrl->id) {
1202 case V4L2_CID_BRIGHTNESS:
1203 mode.bright = ctrl->val;
1204 break;
1205 case V4L2_CID_CONTRAST:
1206 mode.contrast = ctrl->val;
1207 break;
1208 case V4L2_CID_HUE:
1209 mode.hue = ctrl->val;
1210 break;
1211 case V4L2_CID_SATURATION:
1212 mode.saturation = ctrl->val;
1213 break;
1214 case V4L2_CID_S2255_COLORFILTER:
1215 mode.color &= ~MASK_INPUT_TYPE;
1216 mode.color |= !ctrl->val << 16;
1217 break;
1218 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1219 vc->jpegqual = ctrl->val;
1220 return 0;
1221 default:
1222 return -EINVAL;
1223 }
1224 mode.restart = 0;
1225 /* set mode here. Note: stream does not need restarted.
1226 some V4L programs restart stream unnecessarily
1227 after a s_crtl.
1228 */
1229 s2255_set_mode(vc, &mode);
1230 return 0;
1231 }
1232
1233 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1234 struct v4l2_jpegcompression *jc)
1235 {
1236 struct s2255_vc *vc = video_drvdata(file);
1237
1238 memset(jc, 0, sizeof(*jc));
1239 jc->quality = vc->jpegqual;
1240 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1241 return 0;
1242 }
1243
1244 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1245 const struct v4l2_jpegcompression *jc)
1246 {
1247 struct s2255_vc *vc = video_drvdata(file);
1248
1249 if (jc->quality < 0 || jc->quality > 100)
1250 return -EINVAL;
1251 v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality);
1252 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1253 return 0;
1254 }
1255
1256 static int vidioc_g_parm(struct file *file, void *priv,
1257 struct v4l2_streamparm *sp)
1258 {
1259 __u32 def_num, def_dem;
1260 struct s2255_vc *vc = video_drvdata(file);
1261
1262 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1263 return -EINVAL;
1264 sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1265 sp->parm.capture.capturemode = vc->cap_parm.capturemode;
1266 sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1267 def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1268 def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1269 sp->parm.capture.timeperframe.denominator = def_dem;
1270 switch (vc->mode.fdec) {
1271 default:
1272 case FDEC_1:
1273 sp->parm.capture.timeperframe.numerator = def_num;
1274 break;
1275 case FDEC_2:
1276 sp->parm.capture.timeperframe.numerator = def_num * 2;
1277 break;
1278 case FDEC_3:
1279 sp->parm.capture.timeperframe.numerator = def_num * 3;
1280 break;
1281 case FDEC_5:
1282 sp->parm.capture.timeperframe.numerator = def_num * 5;
1283 break;
1284 }
1285 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
1286 __func__,
1287 sp->parm.capture.capturemode,
1288 sp->parm.capture.timeperframe.numerator,
1289 sp->parm.capture.timeperframe.denominator);
1290 return 0;
1291 }
1292
1293 static int vidioc_s_parm(struct file *file, void *priv,
1294 struct v4l2_streamparm *sp)
1295 {
1296 struct s2255_vc *vc = video_drvdata(file);
1297 struct s2255_mode mode;
1298 int fdec = FDEC_1;
1299 __u32 def_num, def_dem;
1300 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1301 return -EINVAL;
1302 mode = vc->mode;
1303 /* high quality capture mode requires a stream restart */
1304 if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode)
1305 && vb2_is_streaming(&vc->vb_vidq))
1306 return -EBUSY;
1307 def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1308 def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1309 if (def_dem != sp->parm.capture.timeperframe.denominator)
1310 sp->parm.capture.timeperframe.numerator = def_num;
1311 else if (sp->parm.capture.timeperframe.numerator <= def_num)
1312 sp->parm.capture.timeperframe.numerator = def_num;
1313 else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1314 sp->parm.capture.timeperframe.numerator = def_num * 2;
1315 fdec = FDEC_2;
1316 } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1317 sp->parm.capture.timeperframe.numerator = def_num * 3;
1318 fdec = FDEC_3;
1319 } else {
1320 sp->parm.capture.timeperframe.numerator = def_num * 5;
1321 fdec = FDEC_5;
1322 }
1323 mode.fdec = fdec;
1324 sp->parm.capture.timeperframe.denominator = def_dem;
1325 sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1326 s2255_set_mode(vc, &mode);
1327 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1328 __func__,
1329 sp->parm.capture.capturemode,
1330 sp->parm.capture.timeperframe.numerator,
1331 sp->parm.capture.timeperframe.denominator, fdec);
1332 return 0;
1333 }
1334
1335 #define NUM_SIZE_ENUMS 3
1336 static const struct v4l2_frmsize_discrete ntsc_sizes[] = {
1337 { 640, 480 },
1338 { 640, 240 },
1339 { 320, 240 },
1340 };
1341 static const struct v4l2_frmsize_discrete pal_sizes[] = {
1342 { 704, 576 },
1343 { 704, 288 },
1344 { 352, 288 },
1345 };
1346
1347 static int vidioc_enum_framesizes(struct file *file, void *priv,
1348 struct v4l2_frmsizeenum *fe)
1349 {
1350 struct s2255_vc *vc = video_drvdata(file);
1351 int is_ntsc = vc->std & V4L2_STD_525_60;
1352 const struct s2255_fmt *fmt;
1353
1354 if (fe->index >= NUM_SIZE_ENUMS)
1355 return -EINVAL;
1356
1357 fmt = format_by_fourcc(fe->pixel_format);
1358 if (fmt == NULL)
1359 return -EINVAL;
1360 fe->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1361 fe->discrete = is_ntsc ? ntsc_sizes[fe->index] : pal_sizes[fe->index];
1362 return 0;
1363 }
1364
1365 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1366 struct v4l2_frmivalenum *fe)
1367 {
1368 struct s2255_vc *vc = video_drvdata(file);
1369 const struct s2255_fmt *fmt;
1370 const struct v4l2_frmsize_discrete *sizes;
1371 int is_ntsc = vc->std & V4L2_STD_525_60;
1372 #define NUM_FRAME_ENUMS 4
1373 int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1374 int i;
1375
1376 if (fe->index >= NUM_FRAME_ENUMS)
1377 return -EINVAL;
1378
1379 fmt = format_by_fourcc(fe->pixel_format);
1380 if (fmt == NULL)
1381 return -EINVAL;
1382
1383 sizes = is_ntsc ? ntsc_sizes : pal_sizes;
1384 for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++)
1385 if (fe->width == sizes->width &&
1386 fe->height == sizes->height)
1387 break;
1388 if (i == NUM_SIZE_ENUMS)
1389 return -EINVAL;
1390
1391 fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1392 fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1393 fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1394 dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
1395 fe->discrete.numerator,
1396 fe->discrete.denominator);
1397 return 0;
1398 }
1399
1400 static int s2255_open(struct file *file)
1401 {
1402 struct s2255_vc *vc = video_drvdata(file);
1403 struct s2255_dev *dev = vc->dev;
1404 int state;
1405 int rc = 0;
1406
1407 rc = v4l2_fh_open(file);
1408 if (rc != 0)
1409 return rc;
1410
1411 dprintk(dev, 1, "s2255: %s\n", __func__);
1412 state = atomic_read(&dev->fw_data->fw_state);
1413 switch (state) {
1414 case S2255_FW_DISCONNECTING:
1415 return -ENODEV;
1416 case S2255_FW_FAILED:
1417 s2255_dev_err(&dev->udev->dev,
1418 "firmware load failed. retrying.\n");
1419 s2255_fwload_start(dev);
1420 wait_event_timeout(dev->fw_data->wait_fw,
1421 ((atomic_read(&dev->fw_data->fw_state)
1422 == S2255_FW_SUCCESS) ||
1423 (atomic_read(&dev->fw_data->fw_state)
1424 == S2255_FW_DISCONNECTING)),
1425 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1426 /* state may have changed, re-read */
1427 state = atomic_read(&dev->fw_data->fw_state);
1428 break;
1429 case S2255_FW_NOTLOADED:
1430 case S2255_FW_LOADED_DSPWAIT:
1431 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1432 driver loaded and then device immediately opened */
1433 pr_info("%s waiting for firmware load\n", __func__);
1434 wait_event_timeout(dev->fw_data->wait_fw,
1435 ((atomic_read(&dev->fw_data->fw_state)
1436 == S2255_FW_SUCCESS) ||
1437 (atomic_read(&dev->fw_data->fw_state)
1438 == S2255_FW_DISCONNECTING)),
1439 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1440 /* state may have changed, re-read */
1441 state = atomic_read(&dev->fw_data->fw_state);
1442 break;
1443 case S2255_FW_SUCCESS:
1444 default:
1445 break;
1446 }
1447 /* state may have changed in above switch statement */
1448 switch (state) {
1449 case S2255_FW_SUCCESS:
1450 break;
1451 case S2255_FW_FAILED:
1452 pr_info("2255 firmware load failed.\n");
1453 return -ENODEV;
1454 case S2255_FW_DISCONNECTING:
1455 pr_info("%s: disconnecting\n", __func__);
1456 return -ENODEV;
1457 case S2255_FW_LOADED_DSPWAIT:
1458 case S2255_FW_NOTLOADED:
1459 pr_info("%s: firmware not loaded, please retry\n",
1460 __func__);
1461 /*
1462 * Timeout on firmware load means device unusable.
1463 * Set firmware failure state.
1464 * On next s2255_open the firmware will be reloaded.
1465 */
1466 atomic_set(&dev->fw_data->fw_state,
1467 S2255_FW_FAILED);
1468 return -EAGAIN;
1469 default:
1470 pr_info("%s: unknown state\n", __func__);
1471 return -EFAULT;
1472 }
1473 if (!vc->configured) {
1474 /* configure channel to default state */
1475 vc->fmt = &formats[0];
1476 s2255_set_mode(vc, &vc->mode);
1477 vc->configured = 1;
1478 }
1479 return 0;
1480 }
1481
1482 static void s2255_destroy(struct s2255_dev *dev)
1483 {
1484 dprintk(dev, 1, "%s", __func__);
1485 /* board shutdown stops the read pipe if it is running */
1486 s2255_board_shutdown(dev);
1487 /* make sure firmware still not trying to load */
1488 timer_shutdown_sync(&dev->timer); /* only started in .probe and .open */
1489 if (dev->fw_data->fw_urb) {
1490 usb_kill_urb(dev->fw_data->fw_urb);
1491 usb_free_urb(dev->fw_data->fw_urb);
1492 dev->fw_data->fw_urb = NULL;
1493 }
1494 release_firmware(dev->fw_data->fw);
1495 kfree(dev->fw_data->pfw_data);
1496 kfree(dev->fw_data);
1497 /* reset the DSP so firmware can be reloaded next time */
1498 s2255_reset_dsppower(dev);
1499 mutex_destroy(&dev->lock);
1500 usb_put_dev(dev->udev);
1501 v4l2_device_unregister(&dev->v4l2_dev);
1502 kfree(dev->cmdbuf);
1503 kfree(dev);
1504 }
1505
1506 static const struct v4l2_file_operations s2255_fops_v4l = {
1507 .owner = THIS_MODULE,
1508 .open = s2255_open,
1509 .release = vb2_fop_release,
1510 .poll = vb2_fop_poll,
1511 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1512 .mmap = vb2_fop_mmap,
1513 .read = vb2_fop_read,
1514 };
1515
1516 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1517 .vidioc_querycap = vidioc_querycap,
1518 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1519 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1520 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1521 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1522 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1523 .vidioc_querybuf = vb2_ioctl_querybuf,
1524 .vidioc_qbuf = vb2_ioctl_qbuf,
1525 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1526 .vidioc_s_std = vidioc_s_std,
1527 .vidioc_g_std = vidioc_g_std,
1528 .vidioc_enum_input = vidioc_enum_input,
1529 .vidioc_g_input = vidioc_g_input,
1530 .vidioc_s_input = vidioc_s_input,
1531 .vidioc_streamon = vb2_ioctl_streamon,
1532 .vidioc_streamoff = vb2_ioctl_streamoff,
1533 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1534 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1535 .vidioc_s_parm = vidioc_s_parm,
1536 .vidioc_g_parm = vidioc_g_parm,
1537 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1538 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1539 .vidioc_log_status = v4l2_ctrl_log_status,
1540 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1541 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1542 };
1543
1544 static void s2255_video_device_release(struct video_device *vdev)
1545 {
1546 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1547 struct s2255_vc *vc =
1548 container_of(vdev, struct s2255_vc, vdev);
1549
1550 dprintk(dev, 4, "%s, chnls: %d\n", __func__,
1551 refcount_read(&dev->num_channels));
1552
1553 v4l2_ctrl_handler_free(&vc->hdl);
1554
1555 if (refcount_dec_and_test(&dev->num_channels))
1556 s2255_destroy(dev);
1557 return;
1558 }
1559
1560 static const struct video_device template = {
1561 .name = "s2255v",
1562 .fops = &s2255_fops_v4l,
1563 .ioctl_ops = &s2255_ioctl_ops,
1564 .release = s2255_video_device_release,
1565 .tvnorms = S2255_NORMS,
1566 };
1567
1568 static const struct v4l2_ctrl_ops s2255_ctrl_ops = {
1569 .s_ctrl = s2255_s_ctrl,
1570 };
1571
1572 static const struct v4l2_ctrl_config color_filter_ctrl = {
1573 .ops = &s2255_ctrl_ops,
1574 .name = "Color Filter",
1575 .id = V4L2_CID_S2255_COLORFILTER,
1576 .type = V4L2_CTRL_TYPE_BOOLEAN,
1577 .max = 1,
1578 .step = 1,
1579 .def = 1,
1580 };
1581
1582 static int s2255_probe_v4l(struct s2255_dev *dev)
1583 {
1584 int ret;
1585 int i;
1586 int cur_nr = video_nr;
1587 struct s2255_vc *vc;
1588 struct vb2_queue *q;
1589
1590 ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1591 if (ret)
1592 return ret;
1593 /* initialize all video 4 linux */
1594 /* register 4 video devices */
1595 for (i = 0; i < MAX_CHANNELS; i++) {
1596 vc = &dev->vc[i];
1597 INIT_LIST_HEAD(&vc->buf_list);
1598
1599 v4l2_ctrl_handler_init(&vc->hdl, 6);
1600 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1601 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
1602 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1603 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
1604 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1605 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
1606 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1607 V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
1608 vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl,
1609 &s2255_ctrl_ops,
1610 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1611 0, 100, 1, S2255_DEF_JPEG_QUAL);
1612 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1613 (dev->pid != 0x2257 || vc->idx <= 1))
1614 v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl,
1615 NULL);
1616 if (vc->hdl.error) {
1617 ret = vc->hdl.error;
1618 v4l2_ctrl_handler_free(&vc->hdl);
1619 dev_err(&dev->udev->dev, "couldn't register control\n");
1620 break;
1621 }
1622 q = &vc->vb_vidq;
1623 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1624 q->io_modes = VB2_MMAP | VB2_READ | VB2_USERPTR;
1625 q->drv_priv = vc;
1626 q->lock = &vc->vb_lock;
1627 q->buf_struct_size = sizeof(struct s2255_buffer);
1628 q->mem_ops = &vb2_vmalloc_memops;
1629 q->ops = &s2255_video_qops;
1630 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1631 ret = vb2_queue_init(q);
1632 if (ret != 0) {
1633 dev_err(&dev->udev->dev,
1634 "%s vb2_queue_init 0x%x\n", __func__, ret);
1635 break;
1636 }
1637 /* register video devices */
1638 vc->vdev = template;
1639 vc->vdev.queue = q;
1640 vc->vdev.ctrl_handler = &vc->hdl;
1641 vc->vdev.lock = &dev->lock;
1642 vc->vdev.v4l2_dev = &dev->v4l2_dev;
1643 vc->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE |
1644 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE;
1645 video_set_drvdata(&vc->vdev, vc);
1646 if (video_nr == -1)
1647 ret = video_register_device(&vc->vdev,
1648 VFL_TYPE_VIDEO,
1649 video_nr);
1650 else
1651 ret = video_register_device(&vc->vdev,
1652 VFL_TYPE_VIDEO,
1653 cur_nr + i);
1654
1655 if (ret) {
1656 dev_err(&dev->udev->dev,
1657 "failed to register video device!\n");
1658 break;
1659 }
1660 refcount_inc(&dev->num_channels);
1661 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1662 video_device_node_name(&vc->vdev));
1663
1664 }
1665 pr_info("Sensoray 2255 V4L driver Revision: %s\n",
1666 S2255_VERSION);
1667 /* if no channels registered, return error and probe will fail*/
1668 if (refcount_read(&dev->num_channels) == 0) {
1669 v4l2_device_unregister(&dev->v4l2_dev);
1670 return ret;
1671 }
1672 if (refcount_read(&dev->num_channels) != MAX_CHANNELS)
1673 pr_warn("s2255: Not all channels available.\n");
1674 return 0;
1675 }
1676
1677 /* this function moves the usb stream read pipe data
1678 * into the system buffers.
1679 * returns 0 on success, EAGAIN if more data to process( call this
1680 * function again).
1681 *
1682 * Received frame structure:
1683 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1684 * bytes 4-7: channel: 0-3
1685 * bytes 8-11: payload size: size of the frame
1686 * bytes 12-payloadsize+12: frame data
1687 */
1688 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1689 {
1690 char *pdest;
1691 u32 offset = 0;
1692 int bframe = 0;
1693 char *psrc;
1694 unsigned long copy_size;
1695 unsigned long size;
1696 s32 idx = -1;
1697 struct s2255_framei *frm;
1698 unsigned char *pdata;
1699 struct s2255_vc *vc;
1700 dprintk(dev, 100, "buffer to user\n");
1701 vc = &dev->vc[dev->cc];
1702 idx = vc->cur_frame;
1703 frm = &vc->buffer.frame[idx];
1704 if (frm->ulState == S2255_READ_IDLE) {
1705 int jj;
1706 unsigned int cc;
1707 __le32 *pdword; /*data from dsp is little endian */
1708 int payload;
1709 /* search for marker codes */
1710 pdata = (unsigned char *)pipe_info->transfer_buffer;
1711 pdword = (__le32 *)pdata;
1712 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1713 switch (*pdword) {
1714 case S2255_MARKER_FRAME:
1715 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n",
1716 jj, pdata[0], pdata[1]);
1717 offset = jj + PREFIX_SIZE;
1718 bframe = 1;
1719 cc = le32_to_cpu(pdword[1]);
1720 if (cc >= MAX_CHANNELS) {
1721 dprintk(dev, 0,
1722 "bad channel\n");
1723 return -EINVAL;
1724 }
1725 /* reverse it */
1726 dev->cc = G_chnmap[cc];
1727 vc = &dev->vc[dev->cc];
1728 payload = le32_to_cpu(pdword[3]);
1729 if (payload > vc->req_image_size) {
1730 vc->bad_payload++;
1731 /* discard the bad frame */
1732 return -EINVAL;
1733 }
1734 vc->pkt_size = payload;
1735 vc->jpg_size = le32_to_cpu(pdword[4]);
1736 break;
1737 case S2255_MARKER_RESPONSE:
1738
1739 pdata += DEF_USB_BLOCK;
1740 jj += DEF_USB_BLOCK;
1741 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
1742 break;
1743 cc = G_chnmap[le32_to_cpu(pdword[1])];
1744 if (cc >= MAX_CHANNELS)
1745 break;
1746 vc = &dev->vc[cc];
1747 switch (pdword[2]) {
1748 case S2255_RESPONSE_SETMODE:
1749 /* check if channel valid */
1750 /* set mode ready */
1751 vc->setmode_ready = 1;
1752 wake_up(&vc->wait_setmode);
1753 dprintk(dev, 5, "setmode rdy %d\n", cc);
1754 break;
1755 case S2255_RESPONSE_FW:
1756 dev->chn_ready |= (1 << cc);
1757 if ((dev->chn_ready & 0x0f) != 0x0f)
1758 break;
1759 /* all channels ready */
1760 pr_info("s2255: fw loaded\n");
1761 atomic_set(&dev->fw_data->fw_state,
1762 S2255_FW_SUCCESS);
1763 wake_up(&dev->fw_data->wait_fw);
1764 break;
1765 case S2255_RESPONSE_STATUS:
1766 vc->vidstatus = le32_to_cpu(pdword[3]);
1767 vc->vidstatus_ready = 1;
1768 wake_up(&vc->wait_vidstatus);
1769 dprintk(dev, 5, "vstat %x chan %d\n",
1770 le32_to_cpu(pdword[3]), cc);
1771 break;
1772 default:
1773 pr_info("s2255 unknown resp\n");
1774 }
1775 pdata++;
1776 break;
1777 default:
1778 pdata++;
1779 break;
1780 }
1781 if (bframe)
1782 break;
1783 } /* for */
1784 if (!bframe)
1785 return -EINVAL;
1786 }
1787 vc = &dev->vc[dev->cc];
1788 idx = vc->cur_frame;
1789 frm = &vc->buffer.frame[idx];
1790 /* search done. now find out if should be acquiring on this channel */
1791 if (!vb2_is_streaming(&vc->vb_vidq)) {
1792 /* we found a frame, but this channel is turned off */
1793 frm->ulState = S2255_READ_IDLE;
1794 return -EINVAL;
1795 }
1796
1797 if (frm->ulState == S2255_READ_IDLE) {
1798 frm->ulState = S2255_READ_FRAME;
1799 frm->cur_size = 0;
1800 }
1801
1802 /* skip the marker 512 bytes (and offset if out of sync) */
1803 psrc = (u8 *)pipe_info->transfer_buffer + offset;
1804
1805
1806 if (frm->lpvbits == NULL) {
1807 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1808 frm, dev, dev->cc, idx);
1809 return -ENOMEM;
1810 }
1811
1812 pdest = frm->lpvbits + frm->cur_size;
1813
1814 copy_size = (pipe_info->cur_transfer_size - offset);
1815
1816 size = vc->pkt_size - PREFIX_SIZE;
1817
1818 /* sanity check on pdest */
1819 if ((copy_size + frm->cur_size) < vc->req_image_size)
1820 memcpy(pdest, psrc, copy_size);
1821
1822 frm->cur_size += copy_size;
1823 dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size);
1824
1825 if (frm->cur_size >= size) {
1826 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
1827 dev->cc, idx);
1828 vc->last_frame = vc->cur_frame;
1829 vc->cur_frame++;
1830 /* end of system frame ring buffer, start at zero */
1831 if ((vc->cur_frame == SYS_FRAMES) ||
1832 (vc->cur_frame == vc->buffer.dwFrames))
1833 vc->cur_frame = 0;
1834 /* frame ready */
1835 if (vb2_is_streaming(&vc->vb_vidq))
1836 s2255_got_frame(vc, vc->jpg_size);
1837 vc->frame_count++;
1838 frm->ulState = S2255_READ_IDLE;
1839 frm->cur_size = 0;
1840
1841 }
1842 /* done successfully */
1843 return 0;
1844 }
1845
1846 static void s2255_read_video_callback(struct s2255_dev *dev,
1847 struct s2255_pipeinfo *pipe_info)
1848 {
1849 int res;
1850 dprintk(dev, 50, "callback read video\n");
1851
1852 if (dev->cc >= MAX_CHANNELS) {
1853 dev->cc = 0;
1854 dev_err(&dev->udev->dev, "invalid channel\n");
1855 return;
1856 }
1857 /* otherwise copy to the system buffers */
1858 res = save_frame(dev, pipe_info);
1859 if (res != 0)
1860 dprintk(dev, 4, "s2255: read callback failed\n");
1861
1862 dprintk(dev, 50, "callback read video done\n");
1863 return;
1864 }
1865
1866 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1867 u16 Index, u16 Value, void *TransferBuffer,
1868 s32 TransferBufferLength, int bOut)
1869 {
1870 int r;
1871 unsigned char *buf;
1872
1873 buf = kmalloc(TransferBufferLength, GFP_KERNEL);
1874 if (!buf)
1875 return -ENOMEM;
1876
1877 if (!bOut) {
1878 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1879 Request,
1880 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1881 USB_DIR_IN,
1882 Value, Index, buf,
1883 TransferBufferLength, USB_CTRL_SET_TIMEOUT);
1884
1885 if (r >= 0)
1886 memcpy(TransferBuffer, buf, TransferBufferLength);
1887 } else {
1888 memcpy(buf, TransferBuffer, TransferBufferLength);
1889 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1890 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1891 Value, Index, buf,
1892 TransferBufferLength, USB_CTRL_SET_TIMEOUT);
1893 }
1894 kfree(buf);
1895 return r;
1896 }
1897
1898 /*
1899 * retrieve FX2 firmware version. future use.
1900 * @param dev pointer to device extension
1901 * @return -1 for fail, else returns firmware version as an int(16 bits)
1902 */
1903 static int s2255_get_fx2fw(struct s2255_dev *dev)
1904 {
1905 int fw;
1906 int ret;
1907 u8 transBuffer[2] = {};
1908
1909 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer,
1910 sizeof(transBuffer), S2255_VR_IN);
1911 if (ret < 0)
1912 dprintk(dev, 2, "get fw error: %x\n", ret);
1913 fw = transBuffer[0] + (transBuffer[1] << 8);
1914 dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
1915 return fw;
1916 }
1917
1918 /*
1919 * Create the system ring buffer to copy frames into from the
1920 * usb read pipe.
1921 */
1922 static int s2255_create_sys_buffers(struct s2255_vc *vc)
1923 {
1924 unsigned long i;
1925 unsigned long reqsize;
1926 vc->buffer.dwFrames = SYS_FRAMES;
1927 /* always allocate maximum size(PAL) for system buffers */
1928 reqsize = SYS_FRAMES_MAXSIZE;
1929
1930 if (reqsize > SYS_FRAMES_MAXSIZE)
1931 reqsize = SYS_FRAMES_MAXSIZE;
1932
1933 for (i = 0; i < SYS_FRAMES; i++) {
1934 /* allocate the frames */
1935 vc->buffer.frame[i].lpvbits = vmalloc(reqsize);
1936 vc->buffer.frame[i].size = reqsize;
1937 if (vc->buffer.frame[i].lpvbits == NULL) {
1938 pr_info("out of memory. using less frames\n");
1939 vc->buffer.dwFrames = i;
1940 break;
1941 }
1942 }
1943
1944 /* make sure internal states are set */
1945 for (i = 0; i < SYS_FRAMES; i++) {
1946 vc->buffer.frame[i].ulState = 0;
1947 vc->buffer.frame[i].cur_size = 0;
1948 }
1949
1950 vc->cur_frame = 0;
1951 vc->last_frame = -1;
1952 return 0;
1953 }
1954
1955 static int s2255_release_sys_buffers(struct s2255_vc *vc)
1956 {
1957 unsigned long i;
1958 for (i = 0; i < SYS_FRAMES; i++) {
1959 vfree(vc->buffer.frame[i].lpvbits);
1960 vc->buffer.frame[i].lpvbits = NULL;
1961 }
1962 return 0;
1963 }
1964
1965 static int s2255_board_init(struct s2255_dev *dev)
1966 {
1967 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
1968 int fw_ver;
1969 int j;
1970 struct s2255_pipeinfo *pipe = &dev->pipe;
1971 dprintk(dev, 4, "board init: %p", dev);
1972 memset(pipe, 0, sizeof(*pipe));
1973 pipe->dev = dev;
1974 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
1975 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
1976
1977 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
1978 GFP_KERNEL);
1979 if (pipe->transfer_buffer == NULL) {
1980 dprintk(dev, 1, "out of memory!\n");
1981 return -ENOMEM;
1982 }
1983 /* query the firmware */
1984 fw_ver = s2255_get_fx2fw(dev);
1985
1986 pr_info("s2255: usb firmware version %d.%d\n",
1987 (fw_ver >> 8) & 0xff,
1988 fw_ver & 0xff);
1989
1990 if (fw_ver < S2255_CUR_USB_FWVER)
1991 pr_info("s2255: newer USB firmware available\n");
1992
1993 for (j = 0; j < MAX_CHANNELS; j++) {
1994 struct s2255_vc *vc = &dev->vc[j];
1995 vc->mode = mode_def;
1996 if (dev->pid == 0x2257 && j > 1)
1997 vc->mode.color |= (1 << 16);
1998 vc->jpegqual = S2255_DEF_JPEG_QUAL;
1999 vc->width = LINE_SZ_4CIFS_NTSC;
2000 vc->height = NUM_LINES_4CIFS_NTSC * 2;
2001 vc->std = V4L2_STD_NTSC_M;
2002 vc->fmt = &formats[0];
2003 vc->mode.restart = 1;
2004 vc->req_image_size = get_transfer_size(&mode_def);
2005 vc->frame_count = 0;
2006 /* create the system buffers */
2007 s2255_create_sys_buffers(vc);
2008 }
2009 /* start read pipe */
2010 s2255_start_readpipe(dev);
2011 dprintk(dev, 1, "%s: success\n", __func__);
2012 return 0;
2013 }
2014
2015 static int s2255_board_shutdown(struct s2255_dev *dev)
2016 {
2017 u32 i;
2018 dprintk(dev, 1, "%s: dev: %p", __func__, dev);
2019
2020 for (i = 0; i < MAX_CHANNELS; i++) {
2021 if (vb2_is_streaming(&dev->vc[i].vb_vidq))
2022 s2255_stop_acquire(&dev->vc[i]);
2023 }
2024 s2255_stop_readpipe(dev);
2025 for (i = 0; i < MAX_CHANNELS; i++)
2026 s2255_release_sys_buffers(&dev->vc[i]);
2027 /* release transfer buffer */
2028 kfree(dev->pipe.transfer_buffer);
2029 return 0;
2030 }
2031
2032 static void read_pipe_completion(struct urb *purb)
2033 {
2034 struct s2255_pipeinfo *pipe_info;
2035 struct s2255_dev *dev;
2036 int status;
2037 int pipe;
2038 pipe_info = purb->context;
2039 if (pipe_info == NULL) {
2040 dev_err(&purb->dev->dev, "no context!\n");
2041 return;
2042 }
2043 dev = pipe_info->dev;
2044 if (dev == NULL) {
2045 dev_err(&purb->dev->dev, "no context!\n");
2046 return;
2047 }
2048 status = purb->status;
2049 /* if shutting down, do not resubmit, exit immediately */
2050 if (status == -ESHUTDOWN) {
2051 dprintk(dev, 2, "%s: err shutdown\n", __func__);
2052 pipe_info->err_count++;
2053 return;
2054 }
2055
2056 if (pipe_info->state == 0) {
2057 dprintk(dev, 2, "%s: exiting USB pipe", __func__);
2058 return;
2059 }
2060
2061 if (status == 0)
2062 s2255_read_video_callback(dev, pipe_info);
2063 else {
2064 pipe_info->err_count++;
2065 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status);
2066 }
2067
2068 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2069 /* reuse urb */
2070 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2071 pipe,
2072 pipe_info->transfer_buffer,
2073 pipe_info->cur_transfer_size,
2074 read_pipe_completion, pipe_info);
2075
2076 if (pipe_info->state != 0) {
2077 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC))
2078 dev_err(&dev->udev->dev, "error submitting urb\n");
2079 } else {
2080 dprintk(dev, 2, "%s :complete state 0\n", __func__);
2081 }
2082 return;
2083 }
2084
2085 static int s2255_start_readpipe(struct s2255_dev *dev)
2086 {
2087 int pipe;
2088 int retval;
2089 struct s2255_pipeinfo *pipe_info = &dev->pipe;
2090 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2091 dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint);
2092 pipe_info->state = 1;
2093 pipe_info->err_count = 0;
2094 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2095 if (!pipe_info->stream_urb)
2096 return -ENOMEM;
2097 /* transfer buffer allocated in board_init */
2098 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2099 pipe,
2100 pipe_info->transfer_buffer,
2101 pipe_info->cur_transfer_size,
2102 read_pipe_completion, pipe_info);
2103 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2104 if (retval) {
2105 pr_err("s2255: start read pipe failed\n");
2106 return retval;
2107 }
2108 return 0;
2109 }
2110
2111 /* starts acquisition process */
2112 static int s2255_start_acquire(struct s2255_vc *vc)
2113 {
2114 int res;
2115 unsigned long chn_rev;
2116 int j;
2117 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2118 __le32 *buffer = dev->cmdbuf;
2119
2120 mutex_lock(&dev->cmdlock);
2121 chn_rev = G_chnmap[vc->idx];
2122 vc->last_frame = -1;
2123 vc->bad_payload = 0;
2124 vc->cur_frame = 0;
2125 for (j = 0; j < SYS_FRAMES; j++) {
2126 vc->buffer.frame[j].ulState = 0;
2127 vc->buffer.frame[j].cur_size = 0;
2128 }
2129
2130 /* send the start command */
2131 buffer[0] = IN_DATA_TOKEN;
2132 buffer[1] = (__le32) cpu_to_le32(chn_rev);
2133 buffer[2] = CMD_START;
2134 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2135 if (res != 0)
2136 dev_err(&dev->udev->dev, "CMD_START error\n");
2137
2138 dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
2139 mutex_unlock(&dev->cmdlock);
2140 return res;
2141 }
2142
2143 static int s2255_stop_acquire(struct s2255_vc *vc)
2144 {
2145 int res;
2146 unsigned long chn_rev;
2147 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2148 __le32 *buffer = dev->cmdbuf;
2149
2150 mutex_lock(&dev->cmdlock);
2151 chn_rev = G_chnmap[vc->idx];
2152 /* send the stop command */
2153 buffer[0] = IN_DATA_TOKEN;
2154 buffer[1] = (__le32) cpu_to_le32(chn_rev);
2155 buffer[2] = CMD_STOP;
2156
2157 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2158 if (res != 0)
2159 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2160
2161 dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
2162 mutex_unlock(&dev->cmdlock);
2163 return res;
2164 }
2165
2166 static void s2255_stop_readpipe(struct s2255_dev *dev)
2167 {
2168 struct s2255_pipeinfo *pipe = &dev->pipe;
2169
2170 pipe->state = 0;
2171 if (pipe->stream_urb) {
2172 /* cancel urb */
2173 usb_kill_urb(pipe->stream_urb);
2174 usb_free_urb(pipe->stream_urb);
2175 pipe->stream_urb = NULL;
2176 }
2177 dprintk(dev, 4, "%s", __func__);
2178 return;
2179 }
2180
2181 static void s2255_fwload_start(struct s2255_dev *dev)
2182 {
2183 s2255_reset_dsppower(dev);
2184 dev->fw_data->fw_size = dev->fw_data->fw->size;
2185 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2186 memcpy(dev->fw_data->pfw_data,
2187 dev->fw_data->fw->data, CHUNK_SIZE);
2188 dev->fw_data->fw_loaded = CHUNK_SIZE;
2189 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2190 usb_sndbulkpipe(dev->udev, 2),
2191 dev->fw_data->pfw_data,
2192 CHUNK_SIZE, s2255_fwchunk_complete,
2193 dev->fw_data);
2194 mod_timer(&dev->timer, jiffies + HZ);
2195 }
2196
2197 /* standard usb probe function */
2198 static int s2255_probe(struct usb_interface *interface,
2199 const struct usb_device_id *id)
2200 {
2201 struct s2255_dev *dev = NULL;
2202 struct usb_host_interface *iface_desc;
2203 struct usb_endpoint_descriptor *endpoint;
2204 int i;
2205 int retval = -ENOMEM;
2206 __le32 *pdata;
2207 int fw_size;
2208
2209 /* allocate memory for our device state and initialize it to zero */
2210 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2211 if (dev == NULL) {
2212 s2255_dev_err(&interface->dev, "out of memory\n");
2213 return -ENOMEM;
2214 }
2215
2216 dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL);
2217 if (dev->cmdbuf == NULL) {
2218 s2255_dev_err(&interface->dev, "out of memory\n");
2219 goto errorFWDATA1;
2220 }
2221
2222 refcount_set(&dev->num_channels, 0);
2223 dev->pid = id->idProduct;
2224 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2225 if (!dev->fw_data)
2226 goto errorFWDATA1;
2227 mutex_init(&dev->lock);
2228 mutex_init(&dev->cmdlock);
2229 /* grab usb_device and save it */
2230 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2231 if (dev->udev == NULL) {
2232 dev_err(&interface->dev, "null usb device\n");
2233 retval = -ENODEV;
2234 goto errorUDEV;
2235 }
2236 dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n",
2237 dev, dev->udev, interface);
2238 dev->interface = interface;
2239 /* set up the endpoint information */
2240 iface_desc = interface->cur_altsetting;
2241 dev_dbg(&interface->dev, "num EP: %d\n",
2242 iface_desc->desc.bNumEndpoints);
2243 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2244 endpoint = &iface_desc->endpoint[i].desc;
2245 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2246 /* we found the bulk in endpoint */
2247 dev->read_endpoint = endpoint->bEndpointAddress;
2248 }
2249 }
2250
2251 if (!dev->read_endpoint) {
2252 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2253 goto errorEP;
2254 }
2255 timer_setup(&dev->timer, s2255_timer, 0);
2256 init_waitqueue_head(&dev->fw_data->wait_fw);
2257 for (i = 0; i < MAX_CHANNELS; i++) {
2258 struct s2255_vc *vc = &dev->vc[i];
2259 vc->idx = i;
2260 vc->dev = dev;
2261 init_waitqueue_head(&vc->wait_setmode);
2262 init_waitqueue_head(&vc->wait_vidstatus);
2263 spin_lock_init(&vc->qlock);
2264 mutex_init(&vc->vb_lock);
2265 }
2266
2267 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2268 if (!dev->fw_data->fw_urb)
2269 goto errorFWURB;
2270
2271 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2272 if (!dev->fw_data->pfw_data) {
2273 dev_err(&interface->dev, "out of memory!\n");
2274 goto errorFWDATA2;
2275 }
2276 /* load the first chunk */
2277 if (request_firmware(&dev->fw_data->fw,
2278 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2279 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
2280 goto errorREQFW;
2281 }
2282 /* check the firmware is valid */
2283 fw_size = dev->fw_data->fw->size;
2284 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2285
2286 if (*pdata != S2255_FW_MARKER) {
2287 dev_err(&interface->dev, "Firmware invalid.\n");
2288 retval = -ENODEV;
2289 goto errorFWMARKER;
2290 } else {
2291 /* make sure firmware is the latest */
2292 __le32 *pRel;
2293 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2294 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel));
2295 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2296 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2297 pr_info("s2255: f2255usb.bin out of date.\n");
2298 if (dev->pid == 0x2257 &&
2299 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2300 pr_warn("2257 needs firmware %d or above.\n",
2301 S2255_MIN_DSP_COLORFILTER);
2302 }
2303 usb_reset_device(dev->udev);
2304 /* load 2255 board specific */
2305 retval = s2255_board_init(dev);
2306 if (retval)
2307 goto errorBOARDINIT;
2308 s2255_fwload_start(dev);
2309 /* loads v4l specific */
2310 retval = s2255_probe_v4l(dev);
2311 if (retval)
2312 goto errorBOARDINIT;
2313 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2314 return 0;
2315 errorBOARDINIT:
2316 s2255_board_shutdown(dev);
2317 errorFWMARKER:
2318 release_firmware(dev->fw_data->fw);
2319 errorREQFW:
2320 kfree(dev->fw_data->pfw_data);
2321 errorFWDATA2:
2322 usb_free_urb(dev->fw_data->fw_urb);
2323 errorFWURB:
2324 timer_shutdown_sync(&dev->timer);
2325 errorEP:
2326 usb_put_dev(dev->udev);
2327 errorUDEV:
2328 kfree(dev->fw_data);
2329 mutex_destroy(&dev->lock);
2330 errorFWDATA1:
2331 kfree(dev->cmdbuf);
2332 kfree(dev);
2333 pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval);
2334 return retval;
2335 }
2336
2337 /* disconnect routine. when board is removed physically or with rmmod */
2338 static void s2255_disconnect(struct usb_interface *interface)
2339 {
2340 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2341 int i;
2342 int channels = refcount_read(&dev->num_channels);
2343 mutex_lock(&dev->lock);
2344 v4l2_device_disconnect(&dev->v4l2_dev);
2345 mutex_unlock(&dev->lock);
2346 /*see comments in the uvc_driver.c usb disconnect function */
2347 refcount_inc(&dev->num_channels);
2348 /* unregister each video device. */
2349 for (i = 0; i < channels; i++)
2350 video_unregister_device(&dev->vc[i].vdev);
2351 /* wake up any of our timers */
2352 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2353 wake_up(&dev->fw_data->wait_fw);
2354 for (i = 0; i < MAX_CHANNELS; i++) {
2355 dev->vc[i].setmode_ready = 1;
2356 wake_up(&dev->vc[i].wait_setmode);
2357 dev->vc[i].vidstatus_ready = 1;
2358 wake_up(&dev->vc[i].wait_vidstatus);
2359 }
2360 if (refcount_dec_and_test(&dev->num_channels))
2361 s2255_destroy(dev);
2362 dev_info(&interface->dev, "%s\n", __func__);
2363 }
2364
2365 static struct usb_driver s2255_driver = {
2366 .name = S2255_DRIVER_NAME,
2367 .probe = s2255_probe,
2368 .disconnect = s2255_disconnect,
2369 .id_table = s2255_table,
2370 };
2371
2372 module_usb_driver(s2255_driver);
2373
2374 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2375 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2376 MODULE_LICENSE("GPL");
2377 MODULE_VERSION(S2255_VERSION);
2378 MODULE_FIRMWARE(FIRMWARE_FILE_NAME);
Kernel DRM miscellaneous fixes and cross-tree changes