1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2005-2006 Micronas USA Inc.
4  */
5 
6 #include <linux/module.h>
7 #include <linux/delay.h>
8 #include <linux/sched.h>
9 #include <linux/spinlock.h>
10 #include <linux/slab.h>
11 #include <linux/fs.h>
12 #include <linux/unistd.h>
13 #include <linux/time.h>
14 #include <linux/vmalloc.h>
15 #include <linux/pagemap.h>
16 #include <linux/i2c.h>
17 #include <linux/mutex.h>
18 #include <linux/uaccess.h>
19 #include <linux/videodev2.h>
20 #include <media/v4l2-common.h>
21 #include <media/v4l2-ioctl.h>
22 #include <media/v4l2-subdev.h>
23 #include <media/v4l2-event.h>
24 #include <media/videobuf2-vmalloc.h>
25 #include <media/i2c/saa7115.h>
26 
27 #include "go7007-priv.h"
28 
29 #define call_all(dev, o, f, args...) \
30 	v4l2_device_call_until_err(dev, 0, o, f, ##args)
31 
32 static bool valid_pixelformat(u32 pixelformat)
33 {
34 	switch (pixelformat) {
35 	case V4L2_PIX_FMT_MJPEG:
36 	case V4L2_PIX_FMT_MPEG1:
37 	case V4L2_PIX_FMT_MPEG2:
38 	case V4L2_PIX_FMT_MPEG4:
39 		return true;
40 	default:
41 		return false;
42 	}
43 }
44 
45 static u32 get_frame_type_flag(struct go7007_buffer *vb, int format)
46 {
47 	u8 *ptr = vb2_plane_vaddr(&vb->vb.vb2_buf, 0);
48 
49 	switch (format) {
50 	case V4L2_PIX_FMT_MJPEG:
51 		return V4L2_BUF_FLAG_KEYFRAME;
52 	case V4L2_PIX_FMT_MPEG4:
53 		switch ((ptr[vb->frame_offset + 4] >> 6) & 0x3) {
54 		case 0:
55 			return V4L2_BUF_FLAG_KEYFRAME;
56 		case 1:
57 			return V4L2_BUF_FLAG_PFRAME;
58 		case 2:
59 			return V4L2_BUF_FLAG_BFRAME;
60 		default:
61 			return 0;
62 		}
63 	case V4L2_PIX_FMT_MPEG1:
64 	case V4L2_PIX_FMT_MPEG2:
65 		switch ((ptr[vb->frame_offset + 5] >> 3) & 0x7) {
66 		case 1:
67 			return V4L2_BUF_FLAG_KEYFRAME;
68 		case 2:
69 			return V4L2_BUF_FLAG_PFRAME;
70 		case 3:
71 			return V4L2_BUF_FLAG_BFRAME;
72 		default:
73 			return 0;
74 		}
75 	}
76 
77 	return 0;
78 }
79 
80 static void get_resolution(struct go7007 *go, int *width, int *height)
81 {
82 	switch (go->standard) {
83 	case GO7007_STD_NTSC:
84 		*width = 720;
85 		*height = 480;
86 		break;
87 	case GO7007_STD_PAL:
88 		*width = 720;
89 		*height = 576;
90 		break;
91 	case GO7007_STD_OTHER:
92 	default:
93 		*width = go->board_info->sensor_width;
94 		*height = go->board_info->sensor_height;
95 		break;
96 	}
97 }
98 
99 static void set_formatting(struct go7007 *go)
100 {
101 	if (go->format == V4L2_PIX_FMT_MJPEG) {
102 		go->pali = 0;
103 		go->aspect_ratio = GO7007_RATIO_1_1;
104 		go->gop_size = 0;
105 		go->ipb = 0;
106 		go->closed_gop = 0;
107 		go->repeat_seqhead = 0;
108 		go->seq_header_enable = 0;
109 		go->gop_header_enable = 0;
110 		go->dvd_mode = 0;
111 		return;
112 	}
113 
114 	switch (go->format) {
115 	case V4L2_PIX_FMT_MPEG1:
116 		go->pali = 0;
117 		break;
118 	default:
119 	case V4L2_PIX_FMT_MPEG2:
120 		go->pali = 0x48;
121 		break;
122 	case V4L2_PIX_FMT_MPEG4:
123 		/* For future reference: this is the list of MPEG4
124 		 * profiles that are available, although they are
125 		 * untested:
126 		 *
127 		 * Profile		pali
128 		 * --------------	----
129 		 * PROFILE_S_L0		0x08
130 		 * PROFILE_S_L1		0x01
131 		 * PROFILE_S_L2		0x02
132 		 * PROFILE_S_L3		0x03
133 		 * PROFILE_ARTS_L1	0x91
134 		 * PROFILE_ARTS_L2	0x92
135 		 * PROFILE_ARTS_L3	0x93
136 		 * PROFILE_ARTS_L4	0x94
137 		 * PROFILE_AS_L0	0xf0
138 		 * PROFILE_AS_L1	0xf1
139 		 * PROFILE_AS_L2	0xf2
140 		 * PROFILE_AS_L3	0xf3
141 		 * PROFILE_AS_L4	0xf4
142 		 * PROFILE_AS_L5	0xf5
143 		 */
144 		go->pali = 0xf5;
145 		break;
146 	}
147 	go->gop_size = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_size);
148 	go->closed_gop = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_closure);
149 	go->ipb = v4l2_ctrl_g_ctrl(go->mpeg_video_b_frames) != 0;
150 	go->bitrate = v4l2_ctrl_g_ctrl(go->mpeg_video_bitrate);
151 	go->repeat_seqhead = v4l2_ctrl_g_ctrl(go->mpeg_video_rep_seqheader);
152 	go->gop_header_enable = 1;
153 	go->dvd_mode = 0;
154 	if (go->format == V4L2_PIX_FMT_MPEG2)
155 		go->dvd_mode =
156 			go->bitrate == 9800000 &&
157 			go->gop_size == 15 &&
158 			go->ipb == 0 &&
159 			go->repeat_seqhead == 1 &&
160 			go->closed_gop;
161 
162 	switch (v4l2_ctrl_g_ctrl(go->mpeg_video_aspect_ratio)) {
163 	default:
164 	case V4L2_MPEG_VIDEO_ASPECT_1x1:
165 		go->aspect_ratio = GO7007_RATIO_1_1;
166 		break;
167 	case V4L2_MPEG_VIDEO_ASPECT_4x3:
168 		go->aspect_ratio = GO7007_RATIO_4_3;
169 		break;
170 	case V4L2_MPEG_VIDEO_ASPECT_16x9:
171 		go->aspect_ratio = GO7007_RATIO_16_9;
172 		break;
173 	}
174 }
175 
176 static int set_capture_size(struct go7007 *go, struct v4l2_format *fmt, int try)
177 {
178 	int sensor_height = 0, sensor_width = 0;
179 	int width, height;
180 
181 	if (fmt != NULL && !valid_pixelformat(fmt->fmt.pix.pixelformat))
182 		return -EINVAL;
183 
184 	get_resolution(go, &sensor_width, &sensor_height);
185 
186 	if (fmt == NULL) {
187 		width = sensor_width;
188 		height = sensor_height;
189 	} else if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
190 		if (fmt->fmt.pix.width > sensor_width)
191 			width = sensor_width;
192 		else if (fmt->fmt.pix.width < 144)
193 			width = 144;
194 		else
195 			width = fmt->fmt.pix.width & ~0x0f;
196 
197 		if (fmt->fmt.pix.height > sensor_height)
198 			height = sensor_height;
199 		else if (fmt->fmt.pix.height < 96)
200 			height = 96;
201 		else
202 			height = fmt->fmt.pix.height & ~0x0f;
203 	} else {
204 		width = fmt->fmt.pix.width;
205 
206 		if (width <= sensor_width / 4) {
207 			width = sensor_width / 4;
208 			height = sensor_height / 4;
209 		} else if (width <= sensor_width / 2) {
210 			width = sensor_width / 2;
211 			height = sensor_height / 2;
212 		} else {
213 			width = sensor_width;
214 			height = sensor_height;
215 		}
216 		width &= ~0xf;
217 		height &= ~0xf;
218 	}
219 
220 	if (fmt != NULL) {
221 		u32 pixelformat = fmt->fmt.pix.pixelformat;
222 
223 		memset(fmt, 0, sizeof(*fmt));
224 		fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
225 		fmt->fmt.pix.width = width;
226 		fmt->fmt.pix.height = height;
227 		fmt->fmt.pix.pixelformat = pixelformat;
228 		fmt->fmt.pix.field = V4L2_FIELD_NONE;
229 		fmt->fmt.pix.bytesperline = 0;
230 		fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
231 		fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
232 	}
233 
234 	if (try)
235 		return 0;
236 
237 	if (fmt)
238 		go->format = fmt->fmt.pix.pixelformat;
239 	go->width = width;
240 	go->height = height;
241 	go->encoder_h_offset = go->board_info->sensor_h_offset;
242 	go->encoder_v_offset = go->board_info->sensor_v_offset;
243 
244 	if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
245 		struct v4l2_subdev_format format = {
246 			.which = V4L2_SUBDEV_FORMAT_ACTIVE,
247 		};
248 
249 		format.format.code = MEDIA_BUS_FMT_FIXED;
250 		format.format.width = fmt ? fmt->fmt.pix.width : width;
251 		format.format.height = height;
252 		go->encoder_h_halve = 0;
253 		go->encoder_v_halve = 0;
254 		go->encoder_subsample = 0;
255 		call_all(&go->v4l2_dev, pad, set_fmt, NULL, &format);
256 	} else {
257 		if (width <= sensor_width / 4) {
258 			go->encoder_h_halve = 1;
259 			go->encoder_v_halve = 1;
260 			go->encoder_subsample = 1;
261 		} else if (width <= sensor_width / 2) {
262 			go->encoder_h_halve = 1;
263 			go->encoder_v_halve = 1;
264 			go->encoder_subsample = 0;
265 		} else {
266 			go->encoder_h_halve = 0;
267 			go->encoder_v_halve = 0;
268 			go->encoder_subsample = 0;
269 		}
270 	}
271 	return 0;
272 }
273 
274 static int vidioc_querycap(struct file *file, void  *priv,
275 					struct v4l2_capability *cap)
276 {
277 	struct go7007 *go = video_drvdata(file);
278 
279 	strscpy(cap->driver, "go7007", sizeof(cap->driver));
280 	strscpy(cap->card, go->name, sizeof(cap->card));
281 	strscpy(cap->bus_info, go->bus_info, sizeof(cap->bus_info));
282 	return 0;
283 }
284 
285 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
286 					struct v4l2_fmtdesc *fmt)
287 {
288 	switch (fmt->index) {
289 	case 0:
290 		fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
291 		break;
292 	case 1:
293 		fmt->pixelformat = V4L2_PIX_FMT_MPEG1;
294 		break;
295 	case 2:
296 		fmt->pixelformat = V4L2_PIX_FMT_MPEG2;
297 		break;
298 	case 3:
299 		fmt->pixelformat = V4L2_PIX_FMT_MPEG4;
300 		break;
301 	default:
302 		return -EINVAL;
303 	}
304 	return 0;
305 }
306 
307 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
308 					struct v4l2_format *fmt)
309 {
310 	struct go7007 *go = video_drvdata(file);
311 
312 	fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
313 	fmt->fmt.pix.width = go->width;
314 	fmt->fmt.pix.height = go->height;
315 	fmt->fmt.pix.pixelformat = go->format;
316 	fmt->fmt.pix.field = V4L2_FIELD_NONE;
317 	fmt->fmt.pix.bytesperline = 0;
318 	fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
319 	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
320 
321 	return 0;
322 }
323 
324 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
325 			struct v4l2_format *fmt)
326 {
327 	struct go7007 *go = video_drvdata(file);
328 
329 	return set_capture_size(go, fmt, 1);
330 }
331 
332 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
333 			struct v4l2_format *fmt)
334 {
335 	struct go7007 *go = video_drvdata(file);
336 
337 	if (vb2_is_busy(&go->vidq))
338 		return -EBUSY;
339 
340 	return set_capture_size(go, fmt, 0);
341 }
342 
343 static int go7007_queue_setup(struct vb2_queue *q,
344 		unsigned int *num_buffers, unsigned int *num_planes,
345 		unsigned int sizes[], struct device *alloc_devs[])
346 {
347 	sizes[0] = GO7007_BUF_SIZE;
348 	*num_planes = 1;
349 
350 	if (*num_buffers < 2)
351 		*num_buffers = 2;
352 
353 	return 0;
354 }
355 
356 static void go7007_buf_queue(struct vb2_buffer *vb)
357 {
358 	struct vb2_queue *vq = vb->vb2_queue;
359 	struct go7007 *go = vb2_get_drv_priv(vq);
360 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
361 	struct go7007_buffer *go7007_vb =
362 		container_of(vbuf, struct go7007_buffer, vb);
363 	unsigned long flags;
364 
365 	spin_lock_irqsave(&go->spinlock, flags);
366 	list_add_tail(&go7007_vb->list, &go->vidq_active);
367 	spin_unlock_irqrestore(&go->spinlock, flags);
368 }
369 
370 static int go7007_buf_prepare(struct vb2_buffer *vb)
371 {
372 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
373 	struct go7007_buffer *go7007_vb =
374 		container_of(vbuf, struct go7007_buffer, vb);
375 
376 	go7007_vb->modet_active = 0;
377 	go7007_vb->frame_offset = 0;
378 	vb->planes[0].bytesused = 0;
379 	return 0;
380 }
381 
382 static void go7007_buf_finish(struct vb2_buffer *vb)
383 {
384 	struct vb2_queue *vq = vb->vb2_queue;
385 	struct go7007 *go = vb2_get_drv_priv(vq);
386 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
387 	struct go7007_buffer *go7007_vb =
388 		container_of(vbuf, struct go7007_buffer, vb);
389 	u32 frame_type_flag = get_frame_type_flag(go7007_vb, go->format);
390 
391 	vbuf->flags &= ~(V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_BFRAME |
392 			V4L2_BUF_FLAG_PFRAME);
393 	vbuf->flags |= frame_type_flag;
394 	vbuf->field = V4L2_FIELD_NONE;
395 }
396 
397 static int go7007_start_streaming(struct vb2_queue *q, unsigned int count)
398 {
399 	struct go7007 *go = vb2_get_drv_priv(q);
400 	int ret;
401 
402 	set_formatting(go);
403 	mutex_lock(&go->hw_lock);
404 	go->next_seq = 0;
405 	go->active_buf = NULL;
406 	go->modet_event_status = 0;
407 	if (go7007_start_encoder(go) < 0)
408 		ret = -EIO;
409 	else
410 		ret = 0;
411 	mutex_unlock(&go->hw_lock);
412 	if (ret)
413 		return ret;
414 	call_all(&go->v4l2_dev, video, s_stream, 1);
415 	v4l2_ctrl_grab(go->mpeg_video_gop_size, true);
416 	v4l2_ctrl_grab(go->mpeg_video_gop_closure, true);
417 	v4l2_ctrl_grab(go->mpeg_video_bitrate, true);
418 	v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, true);
419 	/* Turn on Capture LED */
420 	if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
421 		go7007_write_addr(go, 0x3c82, 0x0005);
422 	return ret;
423 }
424 
425 static void go7007_stop_streaming(struct vb2_queue *q)
426 {
427 	struct go7007 *go = vb2_get_drv_priv(q);
428 	unsigned long flags;
429 
430 	go7007_stream_stop(go);
431 	mutex_lock(&go->hw_lock);
432 	go7007_reset_encoder(go);
433 	mutex_unlock(&go->hw_lock);
434 	call_all(&go->v4l2_dev, video, s_stream, 0);
435 
436 	spin_lock_irqsave(&go->spinlock, flags);
437 	INIT_LIST_HEAD(&go->vidq_active);
438 	spin_unlock_irqrestore(&go->spinlock, flags);
439 	v4l2_ctrl_grab(go->mpeg_video_gop_size, false);
440 	v4l2_ctrl_grab(go->mpeg_video_gop_closure, false);
441 	v4l2_ctrl_grab(go->mpeg_video_bitrate, false);
442 	v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, false);
443 	/* Turn on Capture LED */
444 	if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
445 		go7007_write_addr(go, 0x3c82, 0x000d);
446 }
447 
448 static const struct vb2_ops go7007_video_qops = {
449 	.queue_setup    = go7007_queue_setup,
450 	.buf_queue      = go7007_buf_queue,
451 	.buf_prepare    = go7007_buf_prepare,
452 	.buf_finish     = go7007_buf_finish,
453 	.start_streaming = go7007_start_streaming,
454 	.stop_streaming = go7007_stop_streaming,
455 	.wait_prepare   = vb2_ops_wait_prepare,
456 	.wait_finish    = vb2_ops_wait_finish,
457 };
458 
459 static int vidioc_g_parm(struct file *filp, void *priv,
460 		struct v4l2_streamparm *parm)
461 {
462 	struct go7007 *go = video_drvdata(filp);
463 	struct v4l2_fract timeperframe = {
464 		.numerator = 1001 *  go->fps_scale,
465 		.denominator = go->sensor_framerate,
466 	};
467 
468 	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
469 		return -EINVAL;
470 
471 	parm->parm.capture.readbuffers = 2;
472 	parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
473 	parm->parm.capture.timeperframe = timeperframe;
474 
475 	return 0;
476 }
477 
478 static int vidioc_s_parm(struct file *filp, void *priv,
479 		struct v4l2_streamparm *parm)
480 {
481 	struct go7007 *go = video_drvdata(filp);
482 	unsigned int n, d;
483 
484 	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
485 		return -EINVAL;
486 
487 	n = go->sensor_framerate *
488 		parm->parm.capture.timeperframe.numerator;
489 	d = 1001 * parm->parm.capture.timeperframe.denominator;
490 	if (n != 0 && d != 0 && n > d)
491 		go->fps_scale = (n + d/2) / d;
492 	else
493 		go->fps_scale = 1;
494 
495 	return vidioc_g_parm(filp, priv, parm);
496 }
497 
498 /* VIDIOC_ENUMSTD on go7007 were used for enumerating the supported fps and
499    its resolution, when the device is not connected to TV.
500    This is were an API abuse, probably used by the lack of specific IOCTL's to
501    enumerate it, by the time the driver was written.
502 
503    However, since kernel 2.6.19, two new ioctls (VIDIOC_ENUM_FRAMEINTERVALS
504    and VIDIOC_ENUM_FRAMESIZES) were added for this purpose.
505 
506    The two functions below implement the newer ioctls
507 */
508 static int vidioc_enum_framesizes(struct file *filp, void *priv,
509 				  struct v4l2_frmsizeenum *fsize)
510 {
511 	struct go7007 *go = video_drvdata(filp);
512 	int width, height;
513 
514 	if (fsize->index > 2)
515 		return -EINVAL;
516 
517 	if (!valid_pixelformat(fsize->pixel_format))
518 		return -EINVAL;
519 
520 	get_resolution(go, &width, &height);
521 	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
522 	fsize->discrete.width = (width >> fsize->index) & ~0xf;
523 	fsize->discrete.height = (height >> fsize->index) & ~0xf;
524 	return 0;
525 }
526 
527 static int vidioc_enum_frameintervals(struct file *filp, void *priv,
528 				      struct v4l2_frmivalenum *fival)
529 {
530 	struct go7007 *go = video_drvdata(filp);
531 	int width, height;
532 	int i;
533 
534 	if (fival->index > 4)
535 		return -EINVAL;
536 
537 	if (!valid_pixelformat(fival->pixel_format))
538 		return -EINVAL;
539 
540 	if (!(go->board_info->sensor_flags & GO7007_SENSOR_SCALING)) {
541 		get_resolution(go, &width, &height);
542 		for (i = 0; i <= 2; i++)
543 			if (fival->width == ((width >> i) & ~0xf) &&
544 			    fival->height == ((height >> i) & ~0xf))
545 				break;
546 		if (i > 2)
547 			return -EINVAL;
548 	}
549 	fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
550 	fival->discrete.numerator = 1001 * (fival->index + 1);
551 	fival->discrete.denominator = go->sensor_framerate;
552 	return 0;
553 }
554 
555 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std)
556 {
557 	struct go7007 *go = video_drvdata(file);
558 
559 	*std = go->std;
560 	return 0;
561 }
562 
563 static int go7007_s_std(struct go7007 *go)
564 {
565 	if (go->std & V4L2_STD_625_50) {
566 		go->standard = GO7007_STD_PAL;
567 		go->sensor_framerate = 25025;
568 	} else {
569 		go->standard = GO7007_STD_NTSC;
570 		go->sensor_framerate = 30000;
571 	}
572 
573 	call_all(&go->v4l2_dev, video, s_std, go->std);
574 	set_capture_size(go, NULL, 0);
575 	return 0;
576 }
577 
578 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id std)
579 {
580 	struct go7007 *go = video_drvdata(file);
581 
582 	if (vb2_is_busy(&go->vidq))
583 		return -EBUSY;
584 
585 	go->std = std;
586 
587 	return go7007_s_std(go);
588 }
589 
590 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std)
591 {
592 	struct go7007 *go = video_drvdata(file);
593 
594 	return call_all(&go->v4l2_dev, video, querystd, std);
595 }
596 
597 static int vidioc_enum_input(struct file *file, void *priv,
598 				struct v4l2_input *inp)
599 {
600 	struct go7007 *go = video_drvdata(file);
601 
602 	if (inp->index >= go->board_info->num_inputs)
603 		return -EINVAL;
604 
605 	strscpy(inp->name, go->board_info->inputs[inp->index].name,
606 		sizeof(inp->name));
607 
608 	/* If this board has a tuner, it will be the first input */
609 	if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
610 			inp->index == 0)
611 		inp->type = V4L2_INPUT_TYPE_TUNER;
612 	else
613 		inp->type = V4L2_INPUT_TYPE_CAMERA;
614 
615 	if (go->board_info->num_aud_inputs)
616 		inp->audioset = (1 << go->board_info->num_aud_inputs) - 1;
617 	else
618 		inp->audioset = 0;
619 	inp->tuner = 0;
620 	if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
621 		inp->std = video_devdata(file)->tvnorms;
622 	else
623 		inp->std = 0;
624 
625 	return 0;
626 }
627 
628 
629 static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
630 {
631 	struct go7007 *go = video_drvdata(file);
632 
633 	*input = go->input;
634 
635 	return 0;
636 }
637 
638 static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
639 {
640 	struct go7007 *go = video_drvdata(file);
641 
642 	if (a->index >= go->board_info->num_aud_inputs)
643 		return -EINVAL;
644 	strscpy(a->name, go->board_info->aud_inputs[a->index].name,
645 		sizeof(a->name));
646 	a->capability = V4L2_AUDCAP_STEREO;
647 	return 0;
648 }
649 
650 static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
651 {
652 	struct go7007 *go = video_drvdata(file);
653 
654 	a->index = go->aud_input;
655 	strscpy(a->name, go->board_info->aud_inputs[go->aud_input].name,
656 		sizeof(a->name));
657 	a->capability = V4L2_AUDCAP_STEREO;
658 	return 0;
659 }
660 
661 static int vidioc_s_audio(struct file *file, void *fh,
662 	const struct v4l2_audio *a)
663 {
664 	struct go7007 *go = video_drvdata(file);
665 
666 	if (a->index >= go->board_info->num_aud_inputs)
667 		return -EINVAL;
668 	go->aud_input = a->index;
669 	v4l2_subdev_call(go->sd_audio, audio, s_routing,
670 		go->board_info->aud_inputs[go->aud_input].audio_input, 0, 0);
671 	return 0;
672 }
673 
674 static void go7007_s_input(struct go7007 *go)
675 {
676 	unsigned int input = go->input;
677 
678 	v4l2_subdev_call(go->sd_video, video, s_routing,
679 			go->board_info->inputs[input].video_input, 0,
680 			go->board_info->video_config);
681 	if (go->board_info->num_aud_inputs) {
682 		int aud_input = go->board_info->inputs[input].audio_index;
683 
684 		v4l2_subdev_call(go->sd_audio, audio, s_routing,
685 			go->board_info->aud_inputs[aud_input].audio_input, 0, 0);
686 		go->aud_input = aud_input;
687 	}
688 }
689 
690 static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
691 {
692 	struct go7007 *go = video_drvdata(file);
693 
694 	if (input >= go->board_info->num_inputs)
695 		return -EINVAL;
696 	if (vb2_is_busy(&go->vidq))
697 		return -EBUSY;
698 
699 	go->input = input;
700 	go7007_s_input(go);
701 
702 	return 0;
703 }
704 
705 static int vidioc_g_tuner(struct file *file, void *priv,
706 				struct v4l2_tuner *t)
707 {
708 	struct go7007 *go = video_drvdata(file);
709 
710 	if (t->index != 0)
711 		return -EINVAL;
712 
713 	strscpy(t->name, "Tuner", sizeof(t->name));
714 	return call_all(&go->v4l2_dev, tuner, g_tuner, t);
715 }
716 
717 static int vidioc_s_tuner(struct file *file, void *priv,
718 				const struct v4l2_tuner *t)
719 {
720 	struct go7007 *go = video_drvdata(file);
721 
722 	if (t->index != 0)
723 		return -EINVAL;
724 
725 	return call_all(&go->v4l2_dev, tuner, s_tuner, t);
726 }
727 
728 static int vidioc_g_frequency(struct file *file, void *priv,
729 				struct v4l2_frequency *f)
730 {
731 	struct go7007 *go = video_drvdata(file);
732 
733 	if (f->tuner)
734 		return -EINVAL;
735 
736 	return call_all(&go->v4l2_dev, tuner, g_frequency, f);
737 }
738 
739 static int vidioc_s_frequency(struct file *file, void *priv,
740 				const struct v4l2_frequency *f)
741 {
742 	struct go7007 *go = video_drvdata(file);
743 
744 	if (f->tuner)
745 		return -EINVAL;
746 
747 	return call_all(&go->v4l2_dev, tuner, s_frequency, f);
748 }
749 
750 static int vidioc_log_status(struct file *file, void *priv)
751 {
752 	struct go7007 *go = video_drvdata(file);
753 
754 	v4l2_ctrl_log_status(file, priv);
755 	return call_all(&go->v4l2_dev, core, log_status);
756 }
757 
758 static int vidioc_subscribe_event(struct v4l2_fh *fh,
759 				const struct v4l2_event_subscription *sub)
760 {
761 
762 	switch (sub->type) {
763 	case V4L2_EVENT_MOTION_DET:
764 		/* Allow for up to 30 events (1 second for NTSC) to be
765 		 * stored. */
766 		return v4l2_event_subscribe(fh, sub, 30, NULL);
767 	default:
768 		return v4l2_ctrl_subscribe_event(fh, sub);
769 	}
770 }
771 
772 
773 static int go7007_s_ctrl(struct v4l2_ctrl *ctrl)
774 {
775 	struct go7007 *go =
776 		container_of(ctrl->handler, struct go7007, hdl);
777 	unsigned y;
778 	u8 *mt;
779 
780 	switch (ctrl->id) {
781 	case V4L2_CID_PIXEL_THRESHOLD0:
782 		go->modet[0].pixel_threshold = ctrl->val;
783 		break;
784 	case V4L2_CID_MOTION_THRESHOLD0:
785 		go->modet[0].motion_threshold = ctrl->val;
786 		break;
787 	case V4L2_CID_MB_THRESHOLD0:
788 		go->modet[0].mb_threshold = ctrl->val;
789 		break;
790 	case V4L2_CID_PIXEL_THRESHOLD1:
791 		go->modet[1].pixel_threshold = ctrl->val;
792 		break;
793 	case V4L2_CID_MOTION_THRESHOLD1:
794 		go->modet[1].motion_threshold = ctrl->val;
795 		break;
796 	case V4L2_CID_MB_THRESHOLD1:
797 		go->modet[1].mb_threshold = ctrl->val;
798 		break;
799 	case V4L2_CID_PIXEL_THRESHOLD2:
800 		go->modet[2].pixel_threshold = ctrl->val;
801 		break;
802 	case V4L2_CID_MOTION_THRESHOLD2:
803 		go->modet[2].motion_threshold = ctrl->val;
804 		break;
805 	case V4L2_CID_MB_THRESHOLD2:
806 		go->modet[2].mb_threshold = ctrl->val;
807 		break;
808 	case V4L2_CID_PIXEL_THRESHOLD3:
809 		go->modet[3].pixel_threshold = ctrl->val;
810 		break;
811 	case V4L2_CID_MOTION_THRESHOLD3:
812 		go->modet[3].motion_threshold = ctrl->val;
813 		break;
814 	case V4L2_CID_MB_THRESHOLD3:
815 		go->modet[3].mb_threshold = ctrl->val;
816 		break;
817 	case V4L2_CID_DETECT_MD_REGION_GRID:
818 		mt = go->modet_map;
819 		for (y = 0; y < go->height / 16; y++, mt += go->width / 16)
820 			memcpy(mt, ctrl->p_new.p_u8 + y * (720 / 16), go->width / 16);
821 		break;
822 	default:
823 		return -EINVAL;
824 	}
825 	return 0;
826 }
827 
828 static const struct v4l2_file_operations go7007_fops = {
829 	.owner		= THIS_MODULE,
830 	.open		= v4l2_fh_open,
831 	.release	= vb2_fop_release,
832 	.unlocked_ioctl	= video_ioctl2,
833 	.read		= vb2_fop_read,
834 	.mmap		= vb2_fop_mmap,
835 	.poll		= vb2_fop_poll,
836 };
837 
838 static const struct v4l2_ioctl_ops video_ioctl_ops = {
839 	.vidioc_querycap          = vidioc_querycap,
840 	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
841 	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
842 	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
843 	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
844 	.vidioc_reqbufs           = vb2_ioctl_reqbufs,
845 	.vidioc_querybuf          = vb2_ioctl_querybuf,
846 	.vidioc_qbuf              = vb2_ioctl_qbuf,
847 	.vidioc_dqbuf             = vb2_ioctl_dqbuf,
848 	.vidioc_g_std             = vidioc_g_std,
849 	.vidioc_s_std             = vidioc_s_std,
850 	.vidioc_querystd          = vidioc_querystd,
851 	.vidioc_enum_input        = vidioc_enum_input,
852 	.vidioc_g_input           = vidioc_g_input,
853 	.vidioc_s_input           = vidioc_s_input,
854 	.vidioc_enumaudio         = vidioc_enumaudio,
855 	.vidioc_g_audio           = vidioc_g_audio,
856 	.vidioc_s_audio           = vidioc_s_audio,
857 	.vidioc_streamon          = vb2_ioctl_streamon,
858 	.vidioc_streamoff         = vb2_ioctl_streamoff,
859 	.vidioc_g_tuner           = vidioc_g_tuner,
860 	.vidioc_s_tuner           = vidioc_s_tuner,
861 	.vidioc_g_frequency       = vidioc_g_frequency,
862 	.vidioc_s_frequency       = vidioc_s_frequency,
863 	.vidioc_g_parm            = vidioc_g_parm,
864 	.vidioc_s_parm            = vidioc_s_parm,
865 	.vidioc_enum_framesizes   = vidioc_enum_framesizes,
866 	.vidioc_enum_frameintervals = vidioc_enum_frameintervals,
867 	.vidioc_log_status        = vidioc_log_status,
868 	.vidioc_subscribe_event   = vidioc_subscribe_event,
869 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
870 };
871 
872 static const struct video_device go7007_template = {
873 	.name		= "go7007",
874 	.fops		= &go7007_fops,
875 	.release	= video_device_release_empty,
876 	.ioctl_ops	= &video_ioctl_ops,
877 	.tvnorms	= V4L2_STD_ALL,
878 };
879 
880 static const struct v4l2_ctrl_ops go7007_ctrl_ops = {
881 	.s_ctrl = go7007_s_ctrl,
882 };
883 
884 static const struct v4l2_ctrl_config go7007_pixel_threshold0_ctrl = {
885 	.ops = &go7007_ctrl_ops,
886 	.id = V4L2_CID_PIXEL_THRESHOLD0,
887 	.name = "Pixel Threshold Region 0",
888 	.type = V4L2_CTRL_TYPE_INTEGER,
889 	.def = 20,
890 	.max = 32767,
891 	.step = 1,
892 };
893 
894 static const struct v4l2_ctrl_config go7007_motion_threshold0_ctrl = {
895 	.ops = &go7007_ctrl_ops,
896 	.id = V4L2_CID_MOTION_THRESHOLD0,
897 	.name = "Motion Threshold Region 0",
898 	.type = V4L2_CTRL_TYPE_INTEGER,
899 	.def = 80,
900 	.max = 32767,
901 	.step = 1,
902 };
903 
904 static const struct v4l2_ctrl_config go7007_mb_threshold0_ctrl = {
905 	.ops = &go7007_ctrl_ops,
906 	.id = V4L2_CID_MB_THRESHOLD0,
907 	.name = "MB Threshold Region 0",
908 	.type = V4L2_CTRL_TYPE_INTEGER,
909 	.def = 200,
910 	.max = 32767,
911 	.step = 1,
912 };
913 
914 static const struct v4l2_ctrl_config go7007_pixel_threshold1_ctrl = {
915 	.ops = &go7007_ctrl_ops,
916 	.id = V4L2_CID_PIXEL_THRESHOLD1,
917 	.name = "Pixel Threshold Region 1",
918 	.type = V4L2_CTRL_TYPE_INTEGER,
919 	.def = 20,
920 	.max = 32767,
921 	.step = 1,
922 };
923 
924 static const struct v4l2_ctrl_config go7007_motion_threshold1_ctrl = {
925 	.ops = &go7007_ctrl_ops,
926 	.id = V4L2_CID_MOTION_THRESHOLD1,
927 	.name = "Motion Threshold Region 1",
928 	.type = V4L2_CTRL_TYPE_INTEGER,
929 	.def = 80,
930 	.max = 32767,
931 	.step = 1,
932 };
933 
934 static const struct v4l2_ctrl_config go7007_mb_threshold1_ctrl = {
935 	.ops = &go7007_ctrl_ops,
936 	.id = V4L2_CID_MB_THRESHOLD1,
937 	.name = "MB Threshold Region 1",
938 	.type = V4L2_CTRL_TYPE_INTEGER,
939 	.def = 200,
940 	.max = 32767,
941 	.step = 1,
942 };
943 
944 static const struct v4l2_ctrl_config go7007_pixel_threshold2_ctrl = {
945 	.ops = &go7007_ctrl_ops,
946 	.id = V4L2_CID_PIXEL_THRESHOLD2,
947 	.name = "Pixel Threshold Region 2",
948 	.type = V4L2_CTRL_TYPE_INTEGER,
949 	.def = 20,
950 	.max = 32767,
951 	.step = 1,
952 };
953 
954 static const struct v4l2_ctrl_config go7007_motion_threshold2_ctrl = {
955 	.ops = &go7007_ctrl_ops,
956 	.id = V4L2_CID_MOTION_THRESHOLD2,
957 	.name = "Motion Threshold Region 2",
958 	.type = V4L2_CTRL_TYPE_INTEGER,
959 	.def = 80,
960 	.max = 32767,
961 	.step = 1,
962 };
963 
964 static const struct v4l2_ctrl_config go7007_mb_threshold2_ctrl = {
965 	.ops = &go7007_ctrl_ops,
966 	.id = V4L2_CID_MB_THRESHOLD2,
967 	.name = "MB Threshold Region 2",
968 	.type = V4L2_CTRL_TYPE_INTEGER,
969 	.def = 200,
970 	.max = 32767,
971 	.step = 1,
972 };
973 
974 static const struct v4l2_ctrl_config go7007_pixel_threshold3_ctrl = {
975 	.ops = &go7007_ctrl_ops,
976 	.id = V4L2_CID_PIXEL_THRESHOLD3,
977 	.name = "Pixel Threshold Region 3",
978 	.type = V4L2_CTRL_TYPE_INTEGER,
979 	.def = 20,
980 	.max = 32767,
981 	.step = 1,
982 };
983 
984 static const struct v4l2_ctrl_config go7007_motion_threshold3_ctrl = {
985 	.ops = &go7007_ctrl_ops,
986 	.id = V4L2_CID_MOTION_THRESHOLD3,
987 	.name = "Motion Threshold Region 3",
988 	.type = V4L2_CTRL_TYPE_INTEGER,
989 	.def = 80,
990 	.max = 32767,
991 	.step = 1,
992 };
993 
994 static const struct v4l2_ctrl_config go7007_mb_threshold3_ctrl = {
995 	.ops = &go7007_ctrl_ops,
996 	.id = V4L2_CID_MB_THRESHOLD3,
997 	.name = "MB Threshold Region 3",
998 	.type = V4L2_CTRL_TYPE_INTEGER,
999 	.def = 200,
1000 	.max = 32767,
1001 	.step = 1,
1002 };
1003 
1004 static const struct v4l2_ctrl_config go7007_mb_regions_ctrl = {
1005 	.ops = &go7007_ctrl_ops,
1006 	.id = V4L2_CID_DETECT_MD_REGION_GRID,
1007 	.dims = { 576 / 16, 720 / 16 },
1008 	.max = 3,
1009 	.step = 1,
1010 };
1011 
1012 int go7007_v4l2_ctrl_init(struct go7007 *go)
1013 {
1014 	struct v4l2_ctrl_handler *hdl = &go->hdl;
1015 	struct v4l2_ctrl *ctrl;
1016 
1017 	v4l2_ctrl_handler_init(hdl, 22);
1018 	go->mpeg_video_gop_size = v4l2_ctrl_new_std(hdl, NULL,
1019 			V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, 34, 1, 15);
1020 	go->mpeg_video_gop_closure = v4l2_ctrl_new_std(hdl, NULL,
1021 			V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
1022 	go->mpeg_video_bitrate = v4l2_ctrl_new_std(hdl, NULL,
1023 			V4L2_CID_MPEG_VIDEO_BITRATE,
1024 			64000, 10000000, 1, 9800000);
1025 	go->mpeg_video_b_frames = v4l2_ctrl_new_std(hdl, NULL,
1026 			V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 2, 2, 0);
1027 	go->mpeg_video_rep_seqheader = v4l2_ctrl_new_std(hdl, NULL,
1028 			V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, 0, 1, 1, 1);
1029 
1030 	go->mpeg_video_aspect_ratio = v4l2_ctrl_new_std_menu(hdl, NULL,
1031 			V4L2_CID_MPEG_VIDEO_ASPECT,
1032 			V4L2_MPEG_VIDEO_ASPECT_16x9, 0,
1033 			V4L2_MPEG_VIDEO_ASPECT_1x1);
1034 	ctrl = v4l2_ctrl_new_std(hdl, NULL,
1035 			V4L2_CID_JPEG_ACTIVE_MARKER, 0,
1036 			V4L2_JPEG_ACTIVE_MARKER_DQT |
1037 			V4L2_JPEG_ACTIVE_MARKER_DHT, 0,
1038 			V4L2_JPEG_ACTIVE_MARKER_DQT |
1039 			V4L2_JPEG_ACTIVE_MARKER_DHT);
1040 	if (ctrl)
1041 		ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1042 	v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold0_ctrl, NULL);
1043 	v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold0_ctrl, NULL);
1044 	v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold0_ctrl, NULL);
1045 	v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold1_ctrl, NULL);
1046 	v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold1_ctrl, NULL);
1047 	v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold1_ctrl, NULL);
1048 	v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold2_ctrl, NULL);
1049 	v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold2_ctrl, NULL);
1050 	v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold2_ctrl, NULL);
1051 	v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold3_ctrl, NULL);
1052 	v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold3_ctrl, NULL);
1053 	v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold3_ctrl, NULL);
1054 	v4l2_ctrl_new_custom(hdl, &go7007_mb_regions_ctrl, NULL);
1055 	go->modet_mode = v4l2_ctrl_new_std_menu(hdl, NULL,
1056 			V4L2_CID_DETECT_MD_MODE,
1057 			V4L2_DETECT_MD_MODE_REGION_GRID,
1058 			1 << V4L2_DETECT_MD_MODE_THRESHOLD_GRID,
1059 			V4L2_DETECT_MD_MODE_DISABLED);
1060 	if (hdl->error) {
1061 		int rv = hdl->error;
1062 
1063 		v4l2_err(&go->v4l2_dev, "Could not register controls\n");
1064 		return rv;
1065 	}
1066 	go->v4l2_dev.ctrl_handler = hdl;
1067 	return 0;
1068 }
1069 
1070 int go7007_v4l2_init(struct go7007 *go)
1071 {
1072 	struct video_device *vdev = &go->vdev;
1073 	int rv;
1074 
1075 	mutex_init(&go->serialize_lock);
1076 	mutex_init(&go->queue_lock);
1077 
1078 	INIT_LIST_HEAD(&go->vidq_active);
1079 	go->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1080 	go->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1081 	go->vidq.ops = &go7007_video_qops;
1082 	go->vidq.mem_ops = &vb2_vmalloc_memops;
1083 	go->vidq.drv_priv = go;
1084 	go->vidq.buf_struct_size = sizeof(struct go7007_buffer);
1085 	go->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1086 	go->vidq.lock = &go->queue_lock;
1087 	rv = vb2_queue_init(&go->vidq);
1088 	if (rv)
1089 		return rv;
1090 	*vdev = go7007_template;
1091 	vdev->lock = &go->serialize_lock;
1092 	vdev->queue = &go->vidq;
1093 	vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1094 			    V4L2_CAP_STREAMING;
1095 	if (go->board_info->num_aud_inputs)
1096 		vdev->device_caps |= V4L2_CAP_AUDIO;
1097 	if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
1098 		vdev->device_caps |= V4L2_CAP_TUNER;
1099 	video_set_drvdata(vdev, go);
1100 	vdev->v4l2_dev = &go->v4l2_dev;
1101 	if (!v4l2_device_has_op(&go->v4l2_dev, 0, video, querystd))
1102 		v4l2_disable_ioctl(vdev, VIDIOC_QUERYSTD);
1103 	if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER)) {
1104 		v4l2_disable_ioctl(vdev, VIDIOC_S_FREQUENCY);
1105 		v4l2_disable_ioctl(vdev, VIDIOC_G_FREQUENCY);
1106 		v4l2_disable_ioctl(vdev, VIDIOC_S_TUNER);
1107 		v4l2_disable_ioctl(vdev, VIDIOC_G_TUNER);
1108 	} else {
1109 		struct v4l2_frequency f = {
1110 			.type = V4L2_TUNER_ANALOG_TV,
1111 			.frequency = 980,
1112 		};
1113 
1114 		call_all(&go->v4l2_dev, tuner, s_frequency, &f);
1115 	}
1116 	if (!(go->board_info->sensor_flags & GO7007_SENSOR_TV)) {
1117 		v4l2_disable_ioctl(vdev, VIDIOC_G_STD);
1118 		v4l2_disable_ioctl(vdev, VIDIOC_S_STD);
1119 		vdev->tvnorms = 0;
1120 	}
1121 	if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING)
1122 		v4l2_disable_ioctl(vdev, VIDIOC_ENUM_FRAMESIZES);
1123 	if (go->board_info->num_aud_inputs == 0) {
1124 		v4l2_disable_ioctl(vdev, VIDIOC_G_AUDIO);
1125 		v4l2_disable_ioctl(vdev, VIDIOC_S_AUDIO);
1126 		v4l2_disable_ioctl(vdev, VIDIOC_ENUMAUDIO);
1127 	}
1128 	/* Setup correct crystal frequency on this board */
1129 	if (go->board_info->sensor_flags & GO7007_SENSOR_SAA7115)
1130 		v4l2_subdev_call(go->sd_video, video, s_crystal_freq,
1131 				SAA7115_FREQ_24_576_MHZ,
1132 				SAA7115_FREQ_FL_APLL | SAA7115_FREQ_FL_UCGC |
1133 				SAA7115_FREQ_FL_DOUBLE_ASCLK);
1134 	go7007_s_input(go);
1135 	if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
1136 		go7007_s_std(go);
1137 	rv = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1138 	if (rv < 0)
1139 		return rv;
1140 	dev_info(go->dev, "registered device %s [v4l2]\n",
1141 		 video_device_node_name(vdev));
1142 
1143 	return 0;
1144 }
1145 
1146 void go7007_v4l2_remove(struct go7007 *go)
1147 {
1148 	v4l2_ctrl_handler_free(&go->hdl);
1149 }
1150