4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
7 * This file replaces the videodev.c file that comes with the
8 * regular kernel distribution.
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
15 * Author: Bill Dirks <bill@thedirks.org>
16 * based on code by Alan Cox, <alan@cymru.net>
21 * Video capture interface for Linux
23 * A generic video device interface for the LINUX operating system
24 * using a set of device structures/vectors for low level operations.
26 * This program is free software; you can redistribute it and/or
27 * modify it under the terms of the GNU General Public License
28 * as published by the Free Software Foundation; either version
29 * 2 of the License, or (at your option) any later version.
31 * Author: Alan Cox, <alan@lxorguk.ukuu.org.uk>
37 * Video4linux 1/2 integration by Justin Schoeman
38 * <justin@suntiger.ee.up.ac.za>
39 * 2.4 PROCFS support ported from 2.4 kernels by
40 * Iñaki García Etxebarria <garetxe@euskalnet.net>
41 * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
42 * 2.4 devfs support ported from 2.4 kernels by
43 * Dan Merillat <dan@merillat.org>
44 * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
47 #include <linux/module.h>
48 #include <linux/types.h>
49 #include <linux/kernel.h>
51 #include <linux/string.h>
52 #include <linux/errno.h>
53 #include <linux/i2c.h>
54 #include <asm/uaccess.h>
55 #include <asm/system.h>
56 #include <asm/pgtable.h>
58 #include <asm/div64.h>
59 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
60 #include <media/v4l2-common.h>
61 #include <media/v4l2-device.h>
62 #include <media/v4l2-chip-ident.h>
64 #include <linux/videodev2.h>
66 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
67 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
68 MODULE_LICENSE("GPL");
72 * V 4 L 2 D R I V E R H E L P E R A P I
77 * Video Standard Operations (contributed by Michael Schimek)
81 /* ----------------------------------------------------------------- */
82 /* priority handling */
84 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \
85 val == V4L2_PRIORITY_INTERACTIVE || \
86 val == V4L2_PRIORITY_RECORD)
88 int v4l2_prio_init(struct v4l2_prio_state *global)
90 memset(global,0,sizeof(*global));
93 EXPORT_SYMBOL(v4l2_prio_init);
95 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
96 enum v4l2_priority new)
98 if (!V4L2_PRIO_VALID(new))
103 atomic_inc(&global->prios[new]);
104 if (V4L2_PRIO_VALID(*local))
105 atomic_dec(&global->prios[*local]);
109 EXPORT_SYMBOL(v4l2_prio_change);
111 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
113 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
115 EXPORT_SYMBOL(v4l2_prio_open);
117 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
119 if (V4L2_PRIO_VALID(*local))
120 atomic_dec(&global->prios[*local]);
123 EXPORT_SYMBOL(v4l2_prio_close);
125 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
127 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
128 return V4L2_PRIORITY_RECORD;
129 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
130 return V4L2_PRIORITY_INTERACTIVE;
131 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
132 return V4L2_PRIORITY_BACKGROUND;
133 return V4L2_PRIORITY_UNSET;
135 EXPORT_SYMBOL(v4l2_prio_max);
137 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
139 if (*local < v4l2_prio_max(global))
143 EXPORT_SYMBOL(v4l2_prio_check);
145 /* ----------------------------------------------------------------- */
147 /* Helper functions for control handling */
149 /* Check for correctness of the ctrl's value based on the data from
150 struct v4l2_queryctrl and the available menu items. Note that
151 menu_items may be NULL, in that case it is ignored. */
152 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
153 const char **menu_items)
155 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
157 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
159 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
160 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
161 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
163 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
165 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
166 if (menu_items[ctrl->value] == NULL ||
167 menu_items[ctrl->value][0] == '\0')
172 EXPORT_SYMBOL(v4l2_ctrl_check);
174 /* Returns NULL or a character pointer array containing the menu for
175 the given control ID. The pointer array ends with a NULL pointer.
176 An empty string signifies a menu entry that is invalid. This allows
177 drivers to disable certain options if it is not supported. */
178 const char **v4l2_ctrl_get_menu(u32 id)
180 static const char *mpeg_audio_sampling_freq[] = {
186 static const char *mpeg_audio_encoding[] = {
189 "MPEG-1/2 Layer III",
194 static const char *mpeg_audio_l1_bitrate[] = {
211 static const char *mpeg_audio_l2_bitrate[] = {
228 static const char *mpeg_audio_l3_bitrate[] = {
245 static const char *mpeg_audio_ac3_bitrate[] = {
267 static const char *mpeg_audio_mode[] = {
274 static const char *mpeg_audio_mode_extension[] = {
281 static const char *mpeg_audio_emphasis[] = {
287 static const char *mpeg_audio_crc[] = {
292 static const char *mpeg_video_encoding[] = {
298 static const char *mpeg_video_aspect[] = {
305 static const char *mpeg_video_bitrate_mode[] = {
310 static const char *mpeg_stream_type[] = {
311 "MPEG-2 Program Stream",
312 "MPEG-2 Transport Stream",
313 "MPEG-1 System Stream",
314 "MPEG-2 DVD-compatible Stream",
315 "MPEG-1 VCD-compatible Stream",
316 "MPEG-2 SVCD-compatible Stream",
319 static const char *mpeg_stream_vbi_fmt[] = {
321 "Private packet, IVTV format",
324 static const char *camera_power_line_frequency[] = {
330 static const char *camera_exposure_auto[] = {
333 "Shutter Priority Mode",
334 "Aperture Priority Mode",
337 static const char *colorfx[] = {
345 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
346 return mpeg_audio_sampling_freq;
347 case V4L2_CID_MPEG_AUDIO_ENCODING:
348 return mpeg_audio_encoding;
349 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
350 return mpeg_audio_l1_bitrate;
351 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
352 return mpeg_audio_l2_bitrate;
353 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
354 return mpeg_audio_l3_bitrate;
355 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
356 return mpeg_audio_ac3_bitrate;
357 case V4L2_CID_MPEG_AUDIO_MODE:
358 return mpeg_audio_mode;
359 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
360 return mpeg_audio_mode_extension;
361 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
362 return mpeg_audio_emphasis;
363 case V4L2_CID_MPEG_AUDIO_CRC:
364 return mpeg_audio_crc;
365 case V4L2_CID_MPEG_VIDEO_ENCODING:
366 return mpeg_video_encoding;
367 case V4L2_CID_MPEG_VIDEO_ASPECT:
368 return mpeg_video_aspect;
369 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
370 return mpeg_video_bitrate_mode;
371 case V4L2_CID_MPEG_STREAM_TYPE:
372 return mpeg_stream_type;
373 case V4L2_CID_MPEG_STREAM_VBI_FMT:
374 return mpeg_stream_vbi_fmt;
375 case V4L2_CID_POWER_LINE_FREQUENCY:
376 return camera_power_line_frequency;
377 case V4L2_CID_EXPOSURE_AUTO:
378 return camera_exposure_auto;
379 case V4L2_CID_COLORFX:
385 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
387 /* Return the control name. */
388 const char *v4l2_ctrl_get_name(u32 id)
392 case V4L2_CID_USER_CLASS: return "User Controls";
393 case V4L2_CID_BRIGHTNESS: return "Brightness";
394 case V4L2_CID_CONTRAST: return "Contrast";
395 case V4L2_CID_SATURATION: return "Saturation";
396 case V4L2_CID_HUE: return "Hue";
397 case V4L2_CID_AUDIO_VOLUME: return "Volume";
398 case V4L2_CID_AUDIO_BALANCE: return "Balance";
399 case V4L2_CID_AUDIO_BASS: return "Bass";
400 case V4L2_CID_AUDIO_TREBLE: return "Treble";
401 case V4L2_CID_AUDIO_MUTE: return "Mute";
402 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
403 case V4L2_CID_BLACK_LEVEL: return "Black Level";
404 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
405 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
406 case V4L2_CID_RED_BALANCE: return "Red Balance";
407 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
408 case V4L2_CID_GAMMA: return "Gamma";
409 case V4L2_CID_EXPOSURE: return "Exposure";
410 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
411 case V4L2_CID_GAIN: return "Gain";
412 case V4L2_CID_HFLIP: return "Horizontal Flip";
413 case V4L2_CID_VFLIP: return "Vertical Flip";
414 case V4L2_CID_HCENTER: return "Horizontal Center";
415 case V4L2_CID_VCENTER: return "Vertical Center";
416 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
417 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
418 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
419 case V4L2_CID_SHARPNESS: return "Sharpness";
420 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
421 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
422 case V4L2_CID_COLOR_KILLER: return "Color Killer";
423 case V4L2_CID_COLORFX: return "Color Effects";
426 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
427 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
428 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
429 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
430 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
431 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
432 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
433 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
434 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
435 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
436 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
437 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
438 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
439 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
440 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
441 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
442 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
443 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
444 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
445 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
446 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
447 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
448 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
449 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
450 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
451 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
452 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
453 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
454 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
455 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
456 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
457 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
458 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
460 /* CAMERA controls */
461 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
462 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
463 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
464 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
465 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
466 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
467 case V4L2_CID_PAN_RESET: return "Pan, Reset";
468 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
469 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
470 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
471 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
472 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
473 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic";
474 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
475 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
476 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
477 case V4L2_CID_PRIVACY: return "Privacy";
483 EXPORT_SYMBOL(v4l2_ctrl_get_name);
485 /* Fill in a struct v4l2_queryctrl */
486 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
488 const char *name = v4l2_ctrl_get_name(qctrl->id);
495 case V4L2_CID_AUDIO_MUTE:
496 case V4L2_CID_AUDIO_LOUDNESS:
497 case V4L2_CID_AUTO_WHITE_BALANCE:
498 case V4L2_CID_AUTOGAIN:
501 case V4L2_CID_HUE_AUTO:
502 case V4L2_CID_CHROMA_AGC:
503 case V4L2_CID_COLOR_KILLER:
504 case V4L2_CID_MPEG_AUDIO_MUTE:
505 case V4L2_CID_MPEG_VIDEO_MUTE:
506 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
507 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
508 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
509 case V4L2_CID_FOCUS_AUTO:
510 case V4L2_CID_PRIVACY:
511 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
515 case V4L2_CID_PAN_RESET:
516 case V4L2_CID_TILT_RESET:
517 qctrl->type = V4L2_CTRL_TYPE_BUTTON;
518 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
519 min = max = step = def = 0;
521 case V4L2_CID_POWER_LINE_FREQUENCY:
522 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
523 case V4L2_CID_MPEG_AUDIO_ENCODING:
524 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
525 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
526 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
527 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
528 case V4L2_CID_MPEG_AUDIO_MODE:
529 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
530 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
531 case V4L2_CID_MPEG_AUDIO_CRC:
532 case V4L2_CID_MPEG_VIDEO_ENCODING:
533 case V4L2_CID_MPEG_VIDEO_ASPECT:
534 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
535 case V4L2_CID_MPEG_STREAM_TYPE:
536 case V4L2_CID_MPEG_STREAM_VBI_FMT:
537 case V4L2_CID_EXPOSURE_AUTO:
538 case V4L2_CID_COLORFX:
539 qctrl->type = V4L2_CTRL_TYPE_MENU;
542 case V4L2_CID_USER_CLASS:
543 case V4L2_CID_CAMERA_CLASS:
544 case V4L2_CID_MPEG_CLASS:
545 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
546 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
547 min = max = step = def = 0;
550 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
554 case V4L2_CID_MPEG_AUDIO_ENCODING:
555 case V4L2_CID_MPEG_AUDIO_MODE:
556 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
557 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
558 case V4L2_CID_MPEG_STREAM_TYPE:
559 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
561 case V4L2_CID_AUDIO_VOLUME:
562 case V4L2_CID_AUDIO_BALANCE:
563 case V4L2_CID_AUDIO_BASS:
564 case V4L2_CID_AUDIO_TREBLE:
565 case V4L2_CID_BRIGHTNESS:
566 case V4L2_CID_CONTRAST:
567 case V4L2_CID_SATURATION:
569 case V4L2_CID_RED_BALANCE:
570 case V4L2_CID_BLUE_BALANCE:
572 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
574 case V4L2_CID_PAN_RELATIVE:
575 case V4L2_CID_TILT_RELATIVE:
576 case V4L2_CID_FOCUS_RELATIVE:
577 case V4L2_CID_ZOOM_RELATIVE:
578 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
581 qctrl->minimum = min;
582 qctrl->maximum = max;
584 qctrl->default_value = def;
585 qctrl->reserved[0] = qctrl->reserved[1] = 0;
586 strlcpy(qctrl->name, name, sizeof(qctrl->name));
589 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
591 /* Fill in a struct v4l2_queryctrl with standard values based on
593 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
597 case V4L2_CID_USER_CLASS:
598 case V4L2_CID_MPEG_CLASS:
599 case V4L2_CID_CAMERA_CLASS:
600 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
601 case V4L2_CID_AUDIO_VOLUME:
602 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
603 case V4L2_CID_AUDIO_MUTE:
604 case V4L2_CID_AUDIO_LOUDNESS:
605 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
606 case V4L2_CID_AUDIO_BALANCE:
607 case V4L2_CID_AUDIO_BASS:
608 case V4L2_CID_AUDIO_TREBLE:
609 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
610 case V4L2_CID_BRIGHTNESS:
611 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
612 case V4L2_CID_CONTRAST:
613 case V4L2_CID_SATURATION:
614 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
616 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
617 case V4L2_CID_COLORFX:
618 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
621 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
622 return v4l2_ctrl_query_fill(qctrl,
623 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
624 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
625 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
626 case V4L2_CID_MPEG_AUDIO_ENCODING:
627 return v4l2_ctrl_query_fill(qctrl,
628 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
629 V4L2_MPEG_AUDIO_ENCODING_AC3, 1,
630 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
631 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
632 return v4l2_ctrl_query_fill(qctrl,
633 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
634 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
635 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
636 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
637 return v4l2_ctrl_query_fill(qctrl,
638 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
639 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
640 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
641 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
642 return v4l2_ctrl_query_fill(qctrl,
643 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
644 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
645 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
646 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:
647 return v4l2_ctrl_query_fill(qctrl, 0, 6400, 1, 3200000);
648 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
649 return v4l2_ctrl_query_fill(qctrl,
650 V4L2_MPEG_AUDIO_AC3_BITRATE_32K,
651 V4L2_MPEG_AUDIO_AC3_BITRATE_640K, 1,
652 V4L2_MPEG_AUDIO_AC3_BITRATE_384K);
653 case V4L2_CID_MPEG_AUDIO_MODE:
654 return v4l2_ctrl_query_fill(qctrl,
655 V4L2_MPEG_AUDIO_MODE_STEREO,
656 V4L2_MPEG_AUDIO_MODE_MONO, 1,
657 V4L2_MPEG_AUDIO_MODE_STEREO);
658 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
659 return v4l2_ctrl_query_fill(qctrl,
660 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
661 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
662 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
663 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
664 return v4l2_ctrl_query_fill(qctrl,
665 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
666 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
667 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
668 case V4L2_CID_MPEG_AUDIO_CRC:
669 return v4l2_ctrl_query_fill(qctrl,
670 V4L2_MPEG_AUDIO_CRC_NONE,
671 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
672 V4L2_MPEG_AUDIO_CRC_NONE);
673 case V4L2_CID_MPEG_AUDIO_MUTE:
674 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
675 case V4L2_CID_MPEG_VIDEO_ENCODING:
676 return v4l2_ctrl_query_fill(qctrl,
677 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
678 V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC, 1,
679 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
680 case V4L2_CID_MPEG_VIDEO_ASPECT:
681 return v4l2_ctrl_query_fill(qctrl,
682 V4L2_MPEG_VIDEO_ASPECT_1x1,
683 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
684 V4L2_MPEG_VIDEO_ASPECT_4x3);
685 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
686 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
687 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
688 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
689 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
690 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
691 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
692 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
693 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
694 return v4l2_ctrl_query_fill(qctrl,
695 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
696 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
697 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
698 case V4L2_CID_MPEG_VIDEO_BITRATE:
699 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
700 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
701 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
702 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
703 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
704 case V4L2_CID_MPEG_VIDEO_MUTE:
705 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
706 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */
707 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
708 case V4L2_CID_MPEG_STREAM_TYPE:
709 return v4l2_ctrl_query_fill(qctrl,
710 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
711 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
712 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
713 case V4L2_CID_MPEG_STREAM_PID_PMT:
714 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
715 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
716 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
717 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
718 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
719 case V4L2_CID_MPEG_STREAM_PID_PCR:
720 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
721 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
722 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
723 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
724 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
725 case V4L2_CID_MPEG_STREAM_VBI_FMT:
726 return v4l2_ctrl_query_fill(qctrl,
727 V4L2_MPEG_STREAM_VBI_FMT_NONE,
728 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
729 V4L2_MPEG_STREAM_VBI_FMT_NONE);
734 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
736 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
737 the menu. The qctrl pointer may be NULL, in which case it is ignored.
738 If menu_items is NULL, then the menu items are retrieved using
739 v4l2_ctrl_get_menu. */
740 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
741 const char **menu_items)
746 if (menu_items == NULL)
747 menu_items = v4l2_ctrl_get_menu(qmenu->id);
748 if (menu_items == NULL ||
749 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
751 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
752 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
754 strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
757 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
759 /* Fill in a struct v4l2_querymenu based on the specified array of valid
760 menu items (terminated by V4L2_CTRL_MENU_IDS_END).
761 Use this if there are 'holes' in the list of valid menu items. */
762 int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
764 const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
767 if (menu_items == NULL || ids == NULL)
769 while (*ids != V4L2_CTRL_MENU_IDS_END) {
770 if (*ids++ == qmenu->index) {
771 strlcpy(qmenu->name, menu_items[qmenu->index],
772 sizeof(qmenu->name));
778 EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
780 /* ctrl_classes points to an array of u32 pointers, the last element is
781 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
782 Each array must be sorted low to high and belong to the same control
783 class. The array of u32 pointers must also be sorted, from low class IDs
786 This function returns the first ID that follows after the given ID.
787 When no more controls are available 0 is returned. */
788 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
790 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
793 if (ctrl_classes == NULL)
796 /* if no query is desired, then check if the ID is part of ctrl_classes */
797 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
799 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
801 if (*ctrl_classes == NULL)
803 pctrl = *ctrl_classes;
804 /* find control ID */
805 while (*pctrl && *pctrl != id) pctrl++;
806 return *pctrl ? id : 0;
808 id &= V4L2_CTRL_ID_MASK;
809 id++; /* select next control */
810 /* find first class that matches (or is greater than) the class of
812 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
814 /* no more classes */
815 if (*ctrl_classes == NULL)
817 pctrl = *ctrl_classes;
818 /* find first ctrl within the class that is >= ID */
819 while (*pctrl && *pctrl < id) pctrl++;
822 /* we are at the end of the controls of the current class. */
823 /* continue with next class if available */
825 if (*ctrl_classes == NULL)
827 return **ctrl_classes;
829 EXPORT_SYMBOL(v4l2_ctrl_next);
831 int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
833 switch (match->type) {
834 case V4L2_CHIP_MATCH_HOST:
835 return match->addr == 0;
840 EXPORT_SYMBOL(v4l2_chip_match_host);
842 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
843 int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
847 if (c == NULL || match == NULL)
850 switch (match->type) {
851 case V4L2_CHIP_MATCH_I2C_DRIVER:
852 if (c->driver == NULL || c->driver->driver.name == NULL)
854 len = strlen(c->driver->driver.name);
855 /* legacy drivers have a ' suffix, don't try to match that */
856 if (len && c->driver->driver.name[len - 1] == '\'')
858 return len && !strncmp(c->driver->driver.name, match->name, len);
859 case V4L2_CHIP_MATCH_I2C_ADDR:
860 return c->addr == match->addr;
865 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
867 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
868 u32 ident, u32 revision)
870 if (!v4l2_chip_match_i2c_client(c, &chip->match))
872 if (chip->ident == V4L2_IDENT_NONE) {
874 chip->revision = revision;
877 chip->ident = V4L2_IDENT_AMBIGUOUS;
882 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
884 /* ----------------------------------------------------------------- */
886 /* Helper function for I2C legacy drivers */
888 int v4l2_i2c_attach(struct i2c_adapter *adapter, int address, struct i2c_driver *driver,
890 int (*probe)(struct i2c_client *, const struct i2c_device_id *))
892 struct i2c_client *client;
895 client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
899 client->addr = address;
900 client->adapter = adapter;
901 client->driver = driver;
902 strlcpy(client->name, name, sizeof(client->name));
904 err = probe(client, NULL);
906 i2c_attach_client(client);
910 return err != -ENOMEM ? 0 : err;
912 EXPORT_SYMBOL(v4l2_i2c_attach);
914 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
915 const struct v4l2_subdev_ops *ops)
917 v4l2_subdev_init(sd, ops);
918 /* the owner is the same as the i2c_client's driver owner */
919 sd->owner = client->driver->driver.owner;
920 /* i2c_client and v4l2_subdev point to one another */
921 v4l2_set_subdevdata(sd, client);
922 i2c_set_clientdata(client, sd);
923 /* initialize name */
924 snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
925 client->driver->driver.name, i2c_adapter_id(client->adapter),
928 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
932 /* Load an i2c sub-device. It assumes that i2c_get_adapdata(adapter)
933 returns the v4l2_device and that i2c_get_clientdata(client)
934 returns the v4l2_subdev. */
935 struct v4l2_subdev *v4l2_i2c_new_subdev(struct i2c_adapter *adapter,
936 const char *module_name, const char *client_type, u8 addr)
938 struct v4l2_device *dev = i2c_get_adapdata(adapter);
939 struct v4l2_subdev *sd = NULL;
940 struct i2c_client *client;
941 struct i2c_board_info info;
946 request_module(module_name);
948 /* Setup the i2c board info with the device type and
949 the device address. */
950 memset(&info, 0, sizeof(info));
951 strlcpy(info.type, client_type, sizeof(info.type));
954 /* Create the i2c client */
955 client = i2c_new_device(adapter, &info);
956 /* Note: it is possible in the future that
957 c->driver is NULL if the driver is still being loaded.
958 We need better support from the kernel so that we
959 can easily wait for the load to finish. */
960 if (client == NULL || client->driver == NULL)
963 /* Lock the module so we can safely get the v4l2_subdev pointer */
964 if (!try_module_get(client->driver->driver.owner))
966 sd = i2c_get_clientdata(client);
968 /* Register with the v4l2_device which increases the module's
969 use count as well. */
970 if (v4l2_device_register_subdev(dev, sd))
972 /* Decrease the module use count to match the first try_module_get. */
973 module_put(client->driver->driver.owner);
977 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
979 /* Probe and load an i2c sub-device. It assumes that i2c_get_adapdata(adapter)
980 returns the v4l2_device and that i2c_get_clientdata(client)
981 returns the v4l2_subdev. */
982 struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct i2c_adapter *adapter,
983 const char *module_name, const char *client_type,
984 const unsigned short *addrs)
986 struct v4l2_device *dev = i2c_get_adapdata(adapter);
987 struct v4l2_subdev *sd = NULL;
988 struct i2c_client *client = NULL;
989 struct i2c_board_info info;
994 request_module(module_name);
996 /* Setup the i2c board info with the device type and
997 the device address. */
998 memset(&info, 0, sizeof(info));
999 strlcpy(info.type, client_type, sizeof(info.type));
1001 /* Probe and create the i2c client */
1002 client = i2c_new_probed_device(adapter, &info, addrs);
1003 /* Note: it is possible in the future that
1004 c->driver is NULL if the driver is still being loaded.
1005 We need better support from the kernel so that we
1006 can easily wait for the load to finish. */
1007 if (client == NULL || client->driver == NULL)
1010 /* Lock the module so we can safely get the v4l2_subdev pointer */
1011 if (!try_module_get(client->driver->driver.owner))
1013 sd = i2c_get_clientdata(client);
1015 /* Register with the v4l2_device which increases the module's
1016 use count as well. */
1017 if (v4l2_device_register_subdev(dev, sd))
1019 /* Decrease the module use count to match the first try_module_get. */
1020 module_put(client->driver->driver.owner);
1023 EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev);
1025 /* Return i2c client address of v4l2_subdev. */
1026 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
1028 struct i2c_client *client = v4l2_get_subdevdata(sd);
1030 return client ? client->addr : I2C_CLIENT_END;
1032 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
1034 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
1035 addresses are unknown. */
1036 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
1038 static const unsigned short radio_addrs[] = {
1039 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
1045 static const unsigned short demod_addrs[] = {
1046 0x42, 0x43, 0x4a, 0x4b,
1049 static const unsigned short tv_addrs[] = {
1050 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
1051 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
1052 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
1063 case ADDRS_TV_WITH_DEMOD:
1064 return tv_addrs + 4;
1068 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);