← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/media/video/uvc/uvc_ctrl.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/video/uvc/uvc_ctrl.c
42
42
                .selector       = UVC_PU_BRIGHTNESS_CONTROL,
43
43
                .index          = 0,
44
44
                .size           = 2,
45
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
46
 
                                | UVC_CONTROL_RESTORE,
 
45
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
46
                                | UVC_CTRL_FLAG_GET_RANGE
 
47
                                | UVC_CTRL_FLAG_RESTORE,
47
48
        },
48
49
        {
49
50
                .entity         = UVC_GUID_UVC_PROCESSING,
50
51
                .selector       = UVC_PU_CONTRAST_CONTROL,
51
52
                .index          = 1,
52
53
                .size           = 2,
53
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
54
 
                                | UVC_CONTROL_RESTORE,
 
54
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
55
                                | UVC_CTRL_FLAG_GET_RANGE
 
56
                                | UVC_CTRL_FLAG_RESTORE,
55
57
        },
56
58
        {
57
59
                .entity         = UVC_GUID_UVC_PROCESSING,
58
60
                .selector       = UVC_PU_HUE_CONTROL,
59
61
                .index          = 2,
60
62
                .size           = 2,
61
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
62
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
63
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
64
                                | UVC_CTRL_FLAG_GET_RANGE
 
65
                                | UVC_CTRL_FLAG_RESTORE
 
66
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
63
67
        },
64
68
        {
65
69
                .entity         = UVC_GUID_UVC_PROCESSING,
66
70
                .selector       = UVC_PU_SATURATION_CONTROL,
67
71
                .index          = 3,
68
72
                .size           = 2,
69
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
70
 
                                | UVC_CONTROL_RESTORE,
 
73
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
74
                                | UVC_CTRL_FLAG_GET_RANGE
 
75
                                | UVC_CTRL_FLAG_RESTORE,
71
76
        },
72
77
        {
73
78
                .entity         = UVC_GUID_UVC_PROCESSING,
74
79
                .selector       = UVC_PU_SHARPNESS_CONTROL,
75
80
                .index          = 4,
76
81
                .size           = 2,
77
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
78
 
                                | UVC_CONTROL_RESTORE,
 
82
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
83
                                | UVC_CTRL_FLAG_GET_RANGE
 
84
                                | UVC_CTRL_FLAG_RESTORE,
79
85
        },
80
86
        {
81
87
                .entity         = UVC_GUID_UVC_PROCESSING,
82
88
                .selector       = UVC_PU_GAMMA_CONTROL,
83
89
                .index          = 5,
84
90
                .size           = 2,
85
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
86
 
                                | UVC_CONTROL_RESTORE,
 
91
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
92
                                | UVC_CTRL_FLAG_GET_RANGE
 
93
                                | UVC_CTRL_FLAG_RESTORE,
87
94
        },
88
95
        {
89
96
                .entity         = UVC_GUID_UVC_PROCESSING,
90
97
                .selector       = UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL,
91
98
                .index          = 6,
92
99
                .size           = 2,
93
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
94
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
100
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
101
                                | UVC_CTRL_FLAG_GET_RANGE
 
102
                                | UVC_CTRL_FLAG_RESTORE
 
103
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
95
104
        },
96
105
        {
97
106
                .entity         = UVC_GUID_UVC_PROCESSING,
98
107
                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL,
99
108
                .index          = 7,
100
109
                .size           = 4,
101
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
102
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
110
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
111
                                | UVC_CTRL_FLAG_GET_RANGE
 
112
                                | UVC_CTRL_FLAG_RESTORE
 
113
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
103
114
        },
104
115
        {
105
116
                .entity         = UVC_GUID_UVC_PROCESSING,
106
117
                .selector       = UVC_PU_BACKLIGHT_COMPENSATION_CONTROL,
107
118
                .index          = 8,
108
119
                .size           = 2,
109
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
110
 
                                | UVC_CONTROL_RESTORE,
 
120
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
121
                                | UVC_CTRL_FLAG_GET_RANGE
 
122
                                | UVC_CTRL_FLAG_RESTORE,
111
123
        },
112
124
        {
113
125
                .entity         = UVC_GUID_UVC_PROCESSING,
114
126
                .selector       = UVC_PU_GAIN_CONTROL,
115
127
                .index          = 9,
116
128
                .size           = 2,
117
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
118
 
                                | UVC_CONTROL_RESTORE,
 
129
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
130
                                | UVC_CTRL_FLAG_GET_RANGE
 
131
                                | UVC_CTRL_FLAG_RESTORE,
119
132
        },
