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