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