120
133
        {
121
134
                .entity         = UVC_GUID_UVC_PROCESSING,
122
135
                .selector       = UVC_PU_POWER_LINE_FREQUENCY_CONTROL,
123
136
                .index          = 10,
124
137
                .size           = 1,
125
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
126
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
 
138
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
139
                                | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
127
140
        },
128
141
        {
129
142
                .entity         = UVC_GUID_UVC_PROCESSING,
130
143
                .selector       = UVC_PU_HUE_AUTO_CONTROL,
131
144
                .index          = 11,
132
145
                .size           = 1,
133
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
134
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
 
146
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
147
                                | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
135
148
        },
136
149
        {
137
150
                .entity         = UVC_GUID_UVC_PROCESSING,
138
151
                .selector       = UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL,
139
152
                .index          = 12,
140
153
                .size           = 1,
141
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
142
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
 
154
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
155
                                | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
143
156
        },
144
157
        {
145
158
                .entity         = UVC_GUID_UVC_PROCESSING,
146
159
                .selector       = UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL,
147
160
                .index          = 13,
148
161
                .size           = 1,
149
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
150
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
 
162
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
163
                                | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
151
164
        },
152
165
        {
153
166
                .entity         = UVC_GUID_UVC_PROCESSING,
154
167
                .selector       = UVC_PU_DIGITAL_MULTIPLIER_CONTROL,
155
168
                .index          = 14,
156
169
                .size           = 2,
157
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
158
 
                                | UVC_CONTROL_RESTORE,
 
170
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
171
                                | UVC_CTRL_FLAG_GET_RANGE
 
172
                                | UVC_CTRL_FLAG_RESTORE,
159
173
        },
160
174
        {
161
175
                .entity         = UVC_GUID_UVC_PROCESSING,
162
176
                .selector       = UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL,
163
177
                .index          = 15,
164
178
                .size           = 2,
165
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
166
 
                                | UVC_CONTROL_RESTORE,
 
179
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
180
                                | UVC_CTRL_FLAG_GET_RANGE
 
181
                                | UVC_CTRL_FLAG_RESTORE,
167
182
        },
168
183
        {
169
184
                .entity         = UVC_GUID_UVC_PROCESSING,
170
185
                .selector       = UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL,
171
186
                .index          = 16,
172
187
                .size           = 1,
173
 
                .flags          = UVC_CONTROL_GET_CUR,
 
188
                .flags          = UVC_CTRL_FLAG_GET_CUR,
174
189
        },
175
190
        {
176
191
                .entity         = UVC_GUID_UVC_PROCESSING,
177
192
                .selector       = UVC_PU_ANALOG_LOCK_STATUS_CONTROL,
178
193
                .index          = 17,
179
194
                .size           = 1,
180
 
                .flags          = UVC_CONTROL_GET_CUR,
 
195
                .flags          = UVC_CTRL_FLAG_GET_CUR,
181
196
        },
182
197
        {
183
198
                .entity         = UVC_GUID_UVC_CAMERA,
184
199
                .selector       = UVC_CT_SCANNING_MODE_CONTROL,
185
200
                .index          = 0,
186
201
                .size           = 1,
187
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
188
 
                                | UVC_CONTROL_RESTORE,
 
202
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
203
                                | UVC_CTRL_FLAG_RESTORE,
189
204
        },
190
205
        {
191
206
                .entity         = UVC_GUID_UVC_CAMERA,
192
207
                .selector       = UVC_CT_AE_MODE_CONTROL,
193
208
                .index          = 1,
194
209
                .size           = 1,
195
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
196
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_GET_RES
197
 
                                | UVC_CONTROL_RESTORE,
 
210
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
211
                                | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_GET_RES
 
212
                                | UVC_CTRL_FLAG_RESTORE,
198
213
        },
199
214
        {
200
215
                .entity         = UVC_GUID_UVC_CAMERA,
201
216
                .selector       = UVC_CT_AE_PRIORITY_CONTROL,
202
217
                .index          = 2,
203
218
                .size           = 1,
204
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
205
 
                                | UVC_CONTROL_RESTORE,
 
219
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
220
                                | UVC_CTRL_FLAG_RESTORE,
206
221
        },
