?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.34-rc3
[pohmelfs.git] / drivers / media / video / v4l2-common.c
blob36b5cb86fb57c10e9786d51d5e4b13aef0ed5a91
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@lxorguk.ukuu.org.uk>
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-device.h>
62 #include <media/v4l2-chip-ident.h>
63
64 #include <linux/videodev2.h>
65
66 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
67 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
68 MODULE_LICENSE("GPL");
69
70 /*
71 *
72 * V 4 L 2 D R I V E R H E L P E R A P I
73 *
74 */
75
76 /*
77 * Video Standard Operations (contributed by Michael Schimek)
78 */
79
80
81 /* ----------------------------------------------------------------- */
82 /* priority handling */
83
84 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \
85 val == V4L2_PRIORITY_INTERACTIVE || \
86 val == V4L2_PRIORITY_RECORD)
87
88 int v4l2_prio_init(struct v4l2_prio_state *global)
89 {
90 memset(global,0,sizeof(*global));
91 return 0;
92 }
93 EXPORT_SYMBOL(v4l2_prio_init);
94
95 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
96 enum v4l2_priority new)
97 {
98 if (!V4L2_PRIO_VALID(new))
99 return -EINVAL;
100 if (*local == new)
101 return 0;
102
103 atomic_inc(&global->prios[new]);
104 if (V4L2_PRIO_VALID(*local))
105 atomic_dec(&global->prios[*local]);
106 *local = new;
107 return 0;
108 }
109 EXPORT_SYMBOL(v4l2_prio_change);
110
111 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
112 {
113 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
114 }
115 EXPORT_SYMBOL(v4l2_prio_open);
116
117 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
118 {
119 if (V4L2_PRIO_VALID(*local))
120 atomic_dec(&global->prios[*local]);
121 return 0;
122 }
123 EXPORT_SYMBOL(v4l2_prio_close);
124
125 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
126 {
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;
134 }
135 EXPORT_SYMBOL(v4l2_prio_max);
136
137 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
138 {
139 if (*local < v4l2_prio_max(global))
140 return -EBUSY;
141 return 0;
142 }
143 EXPORT_SYMBOL(v4l2_prio_check);
144
145 /* ----------------------------------------------------------------- */
146
147 /* Helper functions for control handling */
148
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)
154 {
155 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
156 return -EINVAL;
157 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
158 return -EBUSY;
159 if (qctrl->type == V4L2_CTRL_TYPE_STRING)
160 return 0;
161 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
162 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
163 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
164 return 0;
165 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
166 return -ERANGE;
167 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
168 if (menu_items[ctrl->value] == NULL ||
169 menu_items[ctrl->value][0] == '\0')
170 return -EINVAL;
171 }
172 return 0;
173 }
174 EXPORT_SYMBOL(v4l2_ctrl_check);
175
176 /* Returns NULL or a character pointer array containing the menu for
177 the given control ID. The pointer array ends with a NULL pointer.
178 An empty string signifies a menu entry that is invalid. This allows
179 drivers to disable certain options if it is not supported. */
180 const char **v4l2_ctrl_get_menu(u32 id)
181 {
182 static const char *mpeg_audio_sampling_freq[] = {
183 "44.1 kHz",
184 "48 kHz",
185 "32 kHz",
186 NULL
187 };
188 static const char *mpeg_audio_encoding[] = {
189 "MPEG-1/2 Layer I",
190 "MPEG-1/2 Layer II",
191 "MPEG-1/2 Layer III",
192 "MPEG-2/4 AAC",
193 "AC-3",
194 NULL
195 };
196 static const char *mpeg_audio_l1_bitrate[] = {
197 "32 kbps",
198 "64 kbps",
199 "96 kbps",
200 "128 kbps",
201 "160 kbps",
202 "192 kbps",
203 "224 kbps",
204 "256 kbps",
205 "288 kbps",
206 "320 kbps",
207 "352 kbps",
208 "384 kbps",
209 "416 kbps",
210 "448 kbps",
211 NULL
212 };
213 static const char *mpeg_audio_l2_bitrate[] = {
214 "32 kbps",
215 "48 kbps",
216 "56 kbps",
217 "64 kbps",
218 "80 kbps",
219 "96 kbps",
220 "112 kbps",
221 "128 kbps",
222 "160 kbps",
223 "192 kbps",
224 "224 kbps",
225 "256 kbps",
226 "320 kbps",
227 "384 kbps",
228 NULL
229 };
230 static const char *mpeg_audio_l3_bitrate[] = {
231 "32 kbps",
232 "40 kbps",
233 "48 kbps",
234 "56 kbps",
235 "64 kbps",
236 "80 kbps",
237 "96 kbps",
238 "112 kbps",
239 "128 kbps",
240 "160 kbps",
241 "192 kbps",
242 "224 kbps",
243 "256 kbps",
244 "320 kbps",
245 NULL
246 };
247 static const char *mpeg_audio_ac3_bitrate[] = {
248 "32 kbps",
249 "40 kbps",
250 "48 kbps",
251 "56 kbps",
252 "64 kbps",
253 "80 kbps",
254 "96 kbps",
255 "112 kbps",
256 "128 kbps",
257 "160 kbps",
258 "192 kbps",
259 "224 kbps",
260 "256 kbps",
261 "320 kbps",
262 "384 kbps",
263 "448 kbps",
264 "512 kbps",
265 "576 kbps",
266 "640 kbps",
267 NULL
268 };
269 static const char *mpeg_audio_mode[] = {
270 "Stereo",
271 "Joint Stereo",
272 "Dual",
273 "Mono",
274 NULL
275 };
276 static const char *mpeg_audio_mode_extension[] = {
277 "Bound 4",
278 "Bound 8",
279 "Bound 12",
280 "Bound 16",
281 NULL
282 };
283 static const char *mpeg_audio_emphasis[] = {
284 "No Emphasis",
285 "50/15 us",
286 "CCITT J17",
287 NULL
288 };
289 static const char *mpeg_audio_crc[] = {
290 "No CRC",
291 "16-bit CRC",
292 NULL
293 };
294 static const char *mpeg_video_encoding[] = {
295 "MPEG-1",
296 "MPEG-2",
297 "MPEG-4 AVC",
298 NULL
299 };
300 static const char *mpeg_video_aspect[] = {
301 "1x1",
302 "4x3",
303 "16x9",
304 "2.21x1",
305 NULL
306 };
307 static const char *mpeg_video_bitrate_mode[] = {
308 "Variable Bitrate",
309 "Constant Bitrate",
310 NULL
311 };
312 static const char *mpeg_stream_type[] = {
313 "MPEG-2 Program Stream",
314 "MPEG-2 Transport Stream",
315 "MPEG-1 System Stream",
316 "MPEG-2 DVD-compatible Stream",
317 "MPEG-1 VCD-compatible Stream",
318 "MPEG-2 SVCD-compatible Stream",
319 NULL
320 };
321 static const char *mpeg_stream_vbi_fmt[] = {
322 "No VBI",
323 "Private packet, IVTV format",
324 NULL
325 };
326 static const char *camera_power_line_frequency[] = {
327 "Disabled",
328 "50 Hz",
329 "60 Hz",
330 NULL
331 };
332 static const char *camera_exposure_auto[] = {
333 "Auto Mode",
334 "Manual Mode",
335 "Shutter Priority Mode",
336 "Aperture Priority Mode",
337 NULL
338 };
339 static const char *colorfx[] = {
340 "None",
341 "Black & White",
342 "Sepia",
343 NULL
344 };
345 static const char *tune_preemphasis[] = {
346 "No preemphasis",
347 "50 useconds",
348 "75 useconds",
349 NULL,
350 };
351
352 switch (id) {
353 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
354 return mpeg_audio_sampling_freq;
355 case V4L2_CID_MPEG_AUDIO_ENCODING:
356 return mpeg_audio_encoding;
357 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
358 return mpeg_audio_l1_bitrate;
359 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
360 return mpeg_audio_l2_bitrate;
361 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
362 return mpeg_audio_l3_bitrate;
363 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
364 return mpeg_audio_ac3_bitrate;
365 case V4L2_CID_MPEG_AUDIO_MODE:
366 return mpeg_audio_mode;
367 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
368 return mpeg_audio_mode_extension;
369 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
370 return mpeg_audio_emphasis;
371 case V4L2_CID_MPEG_AUDIO_CRC:
372 return mpeg_audio_crc;
373 case V4L2_CID_MPEG_VIDEO_ENCODING:
374 return mpeg_video_encoding;
375 case V4L2_CID_MPEG_VIDEO_ASPECT:
376 return mpeg_video_aspect;
377 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
378 return mpeg_video_bitrate_mode;
379 case V4L2_CID_MPEG_STREAM_TYPE:
380 return mpeg_stream_type;
381 case V4L2_CID_MPEG_STREAM_VBI_FMT:
382 return mpeg_stream_vbi_fmt;
383 case V4L2_CID_POWER_LINE_FREQUENCY:
384 return camera_power_line_frequency;
385 case V4L2_CID_EXPOSURE_AUTO:
386 return camera_exposure_auto;
387 case V4L2_CID_COLORFX:
388 return colorfx;
389 case V4L2_CID_TUNE_PREEMPHASIS:
390 return tune_preemphasis;
391 default:
392 return NULL;
393 }
394 }
395 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
396
397 /* Return the control name. */
398 const char *v4l2_ctrl_get_name(u32 id)
399 {
400 switch (id) {
401 /* USER controls */
402 case V4L2_CID_USER_CLASS: return "User Controls";
403 case V4L2_CID_BRIGHTNESS: return "Brightness";
404 case V4L2_CID_CONTRAST: return "Contrast";
405 case V4L2_CID_SATURATION: return "Saturation";
406 case V4L2_CID_HUE: return "Hue";
407 case V4L2_CID_AUDIO_VOLUME: return "Volume";
408 case V4L2_CID_AUDIO_BALANCE: return "Balance";
409 case V4L2_CID_AUDIO_BASS: return "Bass";
410 case V4L2_CID_AUDIO_TREBLE: return "Treble";
411 case V4L2_CID_AUDIO_MUTE: return "Mute";
412 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
413 case V4L2_CID_BLACK_LEVEL: return "Black Level";
414 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
415 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
416 case V4L2_CID_RED_BALANCE: return "Red Balance";
417 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
418 case V4L2_CID_GAMMA: return "Gamma";
419 case V4L2_CID_EXPOSURE: return "Exposure";
420 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
421 case V4L2_CID_GAIN: return "Gain";
422 case V4L2_CID_HFLIP: return "Horizontal Flip";
423 case V4L2_CID_VFLIP: return "Vertical Flip";
424 case V4L2_CID_HCENTER: return "Horizontal Center";
425 case V4L2_CID_VCENTER: return "Vertical Center";
426 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
427 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
428 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
429 case V4L2_CID_SHARPNESS: return "Sharpness";
430 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
431 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
432 case V4L2_CID_COLOR_KILLER: return "Color Killer";
433 case V4L2_CID_COLORFX: return "Color Effects";
434 case V4L2_CID_ROTATE: return "Rotate";
435 case V4L2_CID_BG_COLOR: return "Background color";
436
437 /* MPEG controls */
438 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
439 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
440 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
441 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
442 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
443 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
444 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
445 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
446 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
447 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
448 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
449 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
450 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
451 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
452 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
453 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
454 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
455 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
456 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
457 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
458 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
459 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
460 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
461 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
462 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
463 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
464 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
465 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
466 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
467 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
468 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
469 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
470 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
471
472 /* CAMERA controls */
473 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
474 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
475 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
476 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
477 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
478 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
479 case V4L2_CID_PAN_RESET: return "Pan, Reset";
480 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
481 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
482 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
483 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
484 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
485 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic";
486 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
487 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
488 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
489 case V4L2_CID_PRIVACY: return "Privacy";
490
491 /* FM Radio Modulator control */
492 case V4L2_CID_FM_TX_CLASS: return "FM Radio Modulator Controls";
493 case V4L2_CID_RDS_TX_DEVIATION: return "RDS Signal Deviation";
494 case V4L2_CID_RDS_TX_PI: return "RDS Program ID";
495 case V4L2_CID_RDS_TX_PTY: return "RDS Program Type";
496 case V4L2_CID_RDS_TX_PS_NAME: return "RDS PS Name";
497 case V4L2_CID_RDS_TX_RADIO_TEXT: return "RDS Radio Text";
498 case V4L2_CID_AUDIO_LIMITER_ENABLED: return "Audio Limiter Feature Enabled";
499 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: return "Audio Limiter Release Time";
500 case V4L2_CID_AUDIO_LIMITER_DEVIATION: return "Audio Limiter Deviation";
501 case V4L2_CID_AUDIO_COMPRESSION_ENABLED: return "Audio Compression Feature Enabled";
502 case V4L2_CID_AUDIO_COMPRESSION_GAIN: return "Audio Compression Gain";
503 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: return "Audio Compression Threshold";
504 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: return "Audio Compression Attack Time";
505 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: return "Audio Compression Release Time";
506 case V4L2_CID_PILOT_TONE_ENABLED: return "Pilot Tone Feature Enabled";
507 case V4L2_CID_PILOT_TONE_DEVIATION: return "Pilot Tone Deviation";
508 case V4L2_CID_PILOT_TONE_FREQUENCY: return "Pilot Tone Frequency";
509 case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings";
510 case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level";
511 case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor";
512
513 default:
514 return NULL;
515 }
516 }
517 EXPORT_SYMBOL(v4l2_ctrl_get_name);
518
519 /* Fill in a struct v4l2_queryctrl */
520 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
521 {
522 const char *name = v4l2_ctrl_get_name(qctrl->id);
523
524 qctrl->flags = 0;
525 if (name == NULL)
526 return -EINVAL;
527
528 switch (qctrl->id) {
529 case V4L2_CID_AUDIO_MUTE:
530 case V4L2_CID_AUDIO_LOUDNESS:
531 case V4L2_CID_AUTO_WHITE_BALANCE:
532 case V4L2_CID_AUTOGAIN:
533 case V4L2_CID_HFLIP:
534 case V4L2_CID_VFLIP:
535 case V4L2_CID_HUE_AUTO:
536 case V4L2_CID_CHROMA_AGC:
537 case V4L2_CID_COLOR_KILLER:
538 case V4L2_CID_MPEG_AUDIO_MUTE:
539 case V4L2_CID_MPEG_VIDEO_MUTE:
540 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
541 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
542 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
543 case V4L2_CID_FOCUS_AUTO:
544 case V4L2_CID_PRIVACY:
545 case V4L2_CID_AUDIO_LIMITER_ENABLED:
546 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
547 case V4L2_CID_PILOT_TONE_ENABLED:
548 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
549 min = 0;
550 max = step = 1;
551 break;
552 case V4L2_CID_PAN_RESET:
553 case V4L2_CID_TILT_RESET:
554 qctrl->type = V4L2_CTRL_TYPE_BUTTON;
555 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
556 min = max = step = def = 0;
557 break;
558 case V4L2_CID_POWER_LINE_FREQUENCY:
559 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
560 case V4L2_CID_MPEG_AUDIO_ENCODING:
561 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
562 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
563 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
564 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
565 case V4L2_CID_MPEG_AUDIO_MODE:
566 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
567 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
568 case V4L2_CID_MPEG_AUDIO_CRC:
569 case V4L2_CID_MPEG_VIDEO_ENCODING:
570 case V4L2_CID_MPEG_VIDEO_ASPECT:
571 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
572 case V4L2_CID_MPEG_STREAM_TYPE:
573 case V4L2_CID_MPEG_STREAM_VBI_FMT:
574 case V4L2_CID_EXPOSURE_AUTO:
575 case V4L2_CID_COLORFX:
576 case V4L2_CID_TUNE_PREEMPHASIS:
577 qctrl->type = V4L2_CTRL_TYPE_MENU;
578 step = 1;
579 break;
580 case V4L2_CID_RDS_TX_PS_NAME:
581 case V4L2_CID_RDS_TX_RADIO_TEXT:
582 qctrl->type = V4L2_CTRL_TYPE_STRING;
583 break;
584 case V4L2_CID_USER_CLASS:
585 case V4L2_CID_CAMERA_CLASS:
586 case V4L2_CID_MPEG_CLASS:
587 case V4L2_CID_FM_TX_CLASS:
588 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
589 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
590 min = max = step = def = 0;
591 break;
592 case V4L2_CID_BG_COLOR:
593 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
594 step = 1;
595 min = 0;
596 /* Max is calculated as RGB888 that is 2^24 */
597 max = 0xFFFFFF;
598 break;
599 default:
600 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
601 break;
602 }
603 switch (qctrl->id) {
604 case V4L2_CID_MPEG_AUDIO_ENCODING:
605 case V4L2_CID_MPEG_AUDIO_MODE:
606 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
607 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
608 case V4L2_CID_MPEG_STREAM_TYPE:
609 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
610 break;
611 case V4L2_CID_AUDIO_VOLUME:
612 case V4L2_CID_AUDIO_BALANCE:
613 case V4L2_CID_AUDIO_BASS:
614 case V4L2_CID_AUDIO_TREBLE:
615 case V4L2_CID_BRIGHTNESS:
616 case V4L2_CID_CONTRAST:
617 case V4L2_CID_SATURATION:
618 case V4L2_CID_HUE:
619 case V4L2_CID_RED_BALANCE:
620 case V4L2_CID_BLUE_BALANCE:
621 case V4L2_CID_GAMMA:
622 case V4L2_CID_SHARPNESS:
623 case V4L2_CID_RDS_TX_DEVIATION:
624 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
625 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
626 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
627 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
628 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
629 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
630 case V4L2_CID_PILOT_TONE_DEVIATION:
631 case V4L2_CID_PILOT_TONE_FREQUENCY:
632 case V4L2_CID_TUNE_POWER_LEVEL:
633 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
634 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
635 break;
636 case V4L2_CID_PAN_RELATIVE:
637 case V4L2_CID_TILT_RELATIVE:
638 case V4L2_CID_FOCUS_RELATIVE:
639 case V4L2_CID_ZOOM_RELATIVE:
640 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
641 break;
642 }
643 qctrl->minimum = min;
644 qctrl->maximum = max;
645 qctrl->step = step;
646 qctrl->default_value = def;
647 qctrl->reserved[0] = qctrl->reserved[1] = 0;
648 strlcpy(qctrl->name, name, sizeof(qctrl->name));
649 return 0;
650 }
651 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
652
653 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
654 the menu. The qctrl pointer may be NULL, in which case it is ignored.
655 If menu_items is NULL, then the menu items are retrieved using
656 v4l2_ctrl_get_menu. */
657 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
658 const char **menu_items)
659 {
660 int i;
661
662 qmenu->reserved = 0;
663 if (menu_items == NULL)
664 menu_items = v4l2_ctrl_get_menu(qmenu->id);
665 if (menu_items == NULL ||
666 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
667 return -EINVAL;
668 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
669 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
670 return -EINVAL;
671 strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
672 return 0;
673 }
674 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
675
676 /* Fill in a struct v4l2_querymenu based on the specified array of valid
677 menu items (terminated by V4L2_CTRL_MENU_IDS_END).
678 Use this if there are 'holes' in the list of valid menu items. */
679 int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
680 {
681 const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
682
683 qmenu->reserved = 0;
684 if (menu_items == NULL || ids == NULL)
685 return -EINVAL;
686 while (*ids != V4L2_CTRL_MENU_IDS_END) {
687 if (*ids++ == qmenu->index) {
688 strlcpy(qmenu->name, menu_items[qmenu->index],
689 sizeof(qmenu->name));
690 return 0;
691 }
692 }
693 return -EINVAL;
694 }
695 EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
696
697 /* ctrl_classes points to an array of u32 pointers, the last element is
698 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
699 Each array must be sorted low to high and belong to the same control
700 class. The array of u32 pointers must also be sorted, from low class IDs
701 to high class IDs.
702
703 This function returns the first ID that follows after the given ID.
704 When no more controls are available 0 is returned. */
705 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
706 {
707 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
708 const u32 *pctrl;
709
710 if (ctrl_classes == NULL)
711 return 0;
712
713 /* if no query is desired, then check if the ID is part of ctrl_classes */
714 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
715 /* find class */
716 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
717 ctrl_classes++;
718 if (*ctrl_classes == NULL)
719 return 0;
720 pctrl = *ctrl_classes;
721 /* find control ID */
722 while (*pctrl && *pctrl != id) pctrl++;
723 return *pctrl ? id : 0;
724 }
725 id &= V4L2_CTRL_ID_MASK;
726 id++; /* select next control */
727 /* find first class that matches (or is greater than) the class of
728 the ID */
729 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
730 ctrl_classes++;
731 /* no more classes */
732 if (*ctrl_classes == NULL)
733 return 0;
734 pctrl = *ctrl_classes;
735 /* find first ctrl within the class that is >= ID */
736 while (*pctrl && *pctrl < id) pctrl++;
737 if (*pctrl)
738 return *pctrl;
739 /* we are at the end of the controls of the current class. */
740 /* continue with next class if available */
741 ctrl_classes++;
742 if (*ctrl_classes == NULL)
743 return 0;
744 return **ctrl_classes;
745 }
746 EXPORT_SYMBOL(v4l2_ctrl_next);
747
748 int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
749 {
750 switch (match->type) {
751 case V4L2_CHIP_MATCH_HOST:
752 return match->addr == 0;
753 default:
754 return 0;
755 }
756 }
757 EXPORT_SYMBOL(v4l2_chip_match_host);
758
759 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
760 int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
761 {
762 int len;
763
764 if (c == NULL || match == NULL)
765 return 0;
766
767 switch (match->type) {
768 case V4L2_CHIP_MATCH_I2C_DRIVER:
769 if (c->driver == NULL || c->driver->driver.name == NULL)
770 return 0;
771 len = strlen(c->driver->driver.name);
772 /* legacy drivers have a ' suffix, don't try to match that */
773 if (len && c->driver->driver.name[len - 1] == '\'')
774 len--;
775 return len && !strncmp(c->driver->driver.name, match->name, len);
776 case V4L2_CHIP_MATCH_I2C_ADDR:
777 return c->addr == match->addr;
778 default:
779 return 0;
780 }
781 }
782 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
783
784 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
785 u32 ident, u32 revision)
786 {
787 if (!v4l2_chip_match_i2c_client(c, &chip->match))
788 return 0;
789 if (chip->ident == V4L2_IDENT_NONE) {
790 chip->ident = ident;
791 chip->revision = revision;
792 }
793 else {
794 chip->ident = V4L2_IDENT_AMBIGUOUS;
795 chip->revision = 0;
796 }
797 return 0;
798 }
799 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
800
801 /* ----------------------------------------------------------------- */
802
803 /* I2C Helper functions */
804
805
806 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
807 const struct v4l2_subdev_ops *ops)
808 {
809 v4l2_subdev_init(sd, ops);
810 sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
811 /* the owner is the same as the i2c_client's driver owner */
812 sd->owner = client->driver->driver.owner;
813 /* i2c_client and v4l2_subdev point to one another */
814 v4l2_set_subdevdata(sd, client);
815 i2c_set_clientdata(client, sd);
816 /* initialize name */
817 snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
818 client->driver->driver.name, i2c_adapter_id(client->adapter),
819 client->addr);
820 }
821 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
822
823
824
825 /* Load an i2c sub-device. */
826 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
827 struct i2c_adapter *adapter, const char *module_name,
828 struct i2c_board_info *info, const unsigned short *probe_addrs)
829 {
830 struct v4l2_subdev *sd = NULL;
831 struct i2c_client *client;
832
833 BUG_ON(!v4l2_dev);
834
835 if (module_name)
836 request_module(module_name);
837
838 /* Create the i2c client */
839 if (info->addr == 0 && probe_addrs)
840 client = i2c_new_probed_device(adapter, info, probe_addrs);
841 else
842 client = i2c_new_device(adapter, info);
843
844 /* Note: by loading the module first we are certain that c->driver
845 will be set if the driver was found. If the module was not loaded
846 first, then the i2c core tries to delay-load the module for us,
847 and then c->driver is still NULL until the module is finally
848 loaded. This delay-load mechanism doesn't work if other drivers
849 want to use the i2c device, so explicitly loading the module
850 is the best alternative. */
851 if (client == NULL || client->driver == NULL)
852 goto error;
853
854 /* Lock the module so we can safely get the v4l2_subdev pointer */
855 if (!try_module_get(client->driver->driver.owner))
856 goto error;
857 sd = i2c_get_clientdata(client);
858
859 /* Register with the v4l2_device which increases the module's
860 use count as well. */
861 if (v4l2_device_register_subdev(v4l2_dev, sd))
862 sd = NULL;
863 /* Decrease the module use count to match the first try_module_get. */
864 module_put(client->driver->driver.owner);
865
866 if (sd) {
867 /* We return errors from v4l2_subdev_call only if we have the
868 callback as the .s_config is not mandatory */
869 int err = v4l2_subdev_call(sd, core, s_config,
870 info->irq, info->platform_data);
871
872 if (err && err != -ENOIOCTLCMD) {
873 v4l2_device_unregister_subdev(sd);
874 sd = NULL;
875 }
876 }
877
878 error:
879 /* If we have a client but no subdev, then something went wrong and
880 we must unregister the client. */
881 if (client && sd == NULL)
882 i2c_unregister_device(client);
883 return sd;
884 }
885 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
886
887 struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
888 struct i2c_adapter *adapter,
889 const char *module_name, const char *client_type,
890 int irq, void *platform_data,
891 u8 addr, const unsigned short *probe_addrs)
892 {
893 struct i2c_board_info info;
894
895 /* Setup the i2c board info with the device type and
896 the device address. */
897 memset(&info, 0, sizeof(info));
898 strlcpy(info.type, client_type, sizeof(info.type));
899 info.addr = addr;
900 info.irq = irq;
901 info.platform_data = platform_data;
902
903 return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, module_name,
904 &info, probe_addrs);
905 }
906 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_cfg);
907
908 /* Return i2c client address of v4l2_subdev. */
909 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
910 {
911 struct i2c_client *client = v4l2_get_subdevdata(sd);
912
913 return client ? client->addr : I2C_CLIENT_END;
914 }
915 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
916
917 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
918 addresses are unknown. */
919 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
920 {
921 static const unsigned short radio_addrs[] = {
922 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
923 0x10,
924 #endif
925 0x60,
926 I2C_CLIENT_END
927 };
928 static const unsigned short demod_addrs[] = {
929 0x42, 0x43, 0x4a, 0x4b,
930 I2C_CLIENT_END
931 };
932 static const unsigned short tv_addrs[] = {
933 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
934 0x60, 0x61, 0x62, 0x63, 0x64,
935 I2C_CLIENT_END
936 };
937
938 switch (type) {
939 case ADDRS_RADIO:
940 return radio_addrs;
941 case ADDRS_DEMOD:
942 return demod_addrs;
943 case ADDRS_TV:
944 return tv_addrs;
945 case ADDRS_TV_WITH_DEMOD:
946 return tv_addrs + 4;
947 }
948 return NULL;
949 }
950 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
951
952 #endif /* defined(CONFIG_I2C) */
953
954 /* Clamp x to be between min and max, aligned to a multiple of 2^align. min
955 * and max don't have to be aligned, but there must be at least one valid
956 * value. E.g., min=17,max=31,align=4 is not allowed as there are no multiples
957 * of 16 between 17 and 31. */
958 static unsigned int clamp_align(unsigned int x, unsigned int min,
959 unsigned int max, unsigned int align)
960 {
961 /* Bits that must be zero to be aligned */
962 unsigned int mask = ~((1 << align) - 1);
963
964 /* Round to nearest aligned value */
965 if (align)
966 x = (x + (1 << (align - 1))) & mask;
967
968 /* Clamp to aligned value of min and max */
969 if (x < min)
970 x = (min + ~mask) & mask;
971 else if (x > max)
972 x = max & mask;
973
974 return x;
975 }
976
977 /* Bound an image to have a width between wmin and wmax, and height between
978 * hmin and hmax, inclusive. Additionally, the width will be a multiple of
979 * 2^walign, the height will be a multiple of 2^halign, and the overall size
980 * (width*height) will be a multiple of 2^salign. The image may be shrunk
981 * or enlarged to fit the alignment constraints.
982 *
983 * The width or height maximum must not be smaller than the corresponding
984 * minimum. The alignments must not be so high there are no possible image
985 * sizes within the allowed bounds. wmin and hmin must be at least 1
986 * (don't use 0). If you don't care about a certain alignment, specify 0,
987 * as 2^0 is 1 and one byte alignment is equivalent to no alignment. If
988 * you only want to adjust downward, specify a maximum that's the same as
989 * the initial value.
990 */
991 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
992 unsigned int walign,
993 u32 *h, unsigned int hmin, unsigned int hmax,
994 unsigned int halign, unsigned int salign)
995 {
996 *w = clamp_align(*w, wmin, wmax, walign);
997 *h = clamp_align(*h, hmin, hmax, halign);
998
999 /* Usually we don't need to align the size and are done now. */
1000 if (!salign)
1001 return;
1002
1003 /* How much alignment do we have? */
1004 walign = __ffs(*w);
1005 halign = __ffs(*h);
1006 /* Enough to satisfy the image alignment? */
1007 if (walign + halign < salign) {
1008 /* Max walign where there is still a valid width */
1009 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
1010 /* Max halign where there is still a valid height */
1011 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
1012
1013 /* up the smaller alignment until we have enough */
1014 do {
1015 if (halign >= hmaxa ||
1016 (walign <= halign && walign < wmaxa)) {
1017 *w = clamp_align(*w, wmin, wmax, walign + 1);
1018 walign = __ffs(*w);
1019 } else {
1020 *h = clamp_align(*h, hmin, hmax, halign + 1);
1021 halign = __ffs(*h);
1022 }
1023 } while (halign + walign < salign);
1024 }
1025 }
1026 EXPORT_SYMBOL_GPL(v4l_bound_align_image);
1027
1028 /**
1029 * v4l_fill_dv_preset_info - fill description of a digital video preset
1030 * @preset - preset value
1031 * @info - pointer to struct v4l2_dv_enum_preset
1032 *
1033 * drivers can use this helper function to fill description of dv preset
1034 * in info.
1035 */
1036 int v4l_fill_dv_preset_info(u32 preset, struct v4l2_dv_enum_preset *info)
1037 {
1038 static const struct v4l2_dv_preset_info {
1039 u16 width;
1040 u16 height;
1041 const char *name;
1042 } dv_presets[] = {
1043 { 0, 0, "Invalid" }, /* V4L2_DV_INVALID */
1044 { 720, 480, "480p@59.94" }, /* V4L2_DV_480P59_94 */
1045 { 720, 576, "576p@50" }, /* V4L2_DV_576P50 */
1046 { 1280, 720, "720p@24" }, /* V4L2_DV_720P24 */
1047 { 1280, 720, "720p@25" }, /* V4L2_DV_720P25 */
1048 { 1280, 720, "720p@30" }, /* V4L2_DV_720P30 */
1049 { 1280, 720, "720p@50" }, /* V4L2_DV_720P50 */
1050 { 1280, 720, "720p@59.94" }, /* V4L2_DV_720P59_94 */
1051 { 1280, 720, "720p@60" }, /* V4L2_DV_720P60 */
1052 { 1920, 1080, "1080i@29.97" }, /* V4L2_DV_1080I29_97 */
1053 { 1920, 1080, "1080i@30" }, /* V4L2_DV_1080I30 */
1054 { 1920, 1080, "1080i@25" }, /* V4L2_DV_1080I25 */
1055 { 1920, 1080, "1080i@50" }, /* V4L2_DV_1080I50 */
1056 { 1920, 1080, "1080i@60" }, /* V4L2_DV_1080I60 */
1057 { 1920, 1080, "1080p@24" }, /* V4L2_DV_1080P24 */
1058 { 1920, 1080, "1080p@25" }, /* V4L2_DV_1080P25 */
1059 { 1920, 1080, "1080p@30" }, /* V4L2_DV_1080P30 */
1060 { 1920, 1080, "1080p@50" }, /* V4L2_DV_1080P50 */
1061 { 1920, 1080, "1080p@60" }, /* V4L2_DV_1080P60 */
1062 };
1063
1064 if (info == NULL || preset >= ARRAY_SIZE(dv_presets))
1065 return -EINVAL;
1066
1067 info->preset = preset;
1068 info->width = dv_presets[preset].width;
1069 info->height = dv_presets[preset].height;
1070 strlcpy(info->name, dv_presets[preset].name, sizeof(info->name));
1071 return 0;
1072 }
1073 EXPORT_SYMBOL_GPL(v4l_fill_dv_preset_info);