]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/media/video/gspca/t613.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


74ca17845223e297c6087d423dd8745824ef2994
[mirror_ubuntu-bionic-kernel.git] / drivers / media / video / gspca / t613.c
1 /*
2 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 *Notes: * t613 + tas5130A
19 * * Focus to light do not balance well as in win.
20 * Quality in win is not good, but its kinda better.
21 * * Fix some "extraneous bytes", most of apps will show the image anyway
22 * * Gamma table, is there, but its really doing something?
23 * * 7~8 Fps, its ok, max on win its 10.
24 * Costantino Leandro
25 */
26
27 #define MODULE_NAME "t613"
28
29 #include "gspca.h"
30
31 #define V4L2_CID_EFFECTS (V4L2_CID_PRIVATE_BASE + 0)
32
33 MODULE_AUTHOR("Leandro Costantino <le_costantino@pixartargentina.com.ar>");
34 MODULE_DESCRIPTION("GSPCA/T613 (JPEG Compliance) USB Camera Driver");
35 MODULE_LICENSE("GPL");
36
37 struct sd {
38 struct gspca_dev gspca_dev; /* !! must be the first item */
39
40 unsigned char brightness;
41 unsigned char contrast;
42 unsigned char colors;
43 unsigned char autogain;
44 unsigned char gamma;
45 unsigned char sharpness;
46 unsigned char freq;
47 unsigned char whitebalance;
48 unsigned char mirror;
49 unsigned char effect;
50
51 __u8 sensor;
52 #define SENSOR_TAS5130A 0
53 #define SENSOR_OM6802 1
54 };
55
56 /* V4L2 controls supported by the driver */
57 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
58 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
59 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
60 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
61 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
62 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
63 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val);
64 static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val);
65 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
66 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
67 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
68 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
69 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
70 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
71 static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val);
72 static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val);
73 static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val);
74 static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val);
75 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
76 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
77 static int sd_querymenu(struct gspca_dev *gspca_dev,
78 struct v4l2_querymenu *menu);
79
80 static struct ctrl sd_ctrls[] = {
81 #define SD_BRIGHTNESS 0
82 {
83 {
84 .id = V4L2_CID_BRIGHTNESS,
85 .type = V4L2_CTRL_TYPE_INTEGER,
86 .name = "Brightness",
87 .minimum = 0,
88 .maximum = 14,
89 .step = 1,
90 .default_value = 8,
91 },
92 .set = sd_setbrightness,
93 .get = sd_getbrightness,
94 },
95 #define SD_CONTRAST 1
96 {
97 {
98 .id = V4L2_CID_CONTRAST,
99 .type = V4L2_CTRL_TYPE_INTEGER,
100 .name = "Contrast",
101 .minimum = 0,
102 .maximum = 0x0d,
103 .step = 1,
104 .default_value = 0x07,
105 },
106 .set = sd_setcontrast,
107 .get = sd_getcontrast,
108 },
109 #define SD_COLOR 2
110 {
111 {
112 .id = V4L2_CID_SATURATION,
113 .type = V4L2_CTRL_TYPE_INTEGER,
114 .name = "Color",
115 .minimum = 0,
116 .maximum = 0x0f,
117 .step = 1,
118 .default_value = 0x05,
119 },
120 .set = sd_setcolors,
121 .get = sd_getcolors,
122 },
123 #define GAMMA_MAX 16
124 #define GAMMA_DEF 10
125 {
126 {
127 .id = V4L2_CID_GAMMA, /* (gamma on win) */
128 .type = V4L2_CTRL_TYPE_INTEGER,
129 .name = "Gamma",
130 .minimum = 0,
131 .maximum = GAMMA_MAX - 1,
132 .step = 1,
133 .default_value = GAMMA_DEF,
134 },
135 .set = sd_setgamma,
136 .get = sd_getgamma,
137 },
138 #define SD_AUTOGAIN 4
139 {
140 {
141 .id = V4L2_CID_GAIN, /* here, i activate only the lowlight,
142 * some apps dont bring up the
143 * backligth_compensation control) */
144 .type = V4L2_CTRL_TYPE_INTEGER,
145 .name = "Low Light",
146 .minimum = 0,
147 .maximum = 1,
148 .step = 1,
149 .default_value = 0x01,
150 },
151 .set = sd_setlowlight,
152 .get = sd_getlowlight,
153 },
154 #define SD_MIRROR 5
155 {
156 {
157 .id = V4L2_CID_HFLIP,
158 .type = V4L2_CTRL_TYPE_BOOLEAN,
159 .name = "Mirror Image",
160 .minimum = 0,
161 .maximum = 1,
162 .step = 1,
163 .default_value = 0,
164 },
165 .set = sd_setflip,
166 .get = sd_getflip
167 },
168 #define SD_LIGHTFREQ 6
169 {
170 {
171 .id = V4L2_CID_POWER_LINE_FREQUENCY,
172 .type = V4L2_CTRL_TYPE_MENU,
173 .name = "Light Frequency Filter",
174 .minimum = 1, /* 1 -> 0x50, 2->0x60 */
175 .maximum = 2,
176 .step = 1,
177 .default_value = 1,
178 },
179 .set = sd_setfreq,
180 .get = sd_getfreq},
181
182 #define SD_WHITE_BALANCE 7
183 {
184 {
185 .id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
186 .type = V4L2_CTRL_TYPE_INTEGER,
187 .name = "White Balance",
188 .minimum = 0,
189 .maximum = 1,
190 .step = 1,
191 .default_value = 0,
192 },
193 .set = sd_setwhitebalance,
194 .get = sd_getwhitebalance
195 },
196 #define SD_SHARPNESS 8 /* (aka definition on win) */
197 {
198 {
199 .id = V4L2_CID_SHARPNESS,
200 .type = V4L2_CTRL_TYPE_INTEGER,
201 .name = "Sharpness",
202 .minimum = 0,
203 .maximum = 15,
204 .step = 1,
205 .default_value = 0x06,
206 },
207 .set = sd_setsharpness,
208 .get = sd_getsharpness,
209 },
210 #define SD_EFFECTS 9
211 {
212 {
213 .id = V4L2_CID_EFFECTS,
214 .type = V4L2_CTRL_TYPE_MENU,
215 .name = "Webcam Effects",
216 .minimum = 0,
217 .maximum = 4,
218 .step = 1,
219 .default_value = 0,
220 },
221 .set = sd_seteffect,
222 .get = sd_geteffect
223 },
224 };
225
226 static char *effects_control[] = {
227 "Normal",
228 "Emboss", /* disabled */
229 "Monochrome",
230 "Sepia",
231 "Sketch",
232 "Sun Effect", /* disabled */
233 "Negative",
234 };
235
236 static const struct v4l2_pix_format vga_mode_t16[] = {
237 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
238 .bytesperline = 160,
239 .sizeimage = 160 * 120 * 4 / 8 + 590,
240 .colorspace = V4L2_COLORSPACE_JPEG,
241 .priv = 4},
242 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
243 .bytesperline = 176,
244 .sizeimage = 176 * 144 * 3 / 8 + 590,
245 .colorspace = V4L2_COLORSPACE_JPEG,
246 .priv = 3},
247 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
248 .bytesperline = 320,
249 .sizeimage = 320 * 240 * 3 / 8 + 590,
250 .colorspace = V4L2_COLORSPACE_JPEG,
251 .priv = 2},
252 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
253 .bytesperline = 352,
254 .sizeimage = 352 * 288 * 3 / 8 + 590,
255 .colorspace = V4L2_COLORSPACE_JPEG,
256 .priv = 1},
257 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
258 .bytesperline = 640,
259 .sizeimage = 640 * 480 * 3 / 8 + 590,
260 .colorspace = V4L2_COLORSPACE_JPEG,
261 .priv = 0},
262 };
263
264 /* sensor specific data */
265 struct additional_sensor_data {
266 const __u8 data1[20];
267 const __u8 data2[18];
268 const __u8 data3[18];
269 const __u8 data4[4];
270 const __u8 data5[6];
271 const __u8 stream[4];
272 };
273
274 const static struct additional_sensor_data sensor_data[] = {
275 { /* TAS5130A */
276 .data1 =
277 {0xd0, 0xbb, 0xd1, 0x28, 0xd2, 0x10, 0xd3, 0x10,
278 0xd4, 0xbb, 0xd5, 0x28, 0xd6, 0x1e, 0xd7, 0x27,
279 0xd8, 0xc8, 0xd9, 0xfc},
280 .data2 =
281 {0xe0, 0x60, 0xe1, 0xa8, 0xe2, 0xe0, 0xe3, 0x60,
282 0xe4, 0xa8, 0xe5, 0xe0, 0xe6, 0x60, 0xe7, 0xa8,
283 0xe8, 0xe0},
284 .data3 =
285 {0xc7, 0x60, 0xc8, 0xa8, 0xc9, 0xe0, 0xca, 0x60,
286 0xcb, 0xa8, 0xcc, 0xe0, 0xcd, 0x60, 0xce, 0xa8,
287 0xcf, 0xe0},
288 .data4 = /* Freq (50/60Hz). Splitted for test purpose */
289 {0x66, 0x00, 0xa8, 0xe8},
290 .data5 =
291 {0x0c, 0x03, 0xab, 0x10, 0x81, 0x20},
292 .stream =
293 {0x0b, 0x04, 0x0a, 0x40},
294 },
295 { /* OM6802 */
296 .data1 =
297 {0xd0, 0xc2, 0xd1, 0x28, 0xd2, 0x0f, 0xd3, 0x22,
298 0xd4, 0xcd, 0xd5, 0x27, 0xd6, 0x2c, 0xd7, 0x06,
299 0xd8, 0xb3, 0xd9, 0xfc},
300 .data2 =
301 {0xe0, 0x80, 0xe1, 0xff, 0xe2, 0xff, 0xe3, 0x80,
302 0xe4, 0xff, 0xe5, 0xff, 0xe6, 0x80, 0xe7, 0xff,
303 0xe8, 0xff},
304 .data3 =
305 {0xc7, 0x80, 0xc8, 0xff, 0xc9, 0xff, 0xca, 0x80,
306 0xcb, 0xff, 0xcc, 0xff, 0xcd, 0x80, 0xce, 0xff,
307 0xcf, 0xff},
308 .data4 = /*Freq (50/60Hz). Splitted for test purpose */
309 {0x66, 0xca, 0xa8, 0xf0 },
310 .data5 = /* this could be removed later */
311 {0x0c, 0x03, 0xab, 0x13, 0x81, 0x23},
312 .stream =
313 {0x0b, 0x04, 0x0a, 0x78},
314 }
315 };
316
317 #define MAX_EFFECTS 7
318 /* easily done by soft, this table could be removed,
319 * i keep it here just in case */
320 static const __u8 effects_table[MAX_EFFECTS][6] = {
321 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00}, /* Normal */
322 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04}, /* Repujar */
323 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x20}, /* Monochrome */
324 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x80}, /* Sepia */
325 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x02}, /* Croquis */
326 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x10}, /* Sun Effect */
327 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40}, /* Negative */
328 };
329
330 static const __u8 gamma_table[GAMMA_MAX][34] = {
331 {0x90, 0x00, 0x91, 0x3e, 0x92, 0x69, 0x93, 0x85, /* 0 */
332 0x94, 0x95, 0x95, 0xa1, 0x96, 0xae, 0x97, 0xb9,
333 0x98, 0xc2, 0x99, 0xcb, 0x9a, 0xd4, 0x9b, 0xdb,
334 0x9c, 0xe3, 0x9d, 0xea, 0x9e, 0xf1, 0x9f, 0xf8,
335 0xa0, 0xff},
336 {0x90, 0x00, 0x91, 0x33, 0x92, 0x5a, 0x93, 0x75, /* 1 */
337 0x94, 0x85, 0x95, 0x93, 0x96, 0xa1, 0x97, 0xad,
338 0x98, 0xb7, 0x99, 0xc2, 0x9a, 0xcb, 0x9b, 0xd4,
339 0x9c, 0xde, 0x9D, 0xe7, 0x9e, 0xf0, 0x9f, 0xf7,
340 0xa0, 0xff},
341 {0x90, 0x00, 0x91, 0x2f, 0x92, 0x51, 0x93, 0x6b, /* 2 */
342 0x94, 0x7c, 0x95, 0x8a, 0x96, 0x99, 0x97, 0xa6,
343 0x98, 0xb1, 0x99, 0xbc, 0x9a, 0xc6, 0x9b, 0xd0,
344 0x9c, 0xdb, 0x9d, 0xe4, 0x9e, 0xed, 0x9f, 0xf6,
345 0xa0, 0xff},
346 {0x90, 0x00, 0x91, 0x29, 0x92, 0x48, 0x93, 0x60, /* 3 */
347 0x94, 0x72, 0x95, 0x81, 0x96, 0x90, 0x97, 0x9e,
348 0x98, 0xaa, 0x99, 0xb5, 0x9a, 0xbf, 0x9b, 0xcb,
349 0x9c, 0xd6, 0x9d, 0xe1, 0x9e, 0xeb, 0x9f, 0xf5,
350 0xa0, 0xff},
351 {0x90, 0x00, 0x91, 0x23, 0x92, 0x3f, 0x93, 0x55, /* 4 */
352 0x94, 0x68, 0x95, 0x77, 0x96, 0x86, 0x97, 0x95,
353 0x98, 0xa2, 0x99, 0xad, 0x9a, 0xb9, 0x9b, 0xc6,
354 0x9c, 0xd2, 0x9d, 0xde, 0x9e, 0xe9, 0x9f, 0xf4,
355 0xa0, 0xff},
356 {0x90, 0x00, 0x91, 0x1b, 0x92, 0x33, 0x93, 0x48, /* 5 */
357 0x94, 0x59, 0x95, 0x69, 0x96, 0x79, 0x97, 0x87,
358 0x98, 0x96, 0x99, 0xa3, 0x9a, 0xb1, 0x9b, 0xbe,
359 0x9c, 0xcc, 0x9d, 0xda, 0x9e, 0xe7, 0x9f, 0xf3,
360 0xa0, 0xff},
361 {0x90, 0x00, 0x91, 0x02, 0x92, 0x10, 0x93, 0x20, /* 6 */
362 0x94, 0x32, 0x95, 0x40, 0x96, 0x57, 0x97, 0x67,
363 0x98, 0x77, 0x99, 0x88, 0x9a, 0x99, 0x9b, 0xaa,
364 0x9c, 0xbb, 0x9d, 0xcc, 0x9e, 0xdd, 0x9f, 0xee,
365 0xa0, 0xff},
366 {0x90, 0x00, 0x91, 0x02, 0x92, 0x14, 0x93, 0x26, /* 7 */
367 0x94, 0x38, 0x95, 0x4a, 0x96, 0x60, 0x97, 0x70,
368 0x98, 0x80, 0x99, 0x90, 0x9a, 0xa0, 0x9b, 0xb0,
369 0x9c, 0xc0, 0x9D, 0xd0, 0x9e, 0xe0, 0x9f, 0xf0,
370 0xa0, 0xff},
371 {0x90, 0x00, 0x91, 0x10, 0x92, 0x22, 0x93, 0x35, /* 8 */
372 0x94, 0x47, 0x95, 0x5a, 0x96, 0x69, 0x97, 0x79,
373 0x98, 0x88, 0x99, 0x97, 0x9a, 0xa7, 0x9b, 0xb6,
374 0x9c, 0xc4, 0x9d, 0xd3, 0x9e, 0xe0, 0x9f, 0xf0,
375 0xa0, 0xff},
376 {0x90, 0x00, 0x91, 0x10, 0x92, 0x26, 0x93, 0x40, /* 9 */
377 0x94, 0x54, 0x95, 0x65, 0x96, 0x75, 0x97, 0x84,
378 0x98, 0x93, 0x99, 0xa1, 0x9a, 0xb0, 0x9b, 0xbd,
379 0x9c, 0xca, 0x9d, 0xd6, 0x9e, 0xe0, 0x9f, 0xf0,
380 0xa0, 0xff},
381 {0x90, 0x00, 0x91, 0x18, 0x92, 0x2b, 0x93, 0x44, /* 10 */
382 0x94, 0x60, 0x95, 0x70, 0x96, 0x80, 0x97, 0x8e,
383 0x98, 0x9c, 0x99, 0xaa, 0x9a, 0xb7, 0x9b, 0xc4,
384 0x9c, 0xd0, 0x9d, 0xd8, 0x9e, 0xe2, 0x9f, 0xf0,
385 0xa0, 0xff},
386 {0x90, 0x00, 0x91, 0x1a, 0x92, 0x34, 0x93, 0x52, /* 11 */
387 0x94, 0x66, 0x95, 0x7e, 0x96, 0x8D, 0x97, 0x9B,
388 0x98, 0xa8, 0x99, 0xb4, 0x9a, 0xc0, 0x9b, 0xcb,
389 0x9c, 0xd6, 0x9d, 0xe1, 0x9e, 0xeb, 0x9f, 0xf5,
390 0xa0, 0xff},
391 {0x90, 0x00, 0x91, 0x3f, 0x92, 0x5a, 0x93, 0x6e, /* 12 */
392 0x94, 0x7f, 0x95, 0x8e, 0x96, 0x9c, 0x97, 0xa8,
393 0x98, 0xb4, 0x99, 0xbf, 0x9a, 0xc9, 0x9b, 0xd3,
394 0x9c, 0xdc, 0x9d, 0xe5, 0x9e, 0xee, 0x9f, 0xf6,
395 0xa0, 0xff},
396 {0x90, 0x00, 0x91, 0x54, 0x92, 0x6f, 0x93, 0x83, /* 13 */
397 0x94, 0x93, 0x95, 0xa0, 0x96, 0xad, 0x97, 0xb7,
398 0x98, 0xc2, 0x99, 0xcb, 0x9a, 0xd4, 0x9b, 0xdc,
399 0x9c, 0xe4, 0x9d, 0xeb, 0x9e, 0xf2, 0x9f, 0xf9,
400 0xa0, 0xff},
401 {0x90, 0x00, 0x91, 0x6e, 0x92, 0x88, 0x93, 0x9a, /* 14 */
402 0x94, 0xa8, 0x95, 0xb3, 0x96, 0xbd, 0x97, 0xc6,
403 0x98, 0xcf, 0x99, 0xd6, 0x9a, 0xdd, 0x9b, 0xe3,
404 0x9c, 0xe9, 0x9d, 0xef, 0x9e, 0xf4, 0x9f, 0xfa,
405 0xa0, 0xff},
406 {0x90, 0x00, 0x91, 0x93, 0x92, 0xa8, 0x93, 0xb7, /* 15 */
407 0x94, 0xc1, 0x95, 0xca, 0x96, 0xd2, 0x97, 0xd8,
408 0x98, 0xde, 0x99, 0xe3, 0x9a, 0xe8, 0x9b, 0xed,
409 0x9c, 0xf1, 0x9d, 0xf5, 0x9e, 0xf8, 0x9f, 0xfc,
410 0xa0, 0xff}
411 };
412
413 static const __u8 tas5130a_sensor_init[][8] = {
414 {0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09},
415 {0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09},
416 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
417 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
418 {},
419 };
420
421 static __u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07};
422
423 /* read 1 byte */
424 static int reg_r(struct gspca_dev *gspca_dev,
425 __u16 index)
426 {
427 usb_control_msg(gspca_dev->dev,
428 usb_rcvctrlpipe(gspca_dev->dev, 0),
429 0, /* request */
430 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
431 0, /* value */
432 index,
433 gspca_dev->usb_buf, 1, 500);
434 return gspca_dev->usb_buf[0];
435 }
436
437 static void reg_w(struct gspca_dev *gspca_dev,
438 __u16 index)
439 {
440 usb_control_msg(gspca_dev->dev,
441 usb_sndctrlpipe(gspca_dev->dev, 0),
442 0,
443 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
444 0, index,
445 NULL, 0, 500);
446 }
447
448 static void reg_w_buf(struct gspca_dev *gspca_dev,
449 const __u8 *buffer, __u16 len)
450 {
451 if (len <= USB_BUF_SZ) {
452 memcpy(gspca_dev->usb_buf, buffer, len);
453 usb_control_msg(gspca_dev->dev,
454 usb_sndctrlpipe(gspca_dev->dev, 0),
455 0,
456 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
457 0x01, 0,
458 gspca_dev->usb_buf, len, 500);
459 } else {
460 __u8 *tmpbuf;
461
462 tmpbuf = kmalloc(len, GFP_KERNEL);
463 memcpy(tmpbuf, buffer, len);
464 usb_control_msg(gspca_dev->dev,
465 usb_sndctrlpipe(gspca_dev->dev, 0),
466 0,
467 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
468 0x01, 0,
469 tmpbuf, len, 500);
470 kfree(tmpbuf);
471 }
472 }
473
474 /* Reported as OM6802*/
475 static void om6802_sensor_init(struct gspca_dev *gspca_dev)
476 {
477 int i;
478 const __u8 *p;
479 __u8 byte;
480 __u8 val[6] = {0x62, 0, 0x64, 0, 0x60, 0x05};
481 static const __u8 sensor_init[] = {
482 0xdf, 0x6d,
483 0xdd, 0x18,
484 0x5a, 0xe0,
485 0x5c, 0x07,
486 0x5d, 0xb0,
487 0x5e, 0x1e,
488 0x60, 0x71,
489 0xef, 0x00,
490 0xe9, 0x00,
491 0xea, 0x00,
492 0x90, 0x24,
493 0x91, 0xb2,
494 0x82, 0x32,
495 0xfd, 0x41,
496 0x00 /* table end */
497 };
498
499 reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset);
500 msleep(5);
501 i = 4;
502 while (--i > 0) {
503 byte = reg_r(gspca_dev, 0x0060);
504 if (!(byte & 0x01))
505 break;
506 msleep(100);
507 }
508 byte = reg_r(gspca_dev, 0x0063);
509 if (byte != 0x17) {
510 err("Bad sensor reset %02x", byte);
511 /* continue? */
512 }
513
514 p = sensor_init;
515 while (*p != 0) {
516 val[1] = *p++;
517 val[3] = *p++;
518 if (*p == 0)
519 reg_w(gspca_dev, 0x3c80);
520 reg_w_buf(gspca_dev, val, sizeof val);
521 i = 4;
522 while (--i >= 0) {
523 msleep(15);
524 byte = reg_r(gspca_dev, 0x60);
525 if (!(byte & 0x01))
526 break;
527 }
528 }
529 msleep(15);
530 reg_w(gspca_dev, 0x3c80);
531 }
532
533 /* this function is called at probe time */
534 static int sd_config(struct gspca_dev *gspca_dev,
535 const struct usb_device_id *id)
536 {
537 struct sd *sd = (struct sd *) gspca_dev;
538 struct cam *cam;
539
540 cam = &gspca_dev->cam;
541
542 cam->cam_mode = vga_mode_t16;
543 cam->nmodes = ARRAY_SIZE(vga_mode_t16);
544
545 sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
546 sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
547 sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
548 sd->gamma = GAMMA_DEF;
549 sd->mirror = sd_ctrls[SD_MIRROR].qctrl.default_value;
550 sd->freq = sd_ctrls[SD_LIGHTFREQ].qctrl.default_value;
551 sd->whitebalance = sd_ctrls[SD_WHITE_BALANCE].qctrl.default_value;
552 sd->sharpness = sd_ctrls[SD_SHARPNESS].qctrl.default_value;
553 sd->effect = sd_ctrls[SD_EFFECTS].qctrl.default_value;
554 return 0;
555 }
556
557 static void setbrightness(struct gspca_dev *gspca_dev)
558 {
559 struct sd *sd = (struct sd *) gspca_dev;
560 unsigned int brightness;
561 __u8 set6[4] = { 0x8f, 0x24, 0xc3, 0x00 };
562
563 brightness = sd->brightness;
564 if (brightness < 7) {
565 set6[1] = 0x26;
566 set6[3] = 0x70 - brightness * 0x10;
567 } else {
568 set6[3] = 0x00 + ((brightness - 7) * 0x10);
569 }
570
571 reg_w_buf(gspca_dev, set6, sizeof set6);
572 }
573
574 static void setcontrast(struct gspca_dev *gspca_dev)
575 {
576 struct sd *sd = (struct sd *) gspca_dev;
577 unsigned int contrast = sd->contrast;
578 __u16 reg_to_write;
579
580 if (contrast < 7)
581 reg_to_write = 0x8ea9 - contrast * 0x200;
582 else
583 reg_to_write = 0x00a9 + (contrast - 7) * 0x200;
584
585 reg_w(gspca_dev, reg_to_write);
586 }
587
588 static void setcolors(struct gspca_dev *gspca_dev)
589 {
590 struct sd *sd = (struct sd *) gspca_dev;
591 __u16 reg_to_write;
592
593 reg_to_write = 0x80bb + sd->colors * 0x100; /* was 0xc0 */
594 reg_w(gspca_dev, reg_to_write);
595 }
596
597 static void setgamma(struct gspca_dev *gspca_dev)
598 {
599 struct sd *sd = (struct sd *) gspca_dev;
600
601 PDEBUG(D_CONF, "Gamma: %d", sd->gamma);
602 reg_w_buf(gspca_dev, gamma_table[sd->gamma], sizeof gamma_table[0]);
603 }
604
605 static void setwhitebalance(struct gspca_dev *gspca_dev)
606 {
607 struct sd *sd = (struct sd *) gspca_dev;
608
609 __u8 white_balance[8] =
610 {0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38};
611
612 if (sd->whitebalance)
613 white_balance[7] = 0x3c;
614
615 reg_w_buf(gspca_dev, white_balance, sizeof white_balance);
616 }
617
618 static void setsharpness(struct gspca_dev *gspca_dev)
619 {
620 struct sd *sd = (struct sd *) gspca_dev;
621 __u16 reg_to_write;
622
623 reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
624
625 reg_w(gspca_dev, reg_to_write);
626 }
627
628 /* this function is called at probe and resume time */
629 static int sd_init(struct gspca_dev *gspca_dev)
630 {
631 /* some of this registers are not really neded, because
632 * they are overriden by setbrigthness, setcontrast, etc,
633 * but wont hurt anyway, and can help someone with similar webcam
634 * to see the initial parameters.*/
635 struct sd *sd = (struct sd *) gspca_dev;
636 int i;
637 __u8 byte, test_byte;
638
639 static const __u8 read_indexs[] =
640 { 0x06, 0x07, 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5,
641 0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00, 0x00 };
642 static const __u8 n1[] =
643 {0x08, 0x03, 0x09, 0x03, 0x12, 0x04};
644 static const __u8 n2[] =
645 {0x08, 0x00};
646 static const __u8 n3[] =
647 {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04};
648 static const __u8 n4[] =
649 {0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
650 0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
651 0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
652 0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8,
653 0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48,
654 0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0,
655 0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
656 0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
657 0xac, 0x84, 0xad, 0x86, 0xaf, 0x46};
658 static const __u8 nset9[4] =
659 { 0x0b, 0x04, 0x0a, 0x78 };
660 static const __u8 nset8[6] =
661 { 0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00 };
662
663 byte = reg_r(gspca_dev, 0x06);
664 test_byte = reg_r(gspca_dev, 0x07);
665 if (byte == 0x08 && test_byte == 0x07) {
666 PDEBUG(D_CONF, "sensor om6802");
667 sd->sensor = SENSOR_OM6802;
668 } else if (byte == 0x08 && test_byte == 0x01) {
669 PDEBUG(D_CONF, "sensor tas5130a");
670 sd->sensor = SENSOR_TAS5130A;
671 } else {
672 PDEBUG(D_CONF, "unknown sensor %02x %02x", byte, test_byte);
673 sd->sensor = SENSOR_TAS5130A;
674 }
675
676 reg_w_buf(gspca_dev, n1, sizeof n1);
677 test_byte = 0;
678 i = 5;
679 while (--i >= 0) {
680 reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset);
681 test_byte = reg_r(gspca_dev, 0x0063);
682 msleep(100);
683 if (test_byte == 0x17)
684 break; /* OK */
685 }
686 if (i < 0) {
687 err("Bad sensor reset %02x", test_byte);
688 /* return -EIO; */
689 /*fixme: test - continue */
690 }
691 reg_w_buf(gspca_dev, n2, sizeof n2);
692
693 i = 0;
694 while (read_indexs[i] != 0x00) {
695 test_byte = reg_r(gspca_dev, read_indexs[i]);
696 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", read_indexs[i],
697 test_byte);
698 i++;
699 }
700
701 reg_w_buf(gspca_dev, n3, sizeof n3);
702 reg_w_buf(gspca_dev, n4, sizeof n4);
703 reg_r(gspca_dev, 0x0080);
704 reg_w(gspca_dev, 0x2c80);
705
706 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data1,
707 sizeof sensor_data[sd->sensor].data1);
708 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data3,
709 sizeof sensor_data[sd->sensor].data3);
710 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data2,
711 sizeof sensor_data[sd->sensor].data2);
712
713 reg_w(gspca_dev, 0x3880);
714 reg_w(gspca_dev, 0x3880);
715 reg_w(gspca_dev, 0x338e);
716
717 setbrightness(gspca_dev);
718 setcontrast(gspca_dev);
719 setgamma(gspca_dev);
720 setcolors(gspca_dev);
721 setsharpness(gspca_dev);
722 setwhitebalance(gspca_dev);
723
724 reg_w(gspca_dev, 0x2087); /* tied to white balance? */
725 reg_w(gspca_dev, 0x2088);
726 reg_w(gspca_dev, 0x2089);
727
728 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data4,
729 sizeof sensor_data[sd->sensor].data4);
730 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data5,
731 sizeof sensor_data[sd->sensor].data5);
732 reg_w_buf(gspca_dev, nset8, sizeof nset8);
733 reg_w_buf(gspca_dev, nset9, sizeof nset9);
734
735 reg_w(gspca_dev, 0x2880);
736
737 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data1,
738 sizeof sensor_data[sd->sensor].data1);
739 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data3,
740 sizeof sensor_data[sd->sensor].data3);
741 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data2,
742 sizeof sensor_data[sd->sensor].data2);
743
744 return 0;
745 }
746
747 static void setflip(struct gspca_dev *gspca_dev)
748 {
749 struct sd *sd = (struct sd *) gspca_dev;
750 __u8 flipcmd[8] =
751 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09};
752
753 if (sd->mirror)
754 flipcmd[3] = 0x01;
755
756 reg_w_buf(gspca_dev, flipcmd, sizeof flipcmd);
757 }
758
759 static void seteffect(struct gspca_dev *gspca_dev)
760 {
761 struct sd *sd = (struct sd *) gspca_dev;
762
763 reg_w_buf(gspca_dev, effects_table[sd->effect],
764 sizeof effects_table[0]);
765 if (sd->effect == 1 || sd->effect == 5) {
766 PDEBUG(D_CONF,
767 "This effect have been disabled for webcam \"safety\"");
768 return;
769 }
770
771 if (sd->effect == 1 || sd->effect == 4)
772 reg_w(gspca_dev, 0x4aa6);
773 else
774 reg_w(gspca_dev, 0xfaa6);
775 }
776
777 static void setlightfreq(struct gspca_dev *gspca_dev)
778 {
779 struct sd *sd = (struct sd *) gspca_dev;
780 __u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 };
781
782 if (sd->freq == 2) /* 60hz */
783 freq[1] = 0x00;
784
785 reg_w_buf(gspca_dev, freq, sizeof freq);
786 }
787
788 /* Is this really needed?
789 * i added some module parameters for test with some users */
790 static void poll_sensor(struct gspca_dev *gspca_dev)
791 {
792 struct sd *sd = (struct sd *) gspca_dev;
793 static const __u8 poll1[] =
794 {0x67, 0x05, 0x68, 0x81, 0x69, 0x80, 0x6a, 0x82,
795 0x6b, 0x68, 0x6c, 0x69, 0x72, 0xd9, 0x73, 0x34,
796 0x74, 0x32, 0x75, 0x92, 0x76, 0x00, 0x09, 0x01,
797 0x60, 0x14};
798 static const __u8 poll2[] =
799 {0x67, 0x02, 0x68, 0x71, 0x69, 0x72, 0x72, 0xa9,
800 0x73, 0x02, 0x73, 0x02, 0x60, 0x14};
801 static const __u8 poll3[] =
802 {0x87, 0x3f, 0x88, 0x20, 0x89, 0x2d};
803 static const __u8 poll4[] =
804 {0xa6, 0x0a, 0xea, 0xcf, 0xbe, 0x26, 0xb1, 0x5f,
805 0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c,
806 0xc2, 0x80, 0xc3, 0x10};
807
808 if (sd->sensor != SENSOR_TAS5130A) {
809 PDEBUG(D_STREAM, "[Sensor requires polling]");
810 reg_w_buf(gspca_dev, poll1, sizeof poll1);
811 reg_w_buf(gspca_dev, poll2, sizeof poll2);
812 reg_w_buf(gspca_dev, poll3, sizeof poll3);
813 reg_w_buf(gspca_dev, poll4, sizeof poll4);
814 }
815 }
816
817 static int sd_start(struct gspca_dev *gspca_dev)
818 {
819 struct sd *sd = (struct sd *) gspca_dev;
820 int i, mode;
821 __u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
822 static const __u8 t3[] =
823 { 0xb3, 0x07, 0xb4, 0x00, 0xb5, 0x88, 0xb6, 0x02, 0xb7, 0x06,
824 0xb8, 0x00, 0xb9, 0xe7, 0xba, 0x01 };
825
826 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. priv;
827 switch (mode) {
828 case 1: /* 352x288 */
829 t2[1] = 0x40;
830 break;
831 case 2: /* 320x240 */
832 t2[1] = 0x10;
833 break;
834 case 3: /* 176x144 */
835 t2[1] = 0x50;
836 break;
837 case 4: /* 160x120 */
838 t2[1] = 0x20;
839 break;
840 default: /* 640x480 (0x00) */
841 break;
842 }
843
844 if (sd->sensor == SENSOR_TAS5130A) {
845 i = 0;
846 while (tas5130a_sensor_init[i][0] != 0) {
847 reg_w_buf(gspca_dev, tas5130a_sensor_init[i],
848 sizeof tas5130a_sensor_init[0]);
849 i++;
850 }
851 reg_w(gspca_dev, 0x3c80);
852 /* just in case and to keep sync with logs (for mine) */
853 reg_w_buf(gspca_dev, tas5130a_sensor_init[3],
854 sizeof tas5130a_sensor_init[0]);
855 reg_w(gspca_dev, 0x3c80);
856 } else {
857 om6802_sensor_init(gspca_dev);
858 }
859 reg_w_buf(gspca_dev, sensor_data[sd->sensor].data4,
860 sizeof sensor_data[sd->sensor].data4);
861 reg_r(gspca_dev, 0x0012);
862 reg_w_buf(gspca_dev, t2, sizeof t2);
863 reg_w_buf(gspca_dev, t3, sizeof t3);
864 reg_w(gspca_dev, 0x0013);
865 msleep(15);
866 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
867 sizeof sensor_data[sd->sensor].stream);
868 poll_sensor(gspca_dev);
869
870 /* restart on each start, just in case, sometimes regs goes wrong
871 * when using controls from app */
872 setbrightness(gspca_dev);
873 setcontrast(gspca_dev);
874 setcolors(gspca_dev);
875 return 0;
876 }
877
878 static void sd_stopN(struct gspca_dev *gspca_dev)
879 {
880 struct sd *sd = (struct sd *) gspca_dev;
881
882 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
883 sizeof sensor_data[sd->sensor].stream);
884 msleep(20);
885 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream,
886 sizeof sensor_data[sd->sensor].stream);
887 msleep(20);
888 reg_w(gspca_dev, 0x0309);
889 }
890
891 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
892 struct gspca_frame *frame, /* target */
893 __u8 *data, /* isoc packet */
894 int len) /* iso packet length */
895 {
896 static __u8 ffd9[] = { 0xff, 0xd9 };
897
898 if (data[0] == 0x5a) {
899 /* Control Packet, after this came the header again,
900 * but extra bytes came in the packet before this,
901 * sometimes an EOF arrives, sometimes not... */
902 return;
903 }
904 data += 2;
905 len -= 2;
906 if (data[0] == 0xff && data[1] == 0xd8) {
907 /* extra bytes....., could be processed too but would be
908 * a waste of time, right now leave the application and
909 * libjpeg do it for ourserlves.. */
910 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
911 ffd9, 2);
912 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
913 return;
914 }
915
916 if (data[len - 2] == 0xff && data[len - 1] == 0xd9) {
917 /* Just in case, i have seen packets with the marker,
918 * other's do not include it... */
919 len -= 2;
920 }
921 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
922 }
923
924 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
925 {
926 struct sd *sd = (struct sd *) gspca_dev;
927
928 sd->brightness = val;
929 if (gspca_dev->streaming)
930 setbrightness(gspca_dev);
931 return 0;
932 }
933
934 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
935 {
936 struct sd *sd = (struct sd *) gspca_dev;
937
938 *val = sd->brightness;
939 return *val;
940 }
941
942 static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
943 {
944 struct sd *sd = (struct sd *) gspca_dev;
945
946 sd->whitebalance = val;
947 if (gspca_dev->streaming)
948 setwhitebalance(gspca_dev);
949 return 0;
950 }
951
952 static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
953 {
954 struct sd *sd = (struct sd *) gspca_dev;
955
956 *val = sd->whitebalance;
957 return *val;
958 }
959
960 static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val)
961 {
962 struct sd *sd = (struct sd *) gspca_dev;
963
964 sd->mirror = val;
965 if (gspca_dev->streaming)
966 setflip(gspca_dev);
967 return 0;
968 }
969
970 static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val)
971 {
972 struct sd *sd = (struct sd *) gspca_dev;
973
974 *val = sd->mirror;
975 return *val;
976 }
977
978 static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val)
979 {
980 struct sd *sd = (struct sd *) gspca_dev;
981
982 sd->effect = val;
983 if (gspca_dev->streaming)
984 seteffect(gspca_dev);
985 return 0;
986 }
987
988 static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val)
989 {
990 struct sd *sd = (struct sd *) gspca_dev;
991
992 *val = sd->effect;
993 return *val;
994 }
995
996 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
997 {
998 struct sd *sd = (struct sd *) gspca_dev;
999
1000 sd->contrast = val;
1001 if (gspca_dev->streaming)
1002 setcontrast(gspca_dev);
1003 return 0;
1004 }
1005
1006 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1007 {
1008 struct sd *sd = (struct sd *) gspca_dev;
1009
1010 *val = sd->contrast;
1011 return *val;
1012 }
1013
1014 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1015 {
1016 struct sd *sd = (struct sd *) gspca_dev;
1017
1018 sd->colors = val;
1019 if (gspca_dev->streaming)
1020 setcolors(gspca_dev);
1021 return 0;
1022 }
1023
1024 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1025 {
1026 struct sd *sd = (struct sd *) gspca_dev;
1027
1028 *val = sd->colors;
1029 return 0;
1030 }
1031
1032 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
1033 {
1034 struct sd *sd = (struct sd *) gspca_dev;
1035
1036 sd->gamma = val;
1037 if (gspca_dev->streaming)
1038 setgamma(gspca_dev);
1039 return 0;
1040 }
1041
1042 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
1043 {
1044 struct sd *sd = (struct sd *) gspca_dev;
1045
1046 *val = sd->gamma;
1047 return 0;
1048 }
1049
1050 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1051 {
1052 struct sd *sd = (struct sd *) gspca_dev;
1053
1054 sd->freq = val;
1055 if (gspca_dev->streaming)
1056 setlightfreq(gspca_dev);
1057 return 0;
1058 }
1059
1060 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1061 {
1062 struct sd *sd = (struct sd *) gspca_dev;
1063
1064 *val = sd->freq;
1065 return 0;
1066 }
1067
1068 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
1069 {
1070 struct sd *sd = (struct sd *) gspca_dev;
1071
1072 sd->sharpness = val;
1073 if (gspca_dev->streaming)
1074 setsharpness(gspca_dev);
1075 return 0;
1076 }
1077
1078 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
1079 {
1080 struct sd *sd = (struct sd *) gspca_dev;
1081
1082 *val = sd->sharpness;
1083 return 0;
1084 }
1085
1086 /* Low Light set here......*/
1087 static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val)
1088 {
1089 struct sd *sd = (struct sd *) gspca_dev;
1090
1091 sd->autogain = val;
1092 if (val != 0)
1093 reg_w(gspca_dev, 0xf48e);
1094 else
1095 reg_w(gspca_dev, 0xb48e);
1096 return 0;
1097 }
1098
1099 static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
1100 {
1101 struct sd *sd = (struct sd *) gspca_dev;
1102
1103 *val = sd->autogain;
1104 return 0;
1105 }
1106
1107 static int sd_querymenu(struct gspca_dev *gspca_dev,
1108 struct v4l2_querymenu *menu)
1109 {
1110 switch (menu->id) {
1111 case V4L2_CID_POWER_LINE_FREQUENCY:
1112 switch (menu->index) {
1113 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1114 strcpy((char *) menu->name, "50 Hz");
1115 return 0;
1116 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1117 strcpy((char *) menu->name, "60 Hz");
1118 return 0;
1119 }
1120 break;
1121 case V4L2_CID_EFFECTS:
1122 if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
1123 strncpy((char *) menu->name,
1124 effects_control[menu->index], 32);
1125 return 0;
1126 }
1127 break;
1128 }
1129 return -EINVAL;
1130 }
1131
1132 /* sub-driver description */
1133 static const struct sd_desc sd_desc = {
1134 .name = MODULE_NAME,
1135 .ctrls = sd_ctrls,
1136 .nctrls = ARRAY_SIZE(sd_ctrls),
1137 .config = sd_config,
1138 .init = sd_init,
1139 .start = sd_start,
1140 .stopN = sd_stopN,
1141 .pkt_scan = sd_pkt_scan,
1142 .querymenu = sd_querymenu,
1143 };
1144
1145 /* -- module initialisation -- */
1146 static const __devinitdata struct usb_device_id device_table[] = {
1147 {USB_DEVICE(0x17a1, 0x0128)},
1148 {}
1149 };
1150 MODULE_DEVICE_TABLE(usb, device_table);
1151
1152 /* -- device connect -- */
1153 static int sd_probe(struct usb_interface *intf,
1154 const struct usb_device_id *id)
1155 {
1156 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1157 THIS_MODULE);
1158 }
1159
1160 static struct usb_driver sd_driver = {
1161 .name = MODULE_NAME,
1162 .id_table = device_table,
1163 .probe = sd_probe,
1164 .disconnect = gspca_disconnect,
1165 #ifdef CONFIG_PM
1166 .suspend = gspca_suspend,
1167 .resume = gspca_resume,
1168 #endif
1169 };
1170
1171 /* -- module insert / remove -- */
1172 static int __init sd_mod_init(void)
1173 {
1174 if (usb_register(&sd_driver) < 0)
1175 return -1;
1176 PDEBUG(D_PROBE, "registered");
1177 return 0;
1178 }
1179 static void __exit sd_mod_exit(void)
1180 {
1181 usb_deregister(&sd_driver);
1182 PDEBUG(D_PROBE, "deregistered");
1183 }
1184
1185 module_init(sd_mod_init);
1186 module_exit(sd_mod_exit);
ubuntu-bionic-kernel mirror