207
222
        {
208
223
                .entity         = UVC_GUID_UVC_CAMERA,
209
224
                .selector       = UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL,
210
225
                .index          = 3,
211
226
                .size           = 4,
212
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
213
 
                                | UVC_CONTROL_RESTORE,
 
227
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
228
                                | UVC_CTRL_FLAG_GET_RANGE
 
229
                                | UVC_CTRL_FLAG_RESTORE,
214
230
        },
215
231
        {
216
232
                .entity         = UVC_GUID_UVC_CAMERA,
217
233
                .selector       = UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL,
218
234
                .index          = 4,
219
235
                .size           = 1,
220
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_RESTORE,
 
236
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_RESTORE,
221
237
        },
222
238
        {
223
239
                .entity         = UVC_GUID_UVC_CAMERA,
224
240
                .selector       = UVC_CT_FOCUS_ABSOLUTE_CONTROL,
225
241
                .index          = 5,
226
242
                .size           = 2,
227
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
228
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
243
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
244
                                | UVC_CTRL_FLAG_GET_RANGE
 
245
                                | UVC_CTRL_FLAG_RESTORE
 
246
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
229
247
        },
230
248
        {
231
249
                .entity         = UVC_GUID_UVC_CAMERA,
232
250
                .selector       = UVC_CT_FOCUS_RELATIVE_CONTROL,
233
251
                .index          = 6,
234
252
                .size           = 2,
235
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_MIN
236
 
                                | UVC_CONTROL_GET_MAX | UVC_CONTROL_GET_RES
237
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_AUTO_UPDATE,
 
253
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
 
254
                                | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
 
255
                                | UVC_CTRL_FLAG_GET_DEF
 
256
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
238
257
        },
239
258
        {
240
259
                .entity         = UVC_GUID_UVC_CAMERA,
241
260
                .selector       = UVC_CT_IRIS_ABSOLUTE_CONTROL,
242
261
                .index          = 7,
243
262
                .size           = 2,
244
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
245
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
263
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
264
                                | UVC_CTRL_FLAG_GET_RANGE
 
265
                                | UVC_CTRL_FLAG_RESTORE
 
266
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
246
267
        },
247
268
        {
248
269
                .entity         = UVC_GUID_UVC_CAMERA,
249
270
                .selector       = UVC_CT_IRIS_RELATIVE_CONTROL,
250
271
                .index          = 8,
251
272
                .size           = 1,
252
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_AUTO_UPDATE,
 
273
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
274
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
253
275
        },
254
276
        {
255
277
                .entity         = UVC_GUID_UVC_CAMERA,
256
278
                .selector       = UVC_CT_ZOOM_ABSOLUTE_CONTROL,
257
279
                .index          = 9,
258
280
                .size           = 2,
259
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
260
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
281
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
282
                                | UVC_CTRL_FLAG_GET_RANGE
 
283
                                | UVC_CTRL_FLAG_RESTORE
 
284
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
261
285
        },
262
286
        {
263
287
                .entity         = UVC_GUID_UVC_CAMERA,
264
288
                .selector       = UVC_CT_ZOOM_RELATIVE_CONTROL,
265
289
                .index          = 10,
266
290
                .size           = 3,
267
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_MIN
268
 
                                | UVC_CONTROL_GET_MAX | UVC_CONTROL_GET_RES
269
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_AUTO_UPDATE,
 
291
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
 
292
                                | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
 
293
                                | UVC_CTRL_FLAG_GET_DEF
 
294
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
270
295
        },
271
296
        {
272
297
                .entity         = UVC_GUID_UVC_CAMERA,
273
298
                .selector       = UVC_CT_PANTILT_ABSOLUTE_CONTROL,
274
299
                .index          = 11,
275
300
                .size           = 8,
276
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
277
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
301
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
302
                                | UVC_CTRL_FLAG_GET_RANGE
 
303
                                | UVC_CTRL_FLAG_RESTORE
 
304
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
278
305
        },
279
306
        {
280
307
                .entity         = UVC_GUID_UVC_CAMERA,
281
308
                .selector       = UVC_CT_PANTILT_RELATIVE_CONTROL,
282
309
                .index          = 12,
283
310
                .size           = 4,
284
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_MIN
285
 
                                | UVC_CONTROL_GET_MAX | UVC_CONTROL_GET_RES
286
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_AUTO_UPDATE,
 
311
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
 
312
                                | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
 
313
                                | UVC_CTRL_FLAG_GET_DEF
 
314
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
287
315
        },
