2 * SPCA500 chip based cameras initialization data
4 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define MODULE_NAME "spca500"
27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
28 MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver");
29 MODULE_LICENSE("GPL");
31 /* specific webcam descriptor */
33 struct gspca_dev gspca_dev; /* !! must be the first item */
35 __u8 packet[ISO_MAX_SIZE + 128];
36 /* !! no more than 128 ff in an ISO packet */
38 unsigned char brightness;
39 unsigned char contrast;
45 #define AiptekPocketDV 1
47 #define CreativePCCam300 3
50 #define IntelPocketPCCamera 6
52 #define LogitechClickSmart310 8
53 #define LogitechClickSmart510 9
54 #define LogitechTraveler 10
55 #define MustekGsmart300 11
57 #define PalmPixDC85 13
58 #define ToptroIndus 14
61 /* V4L2 controls supported by the driver */
62 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
63 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
64 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
65 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
66 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
67 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
69 static struct ctrl sd_ctrls[] = {
72 .id = V4L2_CID_BRIGHTNESS,
73 .type = V4L2_CTRL_TYPE_INTEGER,
78 #define BRIGHTNESS_DEF 127
79 .default_value = BRIGHTNESS_DEF,
81 .set = sd_setbrightness,
82 .get = sd_getbrightness,
86 .id = V4L2_CID_CONTRAST,
87 .type = V4L2_CTRL_TYPE_INTEGER,
92 #define CONTRAST_DEF 31
93 .default_value = CONTRAST_DEF,
95 .set = sd_setcontrast,
96 .get = sd_getcontrast,
100 .id = V4L2_CID_SATURATION,
101 .type = V4L2_CTRL_TYPE_INTEGER,
107 .default_value = COLOR_DEF,
114 static const struct v4l2_pix_format vga_mode[] = {
115 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
117 .sizeimage = 320 * 240 * 3 / 8 + 590,
118 .colorspace = V4L2_COLORSPACE_JPEG,
120 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
122 .sizeimage = 640 * 480 * 3 / 8 + 590,
123 .colorspace = V4L2_COLORSPACE_JPEG,
127 static const struct v4l2_pix_format sif_mode[] = {
128 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
130 .sizeimage = 176 * 144 * 3 / 8 + 590,
131 .colorspace = V4L2_COLORSPACE_JPEG,
133 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
135 .sizeimage = 352 * 288 * 3 / 8 + 590,
136 .colorspace = V4L2_COLORSPACE_JPEG,
140 /* Frame packet header offsets for the spca500 */
141 #define SPCA500_OFFSET_PADDINGLB 2
142 #define SPCA500_OFFSET_PADDINGHB 3
143 #define SPCA500_OFFSET_MODE 4
144 #define SPCA500_OFFSET_IMGWIDTH 5
145 #define SPCA500_OFFSET_IMGHEIGHT 6
146 #define SPCA500_OFFSET_IMGMODE 7
147 #define SPCA500_OFFSET_QTBLINDEX 8
148 #define SPCA500_OFFSET_FRAMSEQ 9
149 #define SPCA500_OFFSET_CDSPINFO 10
150 #define SPCA500_OFFSET_GPIO 11
151 #define SPCA500_OFFSET_AUGPIO 12
152 #define SPCA500_OFFSET_DATA 16
155 static const __u16 spca500_visual_defaults[][3] = {
156 {0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
158 * saturation/hue enable,
159 * brightness/contrast enable.
161 {0x00, 0x0000, 0x8167}, /* brightness = 0 */
162 {0x00, 0x0020, 0x8168}, /* contrast = 0 */
163 {0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
164 * hue (H byte) = 0, saturation/hue enable,
165 * brightness/contrast enable.
166 * was 0x0003, now 0x0000.
168 {0x00, 0x0000, 0x816a}, /* hue (L byte) = 0 */
169 {0x00, 0x0020, 0x8169}, /* saturation = 0x20 */
170 {0x00, 0x0050, 0x8157}, /* edge gain high threshold */
171 {0x00, 0x0030, 0x8158}, /* edge gain low threshold */
172 {0x00, 0x0028, 0x8159}, /* edge bandwidth high threshold */
173 {0x00, 0x000a, 0x815a}, /* edge bandwidth low threshold */
174 {0x00, 0x0001, 0x8202}, /* clock rate compensation = 1/25 sec/frame */
175 {0x0c, 0x0004, 0x0000},
179 static const __u16 Clicksmart510_defaults[][3] = {
180 {0x00, 0x00, 0x8211},
181 {0x00, 0x01, 0x82c0},
182 {0x00, 0x10, 0x82cb},
183 {0x00, 0x0f, 0x800d},
184 {0x00, 0x82, 0x8225},
185 {0x00, 0x21, 0x8228},
186 {0x00, 0x00, 0x8203},
187 {0x00, 0x00, 0x8204},
188 {0x00, 0x08, 0x8205},
189 {0x00, 0xf8, 0x8206},
190 {0x00, 0x28, 0x8207},
191 {0x00, 0xa0, 0x8208},
192 {0x00, 0x08, 0x824a},
193 {0x00, 0x08, 0x8214},
194 {0x00, 0x80, 0x82c1},
195 {0x00, 0x00, 0x82c2},
196 {0x00, 0x00, 0x82ca},
197 {0x00, 0x80, 0x82c1},
198 {0x00, 0x04, 0x82c2},
199 {0x00, 0x00, 0x82ca},
200 {0x00, 0xfc, 0x8100},
201 {0x00, 0xfc, 0x8105},
202 {0x00, 0x30, 0x8101},
203 {0x00, 0x00, 0x8102},
204 {0x00, 0x00, 0x8103},
205 {0x00, 0x66, 0x8107},
206 {0x00, 0x00, 0x816b},
207 {0x00, 0x00, 0x8155},
208 {0x00, 0x01, 0x8156},
209 {0x00, 0x60, 0x8157},
210 {0x00, 0x40, 0x8158},
211 {0x00, 0x0a, 0x8159},
212 {0x00, 0x06, 0x815a},
213 {0x00, 0x00, 0x813f},
214 {0x00, 0x00, 0x8200},
215 {0x00, 0x19, 0x8201},
216 {0x00, 0x00, 0x82c1},
217 {0x00, 0xa0, 0x82c2},
218 {0x00, 0x00, 0x82ca},
219 {0x00, 0x00, 0x8117},
220 {0x00, 0x00, 0x8118},
221 {0x00, 0x65, 0x8119},
222 {0x00, 0x00, 0x811a},
223 {0x00, 0x00, 0x811b},
224 {0x00, 0x55, 0x811c},
225 {0x00, 0x65, 0x811d},
226 {0x00, 0x55, 0x811e},
227 {0x00, 0x16, 0x811f},
228 {0x00, 0x19, 0x8120},
229 {0x00, 0x80, 0x8103},
230 {0x00, 0x83, 0x816b},
231 {0x00, 0x25, 0x8168},
232 {0x00, 0x01, 0x820f},
233 {0x00, 0xff, 0x8115},
234 {0x00, 0x48, 0x8116},
235 {0x00, 0x50, 0x8151},
236 {0x00, 0x40, 0x8152},
237 {0x00, 0x78, 0x8153},
238 {0x00, 0x40, 0x8154},
239 {0x00, 0x00, 0x8167},
240 {0x00, 0x20, 0x8168},
241 {0x00, 0x00, 0x816a},
242 {0x00, 0x03, 0x816b},
243 {0x00, 0x20, 0x8169},
244 {0x00, 0x60, 0x8157},
245 {0x00, 0x00, 0x8190},
246 {0x00, 0x00, 0x81a1},
247 {0x00, 0x00, 0x81b2},
248 {0x00, 0x27, 0x8191},
249 {0x00, 0x27, 0x81a2},
250 {0x00, 0x27, 0x81b3},
251 {0x00, 0x4b, 0x8192},
252 {0x00, 0x4b, 0x81a3},
253 {0x00, 0x4b, 0x81b4},
254 {0x00, 0x66, 0x8193},
255 {0x00, 0x66, 0x81a4},
256 {0x00, 0x66, 0x81b5},
257 {0x00, 0x79, 0x8194},
258 {0x00, 0x79, 0x81a5},
259 {0x00, 0x79, 0x81b6},
260 {0x00, 0x8a, 0x8195},
261 {0x00, 0x8a, 0x81a6},
262 {0x00, 0x8a, 0x81b7},
263 {0x00, 0x9b, 0x8196},
264 {0x00, 0x9b, 0x81a7},
265 {0x00, 0x9b, 0x81b8},
266 {0x00, 0xa6, 0x8197},
267 {0x00, 0xa6, 0x81a8},
268 {0x00, 0xa6, 0x81b9},
269 {0x00, 0xb2, 0x8198},
270 {0x00, 0xb2, 0x81a9},
271 {0x00, 0xb2, 0x81ba},
272 {0x00, 0xbe, 0x8199},
273 {0x00, 0xbe, 0x81aa},
274 {0x00, 0xbe, 0x81bb},
275 {0x00, 0xc8, 0x819a},
276 {0x00, 0xc8, 0x81ab},
277 {0x00, 0xc8, 0x81bc},
278 {0x00, 0xd2, 0x819b},
279 {0x00, 0xd2, 0x81ac},
280 {0x00, 0xd2, 0x81bd},
281 {0x00, 0xdb, 0x819c},
282 {0x00, 0xdb, 0x81ad},
283 {0x00, 0xdb, 0x81be},
284 {0x00, 0xe4, 0x819d},
285 {0x00, 0xe4, 0x81ae},
286 {0x00, 0xe4, 0x81bf},
287 {0x00, 0xed, 0x819e},
288 {0x00, 0xed, 0x81af},
289 {0x00, 0xed, 0x81c0},
290 {0x00, 0xf7, 0x819f},
291 {0x00, 0xf7, 0x81b0},
292 {0x00, 0xf7, 0x81c1},
293 {0x00, 0xff, 0x81a0},
294 {0x00, 0xff, 0x81b1},
295 {0x00, 0xff, 0x81c2},
296 {0x00, 0x03, 0x8156},
297 {0x00, 0x00, 0x8211},
298 {0x00, 0x20, 0x8168},
299 {0x00, 0x01, 0x8202},
300 {0x00, 0x30, 0x8101},
301 {0x00, 0x00, 0x8111},
302 {0x00, 0x00, 0x8112},
303 {0x00, 0x00, 0x8113},
304 {0x00, 0x00, 0x8114},
308 static const __u8 qtable_creative_pccam[2][64] = {
309 { /* Q-table Y-components */
310 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
311 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
312 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
313 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
314 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
315 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
316 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
317 0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
318 { /* Q-table C-components */
319 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
320 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
321 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
322 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
323 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
324 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
325 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
326 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
329 static const __u8 qtable_kodak_ez200[2][64] = {
330 { /* Q-table Y-components */
331 0x02, 0x01, 0x01, 0x02, 0x02, 0x04, 0x05, 0x06,
332 0x01, 0x01, 0x01, 0x02, 0x03, 0x06, 0x06, 0x06,
333 0x01, 0x01, 0x02, 0x02, 0x04, 0x06, 0x07, 0x06,
334 0x01, 0x02, 0x02, 0x03, 0x05, 0x09, 0x08, 0x06,
335 0x02, 0x02, 0x04, 0x06, 0x07, 0x0b, 0x0a, 0x08,
336 0x02, 0x04, 0x06, 0x06, 0x08, 0x0a, 0x0b, 0x09,
337 0x05, 0x06, 0x08, 0x09, 0x0a, 0x0c, 0x0c, 0x0a,
338 0x07, 0x09, 0x0a, 0x0a, 0x0b, 0x0a, 0x0a, 0x0a},
339 { /* Q-table C-components */
340 0x02, 0x02, 0x02, 0x05, 0x0a, 0x0a, 0x0a, 0x0a,
341 0x02, 0x02, 0x03, 0x07, 0x0a, 0x0a, 0x0a, 0x0a,
342 0x02, 0x03, 0x06, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
343 0x05, 0x07, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
344 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
345 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
346 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
347 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a}
350 static const __u8 qtable_pocketdv[2][64] = {
351 { /* Q-table Y-components start registers 0x8800 */
352 0x06, 0x04, 0x04, 0x06, 0x0a, 0x10, 0x14, 0x18,
353 0x05, 0x05, 0x06, 0x08, 0x0a, 0x17, 0x18, 0x16,
354 0x06, 0x05, 0x06, 0x0a, 0x10, 0x17, 0x1c, 0x16,
355 0x06, 0x07, 0x09, 0x0c, 0x14, 0x23, 0x20, 0x19,
356 0x07, 0x09, 0x0f, 0x16, 0x1b, 0x2c, 0x29, 0x1f,
357 0x0a, 0x0e, 0x16, 0x1a, 0x20, 0x2a, 0x2d, 0x25,
358 0x14, 0x1a, 0x1f, 0x23, 0x29, 0x30, 0x30, 0x28,
359 0x1d, 0x25, 0x26, 0x27, 0x2d, 0x28, 0x29, 0x28,
361 { /* Q-table C-components start registers 0x8840 */
362 0x07, 0x07, 0x0a, 0x13, 0x28, 0x28, 0x28, 0x28,
363 0x07, 0x08, 0x0a, 0x1a, 0x28, 0x28, 0x28, 0x28,
364 0x0a, 0x0a, 0x16, 0x28, 0x28, 0x28, 0x28, 0x28,
365 0x13, 0x1a, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
366 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
367 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
368 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
369 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28}
372 /* read 'len' bytes to gspca_dev->usb_buf */
373 static void reg_r(struct gspca_dev *gspca_dev,
377 usb_control_msg(gspca_dev->dev,
378 usb_rcvctrlpipe(gspca_dev->dev, 0),
380 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
382 index, gspca_dev->usb_buf, length, 500);
385 static int reg_w(struct gspca_dev *gspca_dev,
386 __u16 req, __u16 index, __u16 value)
390 PDEBUG(D_USBO, "reg write: [0x%02x] = 0x%02x", index, value);
391 ret = usb_control_msg(gspca_dev->dev,
392 usb_sndctrlpipe(gspca_dev->dev, 0),
394 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
395 value, index, NULL, 0, 500);
397 PDEBUG(D_ERR, "reg write: error %d", ret);
401 /* returns: negative is error, pos or zero is data */
402 static int reg_r_12(struct gspca_dev *gspca_dev,
403 __u16 req, /* bRequest */
404 __u16 index, /* wIndex */
405 __u16 length) /* wLength (1 or 2 only) */
409 gspca_dev->usb_buf[1] = 0;
410 ret = usb_control_msg(gspca_dev->dev,
411 usb_rcvctrlpipe(gspca_dev->dev, 0),
413 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
416 gspca_dev->usb_buf, length,
419 PDEBUG(D_ERR, "reg_r_12 err %d", ret);
422 return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
426 * Simple function to wait for a given 8-bit value to be returned from
428 * Returns: negative is error or timeout, zero is success.
430 static int reg_r_wait(struct gspca_dev *gspca_dev,
431 __u16 reg, __u16 index, __u16 value)
436 ret = reg_r_12(gspca_dev, reg, index, 1);
444 static int write_vector(struct gspca_dev *gspca_dev,
445 const __u16 data[][3])
449 while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
450 ret = reg_w(gspca_dev, data[i][0], data[i][2], data[i][1]);
458 static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
459 unsigned int request,
462 const __u8 qtable[2][64])
466 /* loop over y components */
467 for (i = 0; i < 64; i++) {
468 err = reg_w(gspca_dev, request, ybase + i, qtable[0][i]);
473 /* loop over c components */
474 for (i = 0; i < 64; i++) {
475 err = reg_w(gspca_dev, request, cbase + i, qtable[1][i]);
482 static void spca500_ping310(struct gspca_dev *gspca_dev)
484 reg_r(gspca_dev, 0x0d04, 2);
485 PDEBUG(D_STREAM, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x",
486 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
489 static void spca500_clksmart310_init(struct gspca_dev *gspca_dev)
491 reg_r(gspca_dev, 0x0d05, 2);
492 PDEBUG(D_STREAM, "ClickSmart310 init 0x0d05 0x%02x 0x%02x",
493 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
494 reg_w(gspca_dev, 0x00, 0x8167, 0x5a);
495 spca500_ping310(gspca_dev);
497 reg_w(gspca_dev, 0x00, 0x8168, 0x22);
498 reg_w(gspca_dev, 0x00, 0x816a, 0xc0);
499 reg_w(gspca_dev, 0x00, 0x816b, 0x0b);
500 reg_w(gspca_dev, 0x00, 0x8169, 0x25);
501 reg_w(gspca_dev, 0x00, 0x8157, 0x5b);
502 reg_w(gspca_dev, 0x00, 0x8158, 0x5b);
503 reg_w(gspca_dev, 0x00, 0x813f, 0x03);
504 reg_w(gspca_dev, 0x00, 0x8151, 0x4a);
505 reg_w(gspca_dev, 0x00, 0x8153, 0x78);
506 reg_w(gspca_dev, 0x00, 0x0d01, 0x04);
507 /* 00 for adjust shutter */
508 reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
509 reg_w(gspca_dev, 0x00, 0x8169, 0x25);
510 reg_w(gspca_dev, 0x00, 0x0d01, 0x02);
513 static void spca500_setmode(struct gspca_dev *gspca_dev,
514 __u8 xmult, __u8 ymult)
518 /* set x multiplier */
519 reg_w(gspca_dev, 0, 0x8001, xmult);
521 /* set y multiplier */
522 reg_w(gspca_dev, 0, 0x8002, ymult);
524 /* use compressed mode, VGA, with mode specific subsample */
525 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
526 reg_w(gspca_dev, 0, 0x8003, mode << 4);
529 static int spca500_full_reset(struct gspca_dev *gspca_dev)
533 /* send the reset command */
534 err = reg_w(gspca_dev, 0xe0, 0x0001, 0x0000);
538 /* wait for the reset to complete */
539 err = reg_r_wait(gspca_dev, 0x06, 0x0000, 0x0000);
542 err = reg_w(gspca_dev, 0xe0, 0x0000, 0x0000);
545 err = reg_r_wait(gspca_dev, 0x06, 0, 0);
547 PDEBUG(D_ERR, "reg_r_wait() failed");
554 /* Synchro the Bridge with sensor */
555 /* Maybe that will work on all spca500 chip */
556 /* because i only own a clicksmart310 try for that chip */
557 /* using spca50x_set_packet_size() cause an Ooops here */
558 /* usb_set_interface from kernel 2.6.x clear all the urb stuff */
559 /* up-port the same feature as in 2.4.x kernel */
560 static int spca500_synch310(struct gspca_dev *gspca_dev)
562 if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0) < 0) {
563 PDEBUG(D_ERR, "Set packet size: set interface error");
566 spca500_ping310(gspca_dev);
568 reg_r(gspca_dev, 0x0d00, 1);
570 /* need alt setting here */
571 PDEBUG(D_PACK, "ClickSmart310 sync alt: %d", gspca_dev->alt);
573 /* Windoze use pipe with altsetting 6 why 7 here */
574 if (usb_set_interface(gspca_dev->dev,
576 gspca_dev->alt) < 0) {
577 PDEBUG(D_ERR, "Set packet size: set interface error");
585 static void spca500_reinit(struct gspca_dev *gspca_dev)
590 /* some unknow command from Aiptek pocket dv and family300 */
592 reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
593 reg_w(gspca_dev, 0x00, 0x0d03, 0x00);
594 reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
596 /* enable drop packet */
597 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
599 err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840,
602 PDEBUG(D_ERR|D_STREAM, "spca50x_setup_qtable failed on init");
604 /* set qtable index */
605 reg_w(gspca_dev, 0x00, 0x8880, 2);
606 /* family cam Quicksmart stuff */
607 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
608 /* Set agc transfer: synced inbetween frames */
609 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
610 /* Init SDRAM - needed for SDRAM access */
611 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
612 /*Start init sequence or stream */
613 reg_w(gspca_dev, 0, 0x8003, 0x00);
614 /* switch to video camera mode */
615 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
617 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) {
618 reg_r(gspca_dev, 0x816b, 1);
619 Data = gspca_dev->usb_buf[0];
620 reg_w(gspca_dev, 0x00, 0x816b, Data);
624 /* this function is called at probe time */
625 static int sd_config(struct gspca_dev *gspca_dev,
626 const struct usb_device_id *id)
628 struct sd *sd = (struct sd *) gspca_dev;
631 cam = &gspca_dev->cam;
632 sd->subtype = id->driver_info;
633 if (sd->subtype != LogitechClickSmart310) {
634 cam->cam_mode = vga_mode;
635 cam->nmodes = ARRAY_SIZE(vga_mode);
637 cam->cam_mode = sif_mode;
638 cam->nmodes = ARRAY_SIZE(sif_mode);
641 sd->brightness = BRIGHTNESS_DEF;
642 sd->contrast = CONTRAST_DEF;
643 sd->colors = COLOR_DEF;
647 /* this function is called at probe and resume time */
648 static int sd_init(struct gspca_dev *gspca_dev)
650 struct sd *sd = (struct sd *) gspca_dev;
652 /* initialisation of spca500 based cameras is deferred */
653 PDEBUG(D_STREAM, "SPCA500 init");
654 if (sd->subtype == LogitechClickSmart310)
655 spca500_clksmart310_init(gspca_dev);
657 spca500_initialise(gspca_dev); */
658 PDEBUG(D_STREAM, "SPCA500 init done");
662 static int sd_start(struct gspca_dev *gspca_dev)
664 struct sd *sd = (struct sd *) gspca_dev;
669 if (sd->subtype == LogitechClickSmart310) {
677 /* is there a sensor here ? */
678 reg_r(gspca_dev, 0x8a04, 1);
679 PDEBUG(D_STREAM, "Spca500 Sensor Address 0x%02x",
680 gspca_dev->usb_buf[0]);
681 PDEBUG(D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02x, Ymult: 0x%02x",
682 gspca_dev->curr_mode, xmult, ymult);
685 switch (sd->subtype) {
686 case LogitechClickSmart310:
687 spca500_setmode(gspca_dev, xmult, ymult);
689 /* enable drop packet */
690 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
691 reg_w(gspca_dev, 0x00, 0x8880, 3);
692 err = spca50x_setup_qtable(gspca_dev,
693 0x00, 0x8800, 0x8840,
694 qtable_creative_pccam);
696 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
697 /* Init SDRAM - needed for SDRAM access */
698 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
700 /* switch to video camera mode */
701 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
703 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
704 PDEBUG(D_ERR, "reg_r_wait() failed");
706 reg_r(gspca_dev, 0x816b, 1);
707 Data = gspca_dev->usb_buf[0];
708 reg_w(gspca_dev, 0x00, 0x816b, Data);
710 spca500_synch310(gspca_dev);
712 write_vector(gspca_dev, spca500_visual_defaults);
713 spca500_setmode(gspca_dev, xmult, ymult);
714 /* enable drop packet */
715 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
716 PDEBUG(D_ERR, "failed to enable drop packet");
717 reg_w(gspca_dev, 0x00, 0x8880, 3);
718 err = spca50x_setup_qtable(gspca_dev,
719 0x00, 0x8800, 0x8840,
720 qtable_creative_pccam);
722 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
724 /* Init SDRAM - needed for SDRAM access */
725 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
727 /* switch to video camera mode */
728 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
730 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
731 PDEBUG(D_ERR, "reg_r_wait() failed");
733 reg_r(gspca_dev, 0x816b, 1);
734 Data = gspca_dev->usb_buf[0];
735 reg_w(gspca_dev, 0x00, 0x816b, Data);
737 case CreativePCCam300: /* Creative PC-CAM 300 640x480 CCD */
738 case IntelPocketPCCamera: /* FIXME: Temporary fix for
739 * Intel Pocket PC Camera
740 * - NWG (Sat 29th March 2003) */
742 /* do a full reset */
743 err = spca500_full_reset(gspca_dev);
745 PDEBUG(D_ERR, "spca500_full_reset failed");
747 /* enable drop packet */
748 err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
750 PDEBUG(D_ERR, "failed to enable drop packet");
751 reg_w(gspca_dev, 0x00, 0x8880, 3);
752 err = spca50x_setup_qtable(gspca_dev,
753 0x00, 0x8800, 0x8840,
754 qtable_creative_pccam);
756 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
758 spca500_setmode(gspca_dev, xmult, ymult);
759 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
761 /* switch to video camera mode */
762 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
764 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
765 PDEBUG(D_ERR, "reg_r_wait() failed");
767 reg_r(gspca_dev, 0x816b, 1);
768 Data = gspca_dev->usb_buf[0];
769 reg_w(gspca_dev, 0x00, 0x816b, Data);
771 /* write_vector(gspca_dev, spca500_visual_defaults); */
773 case KodakEZ200: /* Kodak EZ200 */
775 /* do a full reset */
776 err = spca500_full_reset(gspca_dev);
778 PDEBUG(D_ERR, "spca500_full_reset failed");
779 /* enable drop packet */
780 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
781 reg_w(gspca_dev, 0x00, 0x8880, 0);
782 err = spca50x_setup_qtable(gspca_dev,
783 0x00, 0x8800, 0x8840,
786 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
787 spca500_setmode(gspca_dev, xmult, ymult);
789 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
791 /* switch to video camera mode */
792 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
794 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
795 PDEBUG(D_ERR, "reg_r_wait() failed");
797 reg_r(gspca_dev, 0x816b, 1);
798 Data = gspca_dev->usb_buf[0];
799 reg_w(gspca_dev, 0x00, 0x816b, Data);
801 /* write_vector(gspca_dev, spca500_visual_defaults); */
805 case DLinkDSC350: /* FamilyCam 300 */
806 case AiptekPocketDV: /* Aiptek PocketDV */
807 case Gsmartmini: /*Mustek Gsmart Mini */
808 case MustekGsmart300: /* Mustek Gsmart 300 */
813 spca500_reinit(gspca_dev);
814 reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
815 /* enable drop packet */
816 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
818 err = spca50x_setup_qtable(gspca_dev,
819 0x00, 0x8800, 0x8840, qtable_pocketdv);
821 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
822 reg_w(gspca_dev, 0x00, 0x8880, 2);
824 /* familycam Quicksmart pocketDV stuff */
825 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
826 /* Set agc transfer: synced inbetween frames */
827 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
828 /* Init SDRAM - needed for SDRAM access */
829 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
831 spca500_setmode(gspca_dev, xmult, ymult);
832 /* switch to video camera mode */
833 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
835 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
837 reg_r(gspca_dev, 0x816b, 1);
838 Data = gspca_dev->usb_buf[0];
839 reg_w(gspca_dev, 0x00, 0x816b, Data);
841 case LogitechTraveler:
842 case LogitechClickSmart510:
843 reg_w(gspca_dev, 0x02, 0x00, 0x00);
844 /* enable drop packet */
845 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
847 err = spca50x_setup_qtable(gspca_dev,
849 0x8840, qtable_creative_pccam);
851 PDEBUG(D_ERR, "spca50x_setup_qtable failed");
852 reg_w(gspca_dev, 0x00, 0x8880, 3);
853 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
854 /* Init SDRAM - needed for SDRAM access */
855 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
857 spca500_setmode(gspca_dev, xmult, ymult);
859 /* switch to video camera mode */
860 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
861 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
863 reg_r(gspca_dev, 0x816b, 1);
864 Data = gspca_dev->usb_buf[0];
865 reg_w(gspca_dev, 0x00, 0x816b, Data);
866 write_vector(gspca_dev, Clicksmart510_defaults);
872 static void sd_stopN(struct gspca_dev *gspca_dev)
874 reg_w(gspca_dev, 0, 0x8003, 0x00);
876 /* switch to video camera mode */
877 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
878 reg_r(gspca_dev, 0x8000, 1);
879 PDEBUG(D_STREAM, "stop SPCA500 done reg8000: 0x%2x",
880 gspca_dev->usb_buf[0]);
883 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
884 struct gspca_frame *frame, /* target */
885 __u8 *data, /* isoc packet */
886 int len) /* iso packet length */
888 struct sd *sd = (struct sd *) gspca_dev;
891 static __u8 ffd9[] = {0xff, 0xd9};
893 /* frames are jpeg 4.1.1 without 0xff escape */
894 if (data[0] == 0xff) {
895 if (data[1] != 0x01) { /* drop packet */
896 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
899 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
902 /* put the JPEG header in the new frame */
903 jpeg_put_header(gspca_dev, frame, sd->qindex, 0x22);
905 data += SPCA500_OFFSET_DATA;
906 len -= SPCA500_OFFSET_DATA;
912 /* add 0x00 after 0xff */
913 for (i = len; --i >= 0; )
916 if (i < 0) { /* no 0xff */
917 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
922 for (i = 0; i < len; i++) {
927 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
928 sd->packet, d - sd->packet);
931 static void setbrightness(struct gspca_dev *gspca_dev)
933 struct sd *sd = (struct sd *) gspca_dev;
935 reg_w(gspca_dev, 0x00, 0x8167,
936 (__u8) (sd->brightness - 128));
939 static void getbrightness(struct gspca_dev *gspca_dev)
941 struct sd *sd = (struct sd *) gspca_dev;
944 ret = reg_r_12(gspca_dev, 0x00, 0x8167, 1);
946 sd->brightness = ret + 128;
949 static void setcontrast(struct gspca_dev *gspca_dev)
951 struct sd *sd = (struct sd *) gspca_dev;
953 reg_w(gspca_dev, 0x00, 0x8168, sd->contrast);
956 static void getcontrast(struct gspca_dev *gspca_dev)
958 struct sd *sd = (struct sd *) gspca_dev;
961 ret = reg_r_12(gspca_dev, 0x0, 0x8168, 1);
966 static void setcolors(struct gspca_dev *gspca_dev)
968 struct sd *sd = (struct sd *) gspca_dev;
970 reg_w(gspca_dev, 0x00, 0x8169, sd->colors);
973 static void getcolors(struct gspca_dev *gspca_dev)
975 struct sd *sd = (struct sd *) gspca_dev;
978 ret = reg_r_12(gspca_dev, 0x0, 0x8169, 1);
983 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
985 struct sd *sd = (struct sd *) gspca_dev;
987 sd->brightness = val;
988 if (gspca_dev->streaming)
989 setbrightness(gspca_dev);
993 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
995 struct sd *sd = (struct sd *) gspca_dev;
997 getbrightness(gspca_dev);
998 *val = sd->brightness;
1002 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1004 struct sd *sd = (struct sd *) gspca_dev;
1007 if (gspca_dev->streaming)
1008 setcontrast(gspca_dev);
1012 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1014 struct sd *sd = (struct sd *) gspca_dev;
1016 getcontrast(gspca_dev);
1017 *val = sd->contrast;
1021 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
1023 struct sd *sd = (struct sd *) gspca_dev;
1026 if (gspca_dev->streaming)
1027 setcolors(gspca_dev);
1031 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
1033 struct sd *sd = (struct sd *) gspca_dev;
1035 getcolors(gspca_dev);
1040 /* sub-driver description */
1041 static struct sd_desc sd_desc = {
1042 .name = MODULE_NAME,
1044 .nctrls = ARRAY_SIZE(sd_ctrls),
1045 .config = sd_config,
1049 .pkt_scan = sd_pkt_scan,
1052 /* -- module initialisation -- */
1053 static const __devinitdata struct usb_device_id device_table[] = {
1054 {USB_DEVICE(0x040a, 0x0300), .driver_info = KodakEZ200},
1055 {USB_DEVICE(0x041e, 0x400a), .driver_info = CreativePCCam300},
1056 {USB_DEVICE(0x046d, 0x0890), .driver_info = LogitechTraveler},
1057 {USB_DEVICE(0x046d, 0x0900), .driver_info = LogitechClickSmart310},
1058 {USB_DEVICE(0x046d, 0x0901), .driver_info = LogitechClickSmart510},
1059 {USB_DEVICE(0x04a5, 0x300c), .driver_info = BenqDC1016},
1060 {USB_DEVICE(0x04fc, 0x7333), .driver_info = PalmPixDC85},
1061 {USB_DEVICE(0x055f, 0xc200), .driver_info = MustekGsmart300},
1062 {USB_DEVICE(0x055f, 0xc220), .driver_info = Gsmartmini},
1063 {USB_DEVICE(0x06bd, 0x0404), .driver_info = AgfaCl20},
1064 {USB_DEVICE(0x06be, 0x0800), .driver_info = Optimedia},
1065 {USB_DEVICE(0x084d, 0x0003), .driver_info = DLinkDSC350},
1066 {USB_DEVICE(0x08ca, 0x0103), .driver_info = AiptekPocketDV},
1067 {USB_DEVICE(0x2899, 0x012c), .driver_info = ToptroIndus},
1068 {USB_DEVICE(0x8086, 0x0630), .driver_info = IntelPocketPCCamera},
1071 MODULE_DEVICE_TABLE(usb, device_table);
1073 /* -- device connect -- */
1074 static int sd_probe(struct usb_interface *intf,
1075 const struct usb_device_id *id)
1077 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1081 static struct usb_driver sd_driver = {
1082 .name = MODULE_NAME,
1083 .id_table = device_table,
1085 .disconnect = gspca_disconnect,
1087 .suspend = gspca_suspend,
1088 .resume = gspca_resume,
1092 /* -- module insert / remove -- */
1093 static int __init sd_mod_init(void)
1095 if (usb_register(&sd_driver) < 0)
1097 PDEBUG(D_PROBE, "registered");
1100 static void __exit sd_mod_exit(void)
1102 usb_deregister(&sd_driver);
1103 PDEBUG(D_PROBE, "deregistered");
1106 module_init(sd_mod_init);
1107 module_exit(sd_mod_exit);