2 * Pixart PAC7302 driver
4 * Copyright (C) 2008-2012 Jean-Francois Moine <http://moinejf.free.fr>
5 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
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>
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
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.
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
27 * Some documentation about various registers as determined by trial and error.
32 * 0x78 Global control, bit 6 controls the LED (inverted)
33 * 0x80 Compression balance, 2 interesting settings:
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
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
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
63 * The registers are accessed in the following functions:
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()
79 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
81 #include <linux/input.h>
82 #include <media/v4l2-chip-ident.h>
84 /* Include pac common sof detection functions */
85 #include "pac_common.h"
87 #define PAC7302_GAIN_DEFAULT 15
88 #define PAC7302_GAIN_KNEE 42
89 #define PAC7302_EXPOSURE_DEFAULT 66 /* 33 ms / 30 fps */
90 #define PAC7302_EXPOSURE_KNEE 133 /* 66 ms / 15 fps */
92 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, "
93 "Thomas Kaiser thomas@kaiser-linux.li");
94 MODULE_DESCRIPTION("Pixart PAC7302");
95 MODULE_LICENSE("GPL");
98 struct gspca_dev gspca_dev; /* !! must be the first item */
100 struct { /* brightness / contrast cluster */
101 struct v4l2_ctrl *brightness;
102 struct v4l2_ctrl *contrast;
104 struct v4l2_ctrl *saturation;
105 struct v4l2_ctrl *white_balance;
106 struct v4l2_ctrl *red_balance;
107 struct v4l2_ctrl *blue_balance;
108 struct { /* flip cluster */
109 struct v4l2_ctrl *hflip;
110 struct v4l2_ctrl *vflip;
113 #define FL_HFLIP 0x01 /* mirrored by default */
114 #define FL_VFLIP 0x02 /* vertical flipped by default */
117 s8 autogain_ignore_frames;
122 static const struct v4l2_pix_format vga_mode[] = {
123 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
125 .sizeimage = 640 * 480 * 3 / 8 + 590,
126 .colorspace = V4L2_COLORSPACE_JPEG,
130 #define LOAD_PAGE3 255
131 #define END_OF_SEQUENCE 0
133 static const u8 init_7302[] = {
135 0xff, 0x01, /* page 1 */
136 0x78, 0x00, /* deactivate */
138 0x78, 0x40, /* led off */
140 static const u8 start_7302[] = {
141 /* index, len, [value]* */
142 0xff, 1, 0x00, /* page 0 */
143 0x00, 12, 0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80,
144 0x00, 0x00, 0x00, 0x00,
145 0x0d, 24, 0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00,
146 0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7,
147 0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11,
151 0x3a, 3, 0x14, 0xff, 0x5a,
152 0x43, 11, 0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11,
155 0x62, 4, 0x10, 0x1e, 0x1e, 0x18,
157 0x6e, 3, 0x08, 0x06, 0x00,
158 0x72, 3, 0x00, 0xff, 0x00,
159 0x7d, 23, 0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c,
160 0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50,
161 0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00,
162 0xa2, 10, 0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9,
167 0xc4, 4, 0xae, 0x01, 0x04, 0x01,
169 0xd1, 11, 0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9,
172 0xff, 1, 0x01, /* page 1 */
173 0x12, 3, 0x02, 0x00, 0x01,
175 0x76, 5, 0x01, 0x20, 0x40, 0x00, 0xf2,
177 0x7f, 10, 0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20,
179 0x96, 5, 0x01, 0x10, 0x04, 0x01, 0x04,
180 0xc8, 14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
181 0x07, 0x00, 0x01, 0x07, 0x04, 0x01,
184 0xde, 7, 0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
185 0xe6, 4, 0x00, 0x00, 0x00, 0x01,
187 0xff, 1, 0x02, /* page 2 */
189 0xff, 1, 0x03, /* page 3 */
190 0, LOAD_PAGE3, /* load the page 3 */
192 0xff, 1, 0x02, /* page 2 */
194 0x22, 4, 0x1f, 0xa4, 0xf0, 0x96,
196 0x2a, 5, 0xc8, 0x00, 0x18, 0x12, 0x22,
197 0x64, 8, 0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44,
199 0xff, 1, 0x01, /* page 1 */
201 0, END_OF_SEQUENCE /* end of sequence */
205 /* page 3 - the value SKIP says skip the index - see reg_w_page() */
206 static const u8 page3_7302[] = {
207 0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16,
208 0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
209 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
210 0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
211 0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21,
212 0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54,
213 0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
214 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
215 0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
216 SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
217 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218 0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
219 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
220 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8,
221 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,
222 0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00,
223 0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00,
224 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
225 0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00,
229 static void reg_w_buf(struct gspca_dev *gspca_dev,
231 const u8 *buffer, int len)
235 if (gspca_dev->usb_err < 0)
237 memcpy(gspca_dev->usb_buf, buffer, len);
238 ret = usb_control_msg(gspca_dev->dev,
239 usb_sndctrlpipe(gspca_dev->dev, 0),
241 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
243 index, gspca_dev->usb_buf, len,
246 pr_err("reg_w_buf failed i: %02x error %d\n",
248 gspca_dev->usb_err = ret;
253 static void reg_w(struct gspca_dev *gspca_dev,
259 if (gspca_dev->usb_err < 0)
261 gspca_dev->usb_buf[0] = value;
262 ret = usb_control_msg(gspca_dev->dev,
263 usb_sndctrlpipe(gspca_dev->dev, 0),
265 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
266 0, index, gspca_dev->usb_buf, 1,
269 pr_err("reg_w() failed i: %02x v: %02x error %d\n",
271 gspca_dev->usb_err = ret;
275 static void reg_w_seq(struct gspca_dev *gspca_dev,
276 const u8 *seq, int len)
279 reg_w(gspca_dev, seq[0], seq[1]);
284 /* load the beginning of a page */
285 static void reg_w_page(struct gspca_dev *gspca_dev,
286 const u8 *page, int len)
291 if (gspca_dev->usb_err < 0)
293 for (index = 0; index < len; index++) {
294 if (page[index] == SKIP) /* skip this index */
296 gspca_dev->usb_buf[0] = page[index];
297 ret = usb_control_msg(gspca_dev->dev,
298 usb_sndctrlpipe(gspca_dev->dev, 0),
300 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
301 0, index, gspca_dev->usb_buf, 1,
304 pr_err("reg_w_page() failed i: %02x v: %02x error %d\n",
305 index, page[index], ret);
306 gspca_dev->usb_err = ret;
312 /* output a variable sequence */
313 static void reg_w_var(struct gspca_dev *gspca_dev,
315 const u8 *page3, unsigned int page3_len)
323 case END_OF_SEQUENCE:
326 reg_w_page(gspca_dev, page3, page3_len);
330 if (len > USB_BUF_SZ) {
331 PDEBUG(D_ERR|D_STREAM,
332 "Incorrect variable sequence");
343 reg_w_buf(gspca_dev, index, seq, 8);
353 /* this function is called at probe time for pac7302 */
354 static int sd_config(struct gspca_dev *gspca_dev,
355 const struct usb_device_id *id)
357 struct sd *sd = (struct sd *) gspca_dev;
360 cam = &gspca_dev->cam;
362 cam->cam_mode = vga_mode; /* only 640x480 */
363 cam->nmodes = ARRAY_SIZE(vga_mode);
365 sd->flags = id->driver_info;
369 static void setbrightcont(struct gspca_dev *gspca_dev)
371 struct sd *sd = (struct sd *) gspca_dev;
373 static const u8 max[10] =
374 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
376 static const u8 delta[10] =
377 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
380 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
381 for (i = 0; i < 10; i++) {
383 v += (sd->brightness->val - sd->brightness->maximum)
384 * 150 / sd->brightness->maximum; /* 200 ? */
385 v -= delta[i] * sd->contrast->val / sd->contrast->maximum;
390 reg_w(gspca_dev, 0xa2 + i, v);
392 reg_w(gspca_dev, 0xdc, 0x01);
395 static void setcolors(struct gspca_dev *gspca_dev)
397 struct sd *sd = (struct sd *) gspca_dev;
399 static const int a[9] =
400 {217, -212, 0, -101, 170, -67, -38, -315, 355};
401 static const int b[9] =
402 {19, 106, 0, 19, 106, 1, 19, 106, 1};
404 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
405 reg_w(gspca_dev, 0x11, 0x01);
406 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
407 for (i = 0; i < 9; i++) {
408 v = a[i] * sd->saturation->val / sd->saturation->maximum;
410 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
411 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
413 reg_w(gspca_dev, 0xdc, 0x01);
416 static void setwhitebalance(struct gspca_dev *gspca_dev)
418 struct sd *sd = (struct sd *) gspca_dev;
420 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
421 reg_w(gspca_dev, 0xc6, sd->white_balance->val);
423 reg_w(gspca_dev, 0xdc, 0x01);
426 static void setredbalance(struct gspca_dev *gspca_dev)
428 struct sd *sd = (struct sd *) gspca_dev;
430 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
431 reg_w(gspca_dev, 0xc5, sd->red_balance->val);
433 reg_w(gspca_dev, 0xdc, 0x01);
436 static void setbluebalance(struct gspca_dev *gspca_dev)
438 struct sd *sd = (struct sd *) gspca_dev;
440 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
441 reg_w(gspca_dev, 0xc7, sd->blue_balance->val);
443 reg_w(gspca_dev, 0xdc, 0x01);
446 static void setgain(struct gspca_dev *gspca_dev)
450 if (gspca_dev->gain->val < 32) {
451 reg10 = gspca_dev->gain->val;
455 reg12 = gspca_dev->gain->val - 31;
458 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
459 reg_w(gspca_dev, 0x10, reg10);
460 reg_w(gspca_dev, 0x12, reg12);
462 /* load registers to sensor (Bit 0, auto clear) */
463 reg_w(gspca_dev, 0x11, 0x01);
466 static void setexposure(struct gspca_dev *gspca_dev)
472 * Register 2 of frame 3 contains the clock divider configuring the
473 * no fps according to the formula: 90 / reg. sd->exposure is the
474 * desired exposure time in 0.5 ms.
476 clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000;
479 * Note clockdiv = 3 also works, but when running at 30 fps, depending
480 * on the scene being recorded, the camera switches to another
481 * quantization table for certain JPEG blocks, and we don't know how
482 * to decompress these blocks. So we cap the framerate at 15 fps.
486 else if (clockdiv > 63)
490 * Register 2 MUST be a multiple of 3, except when between 6 and 12?
491 * Always round up, otherwise we cannot get the desired frametime
492 * using the partial frame time exposure control.
494 if (clockdiv < 6 || clockdiv > 12)
495 clockdiv = ((clockdiv + 2) / 3) * 3;
498 * frame exposure time in ms = 1000 * clockdiv / 90 ->
499 * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90)
501 exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv);
502 /* 0 = use full frametime, 448 = no exposure, reverse it */
503 exposure = 448 - exposure;
505 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
506 reg_w(gspca_dev, 0x02, clockdiv);
507 reg_w(gspca_dev, 0x0e, exposure & 0xff);
508 reg_w(gspca_dev, 0x0f, exposure >> 8);
510 /* load registers to sensor (Bit 0, auto clear) */
511 reg_w(gspca_dev, 0x11, 0x01);
514 static void sethvflip(struct gspca_dev *gspca_dev)
516 struct sd *sd = (struct sd *) gspca_dev;
517 u8 data, hflip, vflip;
519 hflip = sd->hflip->val;
520 if (sd->flags & FL_HFLIP)
522 vflip = sd->vflip->val;
523 if (sd->flags & FL_VFLIP)
526 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
527 data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
528 reg_w(gspca_dev, 0x21, data);
530 /* load registers to sensor (Bit 0, auto clear) */
531 reg_w(gspca_dev, 0x11, 0x01);
534 /* this function is called at probe and resume time for pac7302 */
535 static int sd_init(struct gspca_dev *gspca_dev)
537 reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
538 return gspca_dev->usb_err;
541 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
543 struct gspca_dev *gspca_dev =
544 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
545 struct sd *sd = (struct sd *)gspca_dev;
547 gspca_dev->usb_err = 0;
549 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
550 /* when switching to autogain set defaults to make sure
551 we are on a valid point of the autogain gain /
552 exposure knee graph, and give this change time to
553 take effect before doing autogain. */
554 gspca_dev->exposure->val = PAC7302_EXPOSURE_DEFAULT;
555 gspca_dev->gain->val = PAC7302_GAIN_DEFAULT;
556 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
559 if (!gspca_dev->streaming)
563 case V4L2_CID_BRIGHTNESS:
564 setbrightcont(gspca_dev);
566 case V4L2_CID_SATURATION:
567 setcolors(gspca_dev);
569 case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
570 setwhitebalance(gspca_dev);
572 case V4L2_CID_RED_BALANCE:
573 setredbalance(gspca_dev);
575 case V4L2_CID_BLUE_BALANCE:
576 setbluebalance(gspca_dev);
578 case V4L2_CID_AUTOGAIN:
579 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
580 setexposure(gspca_dev);
581 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
585 sethvflip(gspca_dev);
590 return gspca_dev->usb_err;
593 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
597 /* this function is called at probe time */
598 static int sd_init_controls(struct gspca_dev *gspca_dev)
600 struct sd *sd = (struct sd *) gspca_dev;
601 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
603 gspca_dev->vdev.ctrl_handler = hdl;
604 v4l2_ctrl_handler_init(hdl, 11);
606 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
607 V4L2_CID_BRIGHTNESS, 0, 32, 1, 16);
608 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
609 V4L2_CID_CONTRAST, 0, 255, 1, 127);
611 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
612 V4L2_CID_SATURATION, 0, 255, 1, 127);
613 sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
614 V4L2_CID_WHITE_BALANCE_TEMPERATURE,
616 sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
617 V4L2_CID_RED_BALANCE, 0, 3, 1, 1);
618 sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
619 V4L2_CID_RED_BALANCE, 0, 3, 1, 1);
621 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
622 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
623 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
624 V4L2_CID_EXPOSURE, 0, 1023, 1,
625 PAC7302_EXPOSURE_DEFAULT);
626 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
627 V4L2_CID_GAIN, 0, 62, 1,
628 PAC7302_GAIN_DEFAULT);
630 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
631 V4L2_CID_HFLIP, 0, 1, 1, 0);
632 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
633 V4L2_CID_VFLIP, 0, 1, 1, 0);
636 pr_err("Could not initialize controls\n");
640 v4l2_ctrl_cluster(2, &sd->brightness);
641 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
642 v4l2_ctrl_cluster(2, &sd->hflip);
646 /* -- start the camera -- */
647 static int sd_start(struct gspca_dev *gspca_dev)
649 struct sd *sd = (struct sd *) gspca_dev;
651 reg_w_var(gspca_dev, start_7302,
652 page3_7302, sizeof(page3_7302));
653 setbrightcont(gspca_dev);
654 setcolors(gspca_dev);
655 setwhitebalance(gspca_dev);
656 setredbalance(gspca_dev);
657 setbluebalance(gspca_dev);
658 setexposure(gspca_dev);
660 sethvflip(gspca_dev);
663 sd->autogain_ignore_frames = 0;
664 atomic_set(&sd->avg_lum, 270 + sd->brightness->val);
667 reg_w(gspca_dev, 0xff, 0x01);
668 reg_w(gspca_dev, 0x78, 0x01);
670 return gspca_dev->usb_err;
673 static void sd_stopN(struct gspca_dev *gspca_dev)
677 reg_w(gspca_dev, 0xff, 0x01);
678 reg_w(gspca_dev, 0x78, 0x00);
681 /* called on streamoff with alt 0 and on disconnect for pac7302 */
682 static void sd_stop0(struct gspca_dev *gspca_dev)
684 if (!gspca_dev->present)
686 reg_w(gspca_dev, 0xff, 0x01);
687 reg_w(gspca_dev, 0x78, 0x40);
690 static void do_autogain(struct gspca_dev *gspca_dev)
692 struct sd *sd = (struct sd *) gspca_dev;
693 int avg_lum = atomic_read(&sd->avg_lum);
695 const int deadzone = 30;
697 if (sd->autogain_ignore_frames < 0)
700 if (sd->autogain_ignore_frames > 0) {
701 sd->autogain_ignore_frames--;
703 desired_lum = 270 + sd->brightness->val;
705 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum,
706 deadzone, PAC7302_GAIN_KNEE,
707 PAC7302_EXPOSURE_KNEE))
708 sd->autogain_ignore_frames =
709 PAC_AUTOGAIN_IGNORE_FRAMES;
714 static const u8 jpeg_header[] = {
715 0xff, 0xd8, /* SOI: Start of Image */
717 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */
718 0x00, 0x11, /* length = 17 bytes (including this length field) */
719 0x08, /* Precision: 8 */
720 0x02, 0x80, /* height = 640 (image rotated) */
721 0x01, 0xe0, /* width = 480 */
722 0x03, /* Number of image components: 3 */
723 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
724 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
725 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
727 0xff, 0xda, /* SOS: Start Of Scan */
728 0x00, 0x0c, /* length = 12 bytes (including this length field) */
729 0x03, /* number of components: 3 */
730 0x01, 0x00, /* selector 1, table 0x00 */
731 0x02, 0x11, /* selector 2, table 0x11 */
732 0x03, 0x11, /* selector 3, table 0x11 */
733 0x00, 0x3f, /* Spectral selection: 0 .. 63 */
734 0x00 /* Successive approximation: 0 */
737 /* this function is run at interrupt level */
738 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
739 u8 *data, /* isoc packet */
740 int len) /* iso packet length */
742 struct sd *sd = (struct sd *) gspca_dev;
746 sof = pac_find_sof(&sd->sof_read, data, len);
748 int n, lum_offset, footer_length;
751 * 6 bytes after the FF D9 EOF marker a number of lumination
752 * bytes are send corresponding to different parts of the
753 * image, the 14th and 15th byte after the EOF seem to
754 * correspond to the center of the image.
756 lum_offset = 61 + sizeof pac_sof_marker;
759 /* Finish decoding current frame */
760 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
762 gspca_dev->image_len += n;
765 gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
768 image = gspca_dev->image;
770 && image[gspca_dev->image_len - 2] == 0xff
771 && image[gspca_dev->image_len - 1] == 0xd9)
772 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
778 /* Get average lumination */
779 if (gspca_dev->last_packet_type == LAST_PACKET &&
781 atomic_set(&sd->avg_lum, data[-lum_offset] +
782 data[-lum_offset + 1]);
784 /* Start the new frame with the jpeg header */
785 /* The PAC7302 has the image rotated 90 degrees */
786 gspca_frame_add(gspca_dev, FIRST_PACKET,
787 jpeg_header, sizeof jpeg_header);
789 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
792 #ifdef CONFIG_VIDEO_ADV_DEBUG
793 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
794 struct v4l2_dbg_register *reg)
800 * reg->reg: bit0..15: reserved for register index (wIndex is 16bit
801 * long on the USB bus)
803 if (reg->match.type == V4L2_CHIP_MATCH_HOST &&
804 reg->match.addr == 0 &&
805 (reg->reg < 0x000000ff) &&
806 (reg->val <= 0x000000ff)
808 /* Currently writing to page 0 is only supported. */
809 /* reg_w() only supports 8bit index */
814 * Note that there shall be no access to other page
815 * by any other function between the page switch and
816 * the actual register write.
818 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
819 reg_w(gspca_dev, index, value);
821 reg_w(gspca_dev, 0xdc, 0x01);
823 return gspca_dev->usb_err;
826 static int sd_chip_ident(struct gspca_dev *gspca_dev,
827 struct v4l2_dbg_chip_ident *chip)
831 if (chip->match.type == V4L2_CHIP_MATCH_HOST &&
832 chip->match.addr == 0) {
834 chip->ident = V4L2_IDENT_UNKNOWN;
841 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
842 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
843 u8 *data, /* interrupt packet data */
844 int len) /* interrput packet length */
852 if ((data0 == 0x00 && data1 == 0x11) ||
853 (data0 == 0x22 && data1 == 0x33) ||
854 (data0 == 0x44 && data1 == 0x55) ||
855 (data0 == 0x66 && data1 == 0x77) ||
856 (data0 == 0x88 && data1 == 0x99) ||
857 (data0 == 0xaa && data1 == 0xbb) ||
858 (data0 == 0xcc && data1 == 0xdd) ||
859 (data0 == 0xee && data1 == 0xff)) {
860 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
861 input_sync(gspca_dev->input_dev);
862 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
863 input_sync(gspca_dev->input_dev);
872 /* sub-driver description for pac7302 */
873 static const struct sd_desc sd_desc = {
874 .name = KBUILD_MODNAME,
877 .init_controls = sd_init_controls,
881 .pkt_scan = sd_pkt_scan,
882 .dq_callback = do_autogain,
883 #ifdef CONFIG_VIDEO_ADV_DEBUG
884 .set_register = sd_dbg_s_register,
885 .get_chip_ident = sd_chip_ident,
887 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
888 .int_pkt_scan = sd_int_pkt_scan,
892 /* -- module initialisation -- */
893 static const struct usb_device_id device_table[] = {
894 {USB_DEVICE(0x06f8, 0x3009)},
895 {USB_DEVICE(0x06f8, 0x301b)},
896 {USB_DEVICE(0x093a, 0x2620)},
897 {USB_DEVICE(0x093a, 0x2621)},
898 {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
899 {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
900 {USB_DEVICE(0x093a, 0x2625)},
901 {USB_DEVICE(0x093a, 0x2626)},
902 {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP},
903 {USB_DEVICE(0x093a, 0x2628)},
904 {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
905 {USB_DEVICE(0x093a, 0x262a)},
906 {USB_DEVICE(0x093a, 0x262c)},
907 {USB_DEVICE(0x145f, 0x013c)},
910 MODULE_DEVICE_TABLE(usb, device_table);
912 /* -- device connect -- */
913 static int sd_probe(struct usb_interface *intf,
914 const struct usb_device_id *id)
916 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
920 static struct usb_driver sd_driver = {
921 .name = KBUILD_MODNAME,
922 .id_table = device_table,
924 .disconnect = gspca_disconnect,
926 .suspend = gspca_suspend,
927 .resume = gspca_resume,
928 .reset_resume = gspca_resume,
932 module_usb_driver(sd_driver);