288
316
        {
289
317
                .entity         = UVC_GUID_UVC_CAMERA,
290
318
                .selector       = UVC_CT_ROLL_ABSOLUTE_CONTROL,
291
319
                .index          = 13,
292
320
                .size           = 2,
293
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_RANGE
294
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
321
                .flags          = UVC_CTRL_FLAG_SET_CUR
 
322
                                | UVC_CTRL_FLAG_GET_RANGE
 
323
                                | UVC_CTRL_FLAG_RESTORE
 
324
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
295
325
        },
296
326
        {
297
327
                .entity         = UVC_GUID_UVC_CAMERA,
298
328
                .selector       = UVC_CT_ROLL_RELATIVE_CONTROL,
299
329
                .index          = 14,
300
330
                .size           = 2,
301
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_MIN
302
 
                                | UVC_CONTROL_GET_MAX | UVC_CONTROL_GET_RES
303
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_AUTO_UPDATE,
 
331
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_MIN
 
332
                                | UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES
 
333
                                | UVC_CTRL_FLAG_GET_DEF
 
334
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
304
335
        },
305
336
        {
306
337
                .entity         = UVC_GUID_UVC_CAMERA,
307
338
                .selector       = UVC_CT_FOCUS_AUTO_CONTROL,
308
339
                .index          = 17,
309
340
                .size           = 1,
310
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
311
 
                                | UVC_CONTROL_GET_DEF | UVC_CONTROL_RESTORE,
 
341
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
342
                                | UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_RESTORE,
312
343
        },
313
344
        {
314
345
                .entity         = UVC_GUID_UVC_CAMERA,
315
346
                .selector       = UVC_CT_PRIVACY_CONTROL,
316
347
                .index          = 18,
317
348
                .size           = 1,
318
 
                .flags          = UVC_CONTROL_SET_CUR | UVC_CONTROL_GET_CUR
319
 
                                | UVC_CONTROL_RESTORE | UVC_CONTROL_AUTO_UPDATE,
 
349
                .flags          = UVC_CTRL_FLAG_SET_CUR | UVC_CTRL_FLAG_GET_CUR
 
350
                                | UVC_CTRL_FLAG_RESTORE
 
351
                                | UVC_CTRL_FLAG_AUTO_UPDATE,
320
352
        },
321
353
};
322
354
 
816
848
{
817
849
        int ret;
818
850
 
819
 
        if (ctrl->info.flags & UVC_CONTROL_GET_DEF) {
 
851
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_DEF) {
820
852
                ret = uvc_query_ctrl(chain->dev, UVC_GET_DEF, ctrl->entity->id,
821
853
                                     chain->dev->intfnum, ctrl->info.selector,
822
854
                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF),
825
857
                        return ret;
826
858
        }
827
859
 
828
 
        if (ctrl->info.flags & UVC_CONTROL_GET_MIN) {
 
860
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MIN) {
829
861
                ret = uvc_query_ctrl(chain->dev, UVC_GET_MIN, ctrl->entity->id,
830
862
                                     chain->dev->intfnum, ctrl->info.selector,
831
863
                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN),
833
865
                if (ret < 0)
834
866
                        return ret;
835
867
        }
836
 
        if (ctrl->info.flags & UVC_CONTROL_GET_MAX) {
 
868
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MAX) {
837
869
                ret = uvc_query_ctrl(chain->dev, UVC_GET_MAX, ctrl->entity->id,
838
870
                                     chain->dev->intfnum, ctrl->info.selector,
839
871
                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX),
841
873
                if (ret < 0)
842
874
                        return ret;
843
875
        }
844
 
        if (ctrl->info.flags & UVC_CONTROL_GET_RES) {
 
876
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES) {
845
877
                ret = uvc_query_ctrl(chain->dev, UVC_GET_RES, ctrl->entity->id,
846
878
                                     chain->dev->intfnum, ctrl->info.selector,
847
879
                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES),
879
911
        strlcpy(v4l2_ctrl->name, mapping->name, sizeof v4l2_ctrl->name);
880
912
        v4l2_ctrl->flags = 0;
881
913
 
882
 
        if (!(ctrl->info.flags & UVC_CONTROL_GET_CUR))
 
914
        if (!(ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR))
883
915
                v4l2_ctrl->flags |= V4L2_CTRL_FLAG_WRITE_ONLY;
884
 
        if (!(ctrl->info.flags & UVC_CONTROL_SET_CUR))
 
916
        if (!(ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR))
885
917
                v4l2_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
886
918
 
887
919
        if (!ctrl->cached) {
890
922
                        goto done;
891
923
        }
892
924
 
893
 
        if (ctrl->info.flags & UVC_CONTROL_GET_DEF) {
 
925
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_DEF) {
894
926
                v4l2_ctrl->default_value = mapping->get(mapping, UVC_GET_DEF,
895
927
                                uvc_ctrl_data(ctrl, UVC_CTRL_DATA_DEF));
896
928
        }
927
959
                break;
928
960
        }
929
961
 
930
 
        if (ctrl->info.flags & UVC_CONTROL_GET_MIN)
 
962
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MIN)
931
963
                v4l2_ctrl->minimum = mapping->get(mapping, UVC_GET_MIN,
932
964
                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MIN));
