?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (8442): gspca: Remove the version from the subdrivers.
[linux-2.6/btrfs-unstable.git] / drivers / media / video / gspca / pac7311.c
blob2267ae7cb87f53d122a2fedb97b6a407b35be15e
1 /*
2 * Pixart PAC7311 library
3 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #define MODULE_NAME "pac7311"
23
24 #include "gspca.h"
25
26 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
27 MODULE_DESCRIPTION("Pixart PAC7311");
28 MODULE_LICENSE("GPL");
29
30 /* specific webcam descriptor */
31 struct sd {
32 struct gspca_dev gspca_dev; /* !! must be the first item */
33
34 int avg_lum;
35
36 unsigned char brightness;
37 unsigned char contrast;
38 unsigned char colors;
39 unsigned char autogain;
40
41 char ffseq;
42 signed char ag_cnt;
43 #define AG_CNT_START 13
44 };
45
46 /* V4L2 controls supported by the driver */
47 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
48 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
49 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
50 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
51 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
52 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
53 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
54 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
55
56 static struct ctrl sd_ctrls[] = {
57 {
58 {
59 .id = V4L2_CID_BRIGHTNESS,
60 .type = V4L2_CTRL_TYPE_INTEGER,
61 .name = "Brightness",
62 .minimum = 0,
63 #define BRIGHTNESS_MAX 0x20
64 .maximum = BRIGHTNESS_MAX,
65 .step = 1,
66 #define BRIGHTNESS_DEF 0x10
67 .default_value = BRIGHTNESS_DEF,
68 },
69 .set = sd_setbrightness,
70 .get = sd_getbrightness,
71 },
72 {
73 {
74 .id = V4L2_CID_CONTRAST,
75 .type = V4L2_CTRL_TYPE_INTEGER,
76 .name = "Contrast",
77 .minimum = 0,
78 .maximum = 255,
79 .step = 1,
80 #define CONTRAST_DEF 127
81 .default_value = CONTRAST_DEF,
82 },
83 .set = sd_setcontrast,
84 .get = sd_getcontrast,
85 },
86 {
87 {
88 .id = V4L2_CID_SATURATION,
89 .type = V4L2_CTRL_TYPE_INTEGER,
90 .name = "Color",
91 .minimum = 0,
92 .maximum = 255,
93 .step = 1,
94 #define COLOR_DEF 127
95 .default_value = COLOR_DEF,
96 },
97 .set = sd_setcolors,
98 .get = sd_getcolors,
99 },
100 {
101 {
102 .id = V4L2_CID_AUTOGAIN,
103 .type = V4L2_CTRL_TYPE_BOOLEAN,
104 .name = "Auto Gain",
105 .minimum = 0,
106 .maximum = 1,
107 .step = 1,
108 #define AUTOGAIN_DEF 1
109 .default_value = AUTOGAIN_DEF,
110 },
111 .set = sd_setautogain,
112 .get = sd_getautogain,
113 },
114 };
115
116 static struct v4l2_pix_format vga_mode[] = {
117 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
118 .bytesperline = 160,
119 .sizeimage = 160 * 120 * 3 / 8 + 590,
120 .colorspace = V4L2_COLORSPACE_JPEG,
121 .priv = 2},
122 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
123 .bytesperline = 320,
124 .sizeimage = 320 * 240 * 3 / 8 + 590,
125 .colorspace = V4L2_COLORSPACE_JPEG,
126 .priv = 1},
127 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
128 .bytesperline = 640,
129 .sizeimage = 640 * 480 * 3 / 8 + 590,
130 .colorspace = V4L2_COLORSPACE_JPEG,
131 .priv = 0},
132 };
133
134 #define PAC7311_JPEG_HEADER_SIZE (sizeof pac7311_jpeg_header) /* (594) */
135
136 static const __u8 pac7311_jpeg_header[] = {
137 0xff, 0xd8,
138 0xff, 0xe0, 0x00, 0x03, 0x20,
139 0xff, 0xc0, 0x00, 0x11, 0x08,
140 0x01, 0xe0, /* 12: height */
141 0x02, 0x80, /* 14: width */
142 0x03, /* 16 */
143 0x01, 0x21, 0x00,
144 0x02, 0x11, 0x01,
145 0x03, 0x11, 0x01,
146 0xff, 0xdb, 0x00, 0x84,
147 0x00, 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e, 0x0d,
148 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28, 0x1a, 0x18, 0x16,
149 0x16, 0x18, 0x31, 0x23, 0x25, 0x1d, 0x28, 0x3a, 0x33, 0x3d,
150 0x3c, 0x39, 0x33, 0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40,
151 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57, 0x5f,
152 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71, 0x79, 0x70, 0x64,
153 0x78, 0x5c, 0x65, 0x67, 0x63, 0x01, 0x11, 0x12, 0x12, 0x18,
154 0x15, 0x18, 0x2f, 0x1a, 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42,
155 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
156 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
157 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
158 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
159 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
160 0xff, 0xc4, 0x01, 0xa2, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01,
161 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
162 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
163 0x09, 0x0a, 0x0b, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
164 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d,
165 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31,
166 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32,
167 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52,
168 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
169 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
170 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
171 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57,
172 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
173 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83,
174 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94,
175 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
176 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
177 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
178 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
179 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8,
180 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
181 0xf9, 0xfa, 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01,
182 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
183 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
184 0x0b, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
185 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01,
186 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41,
187 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14,
188 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
189 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25,
190 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a,
191 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46,
192 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
193 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
194 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83,
195 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94,
196 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
197 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
198 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
199 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
200 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
201 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
202 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03,
203 0x11, 0x00, 0x3f, 0x00
204 };
205
206 static void reg_w_buf(struct gspca_dev *gspca_dev,
207 __u16 index,
208 const char *buffer, __u16 len)
209 {
210 memcpy(gspca_dev->usb_buf, buffer, len);
211 usb_control_msg(gspca_dev->dev,
212 usb_sndctrlpipe(gspca_dev->dev, 0),
213 1, /* request */
214 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
215 0, /* value */
216 index, gspca_dev->usb_buf, len,
217 500);
218 }
219
220 static __u8 reg_r(struct gspca_dev *gspca_dev,
221 __u16 index)
222 {
223 usb_control_msg(gspca_dev->dev,
224 usb_rcvctrlpipe(gspca_dev->dev, 0),
225 0, /* request */
226 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
227 0, /* value */
228 index, gspca_dev->usb_buf, 1,
229 500);
230 return gspca_dev->usb_buf[0];
231 }
232
233 static void reg_w(struct gspca_dev *gspca_dev,
234 __u16 index,
235 __u8 value)
236 {
237 gspca_dev->usb_buf[0] = value;
238 usb_control_msg(gspca_dev->dev,
239 usb_sndctrlpipe(gspca_dev->dev, 0),
240 0, /* request */
241 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
242 value, index, gspca_dev->usb_buf, 1,
243 500);
244 }
245
246 /* this function is called at probe time */
247 static int sd_config(struct gspca_dev *gspca_dev,
248 const struct usb_device_id *id)
249 {
250 struct sd *sd = (struct sd *) gspca_dev;
251 struct cam *cam;
252
253 PDEBUG(D_CONF, "Find Sensor PAC7311");
254 reg_w(gspca_dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */
255 reg_w(gspca_dev, 0x78, 0x40); /* Bit_0=start stream, Bit_7=LED */
256 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
257 reg_w(gspca_dev, 0xff, 0x04);
258 reg_w(gspca_dev, 0x27, 0x80);
259 reg_w(gspca_dev, 0x28, 0xca);
260 reg_w(gspca_dev, 0x29, 0x53);
261 reg_w(gspca_dev, 0x2a, 0x0e);
262 reg_w(gspca_dev, 0xff, 0x01);
263 reg_w(gspca_dev, 0x3e, 0x20);
264
265 cam = &gspca_dev->cam;
266 cam->dev_name = (char *) id->driver_info;
267 cam->epaddr = 0x05;
268 cam->cam_mode = vga_mode;
269 cam->nmodes = ARRAY_SIZE(vga_mode);
270
271 sd->brightness = BRIGHTNESS_DEF;
272 sd->contrast = CONTRAST_DEF;
273 sd->colors = COLOR_DEF;
274 sd->autogain = AUTOGAIN_DEF;
275 return 0;
276 }
277
278 static void setbrightness(struct gspca_dev *gspca_dev)
279 {
280 struct sd *sd = (struct sd *) gspca_dev;
281 int brightness;
282
283 /*jfm: inverted?*/
284 brightness = BRIGHTNESS_MAX - sd->brightness;
285 reg_w(gspca_dev, 0xff, 0x04);
286 /* reg_w(gspca_dev, 0x0e, 0x00); */
287 reg_w(gspca_dev, 0x0f, brightness);
288 /* load registers to sensor (Bit 0, auto clear) */
289 reg_w(gspca_dev, 0x11, 0x01);
290 PDEBUG(D_CONF|D_STREAM, "brightness: %i", brightness);
291 }
292
293 static void setcontrast(struct gspca_dev *gspca_dev)
294 {
295 struct sd *sd = (struct sd *) gspca_dev;
296
297 reg_w(gspca_dev, 0xff, 0x01);
298 reg_w(gspca_dev, 0x80, sd->contrast);
299 /* load registers to sensor (Bit 0, auto clear) */
300 reg_w(gspca_dev, 0x11, 0x01);
301 PDEBUG(D_CONF|D_STREAM, "contrast: %i", sd->contrast);
302 }
303
304 static void setcolors(struct gspca_dev *gspca_dev)
305 {
306 struct sd *sd = (struct sd *) gspca_dev;
307
308 reg_w(gspca_dev, 0xff, 0x01);
309 reg_w(gspca_dev, 0x10, sd->colors);
310 /* load registers to sensor (Bit 0, auto clear) */
311 reg_w(gspca_dev, 0x11, 0x01);
312 PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors);
313 }
314
315 /* this function is called at open time */
316 static int sd_open(struct gspca_dev *gspca_dev)
317 {
318 reg_w(gspca_dev, 0x78, 0x00); /* Turn on LED */
319 return 0;
320 }
321
322 static void sd_start(struct gspca_dev *gspca_dev)
323 {
324 struct sd *sd = (struct sd *) gspca_dev;
325
326 reg_w(gspca_dev, 0xff, 0x01);
327 reg_w_buf(gspca_dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8);
328 reg_w_buf(gspca_dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8);
329 reg_w_buf(gspca_dev, 0x0012, "\x00\x07\x00\x0a\x10\x00\xa0\x10", 8);
330 reg_w_buf(gspca_dev, 0x001a, "\x02\x00\x00\x00\x00\x0b\x01\x00", 8);
331 reg_w_buf(gspca_dev, 0x0022, "\x00\x00\x00\x00\x00\x00\x00\x00", 8);
332 reg_w_buf(gspca_dev, 0x002a, "\x00\x00\x00", 3);
333 reg_w_buf(gspca_dev, 0x003e, "\x00\x00\x78\x52\x4a\x52\x78\x6e", 8);
334 reg_w_buf(gspca_dev, 0x0046, "\x48\x46\x48\x6e\x5f\x49\x42\x49", 8);
335 reg_w_buf(gspca_dev, 0x004e, "\x5f\x5f\x49\x42\x49\x5f\x6e\x48", 8);
336 reg_w_buf(gspca_dev, 0x0056, "\x46\x48\x6e\x78\x52\x4a\x52\x78", 8);
337 reg_w_buf(gspca_dev, 0x005e, "\x00\x00\x09\x1b\x34\x49\x5c\x9b", 8);
338 reg_w_buf(gspca_dev, 0x0066, "\xd0\xff", 2);
339 reg_w_buf(gspca_dev, 0x0078, "\x44\x00\xf2\x01\x01\x80", 6);
340 reg_w_buf(gspca_dev, 0x007f, "\x2a\x1c\x00\xc8\x02\x58\x03\x84", 8);
341 reg_w_buf(gspca_dev, 0x0087, "\x12\x00\x1a\x04\x08\x0c\x10\x14", 8);
342 reg_w_buf(gspca_dev, 0x008f, "\x18\x20", 2);
343 reg_w_buf(gspca_dev, 0x0096, "\x01\x08\x04", 3);
344 reg_w_buf(gspca_dev, 0x00a0, "\x44\x44\x44\x04", 4);
345 reg_w_buf(gspca_dev, 0x00f0, "\x01\x00\x00\x00\x22\x00\x20\x00", 8);
346 reg_w_buf(gspca_dev, 0x00f8, "\x3f\x00\x0a\x01\x00", 5);
347
348 reg_w(gspca_dev, 0xff, 0x04);
349 reg_w(gspca_dev, 0x02, 0x04);
350 reg_w(gspca_dev, 0x03, 0x54);
351 reg_w(gspca_dev, 0x04, 0x07);
352 reg_w(gspca_dev, 0x05, 0x2b);
353 reg_w(gspca_dev, 0x06, 0x09);
354 reg_w(gspca_dev, 0x07, 0x0f);
355 reg_w(gspca_dev, 0x08, 0x09);
356 reg_w(gspca_dev, 0x09, 0x00);
357 reg_w(gspca_dev, 0x0c, 0x07);
358 reg_w(gspca_dev, 0x0d, 0x00);
359 reg_w(gspca_dev, 0x0e, 0x00);
360 reg_w(gspca_dev, 0x0f, 0x62);
361 reg_w(gspca_dev, 0x10, 0x08);
362 reg_w(gspca_dev, 0x12, 0x07);
363 reg_w(gspca_dev, 0x13, 0x00);
364 reg_w(gspca_dev, 0x14, 0x00);
365 reg_w(gspca_dev, 0x15, 0x00);
366 reg_w(gspca_dev, 0x16, 0x00);
367 reg_w(gspca_dev, 0x17, 0x00);
368 reg_w(gspca_dev, 0x18, 0x00);
369 reg_w(gspca_dev, 0x19, 0x00);
370 reg_w(gspca_dev, 0x1a, 0x00);
371 reg_w(gspca_dev, 0x1b, 0x03);
372 reg_w(gspca_dev, 0x1c, 0xa0);
373 reg_w(gspca_dev, 0x1d, 0x01);
374 reg_w(gspca_dev, 0x1e, 0xf4);
375 reg_w(gspca_dev, 0x21, 0x00);
376 reg_w(gspca_dev, 0x22, 0x08);
377 reg_w(gspca_dev, 0x24, 0x03);
378 reg_w(gspca_dev, 0x26, 0x00);
379 reg_w(gspca_dev, 0x27, 0x01);
380 reg_w(gspca_dev, 0x28, 0xca);
381 reg_w(gspca_dev, 0x29, 0x10);
382 reg_w(gspca_dev, 0x2a, 0x06);
383 reg_w(gspca_dev, 0x2b, 0x78);
384 reg_w(gspca_dev, 0x2c, 0x00);
385 reg_w(gspca_dev, 0x2d, 0x00);
386 reg_w(gspca_dev, 0x2e, 0x00);
387 reg_w(gspca_dev, 0x2f, 0x00);
388 reg_w(gspca_dev, 0x30, 0x23);
389 reg_w(gspca_dev, 0x31, 0x28);
390 reg_w(gspca_dev, 0x32, 0x04);
391 reg_w(gspca_dev, 0x33, 0x11);
392 reg_w(gspca_dev, 0x34, 0x00);
393 reg_w(gspca_dev, 0x35, 0x00);
394 reg_w(gspca_dev, 0x11, 0x01);
395 setcontrast(gspca_dev);
396 setbrightness(gspca_dev);
397 setcolors(gspca_dev);
398
399 /* set correct resolution */
400 switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
401 case 2: /* 160x120 */
402 reg_w(gspca_dev, 0xff, 0x04);
403 reg_w(gspca_dev, 0x02, 0x03);
404 reg_w(gspca_dev, 0xff, 0x01);
405 reg_w(gspca_dev, 0x08, 0x09);
406 reg_w(gspca_dev, 0x17, 0x20);
407 reg_w(gspca_dev, 0x1b, 0x00);
408 /* reg_w(gspca_dev, 0x80, 0x69); */
409 reg_w(gspca_dev, 0x87, 0x10);
410 break;
411 case 1: /* 320x240 */
412 reg_w(gspca_dev, 0xff, 0x04);
413 reg_w(gspca_dev, 0x02, 0x03);
414 reg_w(gspca_dev, 0xff, 0x01);
415 reg_w(gspca_dev, 0x08, 0x09);
416 reg_w(gspca_dev, 0x17, 0x30);
417 /* reg_w(gspca_dev, 0x80, 0x3f); */
418 reg_w(gspca_dev, 0x87, 0x11);
419 break;
420 case 0: /* 640x480 */
421 reg_w(gspca_dev, 0xff, 0x04);
422 reg_w(gspca_dev, 0x02, 0x03);
423 reg_w(gspca_dev, 0xff, 0x01);
424 reg_w(gspca_dev, 0x08, 0x08);
425 reg_w(gspca_dev, 0x17, 0x00);
426 /* reg_w(gspca_dev, 0x80, 0x1c); */
427 reg_w(gspca_dev, 0x87, 0x12);
428 break;
429 }
430
431 /* start stream */
432 reg_w(gspca_dev, 0xff, 0x01);
433 reg_w(gspca_dev, 0x78, 0x04);
434 reg_w(gspca_dev, 0x78, 0x05);
435
436 if (sd->autogain) {
437 sd->ag_cnt = AG_CNT_START;
438 sd->avg_lum = 0;
439 } else {
440 sd->ag_cnt = -1;
441 }
442 }
443
444 static void sd_stopN(struct gspca_dev *gspca_dev)
445 {
446 reg_w(gspca_dev, 0xff, 0x04);
447 reg_w(gspca_dev, 0x27, 0x80);
448 reg_w(gspca_dev, 0x28, 0xca);
449 reg_w(gspca_dev, 0x29, 0x53);
450 reg_w(gspca_dev, 0x2a, 0x0e);
451 reg_w(gspca_dev, 0xff, 0x01);
452 reg_w(gspca_dev, 0x3e, 0x20);
453 reg_w(gspca_dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */
454 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
455 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
456 }
457
458 static void sd_stop0(struct gspca_dev *gspca_dev)
459 {
460 }
461
462 /* this function is called at close time */
463 static void sd_close(struct gspca_dev *gspca_dev)
464 {
465 reg_w(gspca_dev, 0xff, 0x04);
466 reg_w(gspca_dev, 0x27, 0x80);
467 reg_w(gspca_dev, 0x28, 0xca);
468 reg_w(gspca_dev, 0x29, 0x53);
469 reg_w(gspca_dev, 0x2a, 0x0e);
470 reg_w(gspca_dev, 0xff, 0x01);
471 reg_w(gspca_dev, 0x3e, 0x20);
472 reg_w(gspca_dev, 0x78, 0x04); /* Bit_0=start stream, Bit_7=LED */
473 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
474 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
475 }
476
477 static void setautogain(struct gspca_dev *gspca_dev, int luma)
478 {
479 int luma_mean = 128;
480 int luma_delta = 20;
481 __u8 spring = 5;
482 int Gbright;
483
484 Gbright = reg_r(gspca_dev, 0x02);
485 PDEBUG(D_FRAM, "luma mean %d", luma);
486 if (luma < luma_mean - luma_delta ||
487 luma > luma_mean + luma_delta) {
488 Gbright += (luma_mean - luma) >> spring;
489 if (Gbright > 0x1a)
490 Gbright = 0x1a;
491 else if (Gbright < 4)
492 Gbright = 4;
493 PDEBUG(D_FRAM, "gbright %d", Gbright);
494 reg_w(gspca_dev, 0xff, 0x04);
495 reg_w(gspca_dev, 0x0f, Gbright);
496 /* load registers to sensor (Bit 0, auto clear) */
497 reg_w(gspca_dev, 0x11, 0x01);
498 }
499 }
500
501 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
502 struct gspca_frame *frame, /* target */
503 __u8 *data, /* isoc packet */
504 int len) /* iso packet length */
505 {
506 struct sd *sd = (struct sd *) gspca_dev;
507 unsigned char tmpbuf[4];
508 int i, p, ffseq;
509
510 /* if (len < 5) { */
511 if (len < 6) {
512 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
513 return;
514 }
515
516 ffseq = sd->ffseq;
517
518 for (p = 0; p < len - 6; p++) {
519 if ((data[0 + p] == 0xff)
520 && (data[1 + p] == 0xff)
521 && (data[2 + p] == 0x00)
522 && (data[3 + p] == 0xff)
523 && (data[4 + p] == 0x96)) {
524
525 /* start of frame */
526 if (sd->ag_cnt >= 0 && p > 28) {
527 sd->avg_lum += data[p - 23];
528 if (--sd->ag_cnt < 0) {
529 sd->ag_cnt = AG_CNT_START;
530 setautogain(gspca_dev,
531 sd->avg_lum / AG_CNT_START);
532 sd->avg_lum = 0;
533 }
534 }
535
536 /* copy the end of data to the current frame */
537 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
538 data, p);
539
540 /* put the JPEG header in the new frame */
541 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
542 (unsigned char *) pac7311_jpeg_header,
543 12);
544 tmpbuf[0] = gspca_dev->height >> 8;
545 tmpbuf[1] = gspca_dev->height & 0xff;
546 tmpbuf[2] = gspca_dev->width >> 8;
547 tmpbuf[3] = gspca_dev->width & 0xff;
548 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
549 tmpbuf, 4);
550 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
551 (unsigned char *) &pac7311_jpeg_header[16],
552 PAC7311_JPEG_HEADER_SIZE - 16);
553
554 data += p + 7;
555 len -= p + 7;
556 ffseq = 0;
557 break;
558 }
559 }
560
561 /* remove the 'ff ff ff xx' sequences */
562 switch (ffseq) {
563 case 3:
564 data += 1;
565 len -= 1;
566 break;
567 case 2:
568 if (data[0] == 0xff) {
569 data += 2;
570 len -= 2;
571 frame->data_end -= 2;
572 }
573 break;
574 case 1:
575 if (data[0] == 0xff
576 && data[1] == 0xff) {
577 data += 3;
578 len -= 3;
579 frame->data_end -= 1;
580 }
581 break;
582 }
583 for (i = 0; i < len - 4; i++) {
584 if (data[i] == 0xff
585 && data[i + 1] == 0xff
586 && data[i + 2] == 0xff) {
587 memmove(&data[i], &data[i + 4], len - i - 4);
588 len -= 4;
589 }
590 }
591 ffseq = 0;
592 if (data[len - 4] == 0xff) {
593 if (data[len - 3] == 0xff
594 && data[len - 2] == 0xff) {
595 len -= 4;
596 }
597 } else if (data[len - 3] == 0xff) {
598 if (data[len - 2] == 0xff
599 && data[len - 1] == 0xff)
600 ffseq = 3;
601 } else if (data[len - 2] == 0xff) {
602 if (data[len - 1] == 0xff)
603 ffseq = 2;
604 } else if (data[len - 1] == 0xff)
605 ffseq = 1;
606 sd->ffseq = ffseq;
607 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
608 }
609
610 static void getbrightness(struct gspca_dev *gspca_dev)
611 {
612 /* sd->brightness = reg_r(gspca_dev, 0x08);
613 return sd->brightness; */
614 /* PDEBUG(D_CONF, "Called pac7311_getbrightness: Not implemented yet"); */
615 }
616
617
618
619 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
620 {
621 struct sd *sd = (struct sd *) gspca_dev;
622
623 sd->brightness = val;
624 if (gspca_dev->streaming)
625 setbrightness(gspca_dev);
626 return 0;
627 }
628
629 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
630 {
631 struct sd *sd = (struct sd *) gspca_dev;
632
633 getbrightness(gspca_dev);
634 *val = sd->brightness;
635 return 0;
636 }
637
638 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
639 {
640 struct sd *sd = (struct sd *) gspca_dev;
641
642 sd->contrast = val;
643 if (gspca_dev->streaming)
644 setcontrast(gspca_dev);
645 return 0;
646 }
647
648 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
649 {
650 struct sd *sd = (struct sd *) gspca_dev;
651
652 /* getcontrast(gspca_dev); */
653 *val = sd->contrast;
654 return 0;
655 }
656
657 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
658 {
659 struct sd *sd = (struct sd *) gspca_dev;
660
661 sd->colors = val;
662 if (gspca_dev->streaming)
663 setcolors(gspca_dev);
664 return 0;
665 }
666
667 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
668 {
669 struct sd *sd = (struct sd *) gspca_dev;
670
671 /* getcolors(gspca_dev); */
672 *val = sd->colors;
673 return 0;
674 }
675
676 static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
677 {
678 struct sd *sd = (struct sd *) gspca_dev;
679
680 sd->autogain = val;
681 if (val) {
682 sd->ag_cnt = AG_CNT_START;
683 sd->avg_lum = 0;
684 } else {
685 sd->ag_cnt = -1;
686 }
687 return 0;
688 }
689
690 static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
691 {
692 struct sd *sd = (struct sd *) gspca_dev;
693
694 *val = sd->autogain;
695 return 0;
696 }
697
698 /* sub-driver description */
699 static struct sd_desc sd_desc = {
700 .name = MODULE_NAME,
701 .ctrls = sd_ctrls,
702 .nctrls = ARRAY_SIZE(sd_ctrls),
703 .config = sd_config,
704 .open = sd_open,
705 .start = sd_start,
706 .stopN = sd_stopN,
707 .stop0 = sd_stop0,
708 .close = sd_close,
709 .pkt_scan = sd_pkt_scan,
710 };
711
712 /* -- module initialisation -- */
713 #define DVNM(name) .driver_info = (kernel_ulong_t) name
714 static __devinitdata struct usb_device_id device_table[] = {
715 {USB_DEVICE(0x093a, 0x2600), DVNM("Typhoon")},
716 {USB_DEVICE(0x093a, 0x2601), DVNM("Philips SPC610NC")},
717 {USB_DEVICE(0x093a, 0x2603), DVNM("PAC7312")},
718 {USB_DEVICE(0x093a, 0x2608), DVNM("Trust WB-3300p")},
719 {USB_DEVICE(0x093a, 0x260e), DVNM("Gigaware VGA PC Camera")},
720 /* and also ', Trust WB-3350p, SIGMA cam 2350' */
721 {USB_DEVICE(0x093a, 0x260f), DVNM("SnakeCam")},
722 {USB_DEVICE(0x093a, 0x2621), DVNM("PAC731x")},
723 {}
724 };
725 MODULE_DEVICE_TABLE(usb, device_table);
726
727 /* -- device connect -- */
728 static int sd_probe(struct usb_interface *intf,
729 const struct usb_device_id *id)
730 {
731 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
732 THIS_MODULE);
733 }
734
735 static struct usb_driver sd_driver = {
736 .name = MODULE_NAME,
737 .id_table = device_table,
738 .probe = sd_probe,
739 .disconnect = gspca_disconnect,
740 };
741
742 /* -- module insert / remove -- */
743 static int __init sd_mod_init(void)
744 {
745 if (usb_register(&sd_driver) < 0)
746 return -1;
747 PDEBUG(D_PROBE, "registered");
748 return 0;
749 }
750 static void __exit sd_mod_exit(void)
751 {
752 usb_deregister(&sd_driver);
753 PDEBUG(D_PROBE, "deregistered");
754 }
755
756 module_init(sd_mod_init);
757 module_exit(sd_mod_exit);
(deprecated) Btrfs devel tree