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