933
965
 
934
 
        if (ctrl->info.flags & UVC_CONTROL_GET_MAX)
 
966
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_MAX)
935
967
                v4l2_ctrl->maximum = mapping->get(mapping, UVC_GET_MAX,
936
968
                                     uvc_ctrl_data(ctrl, UVC_CTRL_DATA_MAX));
937
969
 
938
 
        if (ctrl->info.flags & UVC_CONTROL_GET_RES)
 
970
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES)
939
971
                v4l2_ctrl->step = mapping->get(mapping, UVC_GET_RES,
940
972
                                  uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
941
973
 
983
1015
        }
984
1016
 
985
1017
        menu_info = &mapping->menu_info[query_menu->index];
 
1018
 
 
1019
        if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES) {
 
1020
                s32 bitmap;
 
1021
 
 
1022
                if (!ctrl->cached) {
 
1023
                        ret = uvc_ctrl_populate_cache(chain, ctrl);
 
1024
                        if (ret < 0)
 
1025
                                goto done;
 
1026
                }
 
1027
 
 
1028
                bitmap = mapping->get(mapping, UVC_GET_RES,
 
1029
                                      uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
 
1030
                if (!(bitmap & menu_info->value)) {
 
1031
                        ret = -EINVAL;
 
1032
                        goto done;
 
1033
                }
 
1034
        }
 
1035
 
986
1036
        strlcpy(query_menu->name, menu_info->name, sizeof query_menu->name);
987
1037
 
988
1038
done:
1039
1089
                 * marked as loaded in uvc_ctrl_get/uvc_ctrl_set to prevent
1040
1090
                 * uvc_ctrl_get from using the cached value.
1041
1091
                 */
1042
 
                if (ctrl->info.flags & UVC_CONTROL_AUTO_UPDATE)
 
1092
                if (ctrl->info.flags & UVC_CTRL_FLAG_AUTO_UPDATE)
1043
1093
                        ctrl->loaded = 0;
1044
1094
 
1045
1095
                if (!ctrl->dirty)
1094
1144
        int ret;
1095
1145
 
1096
1146
        ctrl = uvc_find_control(chain, xctrl->id, &mapping);
1097
 
        if (ctrl == NULL || (ctrl->info.flags & UVC_CONTROL_GET_CUR) == 0)
 
1147
        if (ctrl == NULL || (ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) == 0)
1098
1148
                return -EINVAL;
1099
1149
 
1100
1150
        if (!ctrl->loaded) {
1136
1186
        int ret;
1137
1187
 
1138
1188
        ctrl = uvc_find_control(chain, xctrl->id, &mapping);
1139
 
        if (ctrl == NULL || (ctrl->info.flags & UVC_CONTROL_SET_CUR) == 0)
 
1189
        if (ctrl == NULL || (ctrl->info.flags & UVC_CTRL_FLAG_SET_CUR) == 0)
1140
1190
                return -EINVAL;
1141
1191
 
1142
1192
        /* Clamp out of range values. */
1171
1221
                if (xctrl->value < 0 || xctrl->value >= mapping->menu_count)
1172
1222
                        return -ERANGE;
1173
1223
                value = mapping->menu_info[xctrl->value].value;
 
1224
 
 
1225
                /* Valid menu indices are reported by the GET_RES request for
 
1226
                 * UVC controls that support it.
 
1227
                 */
 
1228
                if (ctrl->info.flags & UVC_CTRL_FLAG_GET_RES) {
 
1229
                        if (!ctrl->cached) {
 
1230
                                ret = uvc_ctrl_populate_cache(chain, ctrl);
 
1231
                                if (ret < 0)
 
1232
                                        return ret;
 
1233
                        }
 
1234
 
 
1235
                        step = mapping->get(mapping, UVC_GET_RES,
 
1236
                                        uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES));
 
1237
                        if (!(step & value))
 
1238
                                return -ERANGE;
 
1239
                }
 
1240
 
1174
1241
                break;
1175
1242
 
1176
1243
        default:
1183
1250
         * operation.
1184
1251
         */
1185
1252
        if (!ctrl->loaded && (ctrl->info.size * 8) != mapping->size) {
1186
 
                if ((ctrl->info.flags & UVC_CONTROL_GET_CUR) == 0) {
 
1253
                if ((ctrl->info.flags & UVC_CTRL_FLAG_GET_CUR) == 0) {
1187
1254
                        memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1188
1255
                                0, ctrl->info.size);
1189
1256
                } else {
1230
1297
 
1231
1298
        static const struct uvc_ctrl_fixup fixups[] = {
1232
1299
                { { USB_DEVICE(0x046d, 0x08c2) }, 9, 1,
1233
 
                        UVC_CONTROL_GET_MIN | UVC_CONTROL_GET_MAX |
1234
 
                        UVC_CONTROL_GET_DEF | UVC_CONTROL_SET_CUR |
1235
 
                        UVC_CONTROL_AUTO_UPDATE },
 
1300
                        UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX |
 
1301
                        UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_SET_CUR |
 
1302
                        UVC_CTRL_FLAG_AUTO_UPDATE },
1236
1303
                { { USB_DEVICE(0x046d, 0x08cc) }, 9, 1,
1237
 
                        UVC_CONTROL_GET_MIN | UVC_CONTROL_GET_MAX |
1238
 
                        UVC_CONTROL_GET_DEF | UVC_CONTROL_SET_CUR |
1239
 
                        UVC_CONTROL_AUTO_UPDATE },
 
1304
                        UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX |
 
1305
                        UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_SET_CUR |
 
1306
                        UVC_CTRL_FLAG_AUTO_UPDATE },
1240
1307
                { { USB_DEVICE(0x046d, 0x0994) }, 9, 1,
1241
 
                        UVC_CONTROL_GET_MIN | UVC_CONTROL_GET_MAX |
1242
 
                        UVC_CONTROL_GET_DEF | UVC_CONTROL_SET_CUR |
1243
 
                        UVC_CONTROL_AUTO_UPDATE },
 
1308
                        UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX |
 
1309
                        UVC_CTRL_FLAG_GET_DEF | UVC_CTRL_FLAG_SET_CUR |
 
1310
                        UVC_CTRL_FLAG_AUTO_UPDATE },
1244
1311
        };
