projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (11670): tuner: remove tuner_i2c_address_check
[deliverable/linux.git] / drivers / media / video / v4l2-common.c
CommitLineData
1da177e4
LT		 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 *
43db48d3 15 * Author: Bill Dirks <bill@thedirks.org>
1da177e4
LT		 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 *
d9b01449 31 * Author: Alan Cox, <alan@lxorguk.ukuu.org.uk>
1da177e4
LT		 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
96de0e25 40 * Iñaki García Etxebarria <garetxe@euskalnet.net>
1da177e4
LT		 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
1da177e4
LT		 47#include <linux/module.h>
48#include <linux/types.h>
49#include <linux/kernel.h>
1da177e4
LT		 50#include <linux/mm.h>
51#include <linux/string.h>
52#include <linux/errno.h>
f3d092b8 53#include <linux/i2c.h>
1da177e4
LT		 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>
401998fa 59#define __OLD_VIDIOC_ /* To allow fixing old calls*/
5e453dc7 60#include <media/v4l2-common.h>
dd99120c 61#include <media/v4l2-device.h>
3434eb7e 62#include <media/v4l2-chip-ident.h>
1da177e4 63
33b687cf 64#include <linux/videodev2.h>
1da177e4
LT		 65
66MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
67MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
68MODULE_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
1da177e4 80
1da177e4
LT		 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
88int v4l2_prio_init(struct v4l2_prio_state *global)
89{
90 memset(global,0,sizeof(*global));
91 return 0;
92}
057596ee 93EXPORT_SYMBOL(v4l2_prio_init);
1da177e4
LT		 94
95int 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}
057596ee 109EXPORT_SYMBOL(v4l2_prio_change);
1da177e4
LT		 110
111int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
112{
113 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
114}
057596ee 115EXPORT_SYMBOL(v4l2_prio_open);
1da177e4
LT		 116
117int 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}
057596ee 123EXPORT_SYMBOL(v4l2_prio_close);
1da177e4
LT		 124
125enum 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}
057596ee 135EXPORT_SYMBOL(v4l2_prio_max);
1da177e4
LT		 136
137int 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}
057596ee 143EXPORT_SYMBOL(v4l2_prio_check);
1da177e4
LT		 144
145/* ----------------------------------------------------------------- */
146
9cb2318b
HV		 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. */
152int 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_BUTTON ||
160 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
161 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
162 return 0;
163 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
164 return -ERANGE;
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')
168 return -EINVAL;
169 }
170 return 0;
171}
057596ee 172EXPORT_SYMBOL(v4l2_ctrl_check);
9cb2318b
HV		 173
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. */
178const char **v4l2_ctrl_get_menu(u32 id)
179{
180 static const char *mpeg_audio_sampling_freq[] = {
181 "44.1 kHz",
182 "48 kHz",
183 "32 kHz",
184 NULL
185 };
186 static const char *mpeg_audio_encoding[] = {
e6b5da88
HV		 187 "MPEG-1/2 Layer I",
188 "MPEG-1/2 Layer II",
189 "MPEG-1/2 Layer III",
190 "MPEG-2/4 AAC",
191 "AC-3",
9cb2318b
HV		 192 NULL
193 };
194 static const char *mpeg_audio_l1_bitrate[] = {
195 "32 kbps",
196 "64 kbps",
197 "96 kbps",
198 "128 kbps",
199 "160 kbps",
200 "192 kbps",
201 "224 kbps",
202 "256 kbps",
203 "288 kbps",
204 "320 kbps",
205 "352 kbps",
206 "384 kbps",
207 "416 kbps",
208 "448 kbps",
209 NULL
210 };
211 static const char *mpeg_audio_l2_bitrate[] = {
212 "32 kbps",
213 "48 kbps",
214 "56 kbps",
215 "64 kbps",
216 "80 kbps",
217 "96 kbps",
218 "112 kbps",
219 "128 kbps",
220 "160 kbps",
221 "192 kbps",
222 "224 kbps",
223 "256 kbps",
224 "320 kbps",
225 "384 kbps",
226 NULL
227 };
228 static const char *mpeg_audio_l3_bitrate[] = {
229 "32 kbps",
230 "40 kbps",
231 "48 kbps",
232 "56 kbps",
233 "64 kbps",
234 "80 kbps",
235 "96 kbps",
236 "112 kbps",
237 "128 kbps",
238 "160 kbps",
239 "192 kbps",
240 "224 kbps",
241 "256 kbps",
242 "320 kbps",
243 NULL
244 };
e6b5da88
HV		 245 static const char *mpeg_audio_ac3_bitrate[] = {
246 "32 kbps",
247 "40 kbps",
248 "48 kbps",
249 "56 kbps",
250 "64 kbps",
251 "80 kbps",
252 "96 kbps",
253 "112 kbps",
254 "128 kbps",
255 "160 kbps",
256 "192 kbps",
257 "224 kbps",
258 "256 kbps",
259 "320 kbps",
260 "384 kbps",
261 "448 kbps",
262 "512 kbps",
263 "576 kbps",
264 "640 kbps",
265 NULL
266 };
9cb2318b
HV		 267 static const char *mpeg_audio_mode[] = {
268 "Stereo",
269 "Joint Stereo",
270 "Dual",
271 "Mono",
272 NULL
273 };
274 static const char *mpeg_audio_mode_extension[] = {
275 "Bound 4",
276 "Bound 8",
277 "Bound 12",
278 "Bound 16",
279 NULL
280 };
281 static const char *mpeg_audio_emphasis[] = {
282 "No Emphasis",
283 "50/15 us",
284 "CCITT J17",
285 NULL
286 };
287 static const char *mpeg_audio_crc[] = {
288 "No CRC",
289 "16-bit CRC",
290 NULL
291 };
292 static const char *mpeg_video_encoding[] = {
293 "MPEG-1",
294 "MPEG-2",
188919ac 295 "MPEG-4 AVC",
9cb2318b
HV		 296 NULL
297 };
298 static const char *mpeg_video_aspect[] = {
299 "1x1",
300 "4x3",
301 "16x9",
302 "2.21x1",
303 NULL
304 };
305 static const char *mpeg_video_bitrate_mode[] = {
306 "Variable Bitrate",
307 "Constant Bitrate",
308 NULL
309 };
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",
317 NULL
318 };
8cbde94b
HV		 319 static const char *mpeg_stream_vbi_fmt[] = {
320 "No VBI",
99523511 321 "Private packet, IVTV format",
8cbde94b
HV		 322 NULL
323 };
74980159
LP		 324 static const char *camera_power_line_frequency[] = {
325 "Disabled",
326 "50 Hz",
327 "60 Hz",
328 NULL
329 };
330 static const char *camera_exposure_auto[] = {
331 "Auto Mode",
332 "Manual Mode",
333 "Shutter Priority Mode",
334 "Aperture Priority Mode",
335 NULL
336 };
11c469e6
HV		 337 static const char *colorfx[] = {
338 "None",
339 "Black & White",
340 "Sepia",
341 NULL
342 };
9cb2318b
HV		 343
344 switch (id) {
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;
e6b5da88
HV		 355 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
356 return mpeg_audio_ac3_bitrate;
9cb2318b
HV		 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;
8cbde94b
HV		 373 case V4L2_CID_MPEG_STREAM_VBI_FMT:
374 return mpeg_stream_vbi_fmt;
74980159
LP		 375 case V4L2_CID_POWER_LINE_FREQUENCY:
376 return camera_power_line_frequency;
377 case V4L2_CID_EXPOSURE_AUTO:
378 return camera_exposure_auto;
11c469e6
HV		 379 case V4L2_CID_COLORFX:
380 return colorfx;
9cb2318b
HV		 381 default:
382 return NULL;
383 }
384}
057596ee 385EXPORT_SYMBOL(v4l2_ctrl_get_menu);
9cb2318b 386
69028d70
HV		 387/* Return the control name. */
388const char *v4l2_ctrl_get_name(u32 id)
9cb2318b 389{
69028d70 390 switch (id) {
9cb2318b 391 /* USER controls */
74980159 392 case V4L2_CID_USER_CLASS: return "User Controls";
81dde91f
HV		 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";
74980159 397 case V4L2_CID_AUDIO_VOLUME: return "Volume";
74980159
LP		 398 case V4L2_CID_AUDIO_BALANCE: return "Balance";
399 case V4L2_CID_AUDIO_BASS: return "Bass";
400 case V4L2_CID_AUDIO_TREBLE: return "Treble";
81dde91f 401 case V4L2_CID_AUDIO_MUTE: return "Mute";
74980159 402 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
74980159
LP		 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";
11c469e6 423 case V4L2_CID_COLORFX: return "Color Effects";
9cb2318b
HV		 424
425 /* MPEG controls */
69028d70
HV		 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";
f723af16 432 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
69028d70
HV		 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";
9cb2318b 459
74980159
LP		 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";
478
9cb2318b 479 default:
69028d70 480 return NULL;
9cb2318b 481 }
69028d70
HV		 482}
483EXPORT_SYMBOL(v4l2_ctrl_get_name);
484
485/* Fill in a struct v4l2_queryctrl */
486int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
487{
488 const char *name = v4l2_ctrl_get_name(qctrl->id);
489
490 qctrl->flags = 0;
491 if (name == NULL)
492 return -EINVAL;
493
9cb2318b
HV		 494 switch (qctrl->id) {
495 case V4L2_CID_AUDIO_MUTE:
496 case V4L2_CID_AUDIO_LOUDNESS:
74980159
LP		 497 case V4L2_CID_AUTO_WHITE_BALANCE:
498 case V4L2_CID_AUTOGAIN:
499 case V4L2_CID_HFLIP:
500 case V4L2_CID_VFLIP:
501 case V4L2_CID_HUE_AUTO:
81dde91f
HV		 502 case V4L2_CID_CHROMA_AGC:
503 case V4L2_CID_COLOR_KILLER:
5eee72e8 504 case V4L2_CID_MPEG_AUDIO_MUTE:
01f1e44f 505 case V4L2_CID_MPEG_VIDEO_MUTE:
9cb2318b
HV		 506 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
507 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
74980159 508 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
81dde91f 509 case V4L2_CID_FOCUS_AUTO:
74980159 510 case V4L2_CID_PRIVACY:
9cb2318b
HV		 511 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
512 min = 0;
513 max = step = 1;
514 break;
81dde91f
HV		 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;
520 break;
74980159 521 case V4L2_CID_POWER_LINE_FREQUENCY:
9cb2318b
HV		 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:
e6b5da88 527 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
9cb2318b
HV		 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:
8cbde94b 536 case V4L2_CID_MPEG_STREAM_VBI_FMT:
74980159 537 case V4L2_CID_EXPOSURE_AUTO:
11c469e6 538 case V4L2_CID_COLORFX:
9cb2318b
HV		 539 qctrl->type = V4L2_CTRL_TYPE_MENU;
540 step = 1;
541 break;
542 case V4L2_CID_USER_CLASS:
74980159 543 case V4L2_CID_CAMERA_CLASS:
9cb2318b
HV		 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;
548 break;
549 default:
550 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
551 break;
552 }
553 switch (qctrl->id) {
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;
560 break;
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:
568 case V4L2_CID_HUE:
81dde91f
HV		 569 case V4L2_CID_RED_BALANCE:
570 case V4L2_CID_BLUE_BALANCE:
571 case V4L2_CID_GAMMA:
8c84cfda 572 case V4L2_CID_SHARPNESS:
9cb2318b
HV		 573 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
574 break;
81dde91f
HV		 575 case V4L2_CID_PAN_RELATIVE:
576 case V4L2_CID_TILT_RELATIVE:
577 case V4L2_CID_FOCUS_RELATIVE:
578 case V4L2_CID_ZOOM_RELATIVE:
579 qctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
580 break;
9cb2318b
HV		 581 }
582 qctrl->minimum = min;
583 qctrl->maximum = max;
584 qctrl->step = step;
585 qctrl->default_value = def;
586 qctrl->reserved[0] = qctrl->reserved[1] = 0;
b634a93f 587 strlcpy(qctrl->name, name, sizeof(qctrl->name));
9cb2318b
HV		 588 return 0;
589}
057596ee 590EXPORT_SYMBOL(v4l2_ctrl_query_fill);
9cb2318b 591
9cb2318b 592/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
e281db58
HV		 593 the menu. The qctrl pointer may be NULL, in which case it is ignored.
594 If menu_items is NULL, then the menu items are retrieved using
595 v4l2_ctrl_get_menu. */
9cb2318b
HV		 596int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
597 const char **menu_items)
598{
599 int i;
600
1e551266 601 qmenu->reserved = 0;
e281db58
HV		 602 if (menu_items == NULL)
603 menu_items = v4l2_ctrl_get_menu(qmenu->id);
9cb2318b
HV		 604 if (menu_items == NULL ||
605 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
606 return -EINVAL;
607 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
608 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
609 return -EINVAL;
b634a93f 610 strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
9cb2318b
HV		 611 return 0;
612}
057596ee 613EXPORT_SYMBOL(v4l2_ctrl_query_menu);
9cb2318b 614
1e551266
HV		 615/* Fill in a struct v4l2_querymenu based on the specified array of valid
616 menu items (terminated by V4L2_CTRL_MENU_IDS_END).
617 Use this if there are 'holes' in the list of valid menu items. */
618int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
619{
620 const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
621
622 qmenu->reserved = 0;
623 if (menu_items == NULL || ids == NULL)
624 return -EINVAL;
625 while (*ids != V4L2_CTRL_MENU_IDS_END) {
626 if (*ids++ == qmenu->index) {
b634a93f
HV		 627 strlcpy(qmenu->name, menu_items[qmenu->index],
628 sizeof(qmenu->name));
1e551266
HV		 629 return 0;
630 }
631 }
632 return -EINVAL;
633}
634EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
635
9cb2318b
HV		 636/* ctrl_classes points to an array of u32 pointers, the last element is
637 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
638 Each array must be sorted low to high and belong to the same control
2ba58894 639 class. The array of u32 pointers must also be sorted, from low class IDs
9cb2318b
HV		 640 to high class IDs.
641
642 This function returns the first ID that follows after the given ID.
643 When no more controls are available 0 is returned. */
644u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
645{
a46c5fbc 646 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
9cb2318b
HV		 647 const u32 *pctrl;
648
9cb2318b
HV		 649 if (ctrl_classes == NULL)
650 return 0;
a46c5fbc
HV		 651
652 /* if no query is desired, then check if the ID is part of ctrl_classes */
653 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
654 /* find class */
655 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
656 ctrl_classes++;
657 if (*ctrl_classes == NULL)
658 return 0;
659 pctrl = *ctrl_classes;
660 /* find control ID */
661 while (*pctrl && *pctrl != id) pctrl++;
662 return *pctrl ? id : 0;
663 }
9cb2318b 664 id &= V4L2_CTRL_ID_MASK;
9cb2318b
HV		 665 id++; /* select next control */
666 /* find first class that matches (or is greater than) the class of
667 the ID */
668 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
669 ctrl_classes++;
670 /* no more classes */
671 if (*ctrl_classes == NULL)
672 return 0;
673 pctrl = *ctrl_classes;
674 /* find first ctrl within the class that is >= ID */
675 while (*pctrl && *pctrl < id) pctrl++;
676 if (*pctrl)
677 return *pctrl;
678 /* we are at the end of the controls of the current class. */
679 /* continue with next class if available */
680 ctrl_classes++;
681 if (*ctrl_classes == NULL)
682 return 0;
683 return **ctrl_classes;
684}
057596ee 685EXPORT_SYMBOL(v4l2_ctrl_next);
9cb2318b 686
aecde8b5 687int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
a9254475 688{
aecde8b5 689 switch (match->type) {
a9254475 690 case V4L2_CHIP_MATCH_HOST:
aecde8b5 691 return match->addr == 0;
a9254475
MCC		 692 default:
693 return 0;
694 }
695}
696EXPORT_SYMBOL(v4l2_chip_match_host);
697
698#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
aecde8b5 699int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
f3d092b8 700{
aecde8b5
HV		 701 int len;
702
703 if (c == NULL || match == NULL)
704 return 0;
705
706 switch (match->type) {
f3d092b8 707 case V4L2_CHIP_MATCH_I2C_DRIVER:
aecde8b5
HV		 708 if (c->driver == NULL || c->driver->driver.name == NULL)
709 return 0;
710 len = strlen(c->driver->driver.name);
711 /* legacy drivers have a ' suffix, don't try to match that */
712 if (len && c->driver->driver.name[len - 1] == '\'')
713 len--;
714 return len && !strncmp(c->driver->driver.name, match->name, len);
f3d092b8 715 case V4L2_CHIP_MATCH_I2C_ADDR:
aecde8b5 716 return c->addr == match->addr;
f3d092b8
HV		 717 default:
718 return 0;
719 }
720}
a9254475 721EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
f3d092b8 722
aecde8b5 723int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
3434eb7e
HV		 724 u32 ident, u32 revision)
725{
aecde8b5 726 if (!v4l2_chip_match_i2c_client(c, &chip->match))
3434eb7e
HV		 727 return 0;
728 if (chip->ident == V4L2_IDENT_NONE) {
729 chip->ident = ident;
730 chip->revision = revision;
731 }
732 else {
733 chip->ident = V4L2_IDENT_AMBIGUOUS;
734 chip->revision = 0;
735 }
736 return 0;
737}
a9254475 738EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
f3d092b8 739
9cb2318b
HV		 740/* ----------------------------------------------------------------- */
741
78a3b4db 742/* I2C Helper functions */
8ffbc655 743
dd99120c
HV		 744
745void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
746 const struct v4l2_subdev_ops *ops)
747{
748 v4l2_subdev_init(sd, ops);
749 /* the owner is the same as the i2c_client's driver owner */
750 sd->owner = client->driver->driver.owner;
751 /* i2c_client and v4l2_subdev point to one another */
752 v4l2_set_subdevdata(sd, client);
753 i2c_set_clientdata(client, sd);
754 /* initialize name */
755 snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
756 client->driver->driver.name, i2c_adapter_id(client->adapter),
757 client->addr);
758}
759EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
760
761
762
e6574f2f
HV		 763/* Load an i2c sub-device. */
764struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
765 struct i2c_adapter *adapter,
dd99120c
HV		 766 const char *module_name, const char *client_type, u8 addr)
767{
dd99120c
HV		 768 struct v4l2_subdev *sd = NULL;
769 struct i2c_client *client;
770 struct i2c_board_info info;
771
e6574f2f 772 BUG_ON(!v4l2_dev);
d64260d5 773
dd99120c
HV		 774 if (module_name)
775 request_module(module_name);
d64260d5 776
dd99120c
HV		 777 /* Setup the i2c board info with the device type and
778 the device address. */
779 memset(&info, 0, sizeof(info));
780 strlcpy(info.type, client_type, sizeof(info.type));
781 info.addr = addr;
782
783 /* Create the i2c client */
784 client = i2c_new_device(adapter, &info);
785 /* Note: it is possible in the future that
786 c->driver is NULL if the driver is still being loaded.
787 We need better support from the kernel so that we
788 can easily wait for the load to finish. */
789 if (client == NULL || client->driver == NULL)
7c026c35 790 goto error;
dd99120c
HV		 791
792 /* Lock the module so we can safely get the v4l2_subdev pointer */
793 if (!try_module_get(client->driver->driver.owner))
7c026c35 794 goto error;
dd99120c
HV		 795 sd = i2c_get_clientdata(client);
796
797 /* Register with the v4l2_device which increases the module's
798 use count as well. */
e6574f2f 799 if (v4l2_device_register_subdev(v4l2_dev, sd))
dd99120c
HV		 800 sd = NULL;
801 /* Decrease the module use count to match the first try_module_get. */
802 module_put(client->driver->driver.owner);
dd99120c 803
7c026c35
HV		 804error:
805 /* If we have a client but no subdev, then something went wrong and
806 we must unregister the client. */
807 if (client && sd == NULL)
808 i2c_unregister_device(client);
809 return sd;
dd99120c
HV		 810}
811EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
812
e6574f2f
HV		 813/* Probe and load an i2c sub-device. */
814struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
815 struct i2c_adapter *adapter,
dd99120c
HV		 816 const char *module_name, const char *client_type,
817 const unsigned short *addrs)
818{
dd99120c
HV		 819 struct v4l2_subdev *sd = NULL;
820 struct i2c_client *client = NULL;
821 struct i2c_board_info info;
822
e6574f2f 823 BUG_ON(!v4l2_dev);
d64260d5 824
dd99120c
HV		 825 if (module_name)
826 request_module(module_name);
d64260d5 827
dd99120c
HV		 828 /* Setup the i2c board info with the device type and
829 the device address. */
830 memset(&info, 0, sizeof(info));
831 strlcpy(info.type, client_type, sizeof(info.type));
832
833 /* Probe and create the i2c client */
834 client = i2c_new_probed_device(adapter, &info, addrs);
835 /* Note: it is possible in the future that
836 c->driver is NULL if the driver is still being loaded.
837 We need better support from the kernel so that we
838 can easily wait for the load to finish. */
839 if (client == NULL || client->driver == NULL)
7c026c35 840 goto error;
dd99120c
HV		 841
842 /* Lock the module so we can safely get the v4l2_subdev pointer */
843 if (!try_module_get(client->driver->driver.owner))
7c026c35 844 goto error;
dd99120c
HV		 845 sd = i2c_get_clientdata(client);
846
847 /* Register with the v4l2_device which increases the module's
848 use count as well. */
e6574f2f 849 if (v4l2_device_register_subdev(v4l2_dev, sd))
dd99120c
HV		 850 sd = NULL;
851 /* Decrease the module use count to match the first try_module_get. */
852 module_put(client->driver->driver.owner);
7c026c35
HV		 853
854error:
855 /* If we have a client but no subdev, then something went wrong and
856 we must unregister the client. */
857 if (client && sd == NULL)
858 i2c_unregister_device(client);
dd99120c
HV		 859 return sd;
860}
861EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev);
862
868f985c
HV		 863struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev,
864 struct i2c_adapter *adapter,
865 const char *module_name, const char *client_type, u8 addr)
866{
867 unsigned short addrs[2] = { addr, I2C_CLIENT_END };
868
869 return v4l2_i2c_new_probed_subdev(v4l2_dev, adapter,
870 module_name, client_type, addrs);
871}
872EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev_addr);
873
ab373190
HV		 874/* Return i2c client address of v4l2_subdev. */
875unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
876{
877 struct i2c_client *client = v4l2_get_subdevdata(sd);
878
879 return client ? client->addr : I2C_CLIENT_END;
880}
881EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
882
c7d29e2f
HV		 883/* Return a list of I2C tuner addresses to probe. Use only if the tuner
884 addresses are unknown. */
885const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
886{
887 static const unsigned short radio_addrs[] = {
888#if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
889 0x10,
890#endif
891 0x60,
892 I2C_CLIENT_END
893 };
894 static const unsigned short demod_addrs[] = {
895 0x42, 0x43, 0x4a, 0x4b,
896 I2C_CLIENT_END
897 };
898 static const unsigned short tv_addrs[] = {
899 0x42, 0x43, 0x4a, 0x4b, /* tda8290 */
416a7aa8 900 0x60, 0x61, 0x62, 0x63, 0x64,
c7d29e2f
HV		 901 I2C_CLIENT_END
902 };
903
904 switch (type) {
905 case ADDRS_RADIO:
906 return radio_addrs;
907 case ADDRS_DEMOD:
908 return demod_addrs;
909 case ADDRS_TV:
910 return tv_addrs;
911 case ADDRS_TV_WITH_DEMOD:
912 return tv_addrs + 4;
913 }
914 return NULL;
915}
916EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
917
a9254475 918#endif
Linux kernel - Deliverables
This page took 0.521749 seconds and 5 git commands to generate.