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