1245
1312
 
1246
1313
        unsigned int i;
1297
1364
                goto done;
1298
1365
        }
1299
1366
 
1300
 
        info->flags = UVC_CONTROL_GET_MIN | UVC_CONTROL_GET_MAX
1301
 
                    | UVC_CONTROL_GET_RES | UVC_CONTROL_GET_DEF
1302
 
                    | (data[0] & UVC_CONTROL_CAP_GET ? UVC_CONTROL_GET_CUR : 0)
1303
 
                    | (data[0] & UVC_CONTROL_CAP_SET ? UVC_CONTROL_SET_CUR : 0)
 
1367
        info->flags = UVC_CTRL_FLAG_GET_MIN | UVC_CTRL_FLAG_GET_MAX
 
1368
                    | UVC_CTRL_FLAG_GET_RES | UVC_CTRL_FLAG_GET_DEF
 
1369
                    | (data[0] & UVC_CONTROL_CAP_GET ?
 
1370
                       UVC_CTRL_FLAG_GET_CUR : 0)
 
1371
                    | (data[0] & UVC_CONTROL_CAP_SET ?
 
1372
                       UVC_CTRL_FLAG_SET_CUR : 0)
1304
1373
                    | (data[0] & UVC_CONTROL_CAP_AUTOUPDATE ?
1305
 
                       UVC_CONTROL_AUTO_UPDATE : 0);
 
