]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/media/video/v4l2-common.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (9899): v4l2: Add missing control names
[net-next-2.6.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 };
9cb2318b
HV		 337
338 switch (id) {
339 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
340 return mpeg_audio_sampling_freq;
341 case V4L2_CID_MPEG_AUDIO_ENCODING:
342 return mpeg_audio_encoding;
343 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
344 return mpeg_audio_l1_bitrate;
345 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
346 return mpeg_audio_l2_bitrate;
347 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
348 return mpeg_audio_l3_bitrate;
e6b5da88
HV		 349 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
350 return mpeg_audio_ac3_bitrate;
9cb2318b
HV		 351 case V4L2_CID_MPEG_AUDIO_MODE:
352 return mpeg_audio_mode;
353 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
354 return mpeg_audio_mode_extension;
355 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
356 return mpeg_audio_emphasis;
357 case V4L2_CID_MPEG_AUDIO_CRC:
358 return mpeg_audio_crc;
359 case V4L2_CID_MPEG_VIDEO_ENCODING:
360 return mpeg_video_encoding;
361 case V4L2_CID_MPEG_VIDEO_ASPECT:
362 return mpeg_video_aspect;
363 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
364 return mpeg_video_bitrate_mode;
365 case V4L2_CID_MPEG_STREAM_TYPE:
366 return mpeg_stream_type;
8cbde94b
HV		 367 case V4L2_CID_MPEG_STREAM_VBI_FMT:
368 return mpeg_stream_vbi_fmt;
74980159
LP		 369 case V4L2_CID_POWER_LINE_FREQUENCY:
370 return camera_power_line_frequency;
371 case V4L2_CID_EXPOSURE_AUTO:
372 return camera_exposure_auto;
9cb2318b
HV		 373 default:
374 return NULL;
375 }
376}
057596ee 377EXPORT_SYMBOL(v4l2_ctrl_get_menu);
9cb2318b 378
69028d70
HV		 379/* Return the control name. */
380const char *v4l2_ctrl_get_name(u32 id)
9cb2318b 381{
69028d70 382 switch (id) {
9cb2318b 383 /* USER controls */
74980159
LP		 384 case V4L2_CID_USER_CLASS: return "User Controls";
385 case V4L2_CID_AUDIO_VOLUME: return "Volume";
386 case V4L2_CID_AUDIO_MUTE: return "Mute";
387 case V4L2_CID_AUDIO_BALANCE: return "Balance";
388 case V4L2_CID_AUDIO_BASS: return "Bass";
389 case V4L2_CID_AUDIO_TREBLE: return "Treble";
390 case V4L2_CID_AUDIO_LOUDNESS: return "Loudness";
391 case V4L2_CID_BRIGHTNESS: return "Brightness";
392 case V4L2_CID_CONTRAST: return "Contrast";
393 case V4L2_CID_SATURATION: return "Saturation";
394 case V4L2_CID_HUE: return "Hue";
395 case V4L2_CID_BLACK_LEVEL: return "Black Level";
396 case V4L2_CID_AUTO_WHITE_BALANCE: return "White Balance, Automatic";
397 case V4L2_CID_DO_WHITE_BALANCE: return "Do White Balance";
398 case V4L2_CID_RED_BALANCE: return "Red Balance";
399 case V4L2_CID_BLUE_BALANCE: return "Blue Balance";
400 case V4L2_CID_GAMMA: return "Gamma";
401 case V4L2_CID_EXPOSURE: return "Exposure";
402 case V4L2_CID_AUTOGAIN: return "Gain, Automatic";
403 case V4L2_CID_GAIN: return "Gain";
404 case V4L2_CID_HFLIP: return "Horizontal Flip";
405 case V4L2_CID_VFLIP: return "Vertical Flip";
406 case V4L2_CID_HCENTER: return "Horizontal Center";
407 case V4L2_CID_VCENTER: return "Vertical Center";
408 case V4L2_CID_POWER_LINE_FREQUENCY: return "Power Line Frequency";
409 case V4L2_CID_HUE_AUTO: return "Hue, Automatic";
410 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: return "White Balance Temperature";
411 case V4L2_CID_SHARPNESS: return "Sharpness";
412 case V4L2_CID_BACKLIGHT_COMPENSATION: return "Backlight Compensation";
413 case V4L2_CID_CHROMA_AGC: return "Chroma AGC";
414 case V4L2_CID_COLOR_KILLER: return "Color Killer";
9cb2318b
HV		 415
416 /* MPEG controls */
69028d70
HV		 417 case V4L2_CID_MPEG_CLASS: return "MPEG Encoder Controls";
418 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return "Audio Sampling Frequency";
419 case V4L2_CID_MPEG_AUDIO_ENCODING: return "Audio Encoding";
420 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: return "Audio Layer I Bitrate";
421 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: return "Audio Layer II Bitrate";
422 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: return "Audio Layer III Bitrate";
f723af16 423 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE: return "Audio AAC Bitrate";
69028d70
HV		 424 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE: return "Audio AC-3 Bitrate";
425 case V4L2_CID_MPEG_AUDIO_MODE: return "Audio Stereo Mode";
426 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: return "Audio Stereo Mode Extension";
427 case V4L2_CID_MPEG_AUDIO_EMPHASIS: return "Audio Emphasis";
428 case V4L2_CID_MPEG_AUDIO_CRC: return "Audio CRC";
429 case V4L2_CID_MPEG_AUDIO_MUTE: return "Audio Mute";
430 case V4L2_CID_MPEG_VIDEO_ENCODING: return "Video Encoding";
431 case V4L2_CID_MPEG_VIDEO_ASPECT: return "Video Aspect";
432 case V4L2_CID_MPEG_VIDEO_B_FRAMES: return "Video B Frames";
433 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: return "Video GOP Size";
434 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: return "Video GOP Closure";
435 case V4L2_CID_MPEG_VIDEO_PULLDOWN: return "Video Pulldown";
436 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: return "Video Bitrate Mode";
437 case V4L2_CID_MPEG_VIDEO_BITRATE: return "Video Bitrate";
438 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: return "Video Peak Bitrate";
439 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: return "Video Temporal Decimation";
440 case V4L2_CID_MPEG_VIDEO_MUTE: return "Video Mute";
441 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: return "Video Mute YUV";
442 case V4L2_CID_MPEG_STREAM_TYPE: return "Stream Type";
443 case V4L2_CID_MPEG_STREAM_PID_PMT: return "Stream PMT Program ID";
444 case V4L2_CID_MPEG_STREAM_PID_AUDIO: return "Stream Audio Program ID";
445 case V4L2_CID_MPEG_STREAM_PID_VIDEO: return "Stream Video Program ID";
446 case V4L2_CID_MPEG_STREAM_PID_PCR: return "Stream PCR Program ID";
447 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: return "Stream PES Audio ID";
448 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: return "Stream PES Video ID";
449 case V4L2_CID_MPEG_STREAM_VBI_FMT: return "Stream VBI Format";
9cb2318b 450
74980159
LP		 451 /* CAMERA controls */
452 case V4L2_CID_CAMERA_CLASS: return "Camera Controls";
453 case V4L2_CID_EXPOSURE_AUTO: return "Auto Exposure";
454 case V4L2_CID_EXPOSURE_ABSOLUTE: return "Exposure Time, Absolute";
455 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: return "Exposure, Dynamic Framerate";
456 case V4L2_CID_PAN_RELATIVE: return "Pan, Relative";
457 case V4L2_CID_TILT_RELATIVE: return "Tilt, Relative";
458 case V4L2_CID_PAN_RESET: return "Pan, Reset";
459 case V4L2_CID_TILT_RESET: return "Tilt, Reset";
460 case V4L2_CID_PAN_ABSOLUTE: return "Pan, Absolute";
461 case V4L2_CID_TILT_ABSOLUTE: return "Tilt, Absolute";
462 case V4L2_CID_FOCUS_ABSOLUTE: return "Focus, Absolute";
463 case V4L2_CID_FOCUS_RELATIVE: return "Focus, Relative";
464 case V4L2_CID_FOCUS_AUTO: return "Focus, Automatic";
465 case V4L2_CID_ZOOM_ABSOLUTE: return "Zoom, Absolute";
466 case V4L2_CID_ZOOM_RELATIVE: return "Zoom, Relative";
467 case V4L2_CID_ZOOM_CONTINUOUS: return "Zoom, Continuous";
468 case V4L2_CID_PRIVACY: return "Privacy";
469
9cb2318b 470 default:
69028d70 471 return NULL;
9cb2318b 472 }
69028d70
HV		 473}
474EXPORT_SYMBOL(v4l2_ctrl_get_name);
475
476/* Fill in a struct v4l2_queryctrl */
477int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
478{
479 const char *name = v4l2_ctrl_get_name(qctrl->id);
480
481 qctrl->flags = 0;
482 if (name == NULL)
483 return -EINVAL;
484
9cb2318b
HV		 485 switch (qctrl->id) {
486 case V4L2_CID_AUDIO_MUTE:
487 case V4L2_CID_AUDIO_LOUDNESS:
74980159
LP		 488 case V4L2_CID_AUTO_WHITE_BALANCE:
489 case V4L2_CID_AUTOGAIN:
490 case V4L2_CID_HFLIP:
491 case V4L2_CID_VFLIP:
492 case V4L2_CID_HUE_AUTO:
5eee72e8 493 case V4L2_CID_MPEG_AUDIO_MUTE:
01f1e44f 494 case V4L2_CID_MPEG_VIDEO_MUTE:
9cb2318b
HV		 495 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
496 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
74980159
LP		 497 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
498 case V4L2_CID_PRIVACY:
9cb2318b
HV		 499 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
500 min = 0;
501 max = step = 1;
502 break;
74980159 503 case V4L2_CID_POWER_LINE_FREQUENCY:
9cb2318b
HV		 504 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
505 case V4L2_CID_MPEG_AUDIO_ENCODING:
506 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
507 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
508 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
e6b5da88 509 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
9cb2318b
HV		 510 case V4L2_CID_MPEG_AUDIO_MODE:
511 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
512 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
513 case V4L2_CID_MPEG_AUDIO_CRC:
514 case V4L2_CID_MPEG_VIDEO_ENCODING:
515 case V4L2_CID_MPEG_VIDEO_ASPECT:
516 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
517 case V4L2_CID_MPEG_STREAM_TYPE:
8cbde94b 518 case V4L2_CID_MPEG_STREAM_VBI_FMT:
74980159 519 case V4L2_CID_EXPOSURE_AUTO:
9cb2318b
HV		 520 qctrl->type = V4L2_CTRL_TYPE_MENU;
521 step = 1;
522 break;
523 case V4L2_CID_USER_CLASS:
74980159 524 case V4L2_CID_CAMERA_CLASS:
9cb2318b
HV		 525 case V4L2_CID_MPEG_CLASS:
526 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
527 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
528 min = max = step = def = 0;
529 break;
530 default:
531 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
532 break;
533 }
534 switch (qctrl->id) {
535 case V4L2_CID_MPEG_AUDIO_ENCODING:
536 case V4L2_CID_MPEG_AUDIO_MODE:
537 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
538 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
539 case V4L2_CID_MPEG_STREAM_TYPE:
540 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
541 break;
542 case V4L2_CID_AUDIO_VOLUME:
543 case V4L2_CID_AUDIO_BALANCE:
544 case V4L2_CID_AUDIO_BASS:
545 case V4L2_CID_AUDIO_TREBLE:
546 case V4L2_CID_BRIGHTNESS:
547 case V4L2_CID_CONTRAST:
548 case V4L2_CID_SATURATION:
549 case V4L2_CID_HUE:
550 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
551 break;
552 }
553 qctrl->minimum = min;
554 qctrl->maximum = max;
555 qctrl->step = step;
556 qctrl->default_value = def;
557 qctrl->reserved[0] = qctrl->reserved[1] = 0;
558 snprintf(qctrl->name, sizeof(qctrl->name), name);
559 return 0;
560}
057596ee 561EXPORT_SYMBOL(v4l2_ctrl_query_fill);
9cb2318b
HV		 562
563/* Fill in a struct v4l2_queryctrl with standard values based on
564 the control ID. */
565int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
566{
567 switch (qctrl->id) {
568 /* USER controls */
569 case V4L2_CID_USER_CLASS:
570 case V4L2_CID_MPEG_CLASS:
571 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
572 case V4L2_CID_AUDIO_VOLUME:
573 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
574 case V4L2_CID_AUDIO_MUTE:
575 case V4L2_CID_AUDIO_LOUDNESS:
576 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
577 case V4L2_CID_AUDIO_BALANCE:
578 case V4L2_CID_AUDIO_BASS:
579 case V4L2_CID_AUDIO_TREBLE:
580 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
581 case V4L2_CID_BRIGHTNESS:
582 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
583 case V4L2_CID_CONTRAST:
584 case V4L2_CID_SATURATION:
585 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
586 case V4L2_CID_HUE:
587 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
588
589 /* MPEG controls */
590 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
591 return v4l2_ctrl_query_fill(qctrl,
592 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
593 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
594 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
595 case V4L2_CID_MPEG_AUDIO_ENCODING:
596 return v4l2_ctrl_query_fill(qctrl,
597 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
e6b5da88 598 V4L2_MPEG_AUDIO_ENCODING_AC3, 1,
9cb2318b
HV		 599 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
600 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
601 return v4l2_ctrl_query_fill(qctrl,
602 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
603 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
604 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
605 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
606 return v4l2_ctrl_query_fill(qctrl,
607 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
608 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
609 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
610 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
611 return v4l2_ctrl_query_fill(qctrl,
612 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
613 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
614 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
f723af16
HV		 615 case V4L2_CID_MPEG_AUDIO_AAC_BITRATE:
616 return v4l2_ctrl_query_fill(qctrl, 0, 6400, 1, 3200000);
e6b5da88
HV		 617 case V4L2_CID_MPEG_AUDIO_AC3_BITRATE:
618 return v4l2_ctrl_query_fill(qctrl,
619 V4L2_MPEG_AUDIO_AC3_BITRATE_32K,
620 V4L2_MPEG_AUDIO_AC3_BITRATE_640K, 1,
621 V4L2_MPEG_AUDIO_AC3_BITRATE_384K);
9cb2318b
HV		 622 case V4L2_CID_MPEG_AUDIO_MODE:
623 return v4l2_ctrl_query_fill(qctrl,
624 V4L2_MPEG_AUDIO_MODE_STEREO,
625 V4L2_MPEG_AUDIO_MODE_MONO, 1,
626 V4L2_MPEG_AUDIO_MODE_STEREO);
627 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
628 return v4l2_ctrl_query_fill(qctrl,
629 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
630 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
631 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
632 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
633 return v4l2_ctrl_query_fill(qctrl,
634 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
635 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
636 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
637 case V4L2_CID_MPEG_AUDIO_CRC:
638 return v4l2_ctrl_query_fill(qctrl,
639 V4L2_MPEG_AUDIO_CRC_NONE,
640 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
641 V4L2_MPEG_AUDIO_CRC_NONE);
5eee72e8
HV		 642 case V4L2_CID_MPEG_AUDIO_MUTE:
643 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
9cb2318b
HV		 644 case V4L2_CID_MPEG_VIDEO_ENCODING:
645 return v4l2_ctrl_query_fill(qctrl,
646 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
188919ac 647 V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC, 1,
9cb2318b
HV		 648 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
649 case V4L2_CID_MPEG_VIDEO_ASPECT:
650 return v4l2_ctrl_query_fill(qctrl,
651 V4L2_MPEG_VIDEO_ASPECT_1x1,
652 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
653 V4L2_MPEG_VIDEO_ASPECT_4x3);
654 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
655 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
656 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
657 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
658 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
659 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
660 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
661 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
662 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
663 return v4l2_ctrl_query_fill(qctrl,
664 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
665 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
666 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
667 case V4L2_CID_MPEG_VIDEO_BITRATE:
668 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
669 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
670 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
671 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
672 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
5eee72e8
HV		 673 case V4L2_CID_MPEG_VIDEO_MUTE:
674 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
675 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */
676 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
9cb2318b
HV		 677 case V4L2_CID_MPEG_STREAM_TYPE:
678 return v4l2_ctrl_query_fill(qctrl,
679 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
680 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
681 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
682 case V4L2_CID_MPEG_STREAM_PID_PMT:
683 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
684 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
685 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
686 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
687 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
688 case V4L2_CID_MPEG_STREAM_PID_PCR:
689 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
690 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
691 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
692 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
693 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
8cbde94b
HV		 694 case V4L2_CID_MPEG_STREAM_VBI_FMT:
695 return v4l2_ctrl_query_fill(qctrl,
696 V4L2_MPEG_STREAM_VBI_FMT_NONE,
697 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
698 V4L2_MPEG_STREAM_VBI_FMT_NONE);
9cb2318b
HV		 699 default:
700 return -EINVAL;
701 }
702}
057596ee 703EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
9cb2318b
HV		 704
705/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
e281db58
HV		 706 the menu. The qctrl pointer may be NULL, in which case it is ignored.
707 If menu_items is NULL, then the menu items are retrieved using
708 v4l2_ctrl_get_menu. */
9cb2318b
HV		 709int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
710 const char **menu_items)
711{
712 int i;
713
1e551266 714 qmenu->reserved = 0;
e281db58
HV		 715 if (menu_items == NULL)
716 menu_items = v4l2_ctrl_get_menu(qmenu->id);
9cb2318b
HV		 717 if (menu_items == NULL ||
718 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
719 return -EINVAL;
720 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
721 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
722 return -EINVAL;
723 snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
9cb2318b
HV		 724 return 0;
725}
057596ee 726EXPORT_SYMBOL(v4l2_ctrl_query_menu);
9cb2318b 727
1e551266
HV		 728/* Fill in a struct v4l2_querymenu based on the specified array of valid
729 menu items (terminated by V4L2_CTRL_MENU_IDS_END).
730 Use this if there are 'holes' in the list of valid menu items. */
731int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
732{
733 const char **menu_items = v4l2_ctrl_get_menu(qmenu->id);
734
735 qmenu->reserved = 0;
736 if (menu_items == NULL || ids == NULL)
737 return -EINVAL;
738 while (*ids != V4L2_CTRL_MENU_IDS_END) {
739 if (*ids++ == qmenu->index) {
740 snprintf(qmenu->name, sizeof(qmenu->name),
741 menu_items[qmenu->index]);
742 return 0;
743 }
744 }
745 return -EINVAL;
746}
747EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
748
9cb2318b
HV		 749/* ctrl_classes points to an array of u32 pointers, the last element is
750 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
751 Each array must be sorted low to high and belong to the same control
752 class. The array of u32 pointer must also be sorted, from low class IDs
753 to high class IDs.
754
755 This function returns the first ID that follows after the given ID.
756 When no more controls are available 0 is returned. */
757u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
758{
a46c5fbc 759 u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
9cb2318b
HV		 760 const u32 *pctrl;
761
9cb2318b
HV		 762 if (ctrl_classes == NULL)
763 return 0;
a46c5fbc
HV		 764
765 /* if no query is desired, then check if the ID is part of ctrl_classes */
766 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
767 /* find class */
768 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
769 ctrl_classes++;
770 if (*ctrl_classes == NULL)
771 return 0;
772 pctrl = *ctrl_classes;
773 /* find control ID */
774 while (*pctrl && *pctrl != id) pctrl++;
775 return *pctrl ? id : 0;
776 }
9cb2318b 777 id &= V4L2_CTRL_ID_MASK;
9cb2318b
HV		 778 id++; /* select next control */
779 /* find first class that matches (or is greater than) the class of
780 the ID */
781 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
782 ctrl_classes++;
783 /* no more classes */
784 if (*ctrl_classes == NULL)
785 return 0;
786 pctrl = *ctrl_classes;
787 /* find first ctrl within the class that is >= ID */
788 while (*pctrl && *pctrl < id) pctrl++;
789 if (*pctrl)
790 return *pctrl;
791 /* we are at the end of the controls of the current class. */
792 /* continue with next class if available */
793 ctrl_classes++;
794 if (*ctrl_classes == NULL)
795 return 0;
796 return **ctrl_classes;
797}
057596ee 798EXPORT_SYMBOL(v4l2_ctrl_next);
9cb2318b 799
a9254475
MCC		 800int v4l2_chip_match_host(u32 match_type, u32 match_chip)
801{
802 switch (match_type) {
803 case V4L2_CHIP_MATCH_HOST:
804 return match_chip == 0;
805 default:
806 return 0;
807 }
808}
809EXPORT_SYMBOL(v4l2_chip_match_host);
810
811#if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
f3d092b8
HV		 812int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip)
813{
814 switch (match_type) {
f3d092b8
HV		 815 case V4L2_CHIP_MATCH_I2C_DRIVER:
816 return (c != NULL && c->driver != NULL && c->driver->id == match_chip);
817 case V4L2_CHIP_MATCH_I2C_ADDR:
818 return (c != NULL && c->addr == match_chip);
819 default:
820 return 0;
821 }
822}
a9254475 823EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
f3d092b8 824
3434eb7e
HV		 825int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip,
826 u32 ident, u32 revision)
827{
828 if (!v4l2_chip_match_i2c_client(c, chip->match_type, chip->match_chip))
829 return 0;
830 if (chip->ident == V4L2_IDENT_NONE) {
831 chip->ident = ident;
832 chip->revision = revision;
833 }
834 else {
835 chip->ident = V4L2_IDENT_AMBIGUOUS;
836 chip->revision = 0;
837 }
838 return 0;
839}
a9254475 840EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
f3d092b8 841
9cb2318b
HV		 842/* ----------------------------------------------------------------- */
843
8ffbc655
HV		 844/* Helper function for I2C legacy drivers */
845
846int v4l2_i2c_attach(struct i2c_adapter *adapter, int address, struct i2c_driver *driver,
d2653e92
JD		 847 const char *name,
848 int (*probe)(struct i2c_client *, const struct i2c_device_id *))
8ffbc655
HV		 849{
850 struct i2c_client *client;
851 int err;
852
853 client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
a6a3a17b 854 if (!client)
8ffbc655
HV		 855 return -ENOMEM;
856
857 client->addr = address;
858 client->adapter = adapter;
859 client->driver = driver;
393bf557 860 strlcpy(client->name, name, sizeof(client->name));
8ffbc655 861
d2653e92 862 err = probe(client, NULL);
8ffbc655
HV		 863 if (err == 0) {
864 i2c_attach_client(client);
393bf557 865 } else {
8ffbc655
HV		 866 kfree(client);
867 }
188f3457 868 return err != -ENOMEM ? 0 : err;
8ffbc655 869}
a9254475 870EXPORT_SYMBOL(v4l2_i2c_attach);
dd99120c
HV		 871
872void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
873 const struct v4l2_subdev_ops *ops)
874{
875 v4l2_subdev_init(sd, ops);
876 /* the owner is the same as the i2c_client's driver owner */
877 sd->owner = client->driver->driver.owner;
878 /* i2c_client and v4l2_subdev point to one another */
879 v4l2_set_subdevdata(sd, client);
880 i2c_set_clientdata(client, sd);
881 /* initialize name */
882 snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
883 client->driver->driver.name, i2c_adapter_id(client->adapter),
884 client->addr);
885}
886EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
887
888
889
890/* Load an i2c sub-device. It assumes that i2c_get_adapdata(adapter)
891 returns the v4l2_device and that i2c_get_clientdata(client)
892 returns the v4l2_subdev. */
893struct v4l2_subdev *v4l2_i2c_new_subdev(struct i2c_adapter *adapter,
894 const char *module_name, const char *client_type, u8 addr)
895{
896 struct v4l2_device *dev = i2c_get_adapdata(adapter);
897 struct v4l2_subdev *sd = NULL;
898 struct i2c_client *client;
899 struct i2c_board_info info;
900
901 BUG_ON(!dev);
902#ifdef MODULE
903 if (module_name)
904 request_module(module_name);
905#endif
906 /* Setup the i2c board info with the device type and
907 the device address. */
908 memset(&info, 0, sizeof(info));
909 strlcpy(info.type, client_type, sizeof(info.type));
910 info.addr = addr;
911
912 /* Create the i2c client */
913 client = i2c_new_device(adapter, &info);
914 /* Note: it is possible in the future that
915 c->driver is NULL if the driver is still being loaded.
916 We need better support from the kernel so that we
917 can easily wait for the load to finish. */
918 if (client == NULL || client->driver == NULL)
919 return NULL;
920
921 /* Lock the module so we can safely get the v4l2_subdev pointer */
922 if (!try_module_get(client->driver->driver.owner))
923 return NULL;
924 sd = i2c_get_clientdata(client);
925
926 /* Register with the v4l2_device which increases the module's
927 use count as well. */
928 if (v4l2_device_register_subdev(dev, sd))
929 sd = NULL;
930 /* Decrease the module use count to match the first try_module_get. */
931 module_put(client->driver->driver.owner);
932 return sd;
933
934}
935EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
936
937/* Probe and load an i2c sub-device. It assumes that i2c_get_adapdata(adapter)
938 returns the v4l2_device and that i2c_get_clientdata(client)
939 returns the v4l2_subdev. */
940struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct i2c_adapter *adapter,
941 const char *module_name, const char *client_type,
942 const unsigned short *addrs)
943{
944 struct v4l2_device *dev = i2c_get_adapdata(adapter);
945 struct v4l2_subdev *sd = NULL;
946 struct i2c_client *client = NULL;
947 struct i2c_board_info info;
948
949 BUG_ON(!dev);
950#ifdef MODULE
951 if (module_name)
952 request_module(module_name);
953#endif
954 /* Setup the i2c board info with the device type and
955 the device address. */
956 memset(&info, 0, sizeof(info));
957 strlcpy(info.type, client_type, sizeof(info.type));
958
959 /* Probe and create the i2c client */
960 client = i2c_new_probed_device(adapter, &info, addrs);
961 /* Note: it is possible in the future that
962 c->driver is NULL if the driver is still being loaded.
963 We need better support from the kernel so that we
964 can easily wait for the load to finish. */
965 if (client == NULL || client->driver == NULL)
966 return NULL;
967
968 /* Lock the module so we can safely get the v4l2_subdev pointer */
969 if (!try_module_get(client->driver->driver.owner))
970 return NULL;
971 sd = i2c_get_clientdata(client);
972
973 /* Register with the v4l2_device which increases the module's
974 use count as well. */
975 if (v4l2_device_register_subdev(dev, sd))
976 sd = NULL;
977 /* Decrease the module use count to match the first try_module_get. */
978 module_put(client->driver->driver.owner);
979 return sd;
980}
981EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev);
982
a9254475 983#endif
Clone of davem's net-next-2.6 tree