projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] gspca_pac7302: correct register documentation
[deliverable/linux.git] / drivers / media / usb / gspca / pac7302.c
1 /*
2 * Pixart PAC7302 driver
3 *
4 * Copyright (C) 2008-2012 Jean-Francois Moine <http://moinejf.free.fr>
5 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
6 *
7 * Separated from Pixart PAC7311 library by Márton Németh
8 * Camera button input handling by Márton Németh <nm127@freemail.hu>
9 * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26 /*
27 * Some documentation about various registers as determined by trial and error.
28 *
29 * Register page 0:
30 *
31 * Address Description
32 * 0x01 Red balance control
33 * 0x02 Green balance control
34 * 0x03 Blue balance control
35 * The Windows driver uses a quadratic approach to map
36 * the settable values (0-200) on register values:
37 * min=0x20, default=0x40, max=0x80
38 * 0x0f-0x20 Color and saturation control
39 * 0xa2-0xab Brightness, contrast and gamma control
40 * 0xb6 Sharpness control (bits 0-4)
41 *
42 * Register page 1:
43 *
44 * Address Description
45 * 0x78 Global control, bit 6 controls the LED (inverted)
46 * 0x80 Compression balance, 2 interesting settings:
47 * 0x0f Default
48 * 0x50 Values >= this switch the camera to a lower compression,
49 * using the same table for both luminance and chrominance.
50 * This gives a sharper picture. Only usable when running
51 * at < 15 fps! Note currently the driver does not use this
52 * as the quality gain is small and the generated JPG-s are
53 * only understood by v4l-utils >= 0.8.9
54 *
55 * Register page 3:
56 *
57 * Address Description
58 * 0x02 Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on
59 * the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
60 * 0x03 Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps
61 * 0x04 Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps,
62 * 63 -> ~27 fps, the 2 msb's must always be 1 !!
63 * 0x05 Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0:
64 * 1 -> ~30 fps, 2 -> ~20 fps
65 * 0x0e Exposure bits 0-7, 0-448, 0 = use full frame time
66 * 0x0f Exposure bit 8, 0-448, 448 = no exposure at all
67 * 0x10 Gain 0-31
68 * 0x12 Another gain 0-31, unlike 0x10 this one seems to start with an
69 * amplification value of 1 rather then 0 at its lowest setting
70 * 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
71 * 0x80 Another framerate control, best left at 1, moving it from 1 to
72 * 2 causes the framerate to become 3/4th of what it was, and
73 * also seems to cause pixel averaging, resulting in an effective
74 * resolution of 320x240 and thus a much blockier image
75 *
76 * The registers are accessed in the following functions:
77 *
78 * Page | Register | Function
79 * -----+------------+---------------------------------------------------
80 * 0 | 0x0f..0x20 | setcolors()
81 * 0 | 0xa2..0xab | setbrightcont()
82 * 0 | 0xb6 | setsharpness()
83 * 0 | 0xc5 | setredbalance()
84 * 0 | 0xc6 | setwhitebalance()
85 * 0 | 0xc7 | setbluebalance()
86 * 0 | 0xdc | setbrightcont(), setcolors()
87 * 3 | 0x02 | setexposure()
88 * 3 | 0x10, 0x12 | setgain()
89 * 3 | 0x11 | setcolors(), setgain(), setexposure(), sethvflip()
90 * 3 | 0x21 | sethvflip()
91 */
92
93 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
94
95 #include <linux/input.h>
96 #include <media/v4l2-chip-ident.h>
97 #include "gspca.h"
98 /* Include pac common sof detection functions */
99 #include "pac_common.h"
100
101 #define PAC7302_GAIN_DEFAULT 15
102 #define PAC7302_GAIN_KNEE 42
103 #define PAC7302_EXPOSURE_DEFAULT 66 /* 33 ms / 30 fps */
104 #define PAC7302_EXPOSURE_KNEE 133 /* 66 ms / 15 fps */
105
106 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, "
107 "Thomas Kaiser thomas@kaiser-linux.li");
108 MODULE_DESCRIPTION("Pixart PAC7302");
109 MODULE_LICENSE("GPL");
110
111 struct sd {
112 struct gspca_dev gspca_dev; /* !! must be the first item */
113
114 struct { /* brightness / contrast cluster */
115 struct v4l2_ctrl *brightness;
116 struct v4l2_ctrl *contrast;
117 };
118 struct v4l2_ctrl *saturation;
119 struct v4l2_ctrl *white_balance;
120 struct v4l2_ctrl *red_balance;
121 struct v4l2_ctrl *blue_balance;
122 struct { /* flip cluster */
123 struct v4l2_ctrl *hflip;
124 struct v4l2_ctrl *vflip;
125 };
126 struct v4l2_ctrl *sharpness;
127 u8 flags;
128 #define FL_HFLIP 0x01 /* mirrored by default */
129 #define FL_VFLIP 0x02 /* vertical flipped by default */
130
131 u8 sof_read;
132 s8 autogain_ignore_frames;
133
134 atomic_t avg_lum;
135 };
136
137 static const struct v4l2_pix_format vga_mode[] = {
138 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
139 .bytesperline = 640,
140 .sizeimage = 640 * 480 * 3 / 8 + 590,
141 .colorspace = V4L2_COLORSPACE_JPEG,
142 },
143 };
144
145 #define LOAD_PAGE3 255
146 #define END_OF_SEQUENCE 0
147
148 static const u8 init_7302[] = {
149 /* index,value */
150 0xff, 0x01, /* page 1 */
151 0x78, 0x00, /* deactivate */
152 0xff, 0x01,
153 0x78, 0x40, /* led off */
154 };
155 static const u8 start_7302[] = {
156 /* index, len, [value]* */
157 0xff, 1, 0x00, /* page 0 */
158 0x00, 12, 0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80,
159 0x00, 0x00, 0x00, 0x00,
160 0x0d, 24, 0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00,
161 0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7,
162 0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11,
163 0x26, 2, 0xaa, 0xaa,
164 0x2e, 1, 0x31,
165 0x38, 1, 0x01,
166 0x3a, 3, 0x14, 0xff, 0x5a,
167 0x43, 11, 0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11,
168 0x00, 0x54, 0x11,
169 0x55, 1, 0x00,
170 0x62, 4, 0x10, 0x1e, 0x1e, 0x18,
171 0x6b, 1, 0x00,
172 0x6e, 3, 0x08, 0x06, 0x00,
173 0x72, 3, 0x00, 0xff, 0x00,
174 0x7d, 23, 0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c,
175 0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50,
176 0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00,
177 0xa2, 10, 0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9,
178 0xd2, 0xeb,
179 0xaf, 1, 0x02,
180 0xb5, 2, 0x08, 0x08,
181 0xb8, 2, 0x08, 0x88,
182 0xc4, 4, 0xae, 0x01, 0x04, 0x01,
183 0xcc, 1, 0x00,
184 0xd1, 11, 0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9,
185 0xc1, 0xd7, 0xec,
186 0xdc, 1, 0x01,
187 0xff, 1, 0x01, /* page 1 */
188 0x12, 3, 0x02, 0x00, 0x01,
189 0x3e, 2, 0x00, 0x00,
190 0x76, 5, 0x01, 0x20, 0x40, 0x00, 0xf2,
191 0x7c, 1, 0x00,
192 0x7f, 10, 0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20,
193 0x02, 0x00,
194 0x96, 5, 0x01, 0x10, 0x04, 0x01, 0x04,
195 0xc8, 14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
196 0x07, 0x00, 0x01, 0x07, 0x04, 0x01,
197 0xd8, 1, 0x01,
198 0xdb, 2, 0x00, 0x01,
199 0xde, 7, 0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
200 0xe6, 4, 0x00, 0x00, 0x00, 0x01,
201 0xeb, 1, 0x00,
202 0xff, 1, 0x02, /* page 2 */
203 0x22, 1, 0x00,
204 0xff, 1, 0x03, /* page 3 */
205 0, LOAD_PAGE3, /* load the page 3 */
206 0x11, 1, 0x01,
207 0xff, 1, 0x02, /* page 2 */
208 0x13, 1, 0x00,
209 0x22, 4, 0x1f, 0xa4, 0xf0, 0x96,
210 0x27, 2, 0x14, 0x0c,
211 0x2a, 5, 0xc8, 0x00, 0x18, 0x12, 0x22,
212 0x64, 8, 0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44,
213 0x6e, 1, 0x08,
214 0xff, 1, 0x01, /* page 1 */
215 0x78, 1, 0x00,
216 0, END_OF_SEQUENCE /* end of sequence */
217 };
218
219 #define SKIP 0xaa
220 /* page 3 - the value SKIP says skip the index - see reg_w_page() */
221 static const u8 page3_7302[] = {
222 0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16,
223 0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
224 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
225 0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
226 0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21,
227 0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54,
228 0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
229 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
230 0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
231 SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
232 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
234 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
235 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8,
236 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,
237 0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00,
238 0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240 0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00,
241 0x00
242 };
243
244 static void reg_w_buf(struct gspca_dev *gspca_dev,
245 u8 index,
246 const u8 *buffer, int len)
247 {
248 int ret;
249
250 if (gspca_dev->usb_err < 0)
251 return;
252 memcpy(gspca_dev->usb_buf, buffer, len);
253 ret = usb_control_msg(gspca_dev->dev,
254 usb_sndctrlpipe(gspca_dev->dev, 0),
255 0, /* request */
256 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
257 0, /* value */
258 index, gspca_dev->usb_buf, len,
259 500);
260 if (ret < 0) {
261 pr_err("reg_w_buf failed i: %02x error %d\n",
262 index, ret);
263 gspca_dev->usb_err = ret;
264 }
265 }
266
267
268 static void reg_w(struct gspca_dev *gspca_dev,
269 u8 index,
270 u8 value)
271 {
272 int ret;
273
274 if (gspca_dev->usb_err < 0)
275 return;
276 gspca_dev->usb_buf[0] = value;
277 ret = usb_control_msg(gspca_dev->dev,
278 usb_sndctrlpipe(gspca_dev->dev, 0),
279 0, /* request */
280 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
281 0, index, gspca_dev->usb_buf, 1,
282 500);
283 if (ret < 0) {
284 pr_err("reg_w() failed i: %02x v: %02x error %d\n",
285 index, value, ret);
286 gspca_dev->usb_err = ret;
287 }
288 }
289
290 static void reg_w_seq(struct gspca_dev *gspca_dev,
291 const u8 *seq, int len)
292 {
293 while (--len >= 0) {
294 reg_w(gspca_dev, seq[0], seq[1]);
295 seq += 2;
296 }
297 }
298
299 /* load the beginning of a page */
300 static void reg_w_page(struct gspca_dev *gspca_dev,
301 const u8 *page, int len)
302 {
303 int index;
304 int ret = 0;
305
306 if (gspca_dev->usb_err < 0)
307 return;
308 for (index = 0; index < len; index++) {
309 if (page[index] == SKIP) /* skip this index */
310 continue;
311 gspca_dev->usb_buf[0] = page[index];
312 ret = usb_control_msg(gspca_dev->dev,
313 usb_sndctrlpipe(gspca_dev->dev, 0),
314 0, /* request */
315 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
316 0, index, gspca_dev->usb_buf, 1,
317 500);
318 if (ret < 0) {
319 pr_err("reg_w_page() failed i: %02x v: %02x error %d\n",
320 index, page[index], ret);
321 gspca_dev->usb_err = ret;
322 break;
323 }
324 }
325 }
326
327 /* output a variable sequence */
328 static void reg_w_var(struct gspca_dev *gspca_dev,
329 const u8 *seq,
330 const u8 *page3, unsigned int page3_len)
331 {
332 int index, len;
333
334 for (;;) {
335 index = *seq++;
336 len = *seq++;
337 switch (len) {
338 case END_OF_SEQUENCE:
339 return;
340 case LOAD_PAGE3:
341 reg_w_page(gspca_dev, page3, page3_len);
342 break;
343 default:
344 #ifdef GSPCA_DEBUG
345 if (len > USB_BUF_SZ) {
346 PDEBUG(D_ERR|D_STREAM,
347 "Incorrect variable sequence");
348 return;
349 }
350 #endif
351 while (len > 0) {
352 if (len < 8) {
353 reg_w_buf(gspca_dev,
354 index, seq, len);
355 seq += len;
356 break;
357 }
358 reg_w_buf(gspca_dev, index, seq, 8);
359 seq += 8;
360 index += 8;
361 len -= 8;
362 }
363 }
364 }
365 /* not reached */
366 }
367
368 /* this function is called at probe time for pac7302 */
369 static int sd_config(struct gspca_dev *gspca_dev,
370 const struct usb_device_id *id)
371 {
372 struct sd *sd = (struct sd *) gspca_dev;
373 struct cam *cam;
374
375 cam = &gspca_dev->cam;
376
377 cam->cam_mode = vga_mode; /* only 640x480 */
378 cam->nmodes = ARRAY_SIZE(vga_mode);
379
380 sd->flags = id->driver_info;
381 return 0;
382 }
383
384 static void setbrightcont(struct gspca_dev *gspca_dev)
385 {
386 struct sd *sd = (struct sd *) gspca_dev;
387 int i, v;
388 static const u8 max[10] =
389 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
390 0xd4, 0xec};
391 static const u8 delta[10] =
392 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
393 0x11, 0x0b};
394
395 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
396 for (i = 0; i < 10; i++) {
397 v = max[i];
398 v += (sd->brightness->val - sd->brightness->maximum)
399 * 150 / sd->brightness->maximum; /* 200 ? */
400 v -= delta[i] * sd->contrast->val / sd->contrast->maximum;
401 if (v < 0)
402 v = 0;
403 else if (v > 0xff)
404 v = 0xff;
405 reg_w(gspca_dev, 0xa2 + i, v);
406 }
407 reg_w(gspca_dev, 0xdc, 0x01);
408 }
409
410 static void setcolors(struct gspca_dev *gspca_dev)
411 {
412 struct sd *sd = (struct sd *) gspca_dev;
413 int i, v;
414 static const int a[9] =
415 {217, -212, 0, -101, 170, -67, -38, -315, 355};
416 static const int b[9] =
417 {19, 106, 0, 19, 106, 1, 19, 106, 1};
418
419 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
420 reg_w(gspca_dev, 0x11, 0x01);
421 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
422 for (i = 0; i < 9; i++) {
423 v = a[i] * sd->saturation->val / sd->saturation->maximum;
424 v += b[i];
425 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
426 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
427 }
428 reg_w(gspca_dev, 0xdc, 0x01);
429 }
430
431 static void setwhitebalance(struct gspca_dev *gspca_dev)
432 {
433 struct sd *sd = (struct sd *) gspca_dev;
434
435 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
436 reg_w(gspca_dev, 0xc6, sd->white_balance->val);
437
438 reg_w(gspca_dev, 0xdc, 0x01);
439 }
440
441 static void setredbalance(struct gspca_dev *gspca_dev)
442 {
443 struct sd *sd = (struct sd *) gspca_dev;
444
445 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
446 reg_w(gspca_dev, 0xc5, sd->red_balance->val);
447
448 reg_w(gspca_dev, 0xdc, 0x01);
449 }
450
451 static void setbluebalance(struct gspca_dev *gspca_dev)
452 {
453 struct sd *sd = (struct sd *) gspca_dev;
454
455 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
456 reg_w(gspca_dev, 0xc7, sd->blue_balance->val);
457
458 reg_w(gspca_dev, 0xdc, 0x01);
459 }
460
461 static void setgain(struct gspca_dev *gspca_dev)
462 {
463 u8 reg10, reg12;
464
465 if (gspca_dev->gain->val < 32) {
466 reg10 = gspca_dev->gain->val;
467 reg12 = 0;
468 } else {
469 reg10 = 31;
470 reg12 = gspca_dev->gain->val - 31;
471 }
472
473 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
474 reg_w(gspca_dev, 0x10, reg10);
475 reg_w(gspca_dev, 0x12, reg12);
476
477 /* load registers to sensor (Bit 0, auto clear) */
478 reg_w(gspca_dev, 0x11, 0x01);
479 }
480
481 static void setexposure(struct gspca_dev *gspca_dev)
482 {
483 u8 clockdiv;
484 u16 exposure;
485
486 /*
487 * Register 2 of frame 3 contains the clock divider configuring the
488 * no fps according to the formula: 90 / reg. sd->exposure is the
489 * desired exposure time in 0.5 ms.
490 */
491 clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000;
492
493 /*
494 * Note clockdiv = 3 also works, but when running at 30 fps, depending
495 * on the scene being recorded, the camera switches to another
496 * quantization table for certain JPEG blocks, and we don't know how
497 * to decompress these blocks. So we cap the framerate at 15 fps.
498 */
499 if (clockdiv < 6)
500 clockdiv = 6;
501 else if (clockdiv > 63)
502 clockdiv = 63;
503
504 /*
505 * Register 2 MUST be a multiple of 3, except when between 6 and 12?
506 * Always round up, otherwise we cannot get the desired frametime
507 * using the partial frame time exposure control.
508 */
509 if (clockdiv < 6 || clockdiv > 12)
510 clockdiv = ((clockdiv + 2) / 3) * 3;
511
512 /*
513 * frame exposure time in ms = 1000 * clockdiv / 90 ->
514 * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90)
515 */
516 exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv);
517 /* 0 = use full frametime, 448 = no exposure, reverse it */
518 exposure = 448 - exposure;
519
520 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
521 reg_w(gspca_dev, 0x02, clockdiv);
522 reg_w(gspca_dev, 0x0e, exposure & 0xff);
523 reg_w(gspca_dev, 0x0f, exposure >> 8);
524
525 /* load registers to sensor (Bit 0, auto clear) */
526 reg_w(gspca_dev, 0x11, 0x01);
527 }
528
529 static void sethvflip(struct gspca_dev *gspca_dev)
530 {
531 struct sd *sd = (struct sd *) gspca_dev;
532 u8 data, hflip, vflip;
533
534 hflip = sd->hflip->val;
535 if (sd->flags & FL_HFLIP)
536 hflip = !hflip;
537 vflip = sd->vflip->val;
538 if (sd->flags & FL_VFLIP)
539 vflip = !vflip;
540
541 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
542 data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
543 reg_w(gspca_dev, 0x21, data);
544
545 /* load registers to sensor (Bit 0, auto clear) */
546 reg_w(gspca_dev, 0x11, 0x01);
547 }
548
549 static void setsharpness(struct gspca_dev *gspca_dev)
550 {
551 struct sd *sd = (struct sd *) gspca_dev;
552
553 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
554 reg_w(gspca_dev, 0xb6, sd->sharpness->val);
555
556 reg_w(gspca_dev, 0xdc, 0x01);
557 }
558
559 /* this function is called at probe and resume time for pac7302 */
560 static int sd_init(struct gspca_dev *gspca_dev)
561 {
562 reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
563 return gspca_dev->usb_err;
564 }
565
566 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
567 {
568 struct gspca_dev *gspca_dev =
569 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
570 struct sd *sd = (struct sd *)gspca_dev;
571
572 gspca_dev->usb_err = 0;
573
574 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
575 /* when switching to autogain set defaults to make sure
576 we are on a valid point of the autogain gain /
577 exposure knee graph, and give this change time to
578 take effect before doing autogain. */
579 gspca_dev->exposure->val = PAC7302_EXPOSURE_DEFAULT;
580 gspca_dev->gain->val = PAC7302_GAIN_DEFAULT;
581 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
582 }
583
584 if (!gspca_dev->streaming)
585 return 0;
586
587 switch (ctrl->id) {
588 case V4L2_CID_BRIGHTNESS:
589 setbrightcont(gspca_dev);
590 break;
591 case V4L2_CID_SATURATION:
592 setcolors(gspca_dev);
593 break;
594 case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
595 setwhitebalance(gspca_dev);
596 break;
597 case V4L2_CID_RED_BALANCE:
598 setredbalance(gspca_dev);
599 break;
600 case V4L2_CID_BLUE_BALANCE:
601 setbluebalance(gspca_dev);
602 break;
603 case V4L2_CID_AUTOGAIN:
604 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
605 setexposure(gspca_dev);
606 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
607 setgain(gspca_dev);
608 break;
609 case V4L2_CID_HFLIP:
610 sethvflip(gspca_dev);
611 break;
612 case V4L2_CID_SHARPNESS:
613 setsharpness(gspca_dev);
614 break;
615 default:
616 return -EINVAL;
617 }
618 return gspca_dev->usb_err;
619 }
620
621 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
622 .s_ctrl = sd_s_ctrl,
623 };
624
625 /* this function is called at probe time */
626 static int sd_init_controls(struct gspca_dev *gspca_dev)
627 {
628 struct sd *sd = (struct sd *) gspca_dev;
629 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
630
631 gspca_dev->vdev.ctrl_handler = hdl;
632 v4l2_ctrl_handler_init(hdl, 12);
633
634 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
635 V4L2_CID_BRIGHTNESS, 0, 32, 1, 16);
636 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
637 V4L2_CID_CONTRAST, 0, 255, 1, 127);
638
639 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
640 V4L2_CID_SATURATION, 0, 255, 1, 127);
641 sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
642 V4L2_CID_WHITE_BALANCE_TEMPERATURE,
643 0, 255, 1, 55);
644 sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
645 V4L2_CID_RED_BALANCE, 0, 3, 1, 1);
646 sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
647 V4L2_CID_BLUE_BALANCE, 0, 3, 1, 1);
648
649 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
650 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
651 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
652 V4L2_CID_EXPOSURE, 0, 1023, 1,
653 PAC7302_EXPOSURE_DEFAULT);
654 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
655 V4L2_CID_GAIN, 0, 62, 1,
656 PAC7302_GAIN_DEFAULT);
657
658 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
659 V4L2_CID_HFLIP, 0, 1, 1, 0);
660 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
661 V4L2_CID_VFLIP, 0, 1, 1, 0);
662
663 sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
664 V4L2_CID_SHARPNESS, 0, 15, 1, 8);
665
666 if (hdl->error) {
667 pr_err("Could not initialize controls\n");
668 return hdl->error;
669 }
670
671 v4l2_ctrl_cluster(2, &sd->brightness);
672 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
673 v4l2_ctrl_cluster(2, &sd->hflip);
674 return 0;
675 }
676
677 /* -- start the camera -- */
678 static int sd_start(struct gspca_dev *gspca_dev)
679 {
680 struct sd *sd = (struct sd *) gspca_dev;
681
682 reg_w_var(gspca_dev, start_7302,
683 page3_7302, sizeof(page3_7302));
684
685 sd->sof_read = 0;
686 sd->autogain_ignore_frames = 0;
687 atomic_set(&sd->avg_lum, 270 + sd->brightness->val);
688
689 /* start stream */
690 reg_w(gspca_dev, 0xff, 0x01);
691 reg_w(gspca_dev, 0x78, 0x01);
692
693 return gspca_dev->usb_err;
694 }
695
696 static void sd_stopN(struct gspca_dev *gspca_dev)
697 {
698
699 /* stop stream */
700 reg_w(gspca_dev, 0xff, 0x01);
701 reg_w(gspca_dev, 0x78, 0x00);
702 }
703
704 /* called on streamoff with alt 0 and on disconnect for pac7302 */
705 static void sd_stop0(struct gspca_dev *gspca_dev)
706 {
707 if (!gspca_dev->present)
708 return;
709 reg_w(gspca_dev, 0xff, 0x01);
710 reg_w(gspca_dev, 0x78, 0x40);
711 }
712
713 static void do_autogain(struct gspca_dev *gspca_dev)
714 {
715 struct sd *sd = (struct sd *) gspca_dev;
716 int avg_lum = atomic_read(&sd->avg_lum);
717 int desired_lum;
718 const int deadzone = 30;
719
720 if (sd->autogain_ignore_frames < 0)
721 return;
722
723 if (sd->autogain_ignore_frames > 0) {
724 sd->autogain_ignore_frames--;
725 } else {
726 desired_lum = 270 + sd->brightness->val;
727
728 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum,
729 deadzone, PAC7302_GAIN_KNEE,
730 PAC7302_EXPOSURE_KNEE))
731 sd->autogain_ignore_frames =
732 PAC_AUTOGAIN_IGNORE_FRAMES;
733 }
734 }
735
736 /* JPEG header */
737 static const u8 jpeg_header[] = {
738 0xff, 0xd8, /* SOI: Start of Image */
739
740 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */
741 0x00, 0x11, /* length = 17 bytes (including this length field) */
742 0x08, /* Precision: 8 */
743 0x02, 0x80, /* height = 640 (image rotated) */
744 0x01, 0xe0, /* width = 480 */
745 0x03, /* Number of image components: 3 */
746 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
747 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
748 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
749
750 0xff, 0xda, /* SOS: Start Of Scan */
751 0x00, 0x0c, /* length = 12 bytes (including this length field) */
752 0x03, /* number of components: 3 */
753 0x01, 0x00, /* selector 1, table 0x00 */
754 0x02, 0x11, /* selector 2, table 0x11 */
755 0x03, 0x11, /* selector 3, table 0x11 */
756 0x00, 0x3f, /* Spectral selection: 0 .. 63 */
757 0x00 /* Successive approximation: 0 */
758 };
759
760 /* this function is run at interrupt level */
761 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
762 u8 *data, /* isoc packet */
763 int len) /* iso packet length */
764 {
765 struct sd *sd = (struct sd *) gspca_dev;
766 u8 *image;
767 u8 *sof;
768
769 sof = pac_find_sof(&sd->sof_read, data, len);
770 if (sof) {
771 int n, lum_offset, footer_length;
772
773 /*
774 * 6 bytes after the FF D9 EOF marker a number of lumination
775 * bytes are send corresponding to different parts of the
776 * image, the 14th and 15th byte after the EOF seem to
777 * correspond to the center of the image.
778 */
779 lum_offset = 61 + sizeof pac_sof_marker;
780 footer_length = 74;
781
782 /* Finish decoding current frame */
783 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
784 if (n < 0) {
785 gspca_dev->image_len += n;
786 n = 0;
787 } else {
788 gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
789 }
790
791 image = gspca_dev->image;
792 if (image != NULL
793 && image[gspca_dev->image_len - 2] == 0xff
794 && image[gspca_dev->image_len - 1] == 0xd9)
795 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
796
797 n = sof - data;
798 len -= n;
799 data = sof;
800
801 /* Get average lumination */
802 if (gspca_dev->last_packet_type == LAST_PACKET &&
803 n >= lum_offset)
804 atomic_set(&sd->avg_lum, data[-lum_offset] +
805 data[-lum_offset + 1]);
806
807 /* Start the new frame with the jpeg header */
808 /* The PAC7302 has the image rotated 90 degrees */
809 gspca_frame_add(gspca_dev, FIRST_PACKET,
810 jpeg_header, sizeof jpeg_header);
811 }
812 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
813 }
814
815 #ifdef CONFIG_VIDEO_ADV_DEBUG
816 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
817 struct v4l2_dbg_register *reg)
818 {
819 u8 index;
820 u8 value;
821
822 /*
823 * reg->reg: bit0..15: reserved for register index (wIndex is 16bit
824 * long on the USB bus)
825 */
826 if (reg->match.type == V4L2_CHIP_MATCH_HOST &&
827 reg->match.addr == 0 &&
828 (reg->reg < 0x000000ff) &&
829 (reg->val <= 0x000000ff)
830 ) {
831 /* Currently writing to page 0 is only supported. */
832 /* reg_w() only supports 8bit index */
833 index = reg->reg;
834 value = reg->val;
835
836 /*
837 * Note that there shall be no access to other page
838 * by any other function between the page switch and
839 * the actual register write.
840 */
841 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
842 reg_w(gspca_dev, index, value);
843
844 reg_w(gspca_dev, 0xdc, 0x01);
845 }
846 return gspca_dev->usb_err;
847 }
848
849 static int sd_chip_ident(struct gspca_dev *gspca_dev,
850 struct v4l2_dbg_chip_ident *chip)
851 {
852 int ret = -EINVAL;
853
854 if (chip->match.type == V4L2_CHIP_MATCH_HOST &&
855 chip->match.addr == 0) {
856 chip->revision = 0;
857 chip->ident = V4L2_IDENT_UNKNOWN;
858 ret = 0;
859 }
860 return ret;
861 }
862 #endif
863
864 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
865 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
866 u8 *data, /* interrupt packet data */
867 int len) /* interrput packet length */
868 {
869 int ret = -EINVAL;
870 u8 data0, data1;
871
872 if (len == 2) {
873 data0 = data[0];
874 data1 = data[1];
875 if ((data0 == 0x00 && data1 == 0x11) ||
876 (data0 == 0x22 && data1 == 0x33) ||
877 (data0 == 0x44 && data1 == 0x55) ||
878 (data0 == 0x66 && data1 == 0x77) ||
879 (data0 == 0x88 && data1 == 0x99) ||
880 (data0 == 0xaa && data1 == 0xbb) ||
881 (data0 == 0xcc && data1 == 0xdd) ||
882 (data0 == 0xee && data1 == 0xff)) {
883 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
884 input_sync(gspca_dev->input_dev);
885 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
886 input_sync(gspca_dev->input_dev);
887 ret = 0;
888 }
889 }
890
891 return ret;
892 }
893 #endif
894
895 /* sub-driver description for pac7302 */
896 static const struct sd_desc sd_desc = {
897 .name = KBUILD_MODNAME,
898 .config = sd_config,
899 .init = sd_init,
900 .init_controls = sd_init_controls,
901 .start = sd_start,
902 .stopN = sd_stopN,
903 .stop0 = sd_stop0,
904 .pkt_scan = sd_pkt_scan,
905 .dq_callback = do_autogain,
906 #ifdef CONFIG_VIDEO_ADV_DEBUG
907 .set_register = sd_dbg_s_register,
908 .get_chip_ident = sd_chip_ident,
909 #endif
910 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
911 .int_pkt_scan = sd_int_pkt_scan,
912 #endif
913 };
914
915 /* -- module initialisation -- */
916 static const struct usb_device_id device_table[] = {
917 {USB_DEVICE(0x06f8, 0x3009)},
918 {USB_DEVICE(0x06f8, 0x301b)},
919 {USB_DEVICE(0x093a, 0x2620)},
920 {USB_DEVICE(0x093a, 0x2621)},
921 {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
922 {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
923 {USB_DEVICE(0x093a, 0x2625)},
924 {USB_DEVICE(0x093a, 0x2626)},
925 {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP},
926 {USB_DEVICE(0x093a, 0x2628)},
927 {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
928 {USB_DEVICE(0x093a, 0x262a)},
929 {USB_DEVICE(0x093a, 0x262c)},
930 {USB_DEVICE(0x145f, 0x013c)},
931 {USB_DEVICE(0x1ae7, 0x2001)}, /* SpeedLink Snappy Mic SL-6825-SBK */
932 {}
933 };
934 MODULE_DEVICE_TABLE(usb, device_table);
935
936 /* -- device connect -- */
937 static int sd_probe(struct usb_interface *intf,
938 const struct usb_device_id *id)
939 {
940 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
941 THIS_MODULE);
942 }
943
944 static struct usb_driver sd_driver = {
945 .name = KBUILD_MODNAME,
946 .id_table = device_table,
947 .probe = sd_probe,
948 .disconnect = gspca_disconnect,
949 #ifdef CONFIG_PM
950 .suspend = gspca_suspend,
951 .resume = gspca_resume,
952 .reset_resume = gspca_resume,
953 #endif
954 };
955
956 module_usb_driver(sd_driver);
Linux kernel - Deliverables
This page took 0.052003 seconds and 5 git commands to generate.