1374
                       UVC_CTRL_FLAG_AUTO_UPDATE : 0);
1306
1375
 
1307
1376
        uvc_ctrl_fixup_xu_info(dev, ctrl, info);
1308
1377
 
1309
1378
        uvc_trace(UVC_TRACE_CONTROL, "XU control %pUl/%u queried: len %u, "
1310
1379
                  "flags { get %u set %u auto %u }.\n",
1311
1380
                  info->entity, info->selector, info->size,
1312
 
                  (info->flags & UVC_CONTROL_GET_CUR) ? 1 : 0,
1313
 
                  (info->flags & UVC_CONTROL_SET_CUR) ? 1 : 0,
1314
 
                  (info->flags & UVC_CONTROL_AUTO_UPDATE) ? 1 : 0);
 
1381
                  (info->flags & UVC_CTRL_FLAG_GET_CUR) ? 1 : 0,
 
1382
                  (info->flags & UVC_CTRL_FLAG_SET_CUR) ? 1 : 0,
 
1383
                  (info->flags & UVC_CTRL_FLAG_AUTO_UPDATE) ? 1 : 0);
1315
1384
 
1316
1385
done:
1317
1386
        kfree(data);
1344
1413
}
1345
1414
 
1346
1415
int uvc_xu_ctrl_query(struct uvc_video_chain *chain,
1347
 
        struct uvc_xu_control *xctrl, int set)
 
1416
        struct uvc_xu_control_query *xqry)
1348
1417
{
1349
1418
        struct uvc_entity *entity;
1350
 
        struct uvc_control *ctrl = NULL;
 
1419
        struct uvc_control *ctrl;
1351
1420
        unsigned int i, found = 0;
1352
 
        int restore = 0;
1353
 
        __u8 *data;
 
1421
        __u32 reqflags;
 
1422
        __u16 size;
 
1423
        __u8 *data = NULL;
1354
1424
        int ret;
1355
1425
 
1356
1426
        /* Find the extension unit. */
1357
1427
        list_for_each_entry(entity, &chain->entities, chain) {
1358
1428
                if (UVC_ENTITY_TYPE(entity) == UVC_VC_EXTENSION_UNIT &&
1359
 
                    entity->id == xctrl->unit)
 
1429
                    entity->id == xqry->unit)
1360
1430
                        break;
1361
1431
        }
1362
1432
 
1363
 
        if (entity->id != xctrl->unit) {
 
1433
        if (entity->id != xqry->unit) {
1364
1434
                uvc_trace(UVC_TRACE_CONTROL, "Extension unit %u not found.\n",
1365
 
                        xctrl->unit);
1366
 
                return -EINVAL;
 
1435
                        xqry->unit);
 
1436
                return -ENOENT;
1367
1437
        }
1368
1438
 
1369
1439
        /* Find the control and perform delayed initialization if needed. */
1370
1440
        for (i = 0; i < entity->ncontrols; ++i) {
1371
1441
                ctrl = &entity->controls[i];
1372
 
                if (ctrl->index == xctrl->selector - 1) {
 
1442
                if (ctrl->index == xqry->selector - 1) {
1373
1443
                        found = 1;
1374
1444
                        break;
1375
1445
                }
1377
1447
 
1378
1448
        if (!found) {
1379
1449
                uvc_trace(UVC_TRACE_CONTROL, "Control %pUl/%u not found.\n",
1380
 
                        entity->extension.guidExtensionCode, xctrl->selector);
1381
 
                return -EINVAL;
 
1450
                        entity->extension.guidExtensionCode, xqry->selector);
 
1451
                return -ENOENT;
1382
1452
        }
1383
1453
 
1384
1454
        if (mutex_lock_interruptible(&chain->ctrl_mutex))
1390
1460
                goto done;
1391
1461
        }
1392
1462
 
1393
 
        /* Validate control data size. */
1394
 
        if (ctrl->info.size != xctrl->size) {
1395
 
                ret = -EINVAL;
1396
 
                goto done;
1397
 
        }
1398
 
 
1399
 
        if ((set && !(ctrl->info.flags & UVC_CONTROL_SET_CUR)) ||
1400
 
            (!set && !(ctrl->info.flags & UVC_CONTROL_GET_CUR))) {
1401
 
                ret = -EINVAL;
1402
 
                goto done;
1403
 
        }
