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