?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / media / video / v4l2-common.c
blob34deb68ae568fdb910f2d833b1e146a08cad9fdd
1 /*
2 * Video for Linux Two
3 *
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
6 *
7 * This file replaces the videodev.c file that comes with the
8 * regular kernel distribution.
9 *
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.
14 *
15 * Author: Bill Dirks <bill@thedirks.org>
16 * based on code by Alan Cox, <alan@cymru.net>
17 *
18 */
19
20 /*
21 * Video capture interface for Linux
22 *
23 * A generic video device interface for the LINUX operating system
24 * using a set of device structures/vectors for low level operations.
25 *
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.
30 *
31 * Author: Alan Cox, <alan@redhat.com>
32 *
33 * Fixes:
34 */
35
36 /*
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)
45 */
46
47 #include <linux/module.h>
48 #include <linux/types.h>
49 #include <linux/kernel.h>
50 #include <linux/mm.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>
57 #include <asm/io.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-chip-ident.h>
62
63 #ifdef CONFIG_KMOD
64 #include <linux/kmod.h>
65 #endif
66
67 #include <linux/videodev.h>
68
69 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
70 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
71 MODULE_LICENSE("GPL");
72
73 /*
74 *
75 * V 4 L 2 D R I V E R H E L P E R A P I
76 *
77 */
78
79 /*
80 * Video Standard Operations (contributed by Michael Schimek)
81 */
82
83
84 /* ----------------------------------------------------------------- */
85 /* priority handling */
86
87 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \
88 val == V4L2_PRIORITY_INTERACTIVE || \
89 val == V4L2_PRIORITY_RECORD)
90
91 int v4l2_prio_init(struct v4l2_prio_state *global)
92 {
93 memset(global,0,sizeof(*global));
94 return 0;
95 }
96 EXPORT_SYMBOL(v4l2_prio_init);
97
98 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
99 enum v4l2_priority new)
100 {
101 if (!V4L2_PRIO_VALID(new))
102 return -EINVAL;
103 if (*local == new)
104 return 0;
105
106 atomic_inc(&global->prios[new]);
107 if (V4L2_PRIO_VALID(*local))
108 atomic_dec(&global->prios[*local]);
109 *local = new;
110 return 0;
111 }
112 EXPORT_SYMBOL(v4l2_prio_change);
113
114 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
115 {
116 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
117 }
118 EXPORT_SYMBOL(v4l2_prio_open);
119
120 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
121 {
122 if (V4L2_PRIO_VALID(*local))
123 atomic_dec(&global->prios[*local]);
124 return 0;
125 }
126 EXPORT_SYMBOL(v4l2_prio_close);
127
128 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
129 {
130 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
131 return V4L2_PRIORITY_RECORD;
132 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
133 return V4L2_PRIORITY_INTERACTIVE;
134 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
135 return V4L2_PRIORITY_BACKGROUND;
136 return V4L2_PRIORITY_UNSET;
137 }
138 EXPORT_SYMBOL(v4l2_prio_max);
139
140 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
141 {
142 if (*local < v4l2_prio_max(global))
143 return -EBUSY;
144 return 0;
145 }
146 EXPORT_SYMBOL(v4l2_prio_check);
147
148 /* ----------------------------------------------------------------- */
149
150 /* Helper functions for control handling */
151
152 /* Check for correctness of the ctrl's value based on the data from
153 struct v4l2_queryctrl and the available menu items. Note that
154 menu_items may be NULL, in that case it is ignored. */
155 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
156 const char **menu_items)
157 {
158 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
159 return -EINVAL;
160 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
161 return -EBUSY;
162 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
163 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
164 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
165 return 0;
166 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
167 return -ERANGE;
168 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
169 if (menu_items[ctrl->value] == NULL ||
170 menu_items[ctrl->value][0] == '\0')
171 return -EINVAL;
172 }
173 return 0;
174 }
175 EXPORT_SYMBOL(v4l2_ctrl_check);
176
177 /* Returns NULL or a character pointer array containing the menu for
178 the given control ID. The pointer array ends with a NULL pointer.
179 An empty string signifies a menu entry that is invalid. This allows
180 drivers to disable certain options if it is not supported. */
181 const char **v4l2_ctrl_get_menu(u32 id)
182 {
183 static const char *mpeg_audio_sampling_freq[] = {
184 "44.1 kHz",
185 "48 kHz",
186 "32 kHz",
187 NULL
188 };
189 static const char *mpeg_audio_encoding[] = {
190 "Layer I",
191 "Layer II",
192 "Layer III",
193 NULL
194 };
195 static const char *mpeg_audio_l1_bitrate[] = {
196 "32 kbps",
197 "64 kbps",
198 "96 kbps",
199 "128 kbps",
200 "160 kbps",
201 "192 kbps",
202 "224 kbps",
203 "256 kbps",
204 "288 kbps",
205 "320 kbps",
206 "352 kbps",
207 "384 kbps",
208 "416 kbps",
209 "448 kbps",
210 NULL
211 };
212 static const char *mpeg_audio_l2_bitrate[] = {
213 "32 kbps",
214 "48 kbps",
215 "56 kbps",
216 "64 kbps",
217 "80 kbps",
218 "96 kbps",
219 "112 kbps",
220 "128 kbps",
221 "160 kbps",
222 "192 kbps",
223 "224 kbps",
224 "256 kbps",
225 "320 kbps",
226 "384 kbps",
227 NULL
228 };
229 static const char *mpeg_audio_l3_bitrate[] = {
230 "32 kbps",
231 "40 kbps",
232 "48 kbps",
233 "56 kbps",
234 "64 kbps",
235 "80 kbps",
236 "96 kbps",
237 "112 kbps",
238 "128 kbps",
239 "160 kbps",
240 "192 kbps",
241 "224 kbps",
242 "256 kbps",
243 "320 kbps",
244 NULL
245 };
246 static const char *mpeg_audio_mode[] = {
247 "Stereo",
248 "Joint Stereo",
249 "Dual",
250 "Mono",
251 NULL
252 };
253 static const char *mpeg_audio_mode_extension[] = {
254 "Bound 4",
255 "Bound 8",
256 "Bound 12",
257 "Bound 16",
258 NULL
259 };
260 static const char *mpeg_audio_emphasis[] = {
261 "No Emphasis",
262 "50/15 us",
263 "CCITT J17",
264 NULL
265 };
266 static const char *mpeg_audio_crc[] = {
267 "No CRC",
268 "16-bit CRC",
269 NULL
270 };
271 static const char *mpeg_video_encoding[] = {
272 "MPEG-1",
273 "MPEG-2",
274 NULL
275 };
276 static const char *mpeg_video_aspect[] = {
277 "1x1",
278 "4x3",
279 "16x9",
280 "2.21x1",
281 NULL
282 };
283 static const char *mpeg_video_bitrate_mode[] = {
284 "Variable Bitrate",
285 "Constant Bitrate",
286 NULL
287 };
288 static const char *mpeg_stream_type[] = {
289 "MPEG-2 Program Stream",
290 "MPEG-2 Transport Stream",
291 "MPEG-1 System Stream",
292 "MPEG-2 DVD-compatible Stream",
293 "MPEG-1 VCD-compatible Stream",
294 "MPEG-2 SVCD-compatible Stream",
295 NULL
296 };
297 static const char *mpeg_stream_vbi_fmt[] = {
298 "No VBI",
299 "Private packet, IVTV format",
300 NULL
301 };
302
303 switch (id) {
304 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
305 return mpeg_audio_sampling_freq;
306 case V4L2_CID_MPEG_AUDIO_ENCODING:
307 return mpeg_audio_encoding;
308 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
309 return mpeg_audio_l1_bitrate;
310 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
311 return mpeg_audio_l2_bitrate;
312 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
313 return mpeg_audio_l3_bitrate;
314 case V4L2_CID_MPEG_AUDIO_MODE:
315 return mpeg_audio_mode;
316 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
317 return mpeg_audio_mode_extension;
318 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
319 return mpeg_audio_emphasis;
320 case V4L2_CID_MPEG_AUDIO_CRC:
321 return mpeg_audio_crc;
322 case V4L2_CID_MPEG_VIDEO_ENCODING:
323 return mpeg_video_encoding;
324 case V4L2_CID_MPEG_VIDEO_ASPECT:
325 return mpeg_video_aspect;
326 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
327 return mpeg_video_bitrate_mode;
328 case V4L2_CID_MPEG_STREAM_TYPE:
329 return mpeg_stream_type;
330 case V4L2_CID_MPEG_STREAM_VBI_FMT:
331 return mpeg_stream_vbi_fmt;
332 default:
333 return NULL;
334 }
335 }
336 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
337
338 /* Fill in a struct v4l2_queryctrl */
339 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
340 {
341 const char *name;
342
343 qctrl->flags = 0;
344 switch (qctrl->id) {
345 /* USER controls */
346 case V4L2_CID_USER_CLASS: name = "User Controls"; break;
347 case V4L2_CID_AUDIO_VOLUME: name = "Volume"; break;
348 case V4L2_CID_AUDIO_MUTE: name = "Mute"; break;
349 case V4L2_CID_AUDIO_BALANCE: name = "Balance"; break;
350 case V4L2_CID_AUDIO_BASS: name = "Bass"; break;
351 case V4L2_CID_AUDIO_TREBLE: name = "Treble"; break;
352 case V4L2_CID_AUDIO_LOUDNESS: name = "Loudness"; break;
353 case V4L2_CID_BRIGHTNESS: name = "Brightness"; break;
354 case V4L2_CID_CONTRAST: name = "Contrast"; break;
355 case V4L2_CID_SATURATION: name = "Saturation"; break;
356 case V4L2_CID_HUE: name = "Hue"; break;
357
358 /* MPEG controls */
359 case V4L2_CID_MPEG_CLASS: name = "MPEG Encoder Controls"; break;
360 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
361 case V4L2_CID_MPEG_AUDIO_ENCODING: name = "Audio Encoding Layer"; break;
362 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: name = "Audio Layer I Bitrate"; break;
363 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: name = "Audio Layer II Bitrate"; break;
364 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: name = "Audio Layer III Bitrate"; break;
365 case V4L2_CID_MPEG_AUDIO_MODE: name = "Audio Stereo Mode"; break;
366 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
367 case V4L2_CID_MPEG_AUDIO_EMPHASIS: name = "Audio Emphasis"; break;
368 case V4L2_CID_MPEG_AUDIO_CRC: name = "Audio CRC"; break;
369 case V4L2_CID_MPEG_AUDIO_MUTE: name = "Audio Mute"; break;
370 case V4L2_CID_MPEG_VIDEO_ENCODING: name = "Video Encoding"; break;
371 case V4L2_CID_MPEG_VIDEO_ASPECT: name = "Video Aspect"; break;
372 case V4L2_CID_MPEG_VIDEO_B_FRAMES: name = "Video B Frames"; break;
373 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: name = "Video GOP Size"; break;
374 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: name = "Video GOP Closure"; break;
375 case V4L2_CID_MPEG_VIDEO_PULLDOWN: name = "Video Pulldown"; break;
376 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: name = "Video Bitrate Mode"; break;
377 case V4L2_CID_MPEG_VIDEO_BITRATE: name = "Video Bitrate"; break;
378 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: name = "Video Peak Bitrate"; break;
379 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
380 case V4L2_CID_MPEG_VIDEO_MUTE: name = "Video Mute"; break;
381 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: name = "Video Mute YUV"; break;
382 case V4L2_CID_MPEG_STREAM_TYPE: name = "Stream Type"; break;
383 case V4L2_CID_MPEG_STREAM_PID_PMT: name = "Stream PMT Program ID"; break;
384 case V4L2_CID_MPEG_STREAM_PID_AUDIO: name = "Stream Audio Program ID"; break;
385 case V4L2_CID_MPEG_STREAM_PID_VIDEO: name = "Stream Video Program ID"; break;
386 case V4L2_CID_MPEG_STREAM_PID_PCR: name = "Stream PCR Program ID"; break;
387 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
388 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
389 case V4L2_CID_MPEG_STREAM_VBI_FMT: name = "Stream VBI Format"; break;
390
391 default:
392 return -EINVAL;
393 }
394 switch (qctrl->id) {
395 case V4L2_CID_AUDIO_MUTE:
396 case V4L2_CID_AUDIO_LOUDNESS:
397 case V4L2_CID_MPEG_AUDIO_MUTE:
398 case V4L2_CID_MPEG_VIDEO_MUTE:
399 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
400 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
401 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
402 min = 0;
403 max = step = 1;
404 break;
405 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
406 case V4L2_CID_MPEG_AUDIO_ENCODING:
407 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
408 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
409 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
410 case V4L2_CID_MPEG_AUDIO_MODE:
411 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
412 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
413 case V4L2_CID_MPEG_AUDIO_CRC:
414 case V4L2_CID_MPEG_VIDEO_ENCODING:
415 case V4L2_CID_MPEG_VIDEO_ASPECT:
416 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
417 case V4L2_CID_MPEG_STREAM_TYPE:
418 case V4L2_CID_MPEG_STREAM_VBI_FMT:
419 qctrl->type = V4L2_CTRL_TYPE_MENU;
420 step = 1;
421 break;
422 case V4L2_CID_USER_CLASS:
423 case V4L2_CID_MPEG_CLASS:
424 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
425 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
426 min = max = step = def = 0;
427 break;
428 default:
429 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
430 break;
431 }
432 switch (qctrl->id) {
433 case V4L2_CID_MPEG_AUDIO_ENCODING:
434 case V4L2_CID_MPEG_AUDIO_MODE:
435 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
436 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
437 case V4L2_CID_MPEG_STREAM_TYPE:
438 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
439 break;
440 case V4L2_CID_AUDIO_VOLUME:
441 case V4L2_CID_AUDIO_BALANCE:
442 case V4L2_CID_AUDIO_BASS:
443 case V4L2_CID_AUDIO_TREBLE:
444 case V4L2_CID_BRIGHTNESS:
445 case V4L2_CID_CONTRAST:
446 case V4L2_CID_SATURATION:
447 case V4L2_CID_HUE:
448 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
449 break;
450 }
451 qctrl->minimum = min;
452 qctrl->maximum = max;
453 qctrl->step = step;
454 qctrl->default_value = def;
455 qctrl->reserved[0] = qctrl->reserved[1] = 0;
456 snprintf(qctrl->name, sizeof(qctrl->name), name);
457 return 0;
458 }
459 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
460
461 /* Fill in a struct v4l2_queryctrl with standard values based on
462 the control ID. */
463 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
464 {
465 switch (qctrl->id) {
466 /* USER controls */
467 case V4L2_CID_USER_CLASS:
468 case V4L2_CID_MPEG_CLASS:
469 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
470 case V4L2_CID_AUDIO_VOLUME:
471 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
472 case V4L2_CID_AUDIO_MUTE:
473 case V4L2_CID_AUDIO_LOUDNESS:
474 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
475 case V4L2_CID_AUDIO_BALANCE:
476 case V4L2_CID_AUDIO_BASS:
477 case V4L2_CID_AUDIO_TREBLE:
478 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
479 case V4L2_CID_BRIGHTNESS:
480 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
481 case V4L2_CID_CONTRAST:
482 case V4L2_CID_SATURATION:
483 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
484 case V4L2_CID_HUE:
485 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
486
487 /* MPEG controls */
488 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
489 return v4l2_ctrl_query_fill(qctrl,
490 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
491 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
492 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
493 case V4L2_CID_MPEG_AUDIO_ENCODING:
494 return v4l2_ctrl_query_fill(qctrl,
495 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
496 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
497 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
498 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
499 return v4l2_ctrl_query_fill(qctrl,
500 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
501 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
502 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
503 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
504 return v4l2_ctrl_query_fill(qctrl,
505 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
506 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
507 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
508 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
509 return v4l2_ctrl_query_fill(qctrl,
510 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
511 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
512 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
513 case V4L2_CID_MPEG_AUDIO_MODE:
514 return v4l2_ctrl_query_fill(qctrl,
515 V4L2_MPEG_AUDIO_MODE_STEREO,
516 V4L2_MPEG_AUDIO_MODE_MONO, 1,
517 V4L2_MPEG_AUDIO_MODE_STEREO);
518 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
519 return v4l2_ctrl_query_fill(qctrl,
520 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
521 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
522 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
523 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
524 return v4l2_ctrl_query_fill(qctrl,
525 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
526 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
527 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
528 case V4L2_CID_MPEG_AUDIO_CRC:
529 return v4l2_ctrl_query_fill(qctrl,
530 V4L2_MPEG_AUDIO_CRC_NONE,
531 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
532 V4L2_MPEG_AUDIO_CRC_NONE);
533 case V4L2_CID_MPEG_AUDIO_MUTE:
534 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
535 case V4L2_CID_MPEG_VIDEO_ENCODING:
536 return v4l2_ctrl_query_fill(qctrl,
537 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
538 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
539 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
540 case V4L2_CID_MPEG_VIDEO_ASPECT:
541 return v4l2_ctrl_query_fill(qctrl,
542 V4L2_MPEG_VIDEO_ASPECT_1x1,
543 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
544 V4L2_MPEG_VIDEO_ASPECT_4x3);
545 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
546 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
547 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
548 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
549 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
550 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
551 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
552 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
553 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
554 return v4l2_ctrl_query_fill(qctrl,
555 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
556 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
557 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
558 case V4L2_CID_MPEG_VIDEO_BITRATE:
559 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
560 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
561 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
562 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
563 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
564 case V4L2_CID_MPEG_VIDEO_MUTE:
565 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
566 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */
567 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
568 case V4L2_CID_MPEG_STREAM_TYPE:
569 return v4l2_ctrl_query_fill(qctrl,
570 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
571 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
572 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
573 case V4L2_CID_MPEG_STREAM_PID_PMT:
574 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
575 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
576 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
577 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
578 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
579 case V4L2_CID_MPEG_STREAM_PID_PCR:
580 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
581 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
582 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
583 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
584 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
585 case V4L2_CID_MPEG_STREAM_VBI_FMT:
586 return v4l2_ctrl_query_fill(qctrl,
587 V4L2_MPEG_STREAM_VBI_FMT_NONE,
588 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
589 V4L2_MPEG_STREAM_VBI_FMT_NONE);
590 default:
591 return -EINVAL;
592 }
593 }
594 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
595
596 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
597 the menu. The qctrl pointer may be NULL, in which case it is ignored. */
598 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
599 const char **menu_items)
600 {
601 int i;
602
603 if (menu_items == NULL ||
604 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
605 return -EINVAL;
606 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
607 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
608 return -EINVAL;
609 snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
610 qmenu->reserved = 0;
611 return 0;
612 }
613 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
614
615 /* ctrl_classes points to an array of u32 pointers, the last element is
616 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
617 Each array must be sorted low to high and belong to the same control
618 class. The array of u32 pointer must also be sorted, from low class IDs
619 to high class IDs.
620
621 This function returns the first ID that follows after the given ID.
622 When no more controls are available 0 is returned. */
623 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
624 {
625 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
626 const u32 *pctrl;
627
628 if (ctrl_classes == NULL)
629 return 0;
630
631 /* if no query is desired, then check if the ID is part of ctrl_classes */
632 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
633 /* find class */
634 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
635 ctrl_classes++;
636 if (*ctrl_classes == NULL)
637 return 0;
638 pctrl = *ctrl_classes;
639 /* find control ID */
640 while (*pctrl && *pctrl != id) pctrl++;
641 return *pctrl ? id : 0;
642 }
643 id &= V4L2_CTRL_ID_MASK;
644 id++; /* select next control */
645 /* find first class that matches (or is greater than) the class of
646 the ID */
647 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
648 ctrl_classes++;
649 /* no more classes */
650 if (*ctrl_classes == NULL)
651 return 0;
652 pctrl = *ctrl_classes;
653 /* find first ctrl within the class that is >= ID */
654 while (*pctrl && *pctrl < id) pctrl++;
655 if (*pctrl)
656 return *pctrl;
657 /* we are at the end of the controls of the current class. */
658 /* continue with next class if available */
659 ctrl_classes++;
660 if (*ctrl_classes == NULL)
661 return 0;
662 return **ctrl_classes;
663 }
664 EXPORT_SYMBOL(v4l2_ctrl_next);
665
666 int v4l2_chip_match_host(u32 match_type, u32 match_chip)
667 {
668 switch (match_type) {
669 case V4L2_CHIP_MATCH_HOST:
670 return match_chip == 0;
671 default:
672 return 0;
673 }
674 }
675 EXPORT_SYMBOL(v4l2_chip_match_host);
676
677 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
678 int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip)
679 {
680 switch (match_type) {
681 case V4L2_CHIP_MATCH_I2C_DRIVER:
682 return (c != NULL && c->driver != NULL && c->driver->id == match_chip);
683 case V4L2_CHIP_MATCH_I2C_ADDR:
684 return (c != NULL && c->addr == match_chip);
685 default:
686 return 0;
687 }
688 }
689 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
690
691 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip,
692 u32 ident, u32 revision)
693 {
694 if (!v4l2_chip_match_i2c_client(c, chip->match_type, chip->match_chip))
695 return 0;
696 if (chip->ident == V4L2_IDENT_NONE) {
697 chip->ident = ident;
698 chip->revision = revision;
699 }
700 else {
701 chip->ident = V4L2_IDENT_AMBIGUOUS;
702 chip->revision = 0;
703 }
704 return 0;
705 }
706 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
707
708 /* ----------------------------------------------------------------- */
709
710 /* Helper function for I2C legacy drivers */
711
712 int v4l2_i2c_attach(struct i2c_adapter *adapter, int address, struct i2c_driver *driver,
713 const char *name, int (*probe)(struct i2c_client *))
714 {
715 struct i2c_client *client;
716 int err;
717
718 client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
719 if (client == 0)
720 return -ENOMEM;
721
722 client->addr = address;
723 client->adapter = adapter;
724 client->driver = driver;
725 strlcpy(client->name, name, sizeof(client->name));
726
727 err = probe(client);
728 if (err == 0) {
729 i2c_attach_client(client);
730 } else {
731 kfree(client);
732 }
733 return err != -ENOMEM ? 0 : err;
734 }
735 EXPORT_SYMBOL(v4l2_i2c_attach);
736 #endif
mah project overlay