Merge branch 'core-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / drivers / media / video / uvc / uvc_ctrl.c
1 /*
2  *      uvc_ctrl.c  --  USB Video Class driver - Controls
3  *
4  *      Copyright (C) 2005-2008
5  *          Laurent Pinchart (laurent.pinchart@skynet.be)
6  *
7  *      This program is free software; you can redistribute it and/or modify
8  *      it under the terms of the GNU General Public License as published by
9  *      the Free Software Foundation; either version 2 of the License, or
10  *      (at your option) any later version.
11  *
12  */
13
14 #include <linux/kernel.h>
15 #include <linux/version.h>
16 #include <linux/list.h>
17 #include <linux/module.h>
18 #include <linux/uaccess.h>
19 #include <linux/usb.h>
20 #include <linux/videodev2.h>
21 #include <linux/vmalloc.h>
22 #include <linux/wait.h>
23 #include <asm/atomic.h>
24
25 #include "uvcvideo.h"
26
27 #define UVC_CTRL_NDATA          2
28 #define UVC_CTRL_DATA_CURRENT   0
29 #define UVC_CTRL_DATA_BACKUP    1
30
31 /* ------------------------------------------------------------------------
32  * Control, formats, ...
33  */
34
35 static struct uvc_control_info uvc_ctrls[] = {
36         {
37                 .entity         = UVC_GUID_UVC_PROCESSING,
38                 .selector       = PU_BRIGHTNESS_CONTROL,
39                 .index          = 0,
40                 .size           = 2,
41                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
42                                 | UVC_CONTROL_RESTORE,
43         },
44         {
45                 .entity         = UVC_GUID_UVC_PROCESSING,
46                 .selector       = PU_CONTRAST_CONTROL,
47                 .index          = 1,
48                 .size           = 2,
49                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
50                                 | UVC_CONTROL_RESTORE,
51         },
52         {
53                 .entity         = UVC_GUID_UVC_PROCESSING,
54                 .selector       = PU_HUE_CONTROL,
55                 .index          = 2,
56                 .size           = 2,
57                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
58                                 | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
59         },
60         {
61                 .entity         = UVC_GUID_UVC_PROCESSING,
62                 .selector       = PU_SATURATION_CONTROL,
63                 .index          = 3,
64                 .size           = 2,
65                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
66                                 | UVC_CONTROL_RESTORE,
67         },
68         {
69                 .entity         = UVC_GUID_UVC_PROCESSING,
70                 .selector       = PU_SHARPNESS_CONTROL,
71                 .index          = 4,
72                 .size           = 2,
73                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
74                                 | UVC_CONTROL_RESTORE,
75         },
76         {
77                 .entity         = UVC_GUID_UVC_PROCESSING,
78                 .selector       = PU_GAMMA_CONTROL,
79                 .index          = 5,
80                 .size           = 2,
81                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
82                                 | UVC_CONTROL_RESTORE,
83         },
84         {
85                 .entity         = UVC_GUID_UVC_PROCESSING,
86                 .selector       = PU_BACKLIGHT_COMPENSATION_CONTROL,
87                 .index          = 8,
88                 .size           = 2,
89                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
90                                 | UVC_CONTROL_RESTORE,
91         },
92         {
93                 .entity         = UVC_GUID_UVC_PROCESSING,
94                 .selector       = PU_GAIN_CONTROL,
95                 .index          = 9,
96                 .size           = 2,
97                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
98                                 | UVC_CONTROL_RESTORE,
99         },
100         {
101                 .entity         = UVC_GUID_UVC_PROCESSING,
102                 .selector       = PU_POWER_LINE_FREQUENCY_CONTROL,
103                 .index          = 10,
104                 .size           = 1,
105                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
106                                 | UVC_CONTROL_RESTORE,
107         },
108         {
109                 .entity         = UVC_GUID_UVC_PROCESSING,
110                 .selector       = PU_HUE_AUTO_CONTROL,
111                 .index          = 11,
112                 .size           = 1,
113                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
114                                 | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
115         },
116         {
117                 .entity         = UVC_GUID_UVC_CAMERA,
118                 .selector       = CT_AE_MODE_CONTROL,
119                 .index          = 1,
120                 .size           = 1,
121                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
122                                 | UVC_CONTROL_GET_DEF | UVC_CONTROL_GET_RES
123                                 | UVC_CONTROL_RESTORE,
124         },
125         {
126                 .entity         = UVC_GUID_UVC_CAMERA,
127                 .selector       = CT_AE_PRIORITY_CONTROL,
128                 .index          = 2,
129                 .size           = 1,
130                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
131                                 | UVC_CONTROL_RESTORE,
132         },
133         {
134                 .entity         = UVC_GUID_UVC_CAMERA,
135                 .selector       = CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
136                 .index          = 3,
137                 .size           = 4,
138                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
139                                 | UVC_CONTROL_RESTORE,
140         },
141         {
142                 .entity         = UVC_GUID_UVC_CAMERA,
143                 .selector       = CT_FOCUS_ABSOLUTE_CONTROL,
144                 .index          = 5,
145                 .size           = 2,
146                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
147                                 | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
148         },
149         {
150                 .entity         = UVC_GUID_UVC_CAMERA,
151                 .selector       = CT_FOCUS_AUTO_CONTROL,
152                 .index          = 17,
153                 .size           = 1,
154                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
155                                 | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
156         },
157         {
158                 .entity         = UVC_GUID_UVC_PROCESSING,
159                 .selector       = PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
160                 .index          = 12,
161                 .size           = 1,
162                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
163                                 | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
164         },
165         {
166                 .entity         = UVC_GUID_UVC_PROCESSING,
167                 .selector       = PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
168                 .index          = 6,
169                 .size           = 2,
170                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
171                                 | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
172         },
173         {
174                 .entity         = UVC_GUID_UVC_PROCESSING,
175                 .selector       = PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
176                 .index          = 13,
177                 .size           = 1,
178                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
179                                 | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
180         },
181         {
182                 .entity         = UVC_GUID_UVC_PROCESSING,
183                 .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
184                 .index          = 7,
185                 .size           = 4,
186                 .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
187                                 | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
188         },
189 };
190
191 static struct uvc_menu_info power_line_frequency_controls[] = {
192         { 0, "Disabled" },
193         { 1, "50 Hz" },
194         { 2, "60 Hz" },
195 };
196
197 static struct uvc_menu_info exposure_auto_controls[] = {
198         { 2, "Auto Mode" },
199         { 1, "Manual Mode" },
200         { 4, "Shutter Priority Mode" },
201         { 8, "Aperture Priority Mode" },
202 };
203
204 static struct uvc_control_mapping uvc_ctrl_mappings[] = {
205         {
206                 .id             = V4L2_CID_BRIGHTNESS,
207                 .name           = "Brightness",
208                 .entity         = UVC_GUID_UVC_PROCESSING,
209                 .selector       = PU_BRIGHTNESS_CONTROL,
210                 .size           = 16,
211                 .offset         = 0,
212                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
213                 .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
214         },
215         {
216                 .id             = V4L2_CID_CONTRAST,
217                 .name           = "Contrast",
218                 .entity         = UVC_GUID_UVC_PROCESSING,
219                 .selector       = PU_CONTRAST_CONTROL,
220                 .size           = 16,
221                 .offset         = 0,
222                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
223                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
224         },
225         {
226                 .id             = V4L2_CID_HUE,
227                 .name           = "Hue",
228                 .entity         = UVC_GUID_UVC_PROCESSING,
229                 .selector       = PU_HUE_CONTROL,
230                 .size           = 16,
231                 .offset         = 0,
232                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
233                 .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
234         },
235         {
236                 .id             = V4L2_CID_SATURATION,
237                 .name           = "Saturation",
238                 .entity         = UVC_GUID_UVC_PROCESSING,
239                 .selector       = PU_SATURATION_CONTROL,
240                 .size           = 16,
241                 .offset         = 0,
242                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
243                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
244         },
245         {
246                 .id             = V4L2_CID_SHARPNESS,
247                 .name           = "Sharpness",
248                 .entity         = UVC_GUID_UVC_PROCESSING,
249                 .selector       = PU_SHARPNESS_CONTROL,
250                 .size           = 16,
251                 .offset         = 0,
252                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
253                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
254         },
255         {
256                 .id             = V4L2_CID_GAMMA,
257                 .name           = "Gamma",
258                 .entity         = UVC_GUID_UVC_PROCESSING,
259                 .selector       = PU_GAMMA_CONTROL,
260                 .size           = 16,
261                 .offset         = 0,
262                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
263                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
264         },
265         {
266                 .id             = V4L2_CID_BACKLIGHT_COMPENSATION,
267                 .name           = "Backlight Compensation",
268                 .entity         = UVC_GUID_UVC_PROCESSING,
269                 .selector       = PU_BACKLIGHT_COMPENSATION_CONTROL,
270                 .size           = 16,
271                 .offset         = 0,
272                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
273                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
274         },
275         {
276                 .id             = V4L2_CID_GAIN,
277                 .name           = "Gain",
278                 .entity         = UVC_GUID_UVC_PROCESSING,
279                 .selector       = PU_GAIN_CONTROL,
280                 .size           = 16,
281                 .offset         = 0,
282                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
283                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
284         },
285         {
286                 .id             = V4L2_CID_POWER_LINE_FREQUENCY,
287                 .name           = "Power Line Frequency",
288                 .entity         = UVC_GUID_UVC_PROCESSING,
289                 .selector       = PU_POWER_LINE_FREQUENCY_CONTROL,
290                 .size           = 2,
291                 .offset         = 0,
292                 .v4l2_type      = V4L2_CTRL_TYPE_MENU,
293                 .data_type      = UVC_CTRL_DATA_TYPE_ENUM,
294                 .menu_info      = power_line_frequency_controls,
295                 .menu_count     = ARRAY_SIZE(power_line_frequency_controls),
296         },
297         {
298                 .id             = V4L2_CID_HUE_AUTO,
299                 .name           = "Hue, Auto",
300                 .entity         = UVC_GUID_UVC_PROCESSING,
301                 .selector       = PU_HUE_AUTO_CONTROL,
302                 .size           = 1,
303                 .offset         = 0,
304                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
305                 .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
306         },
307         {
308                 .id             = V4L2_CID_EXPOSURE_AUTO,
309                 .name           = "Exposure, Auto",
310                 .entity         = UVC_GUID_UVC_CAMERA,
311                 .selector       = CT_AE_MODE_CONTROL,
312                 .size           = 4,
313                 .offset         = 0,
314                 .v4l2_type      = V4L2_CTRL_TYPE_MENU,
315                 .data_type      = UVC_CTRL_DATA_TYPE_BITMASK,
316                 .menu_info      = exposure_auto_controls,
317                 .menu_count     = ARRAY_SIZE(exposure_auto_controls),
318         },
319         {
320                 .id             = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
321                 .name           = "Exposure, Auto Priority",
322                 .entity         = UVC_GUID_UVC_CAMERA,
323                 .selector       = CT_AE_PRIORITY_CONTROL,
324                 .size           = 1,
325                 .offset         = 0,
326                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
327                 .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
328         },
329         {
330                 .id             = V4L2_CID_EXPOSURE_ABSOLUTE,
331                 .name           = "Exposure (Absolute)",
332                 .entity         = UVC_GUID_UVC_CAMERA,
333                 .selector       = CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
334                 .size           = 32,
335                 .offset         = 0,
336                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
337                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
338         },
339         {
340                 .id             = V4L2_CID_AUTO_WHITE_BALANCE,
341                 .name           = "White Balance Temperature, Auto",
342                 .entity         = UVC_GUID_UVC_PROCESSING,
343                 .selector       = PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
344                 .size           = 1,
345                 .offset         = 0,
346                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
347                 .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
348         },
349         {
350                 .id             = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
351                 .name           = "White Balance Temperature",
352                 .entity         = UVC_GUID_UVC_PROCESSING,
353                 .selector       = PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
354                 .size           = 16,
355                 .offset         = 0,
356                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
357                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
358         },
359         {
360                 .id             = V4L2_CID_AUTO_WHITE_BALANCE,
361                 .name           = "White Balance Component, Auto",
362                 .entity         = UVC_GUID_UVC_PROCESSING,
363                 .selector       = PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
364                 .size           = 1,
365                 .offset         = 0,
366                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
367                 .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
368         },
369         {
370                 .id             = V4L2_CID_BLUE_BALANCE,
371                 .name           = "White Balance Blue Component",
372                 .entity         = UVC_GUID_UVC_PROCESSING,
373                 .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
374                 .size           = 16,
375                 .offset         = 0,
376                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
377                 .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
378         },
379         {
380                 .id             = V4L2_CID_RED_BALANCE,
381                 .name           = "White Balance Red Component",
382                 .entity         = UVC_GUID_UVC_PROCESSING,
383                 .selector       = PU_WHITE_BALANCE_COMPONENT_CONTROL,
384                 .size           = 16,
385                 .offset         = 16,
386                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
387                 .data_type      = UVC_CTRL_DATA_TYPE_SIGNED,
388         },
389         {
390                 .id             = V4L2_CID_FOCUS_ABSOLUTE,
391                 .name           = "Focus (absolute)",
392                 .entity         = UVC_GUID_UVC_CAMERA,
393                 .selector       = CT_FOCUS_ABSOLUTE_CONTROL,
394                 .size           = 16,
395                 .offset         = 0,
396                 .v4l2_type      = V4L2_CTRL_TYPE_INTEGER,
397                 .data_type      = UVC_CTRL_DATA_TYPE_UNSIGNED,
398         },
399         {
400                 .id             = V4L2_CID_FOCUS_AUTO,
401                 .name           = "Focus, Auto",
402                 .entity         = UVC_GUID_UVC_CAMERA,
403                 .selector       = CT_FOCUS_AUTO_CONTROL,
404                 .size           = 1,
405                 .offset         = 0,
406                 .v4l2_type      = V4L2_CTRL_TYPE_BOOLEAN,
407                 .data_type      = UVC_CTRL_DATA_TYPE_BOOLEAN,
408         },
409 };
410
411 /* ------------------------------------------------------------------------
412  * Utility functions
413  */
414
415 static inline __u8 *uvc_ctrl_data(struct uvc_control *ctrl, int id)
416 {
417         return ctrl->data + id * ctrl->info->size;
418 }
419
420 static inline int uvc_get_bit(const __u8 *data, int bit)
421 {
422         return (data[bit >> 3] >> (bit & 7)) & 1;
423 }
424
425 /* Extract the bit string specified by mapping->offset and mapping->size
426  * from the little-endian data stored at 'data' and return the result as
427  * a signed 32bit integer. Sign extension will be performed if the mapping
428  * references a signed data type.
429  */
430 static __s32 uvc_get_le_value(const __u8 *data,
431         struct uvc_control_mapping *mapping)
432 {
433         int bits = mapping->size;
434         int offset = mapping->offset;
435         __s32 value = 0;
436         __u8 mask;
437
438         data += offset / 8;
439         offset &= 7;
440         mask = ((1LL << bits) - 1) << offset;
441
442         for (; bits > 0; data++) {
443                 __u8 byte = *data & mask;
444                 value |= offset > 0 ? (byte >> offset) : (byte << (-offset));
445                 bits -= 8 - (offset > 0 ? offset : 0);
446                 offset -= 8;
447                 mask = (1 << bits) - 1;
448         }
449
450         /* Sign-extend the value if needed */
451         if (mapping->data_type == UVC_CTRL_DATA_TYPE_SIGNED)
452                 value |= -(value & (1 << (mapping->size - 1)));
453
454         return value;
455 }
456
457 /* Set the bit string specified by mapping->offset and mapping->size
458  * in the little-endian data stored at 'data' to the value 'value'.
459  */
460 static void uvc_set_le_value(__s32 value, __u8 *data,
461         struct uvc_control_mapping *mapping)
462 {
463         int bits = mapping->size;
464         int offset = mapping->offset;
465         __u8 mask;
466
467         data += offset / 8;
468         offset &= 7;
469
470         for (; bits > 0; data++) {
471                 mask = ((1LL << bits) - 1) << offset;
472                 *data = (*data & ~mask) | ((value << offset) & mask);
473                 value >>= offset ? offset : 8;
474                 bits -= 8 - offset;
475                 offset = 0;
476         }
477 }
478
479 /* ------------------------------------------------------------------------
480  * Terminal and unit management
481  */
482
483 static const __u8 uvc_processing_guid[16] = UVC_GUID_UVC_PROCESSING;
484 static const __u8 uvc_camera_guid[16] = UVC_GUID_UVC_CAMERA;
485 static const __u8 uvc_media_transport_input_guid[16] =
486         UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT;
487
488 static int uvc_entity_match_guid(struct uvc_entity *entity, __u8 guid[16])
489 {
490         switch (UVC_ENTITY_TYPE(entity)) {
491         case ITT_CAMERA:
492                 return memcmp(uvc_camera_guid, guid, 16) == 0;
493
494         case ITT_MEDIA_TRANSPORT_INPUT:
495                 return memcmp(uvc_media_transport_input_guid, guid, 16) == 0;
496
497         case VC_PROCESSING_UNIT:
498                 return memcmp(uvc_processing_guid, guid, 16) == 0;
499
500         case VC_EXTENSION_UNIT:
501                 return memcmp(entity->extension.guidExtensionCode,
502                               guid, 16) == 0;
503
504         default:
505                 return 0;
506         }
507 }
508
509 /* ------------------------------------------------------------------------
510  * UVC Controls
511  */
512
513 static void __uvc_find_control(struct uvc_entity *entity, __u32 v4l2_id,
514         struct uvc_control_mapping **mapping, struct uvc_control **control,
515         int next)
516 {
517         struct uvc_control *ctrl;
518         struct uvc_control_mapping *map;
519         unsigned int i;
520
521         if (entity == NULL)
522                 return;
523
524         for (i = 0; i < entity->ncontrols; ++i) {
525                 ctrl = &entity->controls[i];
526                 if (ctrl->info == NULL)
527                         continue;
528
529                 list_for_each_entry(map, &ctrl->info->mappings, list) {
530                         if ((map->id == v4l2_id) && !next) {
531                                 *control = ctrl;
532                                 *mapping = map;
533                                 return;
534                         }
535
536                         if ((*mapping == NULL || (*mapping)->id > map->id) &&
537                             (map->id > v4l2_id) && next) {
538                                 *control = ctrl;
539                                 *mapping = map;
540                         }
541                 }
542         }
543 }
544
545 struct uvc_control *uvc_find_control(struct uvc_video_device *video,
546         __u32 v4l2_id, struct uvc_control_mapping **mapping)
547 {
548         struct uvc_control *ctrl = NULL;
549         struct uvc_entity *entity;
550         int next = v4l2_id & V4L2_CTRL_FLAG_NEXT_CTRL;
551
552         *mapping = NULL;
553
554         /* Mask the query flags. */
555         v4l2_id &= V4L2_CTRL_ID_MASK;
556
557         /* Find the control. */
558         __uvc_find_control(video->processing, v4l2_id, mapping, &ctrl, next);
559         if (ctrl && !next)
560                 return ctrl;
561
562         list_for_each_entry(entity, &video->iterms, chain) {
563                 __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
564                 if (ctrl && !next)
565                         return ctrl;
566         }
567
568         list_for_each_entry(entity, &video->extensions, chain) {
569                 __uvc_find_control(entity, v4l2_id, mapping, &ctrl, next);
570                 if (ctrl && !next)
571                         return ctrl;
572         }
573
574         if (ctrl == NULL && !next)
575                 uvc_trace(UVC_TRACE_CONTROL, "Control 0x%08x not found.\n",
576                                 v4l2_id);
577
578         return ctrl;
579 }
580
581 int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
582         struct v4l2_queryctrl *v4l2_ctrl)
583 {
584         struct uvc_control *ctrl;
585         struct uvc_control_mapping *mapping;
586         struct uvc_menu_info *menu;
587         unsigned int i;
588         __u8 data[8];
589         int ret;
590
591         ctrl = uvc_find_control(video, v4l2_ctrl->id, &mapping);
592         if (ctrl == NULL)
593                 return -EINVAL;
594
595         memset(v4l2_ctrl, 0, sizeof *v4l2_ctrl);
596         v4l2_ctrl->id = mapping->id;
597         v4l2_ctrl->type = mapping->v4l2_type;
598         strncpy(v4l2_ctrl->name, mapping->name, sizeof v4l2_ctrl->name);
599         v4l2_ctrl->flags = 0;
600
601         if (!(ctrl->info->flags & UVC_CONTROL_SET_CUR))
602                 v4l2_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
603
604         if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
605                 if ((ret = uvc_query_ctrl(video->dev, GET_DEF, ctrl->entity->id,
606                                 video->dev->intfnum, ctrl->info->selector,
607                                 &data, ctrl->info->size)) < 0)
608                         return ret;
609                 v4l2_ctrl->default_value = uvc_get_le_value(data, mapping);
610         }
611
612         switch (mapping->v4l2_type) {
613         case V4L2_CTRL_TYPE_MENU:
614                 v4l2_ctrl->minimum = 0;
615                 v4l2_ctrl->maximum = mapping->menu_count - 1;
616                 v4l2_ctrl->step = 1;
617
618                 menu = mapping->menu_info;
619                 for (i = 0; i < mapping->menu_count; ++i, ++menu) {
620                         if (menu->value == v4l2_ctrl->default_value) {
621                                 v4l2_ctrl->default_value = i;
622                                 break;
623                         }
624                 }
625
626                 return 0;
627
628         case V4L2_CTRL_TYPE_BOOLEAN:
629                 v4l2_ctrl->minimum = 0;
630                 v4l2_ctrl->maximum = 1;
631                 v4l2_ctrl->step = 1;
632                 return 0;
633
634         default:
635                 break;
636         }
637
638         if (ctrl->info->flags & UVC_CONTROL_GET_MIN) {
639                 if ((ret = uvc_query_ctrl(video->dev, GET_MIN, ctrl->entity->id,
640                                 video->dev->intfnum, ctrl->info->selector,
641                                 &data, ctrl->info->size)) < 0)
642                         return ret;
643                 v4l2_ctrl->minimum = uvc_get_le_value(data, mapping);
644         }
645         if (ctrl->info->flags & UVC_CONTROL_GET_MAX) {
646                 if ((ret = uvc_query_ctrl(video->dev, GET_MAX, ctrl->entity->id,
647                                 video->dev->intfnum, ctrl->info->selector,
648                                 &data, ctrl->info->size)) < 0)
649                         return ret;
650                 v4l2_ctrl->maximum = uvc_get_le_value(data, mapping);
651         }
652         if (ctrl->info->flags & UVC_CONTROL_GET_RES) {
653                 if ((ret = uvc_query_ctrl(video->dev, GET_RES, ctrl->entity->id,
654                                 video->dev->intfnum, ctrl->info->selector,
655                                 &data, ctrl->info->size)) < 0)
656                         return ret;
657                 v4l2_ctrl->step = uvc_get_le_value(data, mapping);
658         }
659
660         return 0;
661 }
662
663
664 /* --------------------------------------------------------------------------
665  * Control transactions
666  *
667  * To make extended set operations as atomic as the hardware allows, controls
668  * are handled using begin/commit/rollback operations.
669  *
670  * At the beginning of a set request, uvc_ctrl_begin should be called to
671  * initialize the request. This function acquires the control lock.
672  *
673  * When setting a control, the new value is stored in the control data field
674  * at position UVC_CTRL_DATA_CURRENT. The control is then marked as dirty for
675  * later processing. If the UVC and V4L2 control sizes differ, the current
676  * value is loaded from the hardware before storing the new value in the data
677  * field.
678  *
679  * After processing all controls in the transaction, uvc_ctrl_commit or
680  * uvc_ctrl_rollback must be called to apply the pending changes to the
681  * hardware or revert them. When applying changes, all controls marked as
682  * dirty will be modified in the UVC device, and the dirty flag will be
683  * cleared. When reverting controls, the control data field
684  * UVC_CTRL_DATA_CURRENT is reverted to its previous value
685  * (UVC_CTRL_DATA_BACKUP) for all dirty controls. Both functions release the
686  * control lock.
687  */
688 int uvc_ctrl_begin(struct uvc_video_device *video)
689 {
690         return mutex_lock_interruptible(&video->ctrl_mutex) ? -ERESTARTSYS : 0;
691 }
692
693 static int uvc_ctrl_commit_entity(struct uvc_device *dev,
694         struct uvc_entity *entity, int rollback)
695 {
696         struct uvc_control *ctrl;
697         unsigned int i;
698         int ret;
699
700         if (entity == NULL)
701                 return 0;
702
703         for (i = 0; i < entity->ncontrols; ++i) {
704                 ctrl = &entity->controls[i];
705                 if (ctrl->info == NULL || !ctrl->dirty)
706                         continue;
707
708                 if (!rollback)
709                         ret = uvc_query_ctrl(dev, SET_CUR, ctrl->entity->id,
710                                 dev->intfnum, ctrl->info->selector,
711                                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
712                                 ctrl->info->size);
713                 else
714                         ret = 0;
715
716                 if (rollback || ret < 0)
717                         memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
718                                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
719                                ctrl->info->size);
720
721                 if ((ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0)
722                         ctrl->loaded = 0;
723
724                 ctrl->dirty = 0;
725
726                 if (ret < 0)
727                         return ret;
728         }
729
730         return 0;
731 }
732
733 int __uvc_ctrl_commit(struct uvc_video_device *video, int rollback)
734 {
735         struct uvc_entity *entity;
736         int ret = 0;
737
738         /* Find the control. */
739         ret = uvc_ctrl_commit_entity(video->dev, video->processing, rollback);
740         if (ret < 0)
741                 goto done;
742
743         list_for_each_entry(entity, &video->iterms, chain) {
744                 ret = uvc_ctrl_commit_entity(video->dev, entity, rollback);
745                 if (ret < 0)
746                         goto done;
747         }
748
749         list_for_each_entry(entity, &video->extensions, chain) {
750                 ret = uvc_ctrl_commit_entity(video->dev, entity, rollback);
751                 if (ret < 0)
752                         goto done;
753         }
754
755 done:
756         mutex_unlock(&video->ctrl_mutex);
757         return ret;
758 }
759
760 int uvc_ctrl_get(struct uvc_video_device *video,
761         struct v4l2_ext_control *xctrl)
762 {
763         struct uvc_control *ctrl;
764         struct uvc_control_mapping *mapping;
765         struct uvc_menu_info *menu;
766         unsigned int i;
767         int ret;
768
769         ctrl = uvc_find_control(video, xctrl->id, &mapping);
770         if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0)
771                 return -EINVAL;
772
773         if (!ctrl->loaded) {
774                 ret = uvc_query_ctrl(video->dev, GET_CUR, ctrl->entity->id,
775                                 video->dev->intfnum, ctrl->info->selector,
776                                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
777                                 ctrl->info->size);
778                 if (ret < 0)
779                         return ret;
780
781                 if ((ctrl->info->flags & UVC_CONTROL_AUTO_UPDATE) == 0)
782                         ctrl->loaded = 1;
783         }
784
785         xctrl->value = uvc_get_le_value(
786                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT), mapping);
787
788         if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
789                 menu = mapping->menu_info;
790                 for (i = 0; i < mapping->menu_count; ++i, ++menu) {
791                         if (menu->value == xctrl->value) {
792                                 xctrl->value = i;
793                                 break;
794                         }
795                 }
796         }
797
798         return 0;
799 }
800
801 int uvc_ctrl_set(struct uvc_video_device *video,
802         struct v4l2_ext_control *xctrl)
803 {
804         struct uvc_control *ctrl;
805         struct uvc_control_mapping *mapping;
806         s32 value = xctrl->value;
807         int ret;
808
809         ctrl = uvc_find_control(video, xctrl->id, &mapping);
810         if (ctrl == NULL || (ctrl->info->flags & UVC_CONTROL_SET_CUR) == 0)
811                 return -EINVAL;
812
813         if (mapping->v4l2_type == V4L2_CTRL_TYPE_MENU) {
814                 if (value < 0 || value >= mapping->menu_count)
815                         return -EINVAL;
816                 value = mapping->menu_info[value].value;
817         }
818
819         if (!ctrl->loaded && (ctrl->info->size * 8) != mapping->size) {
820                 if ((ctrl->info->flags & UVC_CONTROL_GET_CUR) == 0) {
821                         memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
822                                 0, ctrl->info->size);
823                 } else {
824                         ret = uvc_query_ctrl(video->dev, GET_CUR,
825                                 ctrl->entity->id, video->dev->intfnum,
826                                 ctrl->info->selector,
827                                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
828                                 ctrl->info->size);
829                         if (ret < 0)
830                                 return ret;
831                 }
832
833                 if ((ctrl->info->flags & UVC_CONTROL_AUTO_UPDATE) == 0)
834                         ctrl->loaded = 1;
835         }
836
837         if (!ctrl->dirty) {
838                 memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
839                        uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
840                        ctrl->info->size);
841         }
842
843         uvc_set_le_value(value,
844                 uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT), mapping);
845
846         ctrl->dirty = 1;
847         ctrl->modified = 1;
848         return 0;
849 }
850
851 /* --------------------------------------------------------------------------
852  * Dynamic controls
853  */
854
855 int uvc_xu_ctrl_query(struct uvc_video_device *video,
856         struct uvc_xu_control *xctrl, int set)
857 {
858         struct uvc_entity *entity;
859         struct uvc_control *ctrl = NULL;
860         unsigned int i, found = 0;
861         __u8 *data;
862         int ret;
863
864         /* Find the extension unit. */
865         list_for_each_entry(entity, &video->extensions, chain) {
866                 if (entity->id == xctrl->unit)
867                         break;
868         }
869
870         if (entity->id != xctrl->unit) {
871                 uvc_trace(UVC_TRACE_CONTROL, "Extension unit %u not found.\n",
872                         xctrl->unit);
873                 return -EINVAL;
874         }
875
876         /* Find the control. */
877         for (i = 0; i < entity->ncontrols; ++i) {
878                 ctrl = &entity->controls[i];
879                 if (ctrl->info == NULL)
880                         continue;
881
882                 if (ctrl->info->selector == xctrl->selector) {
883                         found = 1;
884                         break;
885                 }
886         }
887
888         if (!found) {
889                 uvc_trace(UVC_TRACE_CONTROL,
890                         "Control " UVC_GUID_FORMAT "/%u not found.\n",
891                         UVC_GUID_ARGS(entity->extension.guidExtensionCode),
892                         xctrl->selector);
893                 return -EINVAL;
894         }
895
896         /* Validate control data size. */
897         if (ctrl->info->size != xctrl->size)
898                 return -EINVAL;
899
900         if ((set && !(ctrl->info->flags & UVC_CONTROL_SET_CUR)) ||
901             (!set && !(ctrl->info->flags & UVC_CONTROL_GET_CUR)))
902                 return -EINVAL;
903
904         if (mutex_lock_interruptible(&video->ctrl_mutex))
905                 return -ERESTARTSYS;
906
907         memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
908                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
909                xctrl->size);
910         data = uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT);
911
912         if (set && copy_from_user(data, xctrl->data, xctrl->size)) {
913                 ret = -EFAULT;
914                 goto out;
915         }
916
917         ret = uvc_query_ctrl(video->dev, set ? SET_CUR : GET_CUR, xctrl->unit,
918                              video->dev->intfnum, xctrl->selector, data,
919                              xctrl->size);
920         if (ret < 0)
921                 goto out;
922
923         if (!set && copy_to_user(xctrl->data, data, xctrl->size)) {
924                 ret = -EFAULT;
925                 goto out;
926         }
927
928 out:
929         if (ret)
930                 memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
931                        uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
932                        xctrl->size);
933
934         mutex_unlock(&video->ctrl_mutex);
935         return ret;
936 }
937
938 /* --------------------------------------------------------------------------
939  * Suspend/resume
940  */
941
942 /*
943  * Restore control values after resume, skipping controls that haven't been
944  * changed.
945  *
946  * TODO
947  * - Don't restore modified controls that are back to their default value.
948  * - Handle restore order (Auto-Exposure Mode should be restored before
949  *   Exposure Time).
950  */
951 int uvc_ctrl_resume_device(struct uvc_device *dev)
952 {
953         struct uvc_control *ctrl;
954         struct uvc_entity *entity;
955         unsigned int i;
956         int ret;
957
958         /* Walk the entities list and restore controls when possible. */
959         list_for_each_entry(entity, &dev->entities, list) {
960
961                 for (i = 0; i < entity->ncontrols; ++i) {
962                         ctrl = &entity->controls[i];
963
964                         if (ctrl->info == NULL || !ctrl->modified ||
965                             (ctrl->info->flags & UVC_CONTROL_RESTORE) == 0)
966                                 continue;
967
968                         printk(KERN_INFO "restoring control " UVC_GUID_FORMAT
969                                 "/%u/%u\n", UVC_GUID_ARGS(ctrl->info->entity),
970                                 ctrl->info->index, ctrl->info->selector);
971                         ctrl->dirty = 1;
972                 }
973
974                 ret = uvc_ctrl_commit_entity(dev, entity, 0);
975                 if (ret < 0)
976                         return ret;
977         }
978
979         return 0;
980 }
981
982 /* --------------------------------------------------------------------------
983  * Control and mapping handling
984  */
985
986 static void uvc_ctrl_add_ctrl(struct uvc_device *dev,
987         struct uvc_control_info *info)
988 {
989         struct uvc_entity *entity;
990         struct uvc_control *ctrl = NULL;
991         int ret, found = 0;
992         unsigned int i;
993
994         list_for_each_entry(entity, &dev->entities, list) {
995                 if (!uvc_entity_match_guid(entity, info->entity))
996                         continue;
997
998                 for (i = 0; i < entity->ncontrols; ++i) {
999                         ctrl = &entity->controls[i];
1000                         if (ctrl->index == info->index) {
1001                                 found = 1;
1002                                 break;
1003                         }
1004                 }
1005
1006                 if (found)
1007                         break;
1008         }
1009
1010         if (!found)
1011                 return;
1012
1013         if (UVC_ENTITY_TYPE(entity) == VC_EXTENSION_UNIT) {
1014                 /* Check if the device control information and length match
1015                  * the user supplied information.
1016                  */
1017                 __u32 flags;
1018                 __le16 size;
1019                 __u8 inf;
1020
1021                 if ((ret = uvc_query_ctrl(dev, GET_LEN, ctrl->entity->id,
1022                         dev->intfnum, info->selector, (__u8 *)&size, 2)) < 0) {
1023                         uvc_trace(UVC_TRACE_CONTROL, "GET_LEN failed on "
1024                                 "control " UVC_GUID_FORMAT "/%u (%d).\n",
1025                                 UVC_GUID_ARGS(info->entity), info->selector,
1026                                 ret);
1027                         return;
1028                 }
1029
1030                 if (info->size != le16_to_cpu(size)) {
1031                         uvc_trace(UVC_TRACE_CONTROL, "Control " UVC_GUID_FORMAT
1032                                 "/%u size doesn't match user supplied "
1033                                 "value.\n", UVC_GUID_ARGS(info->entity),
1034                                 info->selector);
1035                         return;
1036                 }
1037
1038                 if ((ret = uvc_query_ctrl(dev, GET_INFO, ctrl->entity->id,
1039                         dev->intfnum, info->selector, &inf, 1)) < 0) {
1040                         uvc_trace(UVC_TRACE_CONTROL, "GET_INFO failed on "
1041                                 "control " UVC_GUID_FORMAT "/%u (%d).\n",
1042                                 UVC_GUID_ARGS(info->entity), info->selector,
1043                                 ret);
1044                         return;
1045                 }
1046
1047                 flags = info->flags;
1048                 if (((flags & UVC_CONTROL_GET_CUR) && !(inf & (1 << 0))) ||
1049                     ((flags & UVC_CONTROL_SET_CUR) && !(inf & (1 << 1)))) {
1050                         uvc_trace(UVC_TRACE_CONTROL, "Control "
1051                                 UVC_GUID_FORMAT "/%u flags don't match "
1052                                 "supported operations.\n",
1053                                 UVC_GUID_ARGS(info->entity), info->selector);
1054                         return;
1055                 }
1056         }
1057
1058         ctrl->info = info;
1059         ctrl->data = kmalloc(ctrl->info->size * UVC_CTRL_NDATA, GFP_KERNEL);
1060         uvc_trace(UVC_TRACE_CONTROL, "Added control " UVC_GUID_FORMAT "/%u "
1061                 "to device %s entity %u\n", UVC_GUID_ARGS(ctrl->info->entity),
1062                 ctrl->info->selector, dev->udev->devpath, entity->id);
1063 }
1064
1065 /*
1066  * Add an item to the UVC control information list, and instantiate a control
1067  * structure for each device that supports the control.
1068  */
1069 int uvc_ctrl_add_info(struct uvc_control_info *info)
1070 {
1071         struct uvc_control_info *ctrl;
1072         struct uvc_device *dev;
1073         int ret = 0;
1074
1075         /* Find matching controls by walking the devices, entities and
1076          * controls list.
1077          */
1078         mutex_lock(&uvc_driver.ctrl_mutex);
1079
1080         /* First check if the list contains a control matching the new one.
1081          * Bail out if it does.
1082          */
1083         list_for_each_entry(ctrl, &uvc_driver.controls, list) {
1084                 if (memcmp(ctrl->entity, info->entity, 16))
1085                         continue;
1086
1087                 if (ctrl->selector == info->selector) {
1088                         uvc_trace(UVC_TRACE_CONTROL, "Control "
1089                                 UVC_GUID_FORMAT "/%u is already defined.\n",
1090                                 UVC_GUID_ARGS(info->entity), info->selector);
1091                         ret = -EEXIST;
1092                         goto end;
1093                 }
1094                 if (ctrl->index == info->index) {
1095                         uvc_trace(UVC_TRACE_CONTROL, "Control "
1096                                 UVC_GUID_FORMAT "/%u would overwrite index "
1097                                 "%d.\n", UVC_GUID_ARGS(info->entity),
1098                                 info->selector, info->index);
1099                         ret = -EEXIST;
1100                         goto end;
1101                 }
1102         }
1103
1104         list_for_each_entry(dev, &uvc_driver.devices, list)
1105                 uvc_ctrl_add_ctrl(dev, info);
1106
1107         INIT_LIST_HEAD(&info->mappings);
1108         list_add_tail(&info->list, &uvc_driver.controls);
1109 end:
1110         mutex_unlock(&uvc_driver.ctrl_mutex);
1111         return ret;
1112 }
1113
1114 int uvc_ctrl_add_mapping(struct uvc_control_mapping *mapping)
1115 {
1116         struct uvc_control_info *info;
1117         struct uvc_control_mapping *map;
1118         int ret = -EINVAL;
1119
1120         if (mapping->id & ~V4L2_CTRL_ID_MASK) {
1121                 uvc_trace(UVC_TRACE_CONTROL, "Can't add mapping '%s' with "
1122                         "invalid control id 0x%08x\n", mapping->name,
1123                         mapping->id);
1124                 return -EINVAL;
1125         }
1126
1127         mutex_lock(&uvc_driver.ctrl_mutex);
1128         list_for_each_entry(info, &uvc_driver.controls, list) {
1129                 if (memcmp(info->entity, mapping->entity, 16) ||
1130                         info->selector != mapping->selector)
1131                         continue;
1132
1133                 if (info->size * 8 < mapping->size + mapping->offset) {
1134                         uvc_trace(UVC_TRACE_CONTROL, "Mapping '%s' would "
1135                                 "overflow control " UVC_GUID_FORMAT "/%u\n",
1136                                 mapping->name, UVC_GUID_ARGS(info->entity),
1137                                 info->selector);
1138                         ret = -EOVERFLOW;
1139                         goto end;
1140                 }
1141
1142                 /* Check if the list contains a mapping matching the new one.
1143                  * Bail out if it does.
1144                  */
1145                 list_for_each_entry(map, &info->mappings, list) {
1146                         if (map->id == mapping->id) {
1147                                 uvc_trace(UVC_TRACE_CONTROL, "Mapping '%s' is "
1148                                         "already defined.\n", mapping->name);
1149                                 ret = -EEXIST;
1150                                 goto end;
1151                         }
1152                 }
1153
1154                 mapping->ctrl = info;
1155                 list_add_tail(&mapping->list, &info->mappings);
1156                 uvc_trace(UVC_TRACE_CONTROL, "Adding mapping %s to control "
1157                         UVC_GUID_FORMAT "/%u.\n", mapping->name,
1158                         UVC_GUID_ARGS(info->entity), info->selector);
1159
1160                 ret = 0;
1161                 break;
1162         }
1163 end:
1164         mutex_unlock(&uvc_driver.ctrl_mutex);
1165         return ret;
1166 }
1167
1168 /*
1169  * Initialize device controls.
1170  */
1171 int uvc_ctrl_init_device(struct uvc_device *dev)
1172 {
1173         struct uvc_control_info *info;
1174         struct uvc_control *ctrl;
1175         struct uvc_entity *entity;
1176         unsigned int i;
1177
1178         /* Walk the entities list and instantiate controls */
1179         list_for_each_entry(entity, &dev->entities, list) {
1180                 unsigned int bControlSize = 0, ncontrols = 0;
1181                 __u8 *bmControls = NULL;
1182
1183                 if (UVC_ENTITY_TYPE(entity) == VC_EXTENSION_UNIT) {
1184                         bmControls = entity->extension.bmControls;
1185                         bControlSize = entity->extension.bControlSize;
1186                 } else if (UVC_ENTITY_TYPE(entity) == VC_PROCESSING_UNIT) {
1187                         bmControls = entity->processing.bmControls;
1188                         bControlSize = entity->processing.bControlSize;
1189                 } else if (UVC_ENTITY_TYPE(entity) == ITT_CAMERA) {
1190                         bmControls = entity->camera.bmControls;
1191                         bControlSize = entity->camera.bControlSize;
1192                 }
1193
1194                 for (i = 0; i < bControlSize; ++i)
1195                         ncontrols += hweight8(bmControls[i]);
1196
1197                 if (ncontrols == 0)
1198                         continue;
1199
1200                 entity->controls = kzalloc(ncontrols*sizeof *ctrl, GFP_KERNEL);
1201                 if (entity->controls == NULL)
1202                         return -ENOMEM;
1203
1204                 entity->ncontrols = ncontrols;
1205
1206                 ctrl = entity->controls;
1207                 for (i = 0; i < bControlSize * 8; ++i) {
1208                         if (uvc_get_bit(bmControls, i) == 0)
1209                                 continue;
1210
1211                         ctrl->entity = entity;
1212                         ctrl->index = i;
1213                         ctrl++;
1214                 }
1215         }
1216
1217         /* Walk the controls info list and associate them with the device
1218          * controls, then add the device to the global device list. This has
1219          * to be done while holding the controls lock, to make sure
1220          * uvc_ctrl_add_info() will not get called in-between.
1221          */
1222         mutex_lock(&uvc_driver.ctrl_mutex);
1223         list_for_each_entry(info, &uvc_driver.controls, list)
1224                 uvc_ctrl_add_ctrl(dev, info);
1225
1226         list_add_tail(&dev->list, &uvc_driver.devices);
1227         mutex_unlock(&uvc_driver.ctrl_mutex);
1228
1229         return 0;
1230 }
1231
1232 /*
1233  * Cleanup device controls.
1234  */
1235 void uvc_ctrl_cleanup_device(struct uvc_device *dev)
1236 {
1237         struct uvc_entity *entity;
1238         unsigned int i;
1239
1240         /* Remove the device from the global devices list */
1241         mutex_lock(&uvc_driver.ctrl_mutex);
1242         if (dev->list.next != NULL)
1243                 list_del(&dev->list);
1244         mutex_unlock(&uvc_driver.ctrl_mutex);
1245
1246         list_for_each_entry(entity, &dev->entities, list) {
1247                 for (i = 0; i < entity->ncontrols; ++i)
1248                         kfree(entity->controls[i].data);
1249
1250                 kfree(entity->controls);
1251         }
1252 }
1253
1254 void uvc_ctrl_init(void)
1255 {
1256         struct uvc_control_info *ctrl = uvc_ctrls;
1257         struct uvc_control_info *cend = ctrl + ARRAY_SIZE(uvc_ctrls);
1258         struct uvc_control_mapping *mapping = uvc_ctrl_mappings;
1259         struct uvc_control_mapping *mend =
1260                 mapping + ARRAY_SIZE(uvc_ctrl_mappings);
1261
1262         for (; ctrl < cend; ++ctrl)
1263                 uvc_ctrl_add_info(ctrl);
1264
1265         for (; mapping < mend; ++mapping)
1266                 uvc_ctrl_add_mapping(mapping);
1267 }
1268