?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf record: Add missing -C option support for specifying profile cpu
[linux-2.6/mini2440.git] / drivers / staging / go7007 / go7007-v4l2.c
blob06cacd37bbd801a014f35fb45614177441cafab8
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 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
16 */
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/version.h>
21 #include <linux/delay.h>
22 #include <linux/sched.h>
23 #include <linux/spinlock.h>
24 #include <linux/fs.h>
25 #include <linux/unistd.h>
26 #include <linux/time.h>
27 #include <linux/vmalloc.h>
28 #include <linux/pagemap.h>
29 #include <linux/videodev2.h>
30 #include <media/v4l2-common.h>
31 #include <media/v4l2-ioctl.h>
32 #include <linux/i2c.h>
33 #include <linux/semaphore.h>
34 #include <linux/uaccess.h>
35 #include <asm/system.h>
36
37 #include "go7007.h"
38 #include "go7007-priv.h"
39 #include "wis-i2c.h"
40
41 /* Temporary defines until accepted in v4l-dvb */
42 #ifndef V4L2_MPEG_STREAM_TYPE_MPEG_ELEM
43 #define V4L2_MPEG_STREAM_TYPE_MPEG_ELEM 6 /* MPEG elementary stream */
44 #endif
45 #ifndef V4L2_MPEG_VIDEO_ENCODING_MPEG_4
46 #define V4L2_MPEG_VIDEO_ENCODING_MPEG_4 3
47 #endif
48
49 static void deactivate_buffer(struct go7007_buffer *gobuf)
50 {
51 int i;
52
53 if (gobuf->state != BUF_STATE_IDLE) {
54 list_del(&gobuf->stream);
55 gobuf->state = BUF_STATE_IDLE;
56 }
57 if (gobuf->page_count > 0) {
58 for (i = 0; i < gobuf->page_count; ++i)
59 page_cache_release(gobuf->pages[i]);
60 gobuf->page_count = 0;
61 }
62 }
63
64 static void abort_queued(struct go7007 *go)
65 {
66 struct go7007_buffer *gobuf, *next;
67
68 list_for_each_entry_safe(gobuf, next, &go->stream, stream) {
69 deactivate_buffer(gobuf);
70 }
71 }
72
73 static int go7007_streamoff(struct go7007 *go)
74 {
75 int retval = -EINVAL;
76 unsigned long flags;
77
78 down(&go->hw_lock);
79 if (go->streaming) {
80 go->streaming = 0;
81 go7007_stream_stop(go);
82 spin_lock_irqsave(&go->spinlock, flags);
83 abort_queued(go);
84 spin_unlock_irqrestore(&go->spinlock, flags);
85 go7007_reset_encoder(go);
86 retval = 0;
87 }
88 up(&go->hw_lock);
89 return 0;
90 }
91
92 static int go7007_open(struct file *file)
93 {
94 struct go7007 *go = video_get_drvdata(video_devdata(file));
95 struct go7007_file *gofh;
96
97 if (go->status != STATUS_ONLINE)
98 return -EBUSY;
99 gofh = kmalloc(sizeof(struct go7007_file), GFP_KERNEL);
100 if (gofh == NULL)
101 return -ENOMEM;
102 ++go->ref_count;
103 gofh->go = go;
104 init_MUTEX(&gofh->lock);
105 gofh->buf_count = 0;
106 file->private_data = gofh;
107 return 0;
108 }
109
110 static int go7007_release(struct file *file)
111 {
112 struct go7007_file *gofh = file->private_data;
113 struct go7007 *go = gofh->go;
114
115 if (gofh->buf_count > 0) {
116 go7007_streamoff(go);
117 go->in_use = 0;
118 kfree(gofh->bufs);
119 gofh->buf_count = 0;
120 }
121 kfree(gofh);
122 if (--go->ref_count == 0)
123 kfree(go);
124 file->private_data = NULL;
125 return 0;
126 }
127
128 static u32 get_frame_type_flag(struct go7007_buffer *gobuf, int format)
129 {
130 u8 *f = page_address(gobuf->pages[0]);
131
132 switch (format) {
133 case GO7007_FORMAT_MJPEG:
134 return V4L2_BUF_FLAG_KEYFRAME;
135 case GO7007_FORMAT_MPEG4:
136 switch ((f[gobuf->frame_offset + 4] >> 6) & 0x3) {
137 case 0:
138 return V4L2_BUF_FLAG_KEYFRAME;
139 case 1:
140 return V4L2_BUF_FLAG_PFRAME;
141 case 2:
142 return V4L2_BUF_FLAG_BFRAME;
143 default:
144 return 0;
145 }
146 case GO7007_FORMAT_MPEG1:
147 case GO7007_FORMAT_MPEG2:
148 switch ((f[gobuf->frame_offset + 5] >> 3) & 0x7) {
149 case 1:
150 return V4L2_BUF_FLAG_KEYFRAME;
151 case 2:
152 return V4L2_BUF_FLAG_PFRAME;
153 case 3:
154 return V4L2_BUF_FLAG_BFRAME;
155 default:
156 return 0;
157 }
158 }
159
160 return 0;
161 }
162
163 static int set_capture_size(struct go7007 *go, struct v4l2_format *fmt, int try)
164 {
165 int sensor_height = 0, sensor_width = 0;
166 int width, height, i;
167
168 if (fmt != NULL && fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG &&
169 fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MPEG &&
170 fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MPEG4)
171 return -EINVAL;
172
173 switch (go->standard) {
174 case GO7007_STD_NTSC:
175 sensor_width = 720;
176 sensor_height = 480;
177 break;
178 case GO7007_STD_PAL:
179 sensor_width = 720;
180 sensor_height = 576;
181 break;
182 case GO7007_STD_OTHER:
183 sensor_width = go->board_info->sensor_width;
184 sensor_height = go->board_info->sensor_height;
185 break;
186 }
187
188 if (fmt == NULL) {
189 width = sensor_width;
190 height = sensor_height;
191 } else if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
192 if (fmt->fmt.pix.width > sensor_width)
193 width = sensor_width;
194 else if (fmt->fmt.pix.width < 144)
195 width = 144;
196 else
197 width = fmt->fmt.pix.width & ~0x0f;
198
199 if (fmt->fmt.pix.height > sensor_height)
200 height = sensor_height;
201 else if (fmt->fmt.pix.height < 96)
202 height = 96;
203 else
204 height = fmt->fmt.pix.height & ~0x0f;
205 } else {
206 int requested_size = fmt->fmt.pix.width * fmt->fmt.pix.height;
207 int sensor_size = sensor_width * sensor_height;
208
209 if (64 * requested_size < 9 * sensor_size) {
210 width = sensor_width / 4;
211 height = sensor_height / 4;
212 } else if (64 * requested_size < 36 * sensor_size) {
213 width = sensor_width / 2;
214 height = sensor_height / 2;
215 } else {
216 width = sensor_width;
217 height = sensor_height;
218 }
219 width &= ~0xf;
220 height &= ~0xf;
221 }
222
223 if (fmt != NULL) {
224 u32 pixelformat = fmt->fmt.pix.pixelformat;
225
226 memset(fmt, 0, sizeof(*fmt));
227 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
228 fmt->fmt.pix.width = width;
229 fmt->fmt.pix.height = height;
230 fmt->fmt.pix.pixelformat = pixelformat;
231 fmt->fmt.pix.field = V4L2_FIELD_NONE;
232 fmt->fmt.pix.bytesperline = 0;
233 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
234 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; /* ?? */
235 }
236
237 if (try)
238 return 0;
239
240 go->width = width;
241 go->height = height;
242 go->encoder_h_offset = go->board_info->sensor_h_offset;
243 go->encoder_v_offset = go->board_info->sensor_v_offset;
244 for (i = 0; i < 4; ++i)
245 go->modet[i].enable = 0;
246 for (i = 0; i < 1624; ++i)
247 go->modet_map[i] = 0;
248
249 if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
250 struct video_decoder_resolution res;
251
252 res.width = width;
253 if (height > sensor_height / 2) {
254 res.height = height / 2;
255 go->encoder_v_halve = 0;
256 } else {
257 res.height = height;
258 go->encoder_v_halve = 1;
259 }
260 if (go->i2c_adapter_online)
261 i2c_clients_command(&go->i2c_adapter,
262 DECODER_SET_RESOLUTION, &res);
263 } else {
264 if (width <= sensor_width / 4) {
265 go->encoder_h_halve = 1;
266 go->encoder_v_halve = 1;
267 go->encoder_subsample = 1;
268 } else if (width <= sensor_width / 2) {
269 go->encoder_h_halve = 1;
270 go->encoder_v_halve = 1;
271 go->encoder_subsample = 0;
272 } else {
273 go->encoder_h_halve = 0;
274 go->encoder_v_halve = 0;
275 go->encoder_subsample = 0;
276 }
277 }
278
279 if (fmt == NULL)
280 return 0;
281
282 switch (fmt->fmt.pix.pixelformat) {
283 case V4L2_PIX_FMT_MPEG:
284 if (go->format == GO7007_FORMAT_MPEG1 ||
285 go->format == GO7007_FORMAT_MPEG2 ||
286 go->format == GO7007_FORMAT_MPEG4)
287 break;
288 go->format = GO7007_FORMAT_MPEG1;
289 go->pali = 0;
290 go->aspect_ratio = GO7007_RATIO_1_1;
291 go->gop_size = go->sensor_framerate / 1000;
292 go->ipb = 0;
293 go->closed_gop = 1;
294 go->repeat_seqhead = 1;
295 go->seq_header_enable = 1;
296 go->gop_header_enable = 1;
297 go->dvd_mode = 0;
298 break;
299 /* Backwards compatibility only! */
300 case V4L2_PIX_FMT_MPEG4:
301 if (go->format == GO7007_FORMAT_MPEG4)
302 break;
303 go->format = GO7007_FORMAT_MPEG4;
304 go->pali = 0xf5;
305 go->aspect_ratio = GO7007_RATIO_1_1;
306 go->gop_size = go->sensor_framerate / 1000;
307 go->ipb = 0;
308 go->closed_gop = 1;
309 go->repeat_seqhead = 1;
310 go->seq_header_enable = 1;
311 go->gop_header_enable = 1;
312 go->dvd_mode = 0;
313 break;
314 case V4L2_PIX_FMT_MJPEG:
315 go->format = GO7007_FORMAT_MJPEG;
316 go->pali = 0;
317 go->aspect_ratio = GO7007_RATIO_1_1;
318 go->gop_size = 0;
319 go->ipb = 0;
320 go->closed_gop = 0;
321 go->repeat_seqhead = 0;
322 go->seq_header_enable = 0;
323 go->gop_header_enable = 0;
324 go->dvd_mode = 0;
325 break;
326 }
327 return 0;
328 }
329
330 #if 0
331 static int clip_to_modet_map(struct go7007 *go, int region,
332 struct v4l2_clip *clip_list)
333 {
334 struct v4l2_clip clip, *clip_ptr;
335 int x, y, mbnum;
336
337 /* Check if coordinates are OK and if any macroblocks are already
338 * used by other regions (besides 0) */
339 clip_ptr = clip_list;
340 while (clip_ptr) {
341 if (copy_from_user(&clip, clip_ptr, sizeof(clip)))
342 return -EFAULT;
343 if (clip.c.left < 0 || (clip.c.left & 0xF) ||
344 clip.c.width <= 0 || (clip.c.width & 0xF))
345 return -EINVAL;
346 if (clip.c.left + clip.c.width > go->width)
347 return -EINVAL;
348 if (clip.c.top < 0 || (clip.c.top & 0xF) ||
349 clip.c.height <= 0 || (clip.c.height & 0xF))
350 return -EINVAL;
351 if (clip.c.top + clip.c.height > go->height)
352 return -EINVAL;
353 for (y = 0; y < clip.c.height; y += 16)
354 for (x = 0; x < clip.c.width; x += 16) {
355 mbnum = (go->width >> 4) *
356 ((clip.c.top + y) >> 4) +
357 ((clip.c.left + x) >> 4);
358 if (go->modet_map[mbnum] != 0 &&
359 go->modet_map[mbnum] != region)
360 return -EBUSY;
361 }
362 clip_ptr = clip.next;
363 }
364
365 /* Clear old region macroblocks */
366 for (mbnum = 0; mbnum < 1624; ++mbnum)
367 if (go->modet_map[mbnum] == region)
368 go->modet_map[mbnum] = 0;
369
370 /* Claim macroblocks in this list */
371 clip_ptr = clip_list;
372 while (clip_ptr) {
373 if (copy_from_user(&clip, clip_ptr, sizeof(clip)))
374 return -EFAULT;
375 for (y = 0; y < clip.c.height; y += 16)
376 for (x = 0; x < clip.c.width; x += 16) {
377 mbnum = (go->width >> 4) *
378 ((clip.c.top + y) >> 4) +
379 ((clip.c.left + x) >> 4);
380 go->modet_map[mbnum] = region;
381 }
382 clip_ptr = clip.next;
383 }
384 return 0;
385 }
386
387 static int mpeg_queryctrl(u32 id, struct v4l2_queryctrl *ctrl)
388 {
389 static const u32 user_ctrls[] = {
390 V4L2_CID_USER_CLASS,
391 0
392 };
393 static const u32 mpeg_ctrls[] = {
394 V4L2_CID_MPEG_CLASS,
395 V4L2_CID_MPEG_STREAM_TYPE,
396 V4L2_CID_MPEG_VIDEO_ENCODING,
397 V4L2_CID_MPEG_VIDEO_ASPECT,
398 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
399 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
400 V4L2_CID_MPEG_VIDEO_BITRATE,
401 0
402 };
403 static const u32 *ctrl_classes[] = {
404 user_ctrls,
405 mpeg_ctrls,
406 NULL
407 };
408
409 /* The ctrl may already contain the queried i2c controls,
410 * query the mpeg controls if the existing ctrl id is
411 * greater than the next mpeg ctrl id.
412 */
413 id = v4l2_ctrl_next(ctrl_classes, id);
414 if (id >= ctrl->id && ctrl->name[0])
415 return 0;
416
417 memset(ctrl, 0, sizeof(*ctrl));
418 ctrl->id = id;
419
420 switch (ctrl->id) {
421 case V4L2_CID_USER_CLASS:
422 case V4L2_CID_MPEG_CLASS:
423 return v4l2_ctrl_query_fill_std(ctrl);
424 case V4L2_CID_MPEG_STREAM_TYPE:
425 return v4l2_ctrl_query_fill(ctrl,
426 V4L2_MPEG_STREAM_TYPE_MPEG2_DVD,
427 V4L2_MPEG_STREAM_TYPE_MPEG_ELEM, 1,
428 V4L2_MPEG_STREAM_TYPE_MPEG_ELEM);
429 case V4L2_CID_MPEG_VIDEO_ENCODING:
430 return v4l2_ctrl_query_fill(ctrl,
431 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
432 V4L2_MPEG_VIDEO_ENCODING_MPEG_4, 1,
433 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
434 case V4L2_CID_MPEG_VIDEO_ASPECT:
435 return v4l2_ctrl_query_fill(ctrl,
436 V4L2_MPEG_VIDEO_ASPECT_1x1,
437 V4L2_MPEG_VIDEO_ASPECT_16x9, 1,
438 V4L2_MPEG_VIDEO_ASPECT_1x1);
439 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
440 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
441 return v4l2_ctrl_query_fill_std(ctrl);
442 case V4L2_CID_MPEG_VIDEO_BITRATE:
443 return v4l2_ctrl_query_fill(ctrl,
444 64000,
445 10000000, 1,
446 9800000);
447 default:
448 break;
449 }
450 return -EINVAL;
451 }
452
453 static int mpeg_s_control(struct v4l2_control *ctrl, struct go7007 *go)
454 {
455 /* pretty sure we can't change any of these while streaming */
456 if (go->streaming)
457 return -EBUSY;
458
459 switch (ctrl->id) {
460 case V4L2_CID_MPEG_STREAM_TYPE:
461 switch (ctrl->value) {
462 case V4L2_MPEG_STREAM_TYPE_MPEG2_DVD:
463 go->format = GO7007_FORMAT_MPEG2;
464 go->bitrate = 9800000;
465 go->gop_size = 15;
466 go->pali = 0x48;
467 go->closed_gop = 1;
468 go->repeat_seqhead = 0;
469 go->seq_header_enable = 1;
470 go->gop_header_enable = 1;
471 go->dvd_mode = 1;
472 break;
473 case V4L2_MPEG_STREAM_TYPE_MPEG_ELEM:
474 /* todo: */
475 break;
476 default:
477 return -EINVAL;
478 }
479 break;
480 case V4L2_CID_MPEG_VIDEO_ENCODING:
481 switch (ctrl->value) {
482 case V4L2_MPEG_VIDEO_ENCODING_MPEG_1:
483 go->format = GO7007_FORMAT_MPEG1;
484 go->pali = 0;
485 break;
486 case V4L2_MPEG_VIDEO_ENCODING_MPEG_2:
487 go->format = GO7007_FORMAT_MPEG2;
488 /*if (mpeg->pali >> 24 == 2)
489 go->pali = mpeg->pali & 0xff;
490 else*/
491 go->pali = 0x48;
492 break;
493 case V4L2_MPEG_VIDEO_ENCODING_MPEG_4:
494 go->format = GO7007_FORMAT_MPEG4;
495 /*if (mpeg->pali >> 24 == 4)
496 go->pali = mpeg->pali & 0xff;
497 else*/
498 go->pali = 0xf5;
499 break;
500 default:
501 return -EINVAL;
502 }
503 go->gop_header_enable =
504 /*mpeg->flags & GO7007_MPEG_OMIT_GOP_HEADER
505 ? 0 :*/ 1;
506 /*if (mpeg->flags & GO7007_MPEG_REPEAT_SEQHEADER)
507 go->repeat_seqhead = 1;
508 else*/
509 go->repeat_seqhead = 0;
510 go->dvd_mode = 0;
511 break;
512 case V4L2_CID_MPEG_VIDEO_ASPECT:
513 if (go->format == GO7007_FORMAT_MJPEG)
514 return -EINVAL;
515 switch (ctrl->value) {
516 case V4L2_MPEG_VIDEO_ASPECT_1x1:
517 go->aspect_ratio = GO7007_RATIO_1_1;
518 break;
519 case V4L2_MPEG_VIDEO_ASPECT_4x3:
520 go->aspect_ratio = GO7007_RATIO_4_3;
521 break;
522 case V4L2_MPEG_VIDEO_ASPECT_16x9:
523 go->aspect_ratio = GO7007_RATIO_16_9;
524 break;
525 case V4L2_MPEG_VIDEO_ASPECT_221x100:
526 default:
527 return -EINVAL;
528 }
529 break;
530 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
531 go->gop_size = ctrl->value;
532 break;
533 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
534 if (ctrl->value != 0 && ctrl->value != 1)
535 return -EINVAL;
536 go->closed_gop = ctrl->value;
537 break;
538 case V4L2_CID_MPEG_VIDEO_BITRATE:
539 /* Upper bound is kind of arbitrary here */
540 if (ctrl->value < 64000 || ctrl->value > 10000000)
541 return -EINVAL;
542 go->bitrate = ctrl->value;
543 break;
544 default:
545 return -EINVAL;
546 }
547 return 0;
548 }
549
550 static int mpeg_g_control(struct v4l2_control *ctrl, struct go7007 *go)
551 {
552 switch (ctrl->id) {
553 case V4L2_CID_MPEG_STREAM_TYPE:
554 if (go->dvd_mode)
555 ctrl->value = V4L2_MPEG_STREAM_TYPE_MPEG2_DVD;
556 else
557 ctrl->value = V4L2_MPEG_STREAM_TYPE_MPEG_ELEM;
558 break;
559 case V4L2_CID_MPEG_VIDEO_ENCODING:
560 switch (go->format) {
561 case GO7007_FORMAT_MPEG1:
562 ctrl->value = V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
563 break;
564 case GO7007_FORMAT_MPEG2:
565 ctrl->value = V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
566 break;
567 case GO7007_FORMAT_MPEG4:
568 ctrl->value = V4L2_MPEG_VIDEO_ENCODING_MPEG_4;
569 break;
570 default:
571 return -EINVAL;
572 }
573 break;
574 case V4L2_CID_MPEG_VIDEO_ASPECT:
575 switch (go->aspect_ratio) {
576 case GO7007_RATIO_1_1:
577 ctrl->value = V4L2_MPEG_VIDEO_ASPECT_1x1;
578 break;
579 case GO7007_RATIO_4_3:
580 ctrl->value = V4L2_MPEG_VIDEO_ASPECT_4x3;
581 break;
582 case GO7007_RATIO_16_9:
583 ctrl->value = V4L2_MPEG_VIDEO_ASPECT_16x9;
584 break;
585 default:
586 return -EINVAL;
587 }
588 break;
589 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
590 ctrl->value = go->gop_size;
591 break;
592 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
593 ctrl->value = go->closed_gop;
594 break;
595 case V4L2_CID_MPEG_VIDEO_BITRATE:
596 ctrl->value = go->bitrate;
597 break;
598 default:
599 return -EINVAL;
600 }
601 return 0;
602 }
603 #endif
604
605 static int vidioc_querycap(struct file *file, void *priv,
606 struct v4l2_capability *cap)
607 {
608 struct go7007_file *gofh = priv;
609 struct go7007 *go = gofh->go;
610
611 strlcpy(cap->driver, "go7007", sizeof(cap->driver));
612 strlcpy(cap->card, go->name, sizeof(cap->card));
613 #if 0
614 strlcpy(cap->bus_info, dev_name(&dev->udev->dev), sizeof(cap->bus_info));
615 #endif
616
617 cap->version = KERNEL_VERSION(0, 9, 8);
618
619 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
620 V4L2_CAP_STREAMING; /* | V4L2_CAP_AUDIO; */
621
622 if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
623 cap->capabilities |= V4L2_CAP_TUNER;
624
625 return 0;
626 }
627
628 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
629 struct v4l2_fmtdesc *fmt)
630 {
631 char *desc = NULL;
632
633 switch (fmt->index) {
634 case 0:
635 fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
636 desc = "Motion-JPEG";
637 break;
638 case 1:
639 fmt->pixelformat = V4L2_PIX_FMT_MPEG;
640 desc = "MPEG1/MPEG2/MPEG4";
641 break;
642 default:
643 return -EINVAL;
644 }
645 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
646 fmt->flags = V4L2_FMT_FLAG_COMPRESSED;
647
648 strncpy(fmt->description, desc, sizeof(fmt->description));
649
650 return 0;
651 }
652
653 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
654 struct v4l2_format *fmt)
655 {
656 struct go7007_file *gofh = priv;
657 struct go7007 *go = gofh->go;
658
659 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
660 fmt->fmt.pix.width = go->width;
661 fmt->fmt.pix.height = go->height;
662 fmt->fmt.pix.pixelformat = (go->format == GO7007_FORMAT_MJPEG) ?
663 V4L2_PIX_FMT_MJPEG : V4L2_PIX_FMT_MPEG;
664 fmt->fmt.pix.field = V4L2_FIELD_NONE;
665 fmt->fmt.pix.bytesperline = 0;
666 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
667 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
668
669 return 0;
670 }
671
672 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
673 struct v4l2_format *fmt)
674 {
675 struct go7007_file *gofh = priv;
676 struct go7007 *go = gofh->go;
677
678 return set_capture_size(go, fmt, 1);
679 }
680
681 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
682 struct v4l2_format *fmt)
683 {
684 struct go7007_file *gofh = priv;
685 struct go7007 *go = gofh->go;
686
687 if (go->streaming)
688 return -EBUSY;
689
690 return set_capture_size(go, fmt, 0);
691 }
692
693 static int vidioc_reqbufs(struct file *file, void *priv,
694 struct v4l2_requestbuffers *req)
695 {
696 struct go7007_file *gofh = priv;
697 struct go7007 *go = gofh->go;
698 int retval = -EBUSY;
699 unsigned int count, i;
700
701 if (go->streaming)
702 return retval;
703
704 if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
705 req->memory != V4L2_MEMORY_MMAP)
706 return -EINVAL;
707
708 down(&gofh->lock);
709 for (i = 0; i < gofh->buf_count; ++i)
710 if (gofh->bufs[i].mapped > 0)
711 goto unlock_and_return;
712
713 down(&go->hw_lock);
714 if (go->in_use > 0 && gofh->buf_count == 0) {
715 up(&go->hw_lock);
716 goto unlock_and_return;
717 }
718
719 if (gofh->buf_count > 0)
720 kfree(gofh->bufs);
721
722 retval = -ENOMEM;
723 count = req->count;
724 if (count > 0) {
725 if (count < 2)
726 count = 2;
727 if (count > 32)
728 count = 32;
729
730 gofh->bufs = kmalloc(count * sizeof(struct go7007_buffer),
731 GFP_KERNEL);
732
733 if (!gofh->bufs) {
734 up(&go->hw_lock);
735 goto unlock_and_return;
736 }
737
738 memset(gofh->bufs, 0, count * sizeof(struct go7007_buffer));
739
740 for (i = 0; i < count; ++i) {
741 gofh->bufs[i].go = go;
742 gofh->bufs[i].index = i;
743 gofh->bufs[i].state = BUF_STATE_IDLE;
744 gofh->bufs[i].mapped = 0;
745 }
746
747 go->in_use = 1;
748 } else {
749 go->in_use = 0;
750 }
751
752 gofh->buf_count = count;
753 up(&go->hw_lock);
754 up(&gofh->lock);
755
756 memset(req, 0, sizeof(*req));
757
758 req->count = count;
759 req->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
760 req->memory = V4L2_MEMORY_MMAP;
761
762 return 0;
763
764 unlock_and_return:
765 up(&gofh->lock);
766 return retval;
767 }
768
769 static int vidioc_querybuf(struct file *file, void *priv,
770 struct v4l2_buffer *buf)
771 {
772 struct go7007_file *gofh = priv;
773 int retval = -EINVAL;
774 unsigned int index;
775
776 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
777 return retval;
778
779 index = buf->index;
780
781 down(&gofh->lock);
782 if (index >= gofh->buf_count)
783 goto unlock_and_return;
784
785 memset(buf, 0, sizeof(*buf));
786 buf->index = index;
787 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
788
789 switch (gofh->bufs[index].state) {
790 case BUF_STATE_QUEUED:
791 buf->flags = V4L2_BUF_FLAG_QUEUED;
792 break;
793 case BUF_STATE_DONE:
794 buf->flags = V4L2_BUF_FLAG_DONE;
795 break;
796 default:
797 buf->flags = 0;
798 }
799
800 if (gofh->bufs[index].mapped)
801 buf->flags |= V4L2_BUF_FLAG_MAPPED;
802 buf->memory = V4L2_MEMORY_MMAP;
803 buf->m.offset = index * GO7007_BUF_SIZE;
804 buf->length = GO7007_BUF_SIZE;
805 up(&gofh->lock);
806
807 return 0;
808
809 unlock_and_return:
810 up(&gofh->lock);
811 return retval;
812 }
813
814 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
815 {
816 struct go7007_file *gofh = priv;
817 struct go7007 *go = gofh->go;
818 struct go7007_buffer *gobuf;
819 unsigned long flags;
820 int retval = -EINVAL;
821 int ret;
822
823 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
824 buf->memory != V4L2_MEMORY_MMAP)
825 return retval;
826
827 down(&gofh->lock);
828 if (buf->index < 0 || buf->index >= gofh->buf_count)
829 goto unlock_and_return;
830
831 gobuf = &gofh->bufs[buf->index];
832 if (!gobuf->mapped)
833 goto unlock_and_return;
834
835 retval = -EBUSY;
836 if (gobuf->state != BUF_STATE_IDLE)
837 goto unlock_and_return;
838
839 /* offset will be 0 until we really support USERPTR streaming */
840 gobuf->offset = gobuf->user_addr & ~PAGE_MASK;
841 gobuf->bytesused = 0;
842 gobuf->frame_offset = 0;
843 gobuf->modet_active = 0;
844 if (gobuf->offset > 0)
845 gobuf->page_count = GO7007_BUF_PAGES + 1;
846 else
847 gobuf->page_count = GO7007_BUF_PAGES;
848
849 retval = -ENOMEM;
850 down_read(&current->mm->mmap_sem);
851 ret = get_user_pages(current, current->mm,
852 gobuf->user_addr & PAGE_MASK, gobuf->page_count,
853 1, 1, gobuf->pages, NULL);
854 up_read(&current->mm->mmap_sem);
855
856 if (ret != gobuf->page_count) {
857 int i;
858 for (i = 0; i < ret; ++i)
859 page_cache_release(gobuf->pages[i]);
860 gobuf->page_count = 0;
861 goto unlock_and_return;
862 }
863
864 gobuf->state = BUF_STATE_QUEUED;
865 spin_lock_irqsave(&go->spinlock, flags);
866 list_add_tail(&gobuf->stream, &go->stream);
867 spin_unlock_irqrestore(&go->spinlock, flags);
868 up(&gofh->lock);
869
870 return 0;
871
872 unlock_and_return:
873 up(&gofh->lock);
874 return retval;
875 }
876
877
878 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
879 {
880 struct go7007_file *gofh = priv;
881 struct go7007 *go = gofh->go;
882 struct go7007_buffer *gobuf;
883 int retval = -EINVAL;
884 unsigned long flags;
885 u32 frame_type_flag;
886 DEFINE_WAIT(wait);
887
888 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
889 return retval;
890 if (buf->memory != V4L2_MEMORY_MMAP)
891 return retval;
892
893 down(&gofh->lock);
894 if (list_empty(&go->stream))
895 goto unlock_and_return;
896 gobuf = list_entry(go->stream.next,
897 struct go7007_buffer, stream);
898
899 retval = -EAGAIN;
900 if (gobuf->state != BUF_STATE_DONE &&
901 !(file->f_flags & O_NONBLOCK)) {
902 for (;;) {
903 prepare_to_wait(&go->frame_waitq, &wait,
904 TASK_INTERRUPTIBLE);
905 if (gobuf->state == BUF_STATE_DONE)
906 break;
907 if (signal_pending(current)) {
908 retval = -ERESTARTSYS;
909 break;
910 }
911 schedule();
912 }
913 finish_wait(&go->frame_waitq, &wait);
914 }
915 if (gobuf->state != BUF_STATE_DONE)
916 goto unlock_and_return;
917
918 spin_lock_irqsave(&go->spinlock, flags);
919 deactivate_buffer(gobuf);
920 spin_unlock_irqrestore(&go->spinlock, flags);
921 frame_type_flag = get_frame_type_flag(gobuf, go->format);
922 gobuf->state = BUF_STATE_IDLE;
923
924 memset(buf, 0, sizeof(*buf));
925 buf->index = gobuf->index;
926 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
927 buf->bytesused = gobuf->bytesused;
928 buf->flags = V4L2_BUF_FLAG_MAPPED | frame_type_flag;
929 buf->field = V4L2_FIELD_NONE;
930 buf->timestamp = gobuf->timestamp;
931 buf->sequence = gobuf->seq;
932 buf->memory = V4L2_MEMORY_MMAP;
933 buf->m.offset = gobuf->index * GO7007_BUF_SIZE;
934 buf->length = GO7007_BUF_SIZE;
935 buf->reserved = gobuf->modet_active;
936
937 up(&gofh->lock);
938 return 0;
939
940 unlock_and_return:
941 up(&gofh->lock);
942 return retval;
943 }
944
945 static int vidioc_streamon(struct file *file, void *priv,
946 enum v4l2_buf_type type)
947 {
948 struct go7007_file *gofh = priv;
949 struct go7007 *go = gofh->go;
950 int retval = 0;
951
952 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
953 return -EINVAL;
954
955 down(&gofh->lock);
956 down(&go->hw_lock);
957
958 if (!go->streaming) {
959 go->streaming = 1;
960 go->next_seq = 0;
961 go->active_buf = NULL;
962 if (go7007_start_encoder(go) < 0)
963 retval = -EIO;
964 else
965 retval = 0;
966 }
967 up(&go->hw_lock);
968 up(&gofh->lock);
969
970 return retval;
971 }
972
973 static int vidioc_streamoff(struct file *file, void *priv,
974 enum v4l2_buf_type type)
975 {
976 struct go7007_file *gofh = priv;
977 struct go7007 *go = gofh->go;
978
979 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
980 return -EINVAL;
981 down(&gofh->lock);
982 go7007_streamoff(go);
983 up(&gofh->lock);
984
985 return 0;
986 }
987
988 static int vidioc_queryctrl(struct file *file, void *priv,
989 struct v4l2_queryctrl *query)
990 {
991 struct go7007_file *gofh = priv;
992 struct go7007 *go = gofh->go;
993
994 if (!go->i2c_adapter_online)
995 return -EIO;
996
997 i2c_clients_command(&go->i2c_adapter, VIDIOC_QUERYCTRL, query);
998
999 return (!query->name[0]) ? -EINVAL : 0;
1000 }
1001
1002 static int vidioc_g_ctrl(struct file *file, void *priv,
1003 struct v4l2_control *ctrl)
1004 {
1005 struct go7007_file *gofh = priv;
1006 struct go7007 *go = gofh->go;
1007 struct v4l2_queryctrl query;
1008
1009 if (!go->i2c_adapter_online)
1010 return -EIO;
1011
1012 memset(&query, 0, sizeof(query));
1013 query.id = ctrl->id;
1014 i2c_clients_command(&go->i2c_adapter, VIDIOC_QUERYCTRL, &query);
1015 if (query.name[0] == 0)
1016 return -EINVAL;
1017 i2c_clients_command(&go->i2c_adapter, VIDIOC_G_CTRL, ctrl);
1018
1019 return 0;
1020 }
1021
1022 static int vidioc_s_ctrl(struct file *file, void *priv,
1023 struct v4l2_control *ctrl)
1024 {
1025 struct go7007_file *gofh = priv;
1026 struct go7007 *go = gofh->go;
1027 struct v4l2_queryctrl query;
1028
1029 if (!go->i2c_adapter_online)
1030 return -EIO;
1031
1032 memset(&query, 0, sizeof(query));
1033 query.id = ctrl->id;
1034 i2c_clients_command(&go->i2c_adapter, VIDIOC_QUERYCTRL, &query);
1035 if (query.name[0] == 0)
1036 return -EINVAL;
1037 i2c_clients_command(&go->i2c_adapter, VIDIOC_S_CTRL, ctrl);
1038
1039 return 0;
1040 }
1041
1042 static int vidioc_g_parm(struct file *filp, void *priv,
1043 struct v4l2_streamparm *parm)
1044 {
1045 struct go7007_file *gofh = priv;
1046 struct go7007 *go = gofh->go;
1047 struct v4l2_fract timeperframe = {
1048 .numerator = 1001 * go->fps_scale,
1049 .denominator = go->sensor_framerate,
1050 };
1051
1052 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1053 return -EINVAL;
1054
1055 parm->parm.capture.capability |= V4L2_CAP_TIMEPERFRAME;
1056 parm->parm.capture.timeperframe = timeperframe;
1057
1058 return 0;
1059 }
1060
1061 static int vidioc_s_parm(struct file *filp, void *priv,
1062 struct v4l2_streamparm *parm)
1063 {
1064 struct go7007_file *gofh = priv;
1065 struct go7007 *go = gofh->go;
1066 unsigned int n, d;
1067
1068 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1069 return -EINVAL;
1070 if (parm->parm.capture.capturemode != 0)
1071 return -EINVAL;
1072
1073 n = go->sensor_framerate *
1074 parm->parm.capture.timeperframe.numerator;
1075 d = 1001 * parm->parm.capture.timeperframe.denominator;
1076 if (n != 0 && d != 0 && n > d)
1077 go->fps_scale = (n + d/2) / d;
1078 else
1079 go->fps_scale = 1;
1080
1081 return 0;
1082 }
1083
1084 /* VIDIOC_ENUMSTD on go7007 were used for enumberating the supported fps and
1085 its resolution, when the device is not connected to TV.
1086 This were an API abuse, probably used by the lack of specific IOCTL's to
1087 enumberate it, by the time the driver were written.
1088
1089 However, since kernel 2.6.19, two new ioctls (VIDIOC_ENUM_FRAMEINTERVALS
1090 and VIDIOC_ENUM_FRAMESIZES) were added for this purpose.
1091
1092 The two functions bellow implements the newer ioctls
1093 */
1094 static int vidioc_enum_framesizes(struct file *filp, void *priv,
1095 struct v4l2_frmsizeenum *fsize)
1096 {
1097 struct go7007_file *gofh = priv;
1098 struct go7007 *go = gofh->go;
1099
1100 /* Return -EINVAL, if it is a TV board */
1101 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) ||
1102 (go->board_info->sensor_flags & GO7007_SENSOR_TV))
1103 return -EINVAL;
1104
1105 if (fsize->index > 0)
1106 return -EINVAL;
1107
1108 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1109 fsize->discrete.width = go->board_info->sensor_width;
1110 fsize->discrete.height = go->board_info->sensor_height;
1111
1112 return 0;
1113 }
1114
1115 static int vidioc_enum_frameintervals(struct file *filp, void *priv,
1116 struct v4l2_frmivalenum *fival)
1117 {
1118 struct go7007_file *gofh = priv;
1119 struct go7007 *go = gofh->go;
1120
1121 /* Return -EINVAL, if it is a TV board */
1122 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) ||
1123 (go->board_info->sensor_flags & GO7007_SENSOR_TV))
1124 return -EINVAL;
1125
1126 if (fival->index > 0)
1127 return -EINVAL;
1128
1129 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1130 fival->discrete.numerator = 1001;
1131 fival->discrete.denominator = go->board_info->sensor_framerate;
1132
1133 return 0;
1134 }
1135
1136 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *std)
1137 {
1138 struct go7007_file *gofh = priv;
1139 struct go7007 *go = gofh->go;
1140
1141 if (go->streaming)
1142 return -EBUSY;
1143
1144 if (!(go->board_info->sensor_flags & GO7007_SENSOR_TV) &&
1145 *std != 0)
1146 return -EINVAL;
1147
1148 if (*std == 0)
1149 return -EINVAL;
1150
1151 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
1152 go->input == go->board_info->num_inputs - 1) {
1153 if (!go->i2c_adapter_online)
1154 return -EIO;
1155 i2c_clients_command(&go->i2c_adapter,
1156 VIDIOC_S_STD, std);
1157 if (!*std) /* hack to indicate EINVAL from tuner */
1158 return -EINVAL;
1159 }
1160
1161 if (*std & V4L2_STD_NTSC) {
1162 go->standard = GO7007_STD_NTSC;
1163 go->sensor_framerate = 30000;
1164 } else if (*std & V4L2_STD_PAL) {
1165 go->standard = GO7007_STD_PAL;
1166 go->sensor_framerate = 25025;
1167 } else if (*std & V4L2_STD_SECAM) {
1168 go->standard = GO7007_STD_PAL;
1169 go->sensor_framerate = 25025;
1170 } else
1171 return -EINVAL;
1172
1173 if (go->i2c_adapter_online)
1174 i2c_clients_command(&go->i2c_adapter,
1175 VIDIOC_S_STD, std);
1176 set_capture_size(go, NULL, 0);
1177
1178 return 0;
1179 }
1180
1181 #if 0
1182 case VIDIOC_QUERYSTD:
1183 {
1184 v4l2_std_id *std = arg;
1185
1186 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
1187 go->input == go->board_info->num_inputs - 1) {
1188 if (!go->i2c_adapter_online)
1189 return -EIO;
1190 i2c_clients_command(&go->i2c_adapter,
1191 VIDIOC_QUERYSTD, arg);
1192 } else if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
1193 *std = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM;
1194 else
1195 *std = 0;
1196 return 0;
1197 }
1198 #endif
1199
1200 static int vidioc_enum_input(struct file *file, void *priv,
1201 struct v4l2_input *inp)
1202 {
1203 struct go7007_file *gofh = priv;
1204 struct go7007 *go = gofh->go;
1205
1206 if (inp->index >= go->board_info->num_inputs)
1207 return -EINVAL;
1208
1209 strncpy(inp->name, go->board_info->inputs[inp->index].name,
1210 sizeof(inp->name));
1211
1212 /* If this board has a tuner, it will be the last input */
1213 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
1214 inp->index == go->board_info->num_inputs - 1)
1215 inp->type = V4L2_INPUT_TYPE_TUNER;
1216 else
1217 inp->type = V4L2_INPUT_TYPE_CAMERA;
1218
1219 inp->audioset = 0;
1220 inp->tuner = 0;
1221 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
1222 inp->std = V4L2_STD_NTSC | V4L2_STD_PAL |
1223 V4L2_STD_SECAM;
1224 else
1225 inp->std = 0;
1226
1227 return 0;
1228 }
1229
1230
1231 static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
1232 {
1233 struct go7007_file *gofh = priv;
1234 struct go7007 *go = gofh->go;
1235
1236 *input = go->input;
1237
1238 return 0;
1239 }
1240
1241 static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
1242 {
1243 struct go7007_file *gofh = priv;
1244 struct go7007 *go = gofh->go;
1245
1246 if (input >= go->board_info->num_inputs)
1247 return -EINVAL;
1248 if (go->streaming)
1249 return -EBUSY;
1250
1251 go->input = input;
1252 if (go->i2c_adapter_online) {
1253 i2c_clients_command(&go->i2c_adapter, VIDIOC_S_INPUT,
1254 &go->board_info->inputs[input].video_input);
1255 i2c_clients_command(&go->i2c_adapter, VIDIOC_S_AUDIO,
1256 &go->board_info->inputs[input].audio_input);
1257 }
1258
1259 return 0;
1260 }
1261
1262 static int vidioc_g_tuner(struct file *file, void *priv,
1263 struct v4l2_tuner *t)
1264 {
1265 struct go7007_file *gofh = priv;
1266 struct go7007 *go = gofh->go;
1267
1268 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER))
1269 return -EINVAL;
1270 if (t->index != 0)
1271 return -EINVAL;
1272 if (!go->i2c_adapter_online)
1273 return -EIO;
1274
1275 i2c_clients_command(&go->i2c_adapter, VIDIOC_G_TUNER, t);
1276
1277 t->index = 0;
1278 return 0;
1279 }
1280
1281 static int vidioc_s_tuner(struct file *file, void *priv,
1282 struct v4l2_tuner *t)
1283 {
1284 struct go7007_file *gofh = priv;
1285 struct go7007 *go = gofh->go;
1286
1287 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER))
1288 return -EINVAL;
1289 if (t->index != 0)
1290 return -EINVAL;
1291 if (!go->i2c_adapter_online)
1292 return -EIO;
1293
1294 switch (go->board_id) {
1295 case GO7007_BOARDID_PX_TV402U_NA:
1296 case GO7007_BOARDID_PX_TV402U_JP:
1297 /* No selectable options currently */
1298 if (t->audmode != V4L2_TUNER_MODE_STEREO)
1299 return -EINVAL;
1300 break;
1301 }
1302
1303 i2c_clients_command(&go->i2c_adapter, VIDIOC_S_TUNER, t);
1304
1305 return 0;
1306 }
1307
1308 static int vidioc_g_frequency(struct file *file, void *priv,
1309 struct v4l2_frequency *f)
1310 {
1311 struct go7007_file *gofh = priv;
1312 struct go7007 *go = gofh->go;
1313
1314 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER))
1315 return -EINVAL;
1316 if (!go->i2c_adapter_online)
1317 return -EIO;
1318
1319 f->type = V4L2_TUNER_ANALOG_TV;
1320 i2c_clients_command(&go->i2c_adapter, VIDIOC_G_FREQUENCY, f);
1321 return 0;
1322 }
1323
1324 static int vidioc_s_frequency(struct file *file, void *priv,
1325 struct v4l2_frequency *f)
1326 {
1327 struct go7007_file *gofh = priv;
1328 struct go7007 *go = gofh->go;
1329
1330 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER))
1331 return -EINVAL;
1332 if (!go->i2c_adapter_online)
1333 return -EIO;
1334
1335 i2c_clients_command(&go->i2c_adapter, VIDIOC_S_FREQUENCY, f);
1336
1337 return 0;
1338 }
1339
1340 static int vidioc_cropcap(struct file *file, void *priv,
1341 struct v4l2_cropcap *cropcap)
1342 {
1343 struct go7007_file *gofh = priv;
1344 struct go7007 *go = gofh->go;
1345
1346 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1347 return -EINVAL;
1348
1349 /* These specify the raw input of the sensor */
1350 switch (go->standard) {
1351 case GO7007_STD_NTSC:
1352 cropcap->bounds.top = 0;
1353 cropcap->bounds.left = 0;
1354 cropcap->bounds.width = 720;
1355 cropcap->bounds.height = 480;
1356 cropcap->defrect.top = 0;
1357 cropcap->defrect.left = 0;
1358 cropcap->defrect.width = 720;
1359 cropcap->defrect.height = 480;
1360 break;
1361 case GO7007_STD_PAL:
1362 cropcap->bounds.top = 0;
1363 cropcap->bounds.left = 0;
1364 cropcap->bounds.width = 720;
1365 cropcap->bounds.height = 576;
1366 cropcap->defrect.top = 0;
1367 cropcap->defrect.left = 0;
1368 cropcap->defrect.width = 720;
1369 cropcap->defrect.height = 576;
1370 break;
1371 case GO7007_STD_OTHER:
1372 cropcap->bounds.top = 0;
1373 cropcap->bounds.left = 0;
1374 cropcap->bounds.width = go->board_info->sensor_width;
1375 cropcap->bounds.height = go->board_info->sensor_height;
1376 cropcap->defrect.top = 0;
1377 cropcap->defrect.left = 0;
1378 cropcap->defrect.width = go->board_info->sensor_width;
1379 cropcap->defrect.height = go->board_info->sensor_height;
1380 break;
1381 }
1382
1383 return 0;
1384 }
1385
1386 static int vidioc_g_crop(struct file *file, void *priv, struct v4l2_crop *crop)
1387 {
1388 struct go7007_file *gofh = priv;
1389 struct go7007 *go = gofh->go;
1390
1391 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1392 return -EINVAL;
1393
1394 crop->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1395
1396 /* These specify the raw input of the sensor */
1397 switch (go->standard) {
1398 case GO7007_STD_NTSC:
1399 crop->c.top = 0;
1400 crop->c.left = 0;
1401 crop->c.width = 720;
1402 crop->c.height = 480;
1403 break;
1404 case GO7007_STD_PAL:
1405 crop->c.top = 0;
1406 crop->c.left = 0;
1407 crop->c.width = 720;
1408 crop->c.height = 576;
1409 break;
1410 case GO7007_STD_OTHER:
1411 crop->c.top = 0;
1412 crop->c.left = 0;
1413 crop->c.width = go->board_info->sensor_width;
1414 crop->c.height = go->board_info->sensor_height;
1415 break;
1416 }
1417
1418 return 0;
1419 }
1420
1421 /* FIXME: vidioc_s_crop is not really implemented!!!
1422 */
1423 static int vidioc_s_crop(struct file *file, void *priv, struct v4l2_crop *crop)
1424 {
1425 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1426 return -EINVAL;
1427
1428 return 0;
1429 }
1430
1431 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1432 struct v4l2_jpegcompression *params)
1433 {
1434 memset(params, 0, sizeof(*params));
1435 params->quality = 50; /* ?? */
1436 params->jpeg_markers = V4L2_JPEG_MARKER_DHT |
1437 V4L2_JPEG_MARKER_DQT;
1438
1439 return 0;
1440 }
1441
1442 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1443 struct v4l2_jpegcompression *params)
1444 {
1445 if (params->quality != 50 ||
1446 params->jpeg_markers != (V4L2_JPEG_MARKER_DHT |
1447 V4L2_JPEG_MARKER_DQT))
1448 return -EINVAL;
1449
1450 return 0;
1451 }
1452
1453 /* FIXME:
1454 Those ioctls are private, and not needed, since several standard
1455 extended controls already provide streaming control.
1456 So, those ioctls should be converted into vidioc_g_ext_ctrls()
1457 and vidioc_s_ext_ctrls()
1458 */
1459
1460 #if 0
1461 /* Temporary ioctls for controlling compression characteristics */
1462 case GO7007IOC_S_BITRATE:
1463 {
1464 int *bitrate = arg;
1465
1466 if (go->streaming)
1467 return -EINVAL;
1468 /* Upper bound is kind of arbitrary here */
1469 if (*bitrate < 64000 || *bitrate > 10000000)
1470 return -EINVAL;
1471 go->bitrate = *bitrate;
1472 return 0;
1473 }
1474 case GO7007IOC_G_BITRATE:
1475 {
1476 int *bitrate = arg;
1477
1478 *bitrate = go->bitrate;
1479 return 0;
1480 }
1481 case GO7007IOC_S_COMP_PARAMS:
1482 {
1483 struct go7007_comp_params *comp = arg;
1484
1485 if (go->format == GO7007_FORMAT_MJPEG)
1486 return -EINVAL;
1487 if (comp->gop_size > 0)
1488 go->gop_size = comp->gop_size;
1489 else
1490 go->gop_size = go->sensor_framerate / 1000;
1491 if (go->gop_size != 15)
1492 go->dvd_mode = 0;
1493 /*go->ipb = comp->max_b_frames > 0;*/ /* completely untested */
1494 if (go->board_info->sensor_flags & GO7007_SENSOR_TV) {
1495 switch (comp->aspect_ratio) {
1496 case GO7007_ASPECT_RATIO_4_3_NTSC:
1497 case GO7007_ASPECT_RATIO_4_3_PAL:
1498 go->aspect_ratio = GO7007_RATIO_4_3;
1499 break;
1500 case GO7007_ASPECT_RATIO_16_9_NTSC:
1501 case GO7007_ASPECT_RATIO_16_9_PAL:
1502 go->aspect_ratio = GO7007_RATIO_16_9;
1503 break;
1504 default:
1505 go->aspect_ratio = GO7007_RATIO_1_1;
1506 break;
1507 }
1508 }
1509 if (comp->flags & GO7007_COMP_OMIT_SEQ_HEADER) {
1510 go->dvd_mode = 0;
1511 go->seq_header_enable = 0;
1512 } else {
1513 go->seq_header_enable = 1;
1514 }
1515 /* fall-through */
1516 }
1517 case GO7007IOC_G_COMP_PARAMS:
1518 {
1519 struct go7007_comp_params *comp = arg;
1520
1521 if (go->format == GO7007_FORMAT_MJPEG)
1522 return -EINVAL;
1523 memset(comp, 0, sizeof(*comp));
1524 comp->gop_size = go->gop_size;
1525 comp->max_b_frames = go->ipb ? 2 : 0;
1526 switch (go->aspect_ratio) {
1527 case GO7007_RATIO_4_3:
1528 if (go->standard == GO7007_STD_NTSC)
1529 comp->aspect_ratio =
1530 GO7007_ASPECT_RATIO_4_3_NTSC;
1531 else
1532 comp->aspect_ratio =
1533 GO7007_ASPECT_RATIO_4_3_PAL;
1534 break;
1535 case GO7007_RATIO_16_9:
1536 if (go->standard == GO7007_STD_NTSC)
1537 comp->aspect_ratio =
1538 GO7007_ASPECT_RATIO_16_9_NTSC;
1539 else
1540 comp->aspect_ratio =
1541 GO7007_ASPECT_RATIO_16_9_PAL;
1542 break;
1543 default:
1544 comp->aspect_ratio = GO7007_ASPECT_RATIO_1_1;
1545 break;
1546 }
1547 if (go->closed_gop)
1548 comp->flags |= GO7007_COMP_CLOSED_GOP;
1549 if (!go->seq_header_enable)
1550 comp->flags |= GO7007_COMP_OMIT_SEQ_HEADER;
1551 return 0;
1552 }
1553 case GO7007IOC_S_MPEG_PARAMS:
1554 {
1555 struct go7007_mpeg_params *mpeg = arg;
1556
1557 if (go->format != GO7007_FORMAT_MPEG1 &&
1558 go->format != GO7007_FORMAT_MPEG2 &&
1559 go->format != GO7007_FORMAT_MPEG4)
1560 return -EINVAL;
1561
1562 if (mpeg->flags & GO7007_MPEG_FORCE_DVD_MODE) {
1563 go->format = GO7007_FORMAT_MPEG2;
1564 go->bitrate = 9800000;
1565 go->gop_size = 15;
1566 go->pali = 0x48;
1567 go->closed_gop = 1;
1568 go->repeat_seqhead = 0;
1569 go->seq_header_enable = 1;
1570 go->gop_header_enable = 1;
1571 go->dvd_mode = 1;
1572 } else {
1573 switch (mpeg->mpeg_video_standard) {
1574 case GO7007_MPEG_VIDEO_MPEG1:
1575 go->format = GO7007_FORMAT_MPEG1;
1576 go->pali = 0;
1577 break;
1578 case GO7007_MPEG_VIDEO_MPEG2:
1579 go->format = GO7007_FORMAT_MPEG2;
1580 if (mpeg->pali >> 24 == 2)
1581 go->pali = mpeg->pali & 0xff;
1582 else
1583 go->pali = 0x48;
1584 break;
1585 case GO7007_MPEG_VIDEO_MPEG4:
1586 go->format = GO7007_FORMAT_MPEG4;
1587 if (mpeg->pali >> 24 == 4)
1588 go->pali = mpeg->pali & 0xff;
1589 else
1590 go->pali = 0xf5;
1591 break;
1592 default:
1593 return -EINVAL;
1594 }
1595 go->gop_header_enable =
1596 mpeg->flags & GO7007_MPEG_OMIT_GOP_HEADER
1597 ? 0 : 1;
1598 if (mpeg->flags & GO7007_MPEG_REPEAT_SEQHEADER)
1599 go->repeat_seqhead = 1;
1600 else
1601 go->repeat_seqhead = 0;
1602 go->dvd_mode = 0;
1603 }
1604 /* fall-through */
1605 }
1606 case GO7007IOC_G_MPEG_PARAMS:
1607 {
1608 struct go7007_mpeg_params *mpeg = arg;
1609
1610 memset(mpeg, 0, sizeof(*mpeg));
1611 switch (go->format) {
1612 case GO7007_FORMAT_MPEG1:
1613 mpeg->mpeg_video_standard = GO7007_MPEG_VIDEO_MPEG1;
1614 mpeg->pali = 0;
1615 break;
1616 case GO7007_FORMAT_MPEG2:
1617 mpeg->mpeg_video_standard = GO7007_MPEG_VIDEO_MPEG2;
1618 mpeg->pali = GO7007_MPEG_PROFILE(2, go->pali);
1619 break;
1620 case GO7007_FORMAT_MPEG4:
1621 mpeg->mpeg_video_standard = GO7007_MPEG_VIDEO_MPEG4;
1622 mpeg->pali = GO7007_MPEG_PROFILE(4, go->pali);
1623 break;
1624 default:
1625 return -EINVAL;
1626 }
1627 if (!go->gop_header_enable)
1628 mpeg->flags |= GO7007_MPEG_OMIT_GOP_HEADER;
1629 if (go->repeat_seqhead)
1630 mpeg->flags |= GO7007_MPEG_REPEAT_SEQHEADER;
1631 if (go->dvd_mode)
1632 mpeg->flags |= GO7007_MPEG_FORCE_DVD_MODE;
1633 return 0;
1634 }
1635 case GO7007IOC_S_MD_PARAMS:
1636 {
1637 struct go7007_md_params *mdp = arg;
1638
1639 if (mdp->region > 3)
1640 return -EINVAL;
1641 if (mdp->trigger > 0) {
1642 go->modet[mdp->region].pixel_threshold =
1643 mdp->pixel_threshold >> 1;
1644 go->modet[mdp->region].motion_threshold =
1645 mdp->motion_threshold >> 1;
1646 go->modet[mdp->region].mb_threshold =
1647 mdp->trigger >> 1;
1648 go->modet[mdp->region].enable = 1;
1649 } else
1650 go->modet[mdp->region].enable = 0;
1651 /* fall-through */
1652 }
1653 case GO7007IOC_G_MD_PARAMS:
1654 {
1655 struct go7007_md_params *mdp = arg;
1656 int region = mdp->region;
1657
1658 if (mdp->region > 3)
1659 return -EINVAL;
1660 memset(mdp, 0, sizeof(struct go7007_md_params));
1661 mdp->region = region;
1662 if (!go->modet[region].enable)
1663 return 0;
1664 mdp->pixel_threshold =
1665 (go->modet[region].pixel_threshold << 1) + 1;
1666 mdp->motion_threshold =
1667 (go->modet[region].motion_threshold << 1) + 1;
1668 mdp->trigger =
1669 (go->modet[region].mb_threshold << 1) + 1;
1670 return 0;
1671 }
1672 case GO7007IOC_S_MD_REGION:
1673 {
1674 struct go7007_md_region *region = arg;
1675
1676 if (region->region < 1 || region->region > 3)
1677 return -EINVAL;
1678 return clip_to_modet_map(go, region->region, region->clips);
1679 }
1680 #endif
1681
1682 static ssize_t go7007_read(struct file *file, char __user *data,
1683 size_t count, loff_t *ppos)
1684 {
1685 return -EINVAL;
1686 }
1687
1688 static void go7007_vm_open(struct vm_area_struct *vma)
1689 {
1690 struct go7007_buffer *gobuf = vma->vm_private_data;
1691
1692 ++gobuf->mapped;
1693 }
1694
1695 static void go7007_vm_close(struct vm_area_struct *vma)
1696 {
1697 struct go7007_buffer *gobuf = vma->vm_private_data;
1698 unsigned long flags;
1699
1700 if (--gobuf->mapped == 0) {
1701 spin_lock_irqsave(&gobuf->go->spinlock, flags);
1702 deactivate_buffer(gobuf);
1703 spin_unlock_irqrestore(&gobuf->go->spinlock, flags);
1704 }
1705 }
1706
1707 /* Copied from videobuf-dma-sg.c */
1708 static int go7007_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1709 {
1710 struct page *page;
1711
1712 page = alloc_page(GFP_USER | __GFP_DMA32);
1713 if (!page)
1714 return VM_FAULT_OOM;
1715 clear_user_highpage(page, (unsigned long)vmf->virtual_address);
1716 vmf->page = page;
1717 return 0;
1718 }
1719
1720 static struct vm_operations_struct go7007_vm_ops = {
1721 .open = go7007_vm_open,
1722 .close = go7007_vm_close,
1723 .fault = go7007_vm_fault,
1724 };
1725
1726 static int go7007_mmap(struct file *file, struct vm_area_struct *vma)
1727 {
1728 struct go7007_file *gofh = file->private_data;
1729 unsigned int index;
1730
1731 if (gofh->go->status != STATUS_ONLINE)
1732 return -EIO;
1733 if (!(vma->vm_flags & VM_SHARED))
1734 return -EINVAL; /* only support VM_SHARED mapping */
1735 if (vma->vm_end - vma->vm_start != GO7007_BUF_SIZE)
1736 return -EINVAL; /* must map exactly one full buffer */
1737 down(&gofh->lock);
1738 index = vma->vm_pgoff / GO7007_BUF_PAGES;
1739 if (index >= gofh->buf_count) {
1740 up(&gofh->lock);
1741 return -EINVAL; /* trying to map beyond requested buffers */
1742 }
1743 if (index * GO7007_BUF_PAGES != vma->vm_pgoff) {
1744 up(&gofh->lock);
1745 return -EINVAL; /* offset is not aligned on buffer boundary */
1746 }
1747 if (gofh->bufs[index].mapped > 0) {
1748 up(&gofh->lock);
1749 return -EBUSY;
1750 }
1751 gofh->bufs[index].mapped = 1;
1752 gofh->bufs[index].user_addr = vma->vm_start;
1753 vma->vm_ops = &go7007_vm_ops;
1754 vma->vm_flags |= VM_DONTEXPAND;
1755 vma->vm_flags &= ~VM_IO;
1756 vma->vm_private_data = &gofh->bufs[index];
1757 up(&gofh->lock);
1758 return 0;
1759 }
1760
1761 static unsigned int go7007_poll(struct file *file, poll_table *wait)
1762 {
1763 struct go7007_file *gofh = file->private_data;
1764 struct go7007_buffer *gobuf;
1765
1766 if (list_empty(&gofh->go->stream))
1767 return POLLERR;
1768 gobuf = list_entry(gofh->go->stream.next, struct go7007_buffer, stream);
1769 poll_wait(file, &gofh->go->frame_waitq, wait);
1770 if (gobuf->state == BUF_STATE_DONE)
1771 return POLLIN | POLLRDNORM;
1772 return 0;
1773 }
1774
1775 static void go7007_vfl_release(struct video_device *vfd)
1776 {
1777 struct go7007 *go = video_get_drvdata(vfd);
1778
1779 video_device_release(vfd);
1780 if (--go->ref_count == 0)
1781 kfree(go);
1782 }
1783
1784 static struct v4l2_file_operations go7007_fops = {
1785 .owner = THIS_MODULE,
1786 .open = go7007_open,
1787 .release = go7007_release,
1788 .ioctl = video_ioctl2,
1789 .read = go7007_read,
1790 .mmap = go7007_mmap,
1791 .poll = go7007_poll,
1792 };
1793
1794 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1795 .vidioc_querycap = vidioc_querycap,
1796 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1797 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1798 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1799 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1800 .vidioc_reqbufs = vidioc_reqbufs,
1801 .vidioc_querybuf = vidioc_querybuf,
1802 .vidioc_qbuf = vidioc_qbuf,
1803 .vidioc_dqbuf = vidioc_dqbuf,
1804 .vidioc_s_std = vidioc_s_std,
1805 .vidioc_enum_input = vidioc_enum_input,
1806 .vidioc_g_input = vidioc_g_input,
1807 .vidioc_s_input = vidioc_s_input,
1808 .vidioc_queryctrl = vidioc_queryctrl,
1809 .vidioc_g_ctrl = vidioc_g_ctrl,
1810 .vidioc_s_ctrl = vidioc_s_ctrl,
1811 .vidioc_streamon = vidioc_streamon,
1812 .vidioc_streamoff = vidioc_streamoff,
1813 .vidioc_g_tuner = vidioc_g_tuner,
1814 .vidioc_s_tuner = vidioc_s_tuner,
1815 .vidioc_g_frequency = vidioc_g_frequency,
1816 .vidioc_s_frequency = vidioc_s_frequency,
1817 .vidioc_g_parm = vidioc_g_parm,
1818 .vidioc_s_parm = vidioc_s_parm,
1819 .vidioc_enum_framesizes = vidioc_enum_framesizes,
1820 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1821 .vidioc_cropcap = vidioc_cropcap,
1822 .vidioc_g_crop = vidioc_g_crop,
1823 .vidioc_s_crop = vidioc_s_crop,
1824 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1825 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1826 };
1827
1828 static struct video_device go7007_template = {
1829 .name = "go7007",
1830 .fops = &go7007_fops,
1831 .minor = -1,
1832 .release = go7007_vfl_release,
1833 .ioctl_ops = &video_ioctl_ops,
1834 .tvnorms = V4L2_STD_ALL,
1835 .current_norm = V4L2_STD_NTSC,
1836 };
1837
1838 int go7007_v4l2_init(struct go7007 *go)
1839 {
1840 int rv;
1841
1842 go->video_dev = video_device_alloc();
1843 if (go->video_dev == NULL)
1844 return -ENOMEM;
1845 memcpy(go->video_dev, &go7007_template, sizeof(go7007_template));
1846 go->video_dev->parent = go->dev;
1847 rv = video_register_device(go->video_dev, VFL_TYPE_GRABBER, -1);
1848 if (rv < 0) {
1849 video_device_release(go->video_dev);
1850 go->video_dev = NULL;
1851 return rv;
1852 }
1853 video_set_drvdata(go->video_dev, go);
1854 ++go->ref_count;
1855 printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
1856 go->video_dev->name, go->video_dev->num);
1857
1858 return 0;
1859 }
1860
1861 void go7007_v4l2_remove(struct go7007 *go)
1862 {
1863 unsigned long flags;
1864
1865 down(&go->hw_lock);
1866 if (go->streaming) {
1867 go->streaming = 0;
1868 go7007_stream_stop(go);
1869 spin_lock_irqsave(&go->spinlock, flags);
1870 abort_queued(go);
1871 spin_unlock_irqrestore(&go->spinlock, flags);
1872 }
1873 up(&go->hw_lock);
1874 if (go->video_dev)
1875 video_unregister_device(go->video_dev);
1876 }
Support for the Chinese Samsung S3C2440 based development boards