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