2 * Pixart PAC207BCA library
4 * Copyright (C) 2008 Hans de Goede <j.w.r.degoede@hhs.nl>
5 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
6 * Copyleft (C) 2005 Michel Xhaard mxhaard@magic.fr
8 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #define MODULE_NAME "pac207"
30 MODULE_AUTHOR("Hans de Goede <j.w.r.degoede@hhs.nl>");
31 MODULE_DESCRIPTION("Pixart PAC207");
32 MODULE_LICENSE("GPL");
34 #define PAC207_CTRL_TIMEOUT 100 /* ms */
36 #define PAC207_BRIGHTNESS_MIN 0
37 #define PAC207_BRIGHTNESS_MAX 255
38 #define PAC207_BRIGHTNESS_DEFAULT 4 /* power on default: 4 */
40 /* An exposure value of 4 also works (3 does not) but then we need to lower
41 the compression balance setting when in 352x288 mode, otherwise the usb
42 bandwidth is not enough and packets get dropped resulting in corrupt
43 frames. The problem with this is that when the compression balance gets
44 lowered below 0x80, the pac207 starts using a different compression
45 algorithm for some lines, these lines get prefixed with a 0x2dd2 prefix
46 and currently we do not know how to decompress these lines, so for now
47 we use a minimum exposure value of 5 */
48 #define PAC207_EXPOSURE_MIN 5
49 #define PAC207_EXPOSURE_MAX 26
50 #define PAC207_EXPOSURE_DEFAULT 5 /* power on default: 3 ?? */
51 #define PAC207_EXPOSURE_KNEE 11 /* 4 = 30 fps, 11 = 8, 15 = 6 */
53 #define PAC207_GAIN_MIN 0
54 #define PAC207_GAIN_MAX 31
55 #define PAC207_GAIN_DEFAULT 9 /* power on default: 9 */
56 #define PAC207_GAIN_KNEE 20
58 #define PAC207_AUTOGAIN_DEADZONE 30
59 /* We calculating the autogain at the end of the transfer of a frame, at this
60 moment a frame with the old settings is being transmitted, and a frame is
61 being captured with the old settings. So if we adjust the autogain we must
62 ignore atleast the 2 next frames for the new settings to come into effect
63 before doing any other adjustments */
64 #define PAC207_AUTOGAIN_IGNORE_FRAMES 3
66 /* specific webcam descriptor */
68 struct gspca_dev gspca_dev; /* !! must be the first item */
79 u8 autogain_ignore_frames;
84 /* V4L2 controls supported by the driver */
85 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
86 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
87 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
88 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
89 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
90 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
91 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
92 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
94 static struct ctrl sd_ctrls[] = {
95 #define SD_BRIGHTNESS 0
98 .id = V4L2_CID_BRIGHTNESS,
99 .type = V4L2_CTRL_TYPE_INTEGER,
100 .name = "Brightness",
101 .minimum = PAC207_BRIGHTNESS_MIN,
102 .maximum = PAC207_BRIGHTNESS_MAX,
104 .default_value = PAC207_BRIGHTNESS_DEFAULT,
107 .set = sd_setbrightness,
108 .get = sd_getbrightness,
110 #define SD_EXPOSURE 1
113 .id = V4L2_CID_EXPOSURE,
114 .type = V4L2_CTRL_TYPE_INTEGER,
116 .minimum = PAC207_EXPOSURE_MIN,
117 .maximum = PAC207_EXPOSURE_MAX,
119 .default_value = PAC207_EXPOSURE_DEFAULT,
122 .set = sd_setexposure,
123 .get = sd_getexposure,
125 #define SD_AUTOGAIN 2
128 .id = V4L2_CID_AUTOGAIN,
129 .type = V4L2_CTRL_TYPE_BOOLEAN,
134 #define AUTOGAIN_DEF 1
135 .default_value = AUTOGAIN_DEF,
138 .set = sd_setautogain,
139 .get = sd_getautogain,
145 .type = V4L2_CTRL_TYPE_INTEGER,
147 .minimum = PAC207_GAIN_MIN,
148 .maximum = PAC207_GAIN_MAX,
150 .default_value = PAC207_GAIN_DEFAULT,
158 static struct v4l2_pix_format sif_mode[] = {
159 {176, 144, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE,
161 .sizeimage = (176 + 2) * 144,
162 /* uncompressed, add 2 bytes / line for line header */
163 .colorspace = V4L2_COLORSPACE_SRGB,
165 {352, 288, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE,
167 /* compressed, but only when needed (not compressed
168 when the framerate is low) */
169 .sizeimage = (352 + 2) * 288,
170 .colorspace = V4L2_COLORSPACE_SRGB,
174 static const __u8 pac207_sensor_init[][8] = {
175 {0x10, 0x12, 0x0d, 0x12, 0x0c, 0x01, 0x29, 0xf0},
176 {0x00, 0x64, 0x64, 0x64, 0x04, 0x10, 0xf0, 0x30},
177 {0x00, 0x00, 0x00, 0x70, 0xa0, 0xf8, 0x00, 0x00},
178 {0x00, 0x00, 0x32, 0x00, 0x96, 0x00, 0xa2, 0x02},
179 {0x32, 0x00, 0x96, 0x00, 0xA2, 0x02, 0xaf, 0x00},
182 /* 48 reg_72 Rate Control end BalSize_4a =0x36 */
183 static const __u8 PacReg72[] = { 0x00, 0x00, 0x36, 0x00 };
185 static int pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
186 const u8 *buffer, u16 length)
188 struct usb_device *udev = gspca_dev->dev;
191 memcpy(gspca_dev->usb_buf, buffer, length);
193 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x01,
194 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
196 gspca_dev->usb_buf, length, PAC207_CTRL_TIMEOUT);
199 "Failed to write registers to index 0x%04X, error %d)",
206 static int pac207_write_reg(struct gspca_dev *gspca_dev, u16 index, u16 value)
208 struct usb_device *udev = gspca_dev->dev;
211 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
212 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
213 value, index, NULL, 0, PAC207_CTRL_TIMEOUT);
215 PDEBUG(D_ERR, "Failed to write a register (index 0x%04X,"
216 " value 0x%02X, error %d)", index, value, err);
221 static int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index)
223 struct usb_device *udev = gspca_dev->dev;
226 res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
227 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
229 gspca_dev->usb_buf, 1, PAC207_CTRL_TIMEOUT);
232 "Failed to read a register (index 0x%04X, error %d)",
237 return gspca_dev->usb_buf[0];
240 /* this function is called at probe time */
241 static int sd_config(struct gspca_dev *gspca_dev,
242 const struct usb_device_id *id)
244 struct sd *sd = (struct sd *) gspca_dev;
248 idreg[0] = pac207_read_reg(gspca_dev, 0x0000);
249 idreg[1] = pac207_read_reg(gspca_dev, 0x0001);
250 idreg[0] = ((idreg[0] & 0x0F) << 4) | ((idreg[1] & 0xf0) >> 4);
251 idreg[1] = idreg[1] & 0x0f;
252 PDEBUG(D_PROBE, "Pixart Sensor ID 0x%02X Chips ID 0x%02X",
255 if (idreg[0] != 0x27) {
256 PDEBUG(D_PROBE, "Error invalid sensor ID!");
261 "Pixart PAC207BCA Image Processor and Control Chip detected"
262 " (vid/pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
264 cam = &gspca_dev->cam;
266 cam->cam_mode = sif_mode;
267 cam->nmodes = ARRAY_SIZE(sif_mode);
268 sd->brightness = PAC207_BRIGHTNESS_DEFAULT;
269 sd->exposure = PAC207_EXPOSURE_DEFAULT;
270 sd->gain = PAC207_GAIN_DEFAULT;
271 sd->autogain = AUTOGAIN_DEF;
276 /* this function is called at probe and resume time */
277 static int sd_init(struct gspca_dev *gspca_dev)
279 pac207_write_reg(gspca_dev, 0x41, 0x00);
280 /* Bit_0=Image Format,
282 * Bit_2=Compression test mode enable */
283 pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
284 pac207_write_reg(gspca_dev, 0x11, 0x30); /* Analog Bias */
289 /* -- start the camera -- */
290 static void sd_start(struct gspca_dev *gspca_dev)
292 struct sd *sd = (struct sd *) gspca_dev;
295 pac207_write_reg(gspca_dev, 0x0f, 0x10); /* Power control (Bit 6-0) */
296 pac207_write_regs(gspca_dev, 0x0002, pac207_sensor_init[0], 8);
297 pac207_write_regs(gspca_dev, 0x000a, pac207_sensor_init[1], 8);
298 pac207_write_regs(gspca_dev, 0x0012, pac207_sensor_init[2], 8);
299 pac207_write_regs(gspca_dev, 0x0040, pac207_sensor_init[3], 8);
300 pac207_write_regs(gspca_dev, 0x0042, pac207_sensor_init[4], 8);
301 pac207_write_regs(gspca_dev, 0x0048, PacReg72, 4);
303 /* Compression Balance */
304 if (gspca_dev->width == 176)
305 pac207_write_reg(gspca_dev, 0x4a, 0xff);
307 pac207_write_reg(gspca_dev, 0x4a, 0x88);
308 pac207_write_reg(gspca_dev, 0x4b, 0x00); /* Sram test value */
309 pac207_write_reg(gspca_dev, 0x08, sd->brightness);
311 /* PGA global gain (Bit 4-0) */
312 pac207_write_reg(gspca_dev, 0x0e, sd->gain);
313 pac207_write_reg(gspca_dev, 0x02, sd->exposure); /* PXCK = 12MHz /n */
315 mode = 0x02; /* Image Format (Bit 0), LED (1), Compr. test mode (2) */
316 if (gspca_dev->width == 176) { /* 176x144 */
318 PDEBUG(D_STREAM, "pac207_start mode 176x144");
319 } else { /* 352x288 */
320 PDEBUG(D_STREAM, "pac207_start mode 352x288");
322 pac207_write_reg(gspca_dev, 0x41, mode);
324 pac207_write_reg(gspca_dev, 0x13, 0x01); /* Bit 0, auto clear */
325 pac207_write_reg(gspca_dev, 0x1c, 0x01); /* not documented */
327 pac207_write_reg(gspca_dev, 0x40, 0x01); /* Start ISO pipe */
330 sd->autogain_ignore_frames = 0;
331 atomic_set(&sd->avg_lum, -1);
334 static void sd_stopN(struct gspca_dev *gspca_dev)
336 pac207_write_reg(gspca_dev, 0x40, 0x00); /* Stop ISO pipe */
337 pac207_write_reg(gspca_dev, 0x41, 0x00); /* Turn of LED */
338 pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
341 static void pac207_do_auto_gain(struct gspca_dev *gspca_dev)
343 struct sd *sd = (struct sd *) gspca_dev;
344 int avg_lum = atomic_read(&sd->avg_lum);
349 if (sd->autogain_ignore_frames > 0)
350 sd->autogain_ignore_frames--;
351 else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
352 100 + sd->brightness / 2, PAC207_AUTOGAIN_DEADZONE,
353 PAC207_GAIN_KNEE, PAC207_EXPOSURE_KNEE))
354 sd->autogain_ignore_frames = PAC207_AUTOGAIN_IGNORE_FRAMES;
357 /* Include pac common sof detection functions */
358 #include "pac_common.h"
360 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
361 struct gspca_frame *frame,
365 struct sd *sd = (struct sd *) gspca_dev;
368 sof = pac_find_sof(gspca_dev, data, len);
372 /* finish decoding current frame */
374 if (n > sizeof pac_sof_marker)
375 n -= sizeof pac_sof_marker;
378 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
381 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, NULL, 0);
385 if (sd->header_read < 11) {
388 /* get average lumination from frame header (byte 5) */
389 if (sd->header_read < 5) {
390 needed = 5 - sd->header_read;
392 atomic_set(&sd->avg_lum, data[needed - 1]);
394 /* skip the rest of the header */
395 needed = 11 - sd->header_read;
397 sd->header_read += len;
402 sd->header_read = 11;
405 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
408 static void setbrightness(struct gspca_dev *gspca_dev)
410 struct sd *sd = (struct sd *) gspca_dev;
412 pac207_write_reg(gspca_dev, 0x08, sd->brightness);
413 pac207_write_reg(gspca_dev, 0x13, 0x01); /* Bit 0, auto clear */
414 pac207_write_reg(gspca_dev, 0x1c, 0x01); /* not documented */
417 static void setexposure(struct gspca_dev *gspca_dev)
419 struct sd *sd = (struct sd *) gspca_dev;
421 pac207_write_reg(gspca_dev, 0x02, sd->exposure);
422 pac207_write_reg(gspca_dev, 0x13, 0x01); /* Bit 0, auto clear */
423 pac207_write_reg(gspca_dev, 0x1c, 0x01); /* not documented */
426 static void setgain(struct gspca_dev *gspca_dev)
428 struct sd *sd = (struct sd *) gspca_dev;
430 pac207_write_reg(gspca_dev, 0x0e, sd->gain);
431 pac207_write_reg(gspca_dev, 0x13, 0x01); /* Bit 0, auto clear */
432 pac207_write_reg(gspca_dev, 0x1c, 0x01); /* not documented */
435 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
437 struct sd *sd = (struct sd *) gspca_dev;
439 sd->brightness = val;
440 if (gspca_dev->streaming)
441 setbrightness(gspca_dev);
445 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
447 struct sd *sd = (struct sd *) gspca_dev;
449 *val = sd->brightness;
453 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
455 struct sd *sd = (struct sd *) gspca_dev;
458 if (gspca_dev->streaming)
459 setexposure(gspca_dev);
463 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
465 struct sd *sd = (struct sd *) gspca_dev;
471 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
473 struct sd *sd = (struct sd *) gspca_dev;
476 if (gspca_dev->streaming)
481 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
483 struct sd *sd = (struct sd *) gspca_dev;
489 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
491 struct sd *sd = (struct sd *) gspca_dev;
494 /* when switching to autogain set defaults to make sure
495 we are on a valid point of the autogain gain /
496 exposure knee graph, and give this change time to
497 take effect before doing autogain. */
499 sd->exposure = PAC207_EXPOSURE_DEFAULT;
500 sd->gain = PAC207_GAIN_DEFAULT;
501 if (gspca_dev->streaming) {
502 sd->autogain_ignore_frames =
503 PAC207_AUTOGAIN_IGNORE_FRAMES;
504 setexposure(gspca_dev);
512 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
514 struct sd *sd = (struct sd *) gspca_dev;
520 /* sub-driver description */
521 static const struct sd_desc sd_desc = {
524 .nctrls = ARRAY_SIZE(sd_ctrls),
529 .dq_callback = pac207_do_auto_gain,
530 .pkt_scan = sd_pkt_scan,
533 /* -- module initialisation -- */
534 static const __devinitdata struct usb_device_id device_table[] = {
535 {USB_DEVICE(0x041e, 0x4028)},
536 {USB_DEVICE(0x093a, 0x2460)},
537 {USB_DEVICE(0x093a, 0x2463)},
538 {USB_DEVICE(0x093a, 0x2464)},
539 {USB_DEVICE(0x093a, 0x2468)},
540 {USB_DEVICE(0x093a, 0x2470)},
541 {USB_DEVICE(0x093a, 0x2471)},
542 {USB_DEVICE(0x093a, 0x2472)},
543 {USB_DEVICE(0x2001, 0xf115)},
546 MODULE_DEVICE_TABLE(usb, device_table);
548 /* -- device connect -- */
549 static int sd_probe(struct usb_interface *intf,
550 const struct usb_device_id *id)
552 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
556 static struct usb_driver sd_driver = {
558 .id_table = device_table,
560 .disconnect = gspca_disconnect,
562 .suspend = gspca_suspend,
563 .resume = gspca_resume,
567 /* -- module insert / remove -- */
568 static int __init sd_mod_init(void)
570 if (usb_register(&sd_driver) < 0)
572 PDEBUG(D_PROBE, "registered");
575 static void __exit sd_mod_exit(void)
577 usb_deregister(&sd_driver);
578 PDEBUG(D_PROBE, "deregistered");
581 module_init(sd_mod_init);
582 module_exit(sd_mod_exit);