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