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