1404
 
 
1405
 
        memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
1406
 
               uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1407
 
               ctrl->info.size);
1408
 
        data = uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT);
1409
 
        restore = set;
1410
 
 
1411
 
        if (set && copy_from_user(data, xctrl->data, xctrl->size)) {
 
1463
        /* Validate the required buffer size and flags for the request */
 
1464
        reqflags = 0;
 
1465
        size = ctrl->info.size;
 
1466
 
 
1467
        switch (xqry->query) {
 
1468
        case UVC_GET_CUR:
 
1469
                reqflags = UVC_CTRL_FLAG_GET_CUR;
 
1470
                break;
 
1471
        case UVC_GET_MIN:
 
1472
                reqflags = UVC_CTRL_FLAG_GET_MIN;
 
1473
                break;
 
1474
        case UVC_GET_MAX:
 
1475
                reqflags = UVC_CTRL_FLAG_GET_MAX;
 
1476
                break;
 
1477
        case UVC_GET_DEF:
 
1478
                reqflags = UVC_CTRL_FLAG_GET_DEF;
 
1479
                break;
 
1480
        case UVC_GET_RES:
 
1481
                reqflags = UVC_CTRL_FLAG_GET_RES;
 
1482
                break;
 
1483
        case UVC_SET_CUR:
 
1484
                reqflags = UVC_CTRL_FLAG_SET_CUR;
 
1485
                break;
 
1486
        case UVC_GET_LEN:
 
1487
                size = 2;
 
1488
                break;
 
1489
        case UVC_GET_INFO:
 
1490
                size = 1;
 
1491
                break;
 
1492
        default:
 
1493
                ret = -EINVAL;
 
1494
                goto done;
 
1495
        }
 
1496
 
 
1497
        if (size != xqry->size) {
 
1498
                ret = -ENOBUFS;
 
1499
                goto done;
 
1500
        }
 
1501
 
 
1502
        if (reqflags && !(ctrl->info.flags & reqflags)) {
 
1503
                ret = -EBADRQC;
 
1504
                goto done;
 
1505
        }
 
1506
 
 
1507
        data = kmalloc(size, GFP_KERNEL);
 
1508
        if (data == NULL) {
 
1509
                ret = -ENOMEM;
 
1510
                goto done;
 
1511
        }
 
1512
 
 
1513
        if (xqry->query == UVC_SET_CUR &&
 
1514
            copy_from_user(data, xqry->data, size)) {
1412
1515
                ret = -EFAULT;
1413
1516
                goto done;
1414
1517
        }
1415
1518
 
1416
 
        ret = uvc_query_ctrl(chain->dev, set ? UVC_SET_CUR : UVC_GET_CUR,
1417
 
                             xctrl->unit, chain->dev->intfnum, xctrl->selector,
1418
 
                             data, xctrl->size);
 
1519
        ret = uvc_query_ctrl(chain->dev, xqry->query, xqry->unit,
 
1520
                             chain->dev->intfnum, xqry->selector, data, size);
1419
1521
        if (ret < 0)
1420
1522
                goto done;
1421
1523
 
1422
 
        if (!set && copy_to_user(xctrl->data, data, xctrl->size))
 
1524
        if (xqry->query != UVC_SET_CUR &&
 
1525
            copy_to_user(xqry->data, data, size))
1423
1526
                ret = -EFAULT;
1424
1527
done:
1425
 
        if (ret && restore)
1426
 
                memcpy(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_CURRENT),
1427
 
                       uvc_ctrl_data(ctrl, UVC_CTRL_DATA_BACKUP),
1428
 
                       xctrl->size);
1429
 
 
 
1528
        kfree(data);
1430
1529
        mutex_unlock(&chain->ctrl_mutex);
1431
1530
        return ret;
1432
1531
}
1458
1557
                        ctrl = &entity->controls[i];
1459
1558
 
1460
1559
                        if (!ctrl->initialized || !ctrl->modified ||
1461
 
                            (ctrl->info.flags & UVC_CONTROL_RESTORE) == 0)
 
1560
                            (ctrl->info.flags & UVC_CTRL_FLAG_RESTORE) == 0)
1462
1561
                                continue;
1463
1562
 
1464
1563
                        printk(KERN_INFO "restoring control %pUl/%u/%u\n",