1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * SPCA500 chip based cameras initialization data
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #define MODULE_NAME "spca500"
11
12 #include "gspca.h"
13 #include "jpeg.h"
14
15 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
16 MODULE_DESCRIPTION("GSPCA/SPCA500 USB Camera Driver");
17 MODULE_LICENSE("GPL");
18
19 #define QUALITY 85
20
21 /* specific webcam descriptor */
22 struct sd {
23 struct gspca_dev gspca_dev; /* !! must be the first item */
24
25 char subtype;
26 #define AgfaCl20 0
27 #define AiptekPocketDV 1
28 #define BenqDC1016 2
29 #define CreativePCCam300 3
30 #define DLinkDSC350 4
31 #define Gsmartmini 5
32 #define IntelPocketPCCamera 6
33 #define KodakEZ200 7
34 #define LogitechClickSmart310 8
35 #define LogitechClickSmart510 9
36 #define LogitechTraveler 10
37 #define MustekGsmart300 11
38 #define Optimedia 12
39 #define PalmPixDC85 13
40 #define ToptroIndus 14
41
42 u8 jpeg_hdr[JPEG_HDR_SZ];
43 };
44
45 static const struct v4l2_pix_format vga_mode[] = {
46 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
47 .bytesperline = 320,
48 .sizeimage = 320 * 240 * 3 / 8 + 590,
49 .colorspace = V4L2_COLORSPACE_JPEG,
50 .priv = 1},
51 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
52 .bytesperline = 640,
53 .sizeimage = 640 * 480 * 3 / 8 + 590,
54 .colorspace = V4L2_COLORSPACE_JPEG,
55 .priv = 0},
56 };
57
58 static const struct v4l2_pix_format sif_mode[] = {
59 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
60 .bytesperline = 176,
61 .sizeimage = 176 * 144 * 3 / 8 + 590,
62 .colorspace = V4L2_COLORSPACE_JPEG,
63 .priv = 1},
64 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
65 .bytesperline = 352,
66 .sizeimage = 352 * 288 * 3 / 8 + 590,
67 .colorspace = V4L2_COLORSPACE_JPEG,
68 .priv = 0},
69 };
70
71 /* Frame packet header offsets for the spca500 */
72 #define SPCA500_OFFSET_PADDINGLB 2
73 #define SPCA500_OFFSET_PADDINGHB 3
74 #define SPCA500_OFFSET_MODE 4
75 #define SPCA500_OFFSET_IMGWIDTH 5
76 #define SPCA500_OFFSET_IMGHEIGHT 6
77 #define SPCA500_OFFSET_IMGMODE 7
78 #define SPCA500_OFFSET_QTBLINDEX 8
79 #define SPCA500_OFFSET_FRAMSEQ 9
80 #define SPCA500_OFFSET_CDSPINFO 10
81 #define SPCA500_OFFSET_GPIO 11
82 #define SPCA500_OFFSET_AUGPIO 12
83 #define SPCA500_OFFSET_DATA 16
84
85
86 static const __u16 spca500_visual_defaults[][3] = {
87 {0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
88 * hue (H byte) = 0,
89 * saturation/hue enable,
90 * brightness/contrast enable.
91 */
92 {0x00, 0x0000, 0x8167}, /* brightness = 0 */
93 {0x00, 0x0020, 0x8168}, /* contrast = 0 */
94 {0x00, 0x0003, 0x816b}, /* SSI not active sync with vsync,
95 * hue (H byte) = 0, saturation/hue enable,
96 * brightness/contrast enable.
97 * was 0x0003, now 0x0000.
98 */
99 {0x00, 0x0000, 0x816a}, /* hue (L byte) = 0 */
100 {0x00, 0x0020, 0x8169}, /* saturation = 0x20 */
101 {0x00, 0x0050, 0x8157}, /* edge gain high threshold */
102 {0x00, 0x0030, 0x8158}, /* edge gain low threshold */
103 {0x00, 0x0028, 0x8159}, /* edge bandwidth high threshold */
104 {0x00, 0x000a, 0x815a}, /* edge bandwidth low threshold */
105 {0x00, 0x0001, 0x8202}, /* clock rate compensation = 1/25 sec/frame */
106 {0x0c, 0x0004, 0x0000},
107 /* set interface */
108 {}
109 };
110 static const __u16 Clicksmart510_defaults[][3] = {
111 {0x00, 0x00, 0x8211},
112 {0x00, 0x01, 0x82c0},
113 {0x00, 0x10, 0x82cb},
114 {0x00, 0x0f, 0x800d},
115 {0x00, 0x82, 0x8225},
116 {0x00, 0x21, 0x8228},
117 {0x00, 0x00, 0x8203},
118 {0x00, 0x00, 0x8204},
119 {0x00, 0x08, 0x8205},
120 {0x00, 0xf8, 0x8206},
121 {0x00, 0x28, 0x8207},
122 {0x00, 0xa0, 0x8208},
123 {0x00, 0x08, 0x824a},
124 {0x00, 0x08, 0x8214},
125 {0x00, 0x80, 0x82c1},
126 {0x00, 0x00, 0x82c2},
127 {0x00, 0x00, 0x82ca},
128 {0x00, 0x80, 0x82c1},
129 {0x00, 0x04, 0x82c2},
130 {0x00, 0x00, 0x82ca},
131 {0x00, 0xfc, 0x8100},
132 {0x00, 0xfc, 0x8105},
133 {0x00, 0x30, 0x8101},
134 {0x00, 0x00, 0x8102},
135 {0x00, 0x00, 0x8103},
136 {0x00, 0x66, 0x8107},
137 {0x00, 0x00, 0x816b},
138 {0x00, 0x00, 0x8155},
139 {0x00, 0x01, 0x8156},
140 {0x00, 0x60, 0x8157},
141 {0x00, 0x40, 0x8158},
142 {0x00, 0x0a, 0x8159},
143 {0x00, 0x06, 0x815a},
144 {0x00, 0x00, 0x813f},
145 {0x00, 0x00, 0x8200},
146 {0x00, 0x19, 0x8201},
147 {0x00, 0x00, 0x82c1},
148 {0x00, 0xa0, 0x82c2},
149 {0x00, 0x00, 0x82ca},
150 {0x00, 0x00, 0x8117},
151 {0x00, 0x00, 0x8118},
152 {0x00, 0x65, 0x8119},
153 {0x00, 0x00, 0x811a},
154 {0x00, 0x00, 0x811b},
155 {0x00, 0x55, 0x811c},
156 {0x00, 0x65, 0x811d},
157 {0x00, 0x55, 0x811e},
158 {0x00, 0x16, 0x811f},
159 {0x00, 0x19, 0x8120},
160 {0x00, 0x80, 0x8103},
161 {0x00, 0x83, 0x816b},
162 {0x00, 0x25, 0x8168},
163 {0x00, 0x01, 0x820f},
164 {0x00, 0xff, 0x8115},
165 {0x00, 0x48, 0x8116},
166 {0x00, 0x50, 0x8151},
167 {0x00, 0x40, 0x8152},
168 {0x00, 0x78, 0x8153},
169 {0x00, 0x40, 0x8154},
170 {0x00, 0x00, 0x8167},
171 {0x00, 0x20, 0x8168},
172 {0x00, 0x00, 0x816a},
173 {0x00, 0x03, 0x816b},
174 {0x00, 0x20, 0x8169},
175 {0x00, 0x60, 0x8157},
176 {0x00, 0x00, 0x8190},
177 {0x00, 0x00, 0x81a1},
178 {0x00, 0x00, 0x81b2},
179 {0x00, 0x27, 0x8191},
180 {0x00, 0x27, 0x81a2},
181 {0x00, 0x27, 0x81b3},
182 {0x00, 0x4b, 0x8192},
183 {0x00, 0x4b, 0x81a3},
184 {0x00, 0x4b, 0x81b4},
185 {0x00, 0x66, 0x8193},
186 {0x00, 0x66, 0x81a4},
187 {0x00, 0x66, 0x81b5},
188 {0x00, 0x79, 0x8194},
189 {0x00, 0x79, 0x81a5},
190 {0x00, 0x79, 0x81b6},
191 {0x00, 0x8a, 0x8195},
192 {0x00, 0x8a, 0x81a6},
193 {0x00, 0x8a, 0x81b7},
194 {0x00, 0x9b, 0x8196},
195 {0x00, 0x9b, 0x81a7},
196 {0x00, 0x9b, 0x81b8},
197 {0x00, 0xa6, 0x8197},
198 {0x00, 0xa6, 0x81a8},
199 {0x00, 0xa6, 0x81b9},
200 {0x00, 0xb2, 0x8198},
201 {0x00, 0xb2, 0x81a9},
202 {0x00, 0xb2, 0x81ba},
203 {0x00, 0xbe, 0x8199},
204 {0x00, 0xbe, 0x81aa},
205 {0x00, 0xbe, 0x81bb},
206 {0x00, 0xc8, 0x819a},
207 {0x00, 0xc8, 0x81ab},
208 {0x00, 0xc8, 0x81bc},
209 {0x00, 0xd2, 0x819b},
210 {0x00, 0xd2, 0x81ac},
211 {0x00, 0xd2, 0x81bd},
212 {0x00, 0xdb, 0x819c},
213 {0x00, 0xdb, 0x81ad},
214 {0x00, 0xdb, 0x81be},
215 {0x00, 0xe4, 0x819d},
216 {0x00, 0xe4, 0x81ae},
217 {0x00, 0xe4, 0x81bf},
218 {0x00, 0xed, 0x819e},
219 {0x00, 0xed, 0x81af},
220 {0x00, 0xed, 0x81c0},
221 {0x00, 0xf7, 0x819f},
222 {0x00, 0xf7, 0x81b0},
223 {0x00, 0xf7, 0x81c1},
224 {0x00, 0xff, 0x81a0},
225 {0x00, 0xff, 0x81b1},
226 {0x00, 0xff, 0x81c2},
227 {0x00, 0x03, 0x8156},
228 {0x00, 0x00, 0x8211},
229 {0x00, 0x20, 0x8168},
230 {0x00, 0x01, 0x8202},
231 {0x00, 0x30, 0x8101},
232 {0x00, 0x00, 0x8111},
233 {0x00, 0x00, 0x8112},
234 {0x00, 0x00, 0x8113},
235 {0x00, 0x00, 0x8114},
236 {}
237 };
238
239 static const __u8 qtable_creative_pccam[2][64] = {
240 { /* Q-table Y-components */
241 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12,
242 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11,
243 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11,
244 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13,
245 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17,
246 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c,
247 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e,
248 0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e},
249 { /* Q-table C-components */
250 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e,
251 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e,
252 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
253 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
254 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
255 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
256 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
257 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e}
258 };
259
260 static const __u8 qtable_kodak_ez200[2][64] = {
261 { /* Q-table Y-components */
262 0x02, 0x01, 0x01, 0x02, 0x02, 0x04, 0x05, 0x06,
263 0x01, 0x01, 0x01, 0x02, 0x03, 0x06, 0x06, 0x06,
264 0x01, 0x01, 0x02, 0x02, 0x04, 0x06, 0x07, 0x06,
265 0x01, 0x02, 0x02, 0x03, 0x05, 0x09, 0x08, 0x06,
266 0x02, 0x02, 0x04, 0x06, 0x07, 0x0b, 0x0a, 0x08,
267 0x02, 0x04, 0x06, 0x06, 0x08, 0x0a, 0x0b, 0x09,
268 0x05, 0x06, 0x08, 0x09, 0x0a, 0x0c, 0x0c, 0x0a,
269 0x07, 0x09, 0x0a, 0x0a, 0x0b, 0x0a, 0x0a, 0x0a},
270 { /* Q-table C-components */
271 0x02, 0x02, 0x02, 0x05, 0x0a, 0x0a, 0x0a, 0x0a,
272 0x02, 0x02, 0x03, 0x07, 0x0a, 0x0a, 0x0a, 0x0a,
273 0x02, 0x03, 0x06, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
274 0x05, 0x07, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
275 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
276 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
277 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
278 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a}
279 };
280
281 static const __u8 qtable_pocketdv[2][64] = {
282 { /* Q-table Y-components start registers 0x8800 */
283 0x06, 0x04, 0x04, 0x06, 0x0a, 0x10, 0x14, 0x18,
284 0x05, 0x05, 0x06, 0x08, 0x0a, 0x17, 0x18, 0x16,
285 0x06, 0x05, 0x06, 0x0a, 0x10, 0x17, 0x1c, 0x16,
286 0x06, 0x07, 0x09, 0x0c, 0x14, 0x23, 0x20, 0x19,
287 0x07, 0x09, 0x0f, 0x16, 0x1b, 0x2c, 0x29, 0x1f,
288 0x0a, 0x0e, 0x16, 0x1a, 0x20, 0x2a, 0x2d, 0x25,
289 0x14, 0x1a, 0x1f, 0x23, 0x29, 0x30, 0x30, 0x28,
290 0x1d, 0x25, 0x26, 0x27, 0x2d, 0x28, 0x29, 0x28,
291 },
292 { /* Q-table C-components start registers 0x8840 */
293 0x07, 0x07, 0x0a, 0x13, 0x28, 0x28, 0x28, 0x28,
294 0x07, 0x08, 0x0a, 0x1a, 0x28, 0x28, 0x28, 0x28,
295 0x0a, 0x0a, 0x16, 0x28, 0x28, 0x28, 0x28, 0x28,
296 0x13, 0x1a, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
297 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
298 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
299 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
300 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28}
301 };
302
303 /* read 'len' bytes to gspca_dev->usb_buf */
reg_r(struct gspca_dev * gspca_dev,__u16 index,__u16 length)304 static void reg_r(struct gspca_dev *gspca_dev,
305 __u16 index,
306 __u16 length)
307 {
308 usb_control_msg(gspca_dev->dev,
309 usb_rcvctrlpipe(gspca_dev->dev, 0),
310 0,
311 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
312 0, /* value */
313 index, gspca_dev->usb_buf, length, 500);
314 }
315
reg_w(struct gspca_dev * gspca_dev,__u16 req,__u16 index,__u16 value)316 static int reg_w(struct gspca_dev *gspca_dev,
317 __u16 req, __u16 index, __u16 value)
318 {
319 int ret;
320
321 gspca_dbg(gspca_dev, D_USBO, "reg write: [0x%02x] = 0x%02x\n",
322 index, value);
323 ret = usb_control_msg(gspca_dev->dev,
324 usb_sndctrlpipe(gspca_dev->dev, 0),
325 req,
326 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
327 value, index, NULL, 0, 500);
328 if (ret < 0)
329 pr_err("reg write: error %d\n", ret);
330 return ret;
331 }
332
333 /* returns: negative is error, pos or zero is data */
reg_r_12(struct gspca_dev * gspca_dev,__u16 req,__u16 index,__u16 length)334 static int reg_r_12(struct gspca_dev *gspca_dev,
335 __u16 req, /* bRequest */
336 __u16 index, /* wIndex */
337 __u16 length) /* wLength (1 or 2 only) */
338 {
339 int ret;
340
341 gspca_dev->usb_buf[1] = 0;
342 ret = usb_control_msg(gspca_dev->dev,
343 usb_rcvctrlpipe(gspca_dev->dev, 0),
344 req,
345 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
346 0, /* value */
347 index,
348 gspca_dev->usb_buf, length,
349 500); /* timeout */
350 if (ret < 0) {
351 pr_err("reg_r_12 err %d\n", ret);
352 return ret;
353 }
354 return (gspca_dev->usb_buf[1] << 8) + gspca_dev->usb_buf[0];
355 }
356
357 /*
358 * Simple function to wait for a given 8-bit value to be returned from
359 * a reg_read call.
360 * Returns: negative is error or timeout, zero is success.
361 */
reg_r_wait(struct gspca_dev * gspca_dev,__u16 reg,__u16 index,__u16 value)362 static int reg_r_wait(struct gspca_dev *gspca_dev,
363 __u16 reg, __u16 index, __u16 value)
364 {
365 int ret, cnt = 20;
366
367 while (--cnt > 0) {
368 ret = reg_r_12(gspca_dev, reg, index, 1);
369 if (ret == value)
370 return 0;
371 msleep(50);
372 }
373 return -EIO;
374 }
375
write_vector(struct gspca_dev * gspca_dev,const __u16 data[][3])376 static int write_vector(struct gspca_dev *gspca_dev,
377 const __u16 data[][3])
378 {
379 int ret, i = 0;
380
381 while (data[i][0] != 0 || data[i][1] != 0 || data[i][2] != 0) {
382 ret = reg_w(gspca_dev, data[i][0], data[i][2], data[i][1]);
383 if (ret < 0)
384 return ret;
385 i++;
386 }
387 return 0;
388 }
389
spca50x_setup_qtable(struct gspca_dev * gspca_dev,unsigned int request,unsigned int ybase,unsigned int cbase,const __u8 qtable[2][64])390 static int spca50x_setup_qtable(struct gspca_dev *gspca_dev,
391 unsigned int request,
392 unsigned int ybase,
393 unsigned int cbase,
394 const __u8 qtable[2][64])
395 {
396 int i, err;
397
398 /* loop over y components */
399 for (i = 0; i < 64; i++) {
400 err = reg_w(gspca_dev, request, ybase + i, qtable[0][i]);
401 if (err < 0)
402 return err;
403 }
404
405 /* loop over c components */
406 for (i = 0; i < 64; i++) {
407 err = reg_w(gspca_dev, request, cbase + i, qtable[1][i]);
408 if (err < 0)
409 return err;
410 }
411 return 0;
412 }
413
spca500_ping310(struct gspca_dev * gspca_dev)414 static void spca500_ping310(struct gspca_dev *gspca_dev)
415 {
416 reg_r(gspca_dev, 0x0d04, 2);
417 gspca_dbg(gspca_dev, D_STREAM, "ClickSmart310 ping 0x0d04 0x%02x 0x%02x\n",
418 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
419 }
420
spca500_clksmart310_init(struct gspca_dev * gspca_dev)421 static void spca500_clksmart310_init(struct gspca_dev *gspca_dev)
422 {
423 reg_r(gspca_dev, 0x0d05, 2);
424 gspca_dbg(gspca_dev, D_STREAM, "ClickSmart310 init 0x0d05 0x%02x 0x%02x\n",
425 gspca_dev->usb_buf[0], gspca_dev->usb_buf[1]);
426 reg_w(gspca_dev, 0x00, 0x8167, 0x5a);
427 spca500_ping310(gspca_dev);
428
429 reg_w(gspca_dev, 0x00, 0x8168, 0x22);
430 reg_w(gspca_dev, 0x00, 0x816a, 0xc0);
431 reg_w(gspca_dev, 0x00, 0x816b, 0x0b);
432 reg_w(gspca_dev, 0x00, 0x8169, 0x25);
433 reg_w(gspca_dev, 0x00, 0x8157, 0x5b);
434 reg_w(gspca_dev, 0x00, 0x8158, 0x5b);
435 reg_w(gspca_dev, 0x00, 0x813f, 0x03);
436 reg_w(gspca_dev, 0x00, 0x8151, 0x4a);
437 reg_w(gspca_dev, 0x00, 0x8153, 0x78);
438 reg_w(gspca_dev, 0x00, 0x0d01, 0x04);
439 /* 00 for adjust shutter */
440 reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
441 reg_w(gspca_dev, 0x00, 0x8169, 0x25);
442 reg_w(gspca_dev, 0x00, 0x0d01, 0x02);
443 }
444
spca500_setmode(struct gspca_dev * gspca_dev,__u8 xmult,__u8 ymult)445 static void spca500_setmode(struct gspca_dev *gspca_dev,
446 __u8 xmult, __u8 ymult)
447 {
448 int mode;
449
450 /* set x multiplier */
451 reg_w(gspca_dev, 0, 0x8001, xmult);
452
453 /* set y multiplier */
454 reg_w(gspca_dev, 0, 0x8002, ymult);
455
456 /* use compressed mode, VGA, with mode specific subsample */
457 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
458 reg_w(gspca_dev, 0, 0x8003, mode << 4);
459 }
460
spca500_full_reset(struct gspca_dev * gspca_dev)461 static int spca500_full_reset(struct gspca_dev *gspca_dev)
462 {
463 int err;
464
465 /* send the reset command */
466 err = reg_w(gspca_dev, 0xe0, 0x0001, 0x0000);
467 if (err < 0)
468 return err;
469
470 /* wait for the reset to complete */
471 err = reg_r_wait(gspca_dev, 0x06, 0x0000, 0x0000);
472 if (err < 0)
473 return err;
474 err = reg_w(gspca_dev, 0xe0, 0x0000, 0x0000);
475 if (err < 0)
476 return err;
477 err = reg_r_wait(gspca_dev, 0x06, 0, 0);
478 if (err < 0) {
479 gspca_err(gspca_dev, "reg_r_wait() failed\n");
480 return err;
481 }
482 /* all ok */
483 return 0;
484 }
485
486 /* Synchro the Bridge with sensor */
487 /* Maybe that will work on all spca500 chip */
488 /* because i only own a clicksmart310 try for that chip */
489 /* using spca50x_set_packet_size() cause an Ooops here */
490 /* usb_set_interface from kernel 2.6.x clear all the urb stuff */
491 /* up-port the same feature as in 2.4.x kernel */
spca500_synch310(struct gspca_dev * gspca_dev)492 static int spca500_synch310(struct gspca_dev *gspca_dev)
493 {
494 if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0) < 0) {
495 gspca_err(gspca_dev, "Set packet size: set interface error\n");
496 goto error;
497 }
498 spca500_ping310(gspca_dev);
499
500 reg_r(gspca_dev, 0x0d00, 1);
501
502 /* need alt setting here */
503 gspca_dbg(gspca_dev, D_PACK, "ClickSmart310 sync alt: %d\n",
504 gspca_dev->alt);
505
506 /* Windoze use pipe with altsetting 6 why 7 here */
507 if (usb_set_interface(gspca_dev->dev,
508 gspca_dev->iface,
509 gspca_dev->alt) < 0) {
510 gspca_err(gspca_dev, "Set packet size: set interface error\n");
511 goto error;
512 }
513 return 0;
514 error:
515 return -EBUSY;
516 }
517
spca500_reinit(struct gspca_dev * gspca_dev)518 static void spca500_reinit(struct gspca_dev *gspca_dev)
519 {
520 int err;
521 __u8 Data;
522
523 /* some unknown command from Aiptek pocket dv and family300 */
524
525 reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
526 reg_w(gspca_dev, 0x00, 0x0d03, 0x00);
527 reg_w(gspca_dev, 0x00, 0x0d02, 0x01);
528
529 /* enable drop packet */
530 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
531
532 err = spca50x_setup_qtable(gspca_dev, 0x00, 0x8800, 0x8840,
533 qtable_pocketdv);
534 if (err < 0)
535 gspca_err(gspca_dev, "spca50x_setup_qtable failed on init\n");
536
537 /* set qtable index */
538 reg_w(gspca_dev, 0x00, 0x8880, 2);
539 /* family cam Quicksmart stuff */
540 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
541 /* Set agc transfer: synced between frames */
542 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
543 /* Init SDRAM - needed for SDRAM access */
544 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
545 /*Start init sequence or stream */
546 reg_w(gspca_dev, 0, 0x8003, 0x00);
547 /* switch to video camera mode */
548 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
549 msleep(2000);
550 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0) {
551 reg_r(gspca_dev, 0x816b, 1);
552 Data = gspca_dev->usb_buf[0];
553 reg_w(gspca_dev, 0x00, 0x816b, Data);
554 }
555 }
556
557 /* this function is called at probe time */
sd_config(struct gspca_dev * gspca_dev,const struct usb_device_id * id)558 static int sd_config(struct gspca_dev *gspca_dev,
559 const struct usb_device_id *id)
560 {
561 struct sd *sd = (struct sd *) gspca_dev;
562 struct cam *cam;
563
564 cam = &gspca_dev->cam;
565 sd->subtype = id->driver_info;
566 if (sd->subtype != LogitechClickSmart310) {
567 cam->cam_mode = vga_mode;
568 cam->nmodes = ARRAY_SIZE(vga_mode);
569 } else {
570 cam->cam_mode = sif_mode;
571 cam->nmodes = ARRAY_SIZE(sif_mode);
572 }
573 return 0;
574 }
575
576 /* this function is called at probe and resume time */
sd_init(struct gspca_dev * gspca_dev)577 static int sd_init(struct gspca_dev *gspca_dev)
578 {
579 struct sd *sd = (struct sd *) gspca_dev;
580
581 /* initialisation of spca500 based cameras is deferred */
582 gspca_dbg(gspca_dev, D_STREAM, "SPCA500 init\n");
583 if (sd->subtype == LogitechClickSmart310)
584 spca500_clksmart310_init(gspca_dev);
585 /* else
586 spca500_initialise(gspca_dev); */
587 gspca_dbg(gspca_dev, D_STREAM, "SPCA500 init done\n");
588 return 0;
589 }
590
sd_start(struct gspca_dev * gspca_dev)591 static int sd_start(struct gspca_dev *gspca_dev)
592 {
593 struct sd *sd = (struct sd *) gspca_dev;
594 int err;
595 __u8 Data;
596 __u8 xmult, ymult;
597
598 /* create the JPEG header */
599 jpeg_define(sd->jpeg_hdr, gspca_dev->pixfmt.height,
600 gspca_dev->pixfmt.width,
601 0x22); /* JPEG 411 */
602 jpeg_set_qual(sd->jpeg_hdr, QUALITY);
603
604 if (sd->subtype == LogitechClickSmart310) {
605 xmult = 0x16;
606 ymult = 0x12;
607 } else {
608 xmult = 0x28;
609 ymult = 0x1e;
610 }
611
612 /* is there a sensor here ? */
613 reg_r(gspca_dev, 0x8a04, 1);
614 gspca_dbg(gspca_dev, D_STREAM, "Spca500 Sensor Address 0x%02x\n",
615 gspca_dev->usb_buf[0]);
616 gspca_dbg(gspca_dev, D_STREAM, "Spca500 curr_mode: %d Xmult: 0x%02x, Ymult: 0x%02x",
617 gspca_dev->curr_mode, xmult, ymult);
618
619 /* setup qtable */
620 switch (sd->subtype) {
621 case LogitechClickSmart310:
622 spca500_setmode(gspca_dev, xmult, ymult);
623
624 /* enable drop packet */
625 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
626 reg_w(gspca_dev, 0x00, 0x8880, 3);
627 err = spca50x_setup_qtable(gspca_dev,
628 0x00, 0x8800, 0x8840,
629 qtable_creative_pccam);
630 if (err < 0)
631 gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
632 /* Init SDRAM - needed for SDRAM access */
633 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
634
635 /* switch to video camera mode */
636 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
637 msleep(500);
638 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
639 gspca_err(gspca_dev, "reg_r_wait() failed\n");
640
641 reg_r(gspca_dev, 0x816b, 1);
642 Data = gspca_dev->usb_buf[0];
643 reg_w(gspca_dev, 0x00, 0x816b, Data);
644
645 spca500_synch310(gspca_dev);
646
647 write_vector(gspca_dev, spca500_visual_defaults);
648 spca500_setmode(gspca_dev, xmult, ymult);
649 /* enable drop packet */
650 err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
651 if (err < 0)
652 gspca_err(gspca_dev, "failed to enable drop packet\n");
653 reg_w(gspca_dev, 0x00, 0x8880, 3);
654 err = spca50x_setup_qtable(gspca_dev,
655 0x00, 0x8800, 0x8840,
656 qtable_creative_pccam);
657 if (err < 0)
658 gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
659
660 /* Init SDRAM - needed for SDRAM access */
661 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
662
663 /* switch to video camera mode */
664 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
665
666 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
667 gspca_err(gspca_dev, "reg_r_wait() failed\n");
668
669 reg_r(gspca_dev, 0x816b, 1);
670 Data = gspca_dev->usb_buf[0];
671 reg_w(gspca_dev, 0x00, 0x816b, Data);
672 break;
673 case CreativePCCam300: /* Creative PC-CAM 300 640x480 CCD */
674 case IntelPocketPCCamera: /* FIXME: Temporary fix for
675 * Intel Pocket PC Camera
676 * - NWG (Sat 29th March 2003) */
677
678 /* do a full reset */
679 err = spca500_full_reset(gspca_dev);
680 if (err < 0)
681 gspca_err(gspca_dev, "spca500_full_reset failed\n");
682
683 /* enable drop packet */
684 err = reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
685 if (err < 0)
686 gspca_err(gspca_dev, "failed to enable drop packet\n");
687 reg_w(gspca_dev, 0x00, 0x8880, 3);
688 err = spca50x_setup_qtable(gspca_dev,
689 0x00, 0x8800, 0x8840,
690 qtable_creative_pccam);
691 if (err < 0)
692 gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
693
694 spca500_setmode(gspca_dev, xmult, ymult);
695 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
696
697 /* switch to video camera mode */
698 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
699
700 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
701 gspca_err(gspca_dev, "reg_r_wait() failed\n");
702
703 reg_r(gspca_dev, 0x816b, 1);
704 Data = gspca_dev->usb_buf[0];
705 reg_w(gspca_dev, 0x00, 0x816b, Data);
706
707 /* write_vector(gspca_dev, spca500_visual_defaults); */
708 break;
709 case KodakEZ200: /* Kodak EZ200 */
710
711 /* do a full reset */
712 err = spca500_full_reset(gspca_dev);
713 if (err < 0)
714 gspca_err(gspca_dev, "spca500_full_reset failed\n");
715 /* enable drop packet */
716 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
717 reg_w(gspca_dev, 0x00, 0x8880, 0);
718 err = spca50x_setup_qtable(gspca_dev,
719 0x00, 0x8800, 0x8840,
720 qtable_kodak_ez200);
721 if (err < 0)
722 gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
723 spca500_setmode(gspca_dev, xmult, ymult);
724
725 reg_w(gspca_dev, 0x20, 0x0001, 0x0004);
726
727 /* switch to video camera mode */
728 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
729
730 if (reg_r_wait(gspca_dev, 0, 0x8000, 0x44) != 0)
731 gspca_err(gspca_dev, "reg_r_wait() failed\n");
732
733 reg_r(gspca_dev, 0x816b, 1);
734 Data = gspca_dev->usb_buf[0];
735 reg_w(gspca_dev, 0x00, 0x816b, Data);
736
737 /* write_vector(gspca_dev, spca500_visual_defaults); */
738 break;
739
740 case BenqDC1016:
741 case DLinkDSC350: /* FamilyCam 300 */
742 case AiptekPocketDV: /* Aiptek PocketDV */
743 case Gsmartmini: /*Mustek Gsmart Mini */
744 case MustekGsmart300: /* Mustek Gsmart 300 */
745 case PalmPixDC85:
746 case Optimedia:
747 case ToptroIndus:
748 case AgfaCl20:
749 spca500_reinit(gspca_dev);
750 reg_w(gspca_dev, 0x00, 0x0d01, 0x01);
751 /* enable drop packet */
752 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
753
754 err = spca50x_setup_qtable(gspca_dev,
755 0x00, 0x8800, 0x8840, qtable_pocketdv);
756 if (err < 0)
757 gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
758 reg_w(gspca_dev, 0x00, 0x8880, 2);
759
760 /* familycam Quicksmart pocketDV stuff */
761 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
762 /* Set agc transfer: synced between frames */
763 reg_w(gspca_dev, 0x00, 0x820f, 0x01);
764 /* Init SDRAM - needed for SDRAM access */
765 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
766
767 spca500_setmode(gspca_dev, xmult, ymult);
768 /* switch to video camera mode */
769 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
770
771 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
772
773 reg_r(gspca_dev, 0x816b, 1);
774 Data = gspca_dev->usb_buf[0];
775 reg_w(gspca_dev, 0x00, 0x816b, Data);
776 break;
777 case LogitechTraveler:
778 case LogitechClickSmart510:
779 reg_w(gspca_dev, 0x02, 0x00, 0x00);
780 /* enable drop packet */
781 reg_w(gspca_dev, 0x00, 0x850a, 0x0001);
782
783 err = spca50x_setup_qtable(gspca_dev,
784 0x00, 0x8800,
785 0x8840, qtable_creative_pccam);
786 if (err < 0)
787 gspca_err(gspca_dev, "spca50x_setup_qtable failed\n");
788 reg_w(gspca_dev, 0x00, 0x8880, 3);
789 reg_w(gspca_dev, 0x00, 0x800a, 0x00);
790 /* Init SDRAM - needed for SDRAM access */
791 reg_w(gspca_dev, 0x00, 0x870a, 0x04);
792
793 spca500_setmode(gspca_dev, xmult, ymult);
794
795 /* switch to video camera mode */
796 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
797 reg_r_wait(gspca_dev, 0, 0x8000, 0x44);
798
799 reg_r(gspca_dev, 0x816b, 1);
800 Data = gspca_dev->usb_buf[0];
801 reg_w(gspca_dev, 0x00, 0x816b, Data);
802 write_vector(gspca_dev, Clicksmart510_defaults);
803 break;
804 }
805 return 0;
806 }
807
sd_stopN(struct gspca_dev * gspca_dev)808 static void sd_stopN(struct gspca_dev *gspca_dev)
809 {
810 reg_w(gspca_dev, 0, 0x8003, 0x00);
811
812 /* switch to video camera mode */
813 reg_w(gspca_dev, 0x00, 0x8000, 0x0004);
814 reg_r(gspca_dev, 0x8000, 1);
815 gspca_dbg(gspca_dev, D_STREAM, "stop SPCA500 done reg8000: 0x%2x\n",
816 gspca_dev->usb_buf[0]);
817 }
818
sd_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)819 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
820 u8 *data, /* isoc packet */
821 int len) /* iso packet length */
822 {
823 struct sd *sd = (struct sd *) gspca_dev;
824 int i;
825 static __u8 ffd9[] = {0xff, 0xd9};
826
827 /* frames are jpeg 4.1.1 without 0xff escape */
828 if (data[0] == 0xff) {
829 if (data[1] != 0x01) { /* drop packet */
830 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
831 return;
832 }
833 gspca_frame_add(gspca_dev, LAST_PACKET,
834 ffd9, 2);
835
836 /* put the JPEG header in the new frame */
837 gspca_frame_add(gspca_dev, FIRST_PACKET,
838 sd->jpeg_hdr, JPEG_HDR_SZ);
839
840 data += SPCA500_OFFSET_DATA;
841 len -= SPCA500_OFFSET_DATA;
842 } else {
843 data += 1;
844 len -= 1;
845 }
846
847 /* add 0x00 after 0xff */
848 i = 0;
849 do {
850 if (data[i] == 0xff) {
851 gspca_frame_add(gspca_dev, INTER_PACKET,
852 data, i + 1);
853 len -= i;
854 data += i;
855 *data = 0x00;
856 i = 0;
857 }
858 i++;
859 } while (i < len);
860 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
861 }
862
setbrightness(struct gspca_dev * gspca_dev,s32 val)863 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
864 {
865 reg_w(gspca_dev, 0x00, 0x8167,
866 (__u8) (val - 128));
867 }
868
setcontrast(struct gspca_dev * gspca_dev,s32 val)869 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
870 {
871 reg_w(gspca_dev, 0x00, 0x8168, val);
872 }
873
setcolors(struct gspca_dev * gspca_dev,s32 val)874 static void setcolors(struct gspca_dev *gspca_dev, s32 val)
875 {
876 reg_w(gspca_dev, 0x00, 0x8169, val);
877 }
878
sd_s_ctrl(struct v4l2_ctrl * ctrl)879 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
880 {
881 struct gspca_dev *gspca_dev =
882 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
883
884 gspca_dev->usb_err = 0;
885
886 if (!gspca_dev->streaming)
887 return 0;
888
889 switch (ctrl->id) {
890 case V4L2_CID_BRIGHTNESS:
891 setbrightness(gspca_dev, ctrl->val);
892 break;
893 case V4L2_CID_CONTRAST:
894 setcontrast(gspca_dev, ctrl->val);
895 break;
896 case V4L2_CID_SATURATION:
897 setcolors(gspca_dev, ctrl->val);
898 break;
899 }
900 return gspca_dev->usb_err;
901 }
902
903 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
904 .s_ctrl = sd_s_ctrl,
905 };
906
sd_init_controls(struct gspca_dev * gspca_dev)907 static int sd_init_controls(struct gspca_dev *gspca_dev)
908 {
909 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
910
911 gspca_dev->vdev.ctrl_handler = hdl;
912 v4l2_ctrl_handler_init(hdl, 3);
913 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
914 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
915 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
916 V4L2_CID_CONTRAST, 0, 63, 1, 31);
917 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
918 V4L2_CID_SATURATION, 0, 63, 1, 31);
919
920 if (hdl->error) {
921 pr_err("Could not initialize controls\n");
922 return hdl->error;
923 }
924 return 0;
925 }
926
927 /* sub-driver description */
928 static const struct sd_desc sd_desc = {
929 .name = MODULE_NAME,
930 .config = sd_config,
931 .init = sd_init,
932 .init_controls = sd_init_controls,
933 .start = sd_start,
934 .stopN = sd_stopN,
935 .pkt_scan = sd_pkt_scan,
936 };
937
938 /* -- module initialisation -- */
939 static const struct usb_device_id device_table[] = {
940 {USB_DEVICE(0x040a, 0x0300), .driver_info = KodakEZ200},
941 {USB_DEVICE(0x041e, 0x400a), .driver_info = CreativePCCam300},
942 {USB_DEVICE(0x046d, 0x0890), .driver_info = LogitechTraveler},
943 {USB_DEVICE(0x046d, 0x0900), .driver_info = LogitechClickSmart310},
944 {USB_DEVICE(0x046d, 0x0901), .driver_info = LogitechClickSmart510},
945 {USB_DEVICE(0x04a5, 0x300c), .driver_info = BenqDC1016},
946 {USB_DEVICE(0x04fc, 0x7333), .driver_info = PalmPixDC85},
947 {USB_DEVICE(0x055f, 0xc200), .driver_info = MustekGsmart300},
948 {USB_DEVICE(0x055f, 0xc220), .driver_info = Gsmartmini},
949 {USB_DEVICE(0x06bd, 0x0404), .driver_info = AgfaCl20},
950 {USB_DEVICE(0x06be, 0x0800), .driver_info = Optimedia},
951 {USB_DEVICE(0x084d, 0x0003), .driver_info = DLinkDSC350},
952 {USB_DEVICE(0x08ca, 0x0103), .driver_info = AiptekPocketDV},
953 {USB_DEVICE(0x2899, 0x012c), .driver_info = ToptroIndus},
954 {USB_DEVICE(0x8086, 0x0630), .driver_info = IntelPocketPCCamera},
955 {}
956 };
957 MODULE_DEVICE_TABLE(usb, device_table);
958
959 /* -- device connect -- */
sd_probe(struct usb_interface * intf,const struct usb_device_id * id)960 static int sd_probe(struct usb_interface *intf,
961 const struct usb_device_id *id)
962 {
963 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
964 THIS_MODULE);
965 }
966
967 static struct usb_driver sd_driver = {
968 .name = MODULE_NAME,
969 .id_table = device_table,
970 .probe = sd_probe,
971 .disconnect = gspca_disconnect,
972 #ifdef CONFIG_PM
973 .suspend = gspca_suspend,
974 .resume = gspca_resume,
975 .reset_resume = gspca_resume,
976 #endif
977 };
978
979 module_usb_driver(sd_driver);
980
