xref: /openbmc/linux/drivers/media/usb/gspca/mr97310a.c (revision 4a075bd4)
1 /*
2  * Mars MR97310A library
3  *
4  * The original mr97310a driver, which supported the Aiptek Pencam VGA+, is
5  * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
6  *
7  * Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+
8  * and for the routines for detecting and classifying these various cameras,
9  * is Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
10  *
11  * Support for the control settings for the CIF cameras is
12  * Copyright (C) 2009 Hans de Goede <hdegoede@redhat.com> and
13  * Thomas Kaiser <thomas@kaiser-linux.li>
14  *
15  * Support for the control settings for the VGA cameras is
16  * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
17  *
18  * Several previously unsupported cameras are owned and have been tested by
19  * Hans de Goede <hdegoede@redhat.com> and
20  * Thomas Kaiser <thomas@kaiser-linux.li> and
21  * Theodore Kilgore <kilgota@auburn.edu> and
22  * Edmond Rodriguez <erodrig_97@yahoo.com> and
23  * Aurelien Jacobs <aurel@gnuage.org>
24  *
25  * The MR97311A support in gspca/mars.c has been helpful in understanding some
26  * of the registers in these cameras.
27  *
28  * This program is free software; you can redistribute it and/or modify
29  * it under the terms of the GNU General Public License as published by
30  * the Free Software Foundation; either version 2 of the License, or
31  * any later version.
32  *
33  * This program is distributed in the hope that it will be useful,
34  * but WITHOUT ANY WARRANTY; without even the implied warranty of
35  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36  * GNU General Public License for more details.
37  */
38 
39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40 
41 #define MODULE_NAME "mr97310a"
42 
43 #include "gspca.h"
44 
45 #define CAM_TYPE_CIF			0
46 #define CAM_TYPE_VGA			1
47 
48 #define MR97310A_BRIGHTNESS_DEFAULT	0
49 
50 #define MR97310A_EXPOSURE_MIN		0
51 #define MR97310A_EXPOSURE_MAX		4095
52 #define MR97310A_EXPOSURE_DEFAULT	1000
53 
54 #define MR97310A_GAIN_MIN		0
55 #define MR97310A_GAIN_MAX		31
56 #define MR97310A_GAIN_DEFAULT		25
57 
58 #define MR97310A_CONTRAST_MIN		0
59 #define MR97310A_CONTRAST_MAX		31
60 #define MR97310A_CONTRAST_DEFAULT	23
61 
62 #define MR97310A_CS_GAIN_MIN		0
63 #define MR97310A_CS_GAIN_MAX		0x7ff
64 #define MR97310A_CS_GAIN_DEFAULT	0x110
65 
66 #define MR97310A_CID_CLOCKDIV (V4L2_CTRL_CLASS_USER + 0x1000)
67 #define MR97310A_MIN_CLOCKDIV_MIN	3
68 #define MR97310A_MIN_CLOCKDIV_MAX	8
69 #define MR97310A_MIN_CLOCKDIV_DEFAULT	3
70 
71 MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,Theodore Kilgore <kilgota@auburn.edu>");
72 MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver");
73 MODULE_LICENSE("GPL");
74 
75 /* global parameters */
76 static int force_sensor_type = -1;
77 module_param(force_sensor_type, int, 0644);
78 MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)");
79 
80 /* specific webcam descriptor */
81 struct sd {
82 	struct gspca_dev gspca_dev;  /* !! must be the first item */
83 	struct { /* exposure/min_clockdiv control cluster */
84 		struct v4l2_ctrl *exposure;
85 		struct v4l2_ctrl *min_clockdiv;
86 	};
87 	u8 sof_read;
88 	u8 cam_type;	/* 0 is CIF and 1 is VGA */
89 	u8 sensor_type;	/* We use 0 and 1 here, too. */
90 	u8 do_lcd_stop;
91 	u8 adj_colors;
92 };
93 
94 struct sensor_w_data {
95 	u8 reg;
96 	u8 flags;
97 	u8 data[16];
98 	int len;
99 };
100 
101 static void sd_stopN(struct gspca_dev *gspca_dev);
102 
103 static const struct v4l2_pix_format vga_mode[] = {
104 	{160, 120, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
105 		.bytesperline = 160,
106 		.sizeimage = 160 * 120,
107 		.colorspace = V4L2_COLORSPACE_SRGB,
108 		.priv = 4},
109 	{176, 144, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
110 		.bytesperline = 176,
111 		.sizeimage = 176 * 144,
112 		.colorspace = V4L2_COLORSPACE_SRGB,
113 		.priv = 3},
114 	{320, 240, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
115 		.bytesperline = 320,
116 		.sizeimage = 320 * 240,
117 		.colorspace = V4L2_COLORSPACE_SRGB,
118 		.priv = 2},
119 	{352, 288, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
120 		.bytesperline = 352,
121 		.sizeimage = 352 * 288,
122 		.colorspace = V4L2_COLORSPACE_SRGB,
123 		.priv = 1},
124 	{640, 480, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
125 		.bytesperline = 640,
126 		.sizeimage = 640 * 480,
127 		.colorspace = V4L2_COLORSPACE_SRGB,
128 		.priv = 0},
129 };
130 
131 /* the bytes to write are in gspca_dev->usb_buf */
132 static int mr_write(struct gspca_dev *gspca_dev, int len)
133 {
134 	int rc;
135 
136 	rc = usb_bulk_msg(gspca_dev->dev,
137 			  usb_sndbulkpipe(gspca_dev->dev, 4),
138 			  gspca_dev->usb_buf, len, NULL, 500);
139 	if (rc < 0)
140 		pr_err("reg write [%02x] error %d\n",
141 		       gspca_dev->usb_buf[0], rc);
142 	return rc;
143 }
144 
145 /* the bytes are read into gspca_dev->usb_buf */
146 static int mr_read(struct gspca_dev *gspca_dev, int len)
147 {
148 	int rc;
149 
150 	rc = usb_bulk_msg(gspca_dev->dev,
151 			  usb_rcvbulkpipe(gspca_dev->dev, 3),
152 			  gspca_dev->usb_buf, len, NULL, 500);
153 	if (rc < 0)
154 		pr_err("reg read [%02x] error %d\n",
155 		       gspca_dev->usb_buf[0], rc);
156 	return rc;
157 }
158 
159 static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags,
160 	const u8 *data, int len)
161 {
162 	gspca_dev->usb_buf[0] = 0x1f;
163 	gspca_dev->usb_buf[1] = flags;
164 	gspca_dev->usb_buf[2] = reg;
165 	memcpy(gspca_dev->usb_buf + 3, data, len);
166 
167 	return mr_write(gspca_dev, len + 3);
168 }
169 
170 static int sensor_write_regs(struct gspca_dev *gspca_dev,
171 	const struct sensor_w_data *data, int len)
172 {
173 	int i, rc;
174 
175 	for (i = 0; i < len; i++) {
176 		rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags,
177 					  data[i].data, data[i].len);
178 		if (rc < 0)
179 			return rc;
180 	}
181 
182 	return 0;
183 }
184 
185 static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data)
186 {
187 	struct sd *sd = (struct sd *) gspca_dev;
188 	u8 buf, confirm_reg;
189 	int rc;
190 
191 	buf = data;
192 	if (sd->cam_type == CAM_TYPE_CIF) {
193 		rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);
194 		confirm_reg = sd->sensor_type ? 0x13 : 0x11;
195 	} else {
196 		rc = sensor_write_reg(gspca_dev, reg, 0x00, &buf, 1);
197 		confirm_reg = 0x11;
198 	}
199 	if (rc < 0)
200 		return rc;
201 
202 	buf = 0x01;
203 	rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1);
204 	if (rc < 0)
205 		return rc;
206 
207 	return 0;
208 }
209 
210 static int cam_get_response16(struct gspca_dev *gspca_dev, u8 reg, int verbose)
211 {
212 	int err_code;
213 
214 	gspca_dev->usb_buf[0] = reg;
215 	err_code = mr_write(gspca_dev, 1);
216 	if (err_code < 0)
217 		return err_code;
218 
219 	err_code = mr_read(gspca_dev, 16);
220 	if (err_code < 0)
221 		return err_code;
222 
223 	if (verbose)
224 		gspca_dbg(gspca_dev, D_PROBE, "Register: %02x reads %02x%02x%02x\n",
225 			  reg,
226 			  gspca_dev->usb_buf[0],
227 			  gspca_dev->usb_buf[1],
228 			  gspca_dev->usb_buf[2]);
229 
230 	return 0;
231 }
232 
233 static int zero_the_pointer(struct gspca_dev *gspca_dev)
234 {
235 	__u8 *data = gspca_dev->usb_buf;
236 	int err_code;
237 	u8 status = 0;
238 	int tries = 0;
239 
240 	err_code = cam_get_response16(gspca_dev, 0x21, 0);
241 	if (err_code < 0)
242 		return err_code;
243 
244 	data[0] = 0x19;
245 	data[1] = 0x51;
246 	err_code = mr_write(gspca_dev, 2);
247 	if (err_code < 0)
248 		return err_code;
249 
250 	err_code = cam_get_response16(gspca_dev, 0x21, 0);
251 	if (err_code < 0)
252 		return err_code;
253 
254 	data[0] = 0x19;
255 	data[1] = 0xba;
256 	err_code = mr_write(gspca_dev, 2);
257 	if (err_code < 0)
258 		return err_code;
259 
260 	err_code = cam_get_response16(gspca_dev, 0x21, 0);
261 	if (err_code < 0)
262 		return err_code;
263 
264 	data[0] = 0x19;
265 	data[1] = 0x00;
266 	err_code = mr_write(gspca_dev, 2);
267 	if (err_code < 0)
268 		return err_code;
269 
270 	err_code = cam_get_response16(gspca_dev, 0x21, 0);
271 	if (err_code < 0)
272 		return err_code;
273 
274 	data[0] = 0x19;
275 	data[1] = 0x00;
276 	err_code = mr_write(gspca_dev, 2);
277 	if (err_code < 0)
278 		return err_code;
279 
280 	while (status != 0x0a && tries < 256) {
281 		err_code = cam_get_response16(gspca_dev, 0x21, 0);
282 		status = data[0];
283 		tries++;
284 		if (err_code < 0)
285 			return err_code;
286 	}
287 	if (status != 0x0a)
288 		gspca_err(gspca_dev, "status is %02x\n", status);
289 
290 	tries = 0;
291 	while (tries < 4) {
292 		data[0] = 0x19;
293 		data[1] = 0x00;
294 		err_code = mr_write(gspca_dev, 2);
295 		if (err_code < 0)
296 			return err_code;
297 
298 		err_code = cam_get_response16(gspca_dev, 0x21, 0);
299 		status = data[0];
300 		tries++;
301 		if (err_code < 0)
302 			return err_code;
303 	}
304 
305 	data[0] = 0x19;
306 	err_code = mr_write(gspca_dev, 1);
307 	if (err_code < 0)
308 		return err_code;
309 
310 	err_code = mr_read(gspca_dev, 16);
311 	if (err_code < 0)
312 		return err_code;
313 
314 	return 0;
315 }
316 
317 static int stream_start(struct gspca_dev *gspca_dev)
318 {
319 	gspca_dev->usb_buf[0] = 0x01;
320 	gspca_dev->usb_buf[1] = 0x01;
321 	return mr_write(gspca_dev, 2);
322 }
323 
324 static void stream_stop(struct gspca_dev *gspca_dev)
325 {
326 	gspca_dev->usb_buf[0] = 0x01;
327 	gspca_dev->usb_buf[1] = 0x00;
328 	if (mr_write(gspca_dev, 2) < 0)
329 		gspca_err(gspca_dev, "Stream Stop failed\n");
330 }
331 
332 static void lcd_stop(struct gspca_dev *gspca_dev)
333 {
334 	gspca_dev->usb_buf[0] = 0x19;
335 	gspca_dev->usb_buf[1] = 0x54;
336 	if (mr_write(gspca_dev, 2) < 0)
337 		gspca_err(gspca_dev, "LCD Stop failed\n");
338 }
339 
340 static int isoc_enable(struct gspca_dev *gspca_dev)
341 {
342 	gspca_dev->usb_buf[0] = 0x00;
343 	gspca_dev->usb_buf[1] = 0x4d;  /* ISOC transferring enable... */
344 	return mr_write(gspca_dev, 2);
345 }
346 
347 /* This function is called at probe time */
348 static int sd_config(struct gspca_dev *gspca_dev,
349 		     const struct usb_device_id *id)
350 {
351 	struct sd *sd = (struct sd *) gspca_dev;
352 	struct cam *cam;
353 	int err_code;
354 
355 	cam = &gspca_dev->cam;
356 	cam->cam_mode = vga_mode;
357 	cam->nmodes = ARRAY_SIZE(vga_mode);
358 	sd->do_lcd_stop = 0;
359 
360 	/* Several of the supported CIF cameras share the same USB ID but
361 	 * require different initializations and different control settings.
362 	 * The same is true of the VGA cameras. Therefore, we are forced
363 	 * to start the initialization process in order to determine which
364 	 * camera is present. Some of the supported cameras require the
365 	 * memory pointer to be set to 0 as the very first item of business
366 	 * or else they will not stream. So we do that immediately.
367 	 */
368 	err_code = zero_the_pointer(gspca_dev);
369 	if (err_code < 0)
370 		return err_code;
371 
372 	err_code = stream_start(gspca_dev);
373 	if (err_code < 0)
374 		return err_code;
375 
376 	/* Now, the query for sensor type. */
377 	err_code = cam_get_response16(gspca_dev, 0x07, 1);
378 	if (err_code < 0)
379 		return err_code;
380 
381 	if (id->idProduct == 0x0110 || id->idProduct == 0x010e) {
382 		sd->cam_type = CAM_TYPE_CIF;
383 		cam->nmodes--;
384 		/*
385 		 * All but one of the known CIF cameras share the same USB ID,
386 		 * but two different init routines are in use, and the control
387 		 * settings are different, too. We need to detect which camera
388 		 * of the two known varieties is connected!
389 		 *
390 		 * A list of known CIF cameras follows. They all report either
391 		 * 0200 for type 0 or 0300 for type 1.
392 		 * If you have another to report, please do
393 		 *
394 		 * Name		sd->sensor_type		reported by
395 		 *
396 		 * Sakar 56379 Spy-shot	0		T. Kilgore
397 		 * Innovage		0		T. Kilgore
398 		 * Vivitar Mini		0		H. De Goede
399 		 * Vivitar Mini		0		E. Rodriguez
400 		 * Vivitar Mini		1		T. Kilgore
401 		 * Elta-Media 8212dc	1		T. Kaiser
402 		 * Philips dig. keych.	1		T. Kilgore
403 		 * Trust Spyc@m 100	1		A. Jacobs
404 		 */
405 		switch (gspca_dev->usb_buf[0]) {
406 		case 2:
407 			sd->sensor_type = 0;
408 			break;
409 		case 3:
410 			sd->sensor_type = 1;
411 			break;
412 		default:
413 			pr_err("Unknown CIF Sensor id : %02x\n",
414 			       gspca_dev->usb_buf[1]);
415 			return -ENODEV;
416 		}
417 		gspca_dbg(gspca_dev, D_PROBE, "MR97310A CIF camera detected, sensor: %d\n",
418 			  sd->sensor_type);
419 	} else {
420 		sd->cam_type = CAM_TYPE_VGA;
421 
422 		/*
423 		 * Here is a table of the responses to the query for sensor
424 		 * type, from the known MR97310A VGA cameras. Six different
425 		 * cameras of which five share the same USB ID.
426 		 *
427 		 * Name			gspca_dev->usb_buf[]	sd->sensor_type
428 		 *				sd->do_lcd_stop
429 		 * Aiptek Pencam VGA+	0300		0		1
430 		 * ION digital		0300		0		1
431 		 * Argus DC-1620	0450		1		0
432 		 * Argus QuickClix	0420		1		1
433 		 * Sakar 77379 Digital	0350		0		1
434 		 * Sakar 1638x CyberPix	0120		0		2
435 		 *
436 		 * Based upon these results, we assume default settings
437 		 * and then correct as necessary, as follows.
438 		 *
439 		 */
440 
441 		sd->sensor_type = 1;
442 		sd->do_lcd_stop = 0;
443 		sd->adj_colors = 0;
444 		if (gspca_dev->usb_buf[0] == 0x01) {
445 			sd->sensor_type = 2;
446 		} else if ((gspca_dev->usb_buf[0] != 0x03) &&
447 					(gspca_dev->usb_buf[0] != 0x04)) {
448 			pr_err("Unknown VGA Sensor id Byte 0: %02x\n",
449 			       gspca_dev->usb_buf[0]);
450 			pr_err("Defaults assumed, may not work\n");
451 			pr_err("Please report this\n");
452 		}
453 		/* Sakar Digital color needs to be adjusted. */
454 		if ((gspca_dev->usb_buf[0] == 0x03) &&
455 					(gspca_dev->usb_buf[1] == 0x50))
456 			sd->adj_colors = 1;
457 		if (gspca_dev->usb_buf[0] == 0x04) {
458 			sd->do_lcd_stop = 1;
459 			switch (gspca_dev->usb_buf[1]) {
460 			case 0x50:
461 				sd->sensor_type = 0;
462 				gspca_dbg(gspca_dev, D_PROBE, "sensor_type corrected to 0\n");
463 				break;
464 			case 0x20:
465 				/* Nothing to do here. */
466 				break;
467 			default:
468 				pr_err("Unknown VGA Sensor id Byte 1: %02x\n",
469 				       gspca_dev->usb_buf[1]);
470 				pr_err("Defaults assumed, may not work\n");
471 				pr_err("Please report this\n");
472 			}
473 		}
474 		gspca_dbg(gspca_dev, D_PROBE, "MR97310A VGA camera detected, sensor: %d\n",
475 			  sd->sensor_type);
476 	}
477 	/* Stop streaming as we've started it only to probe the sensor type. */
478 	sd_stopN(gspca_dev);
479 
480 	if (force_sensor_type != -1) {
481 		sd->sensor_type = !!force_sensor_type;
482 		gspca_dbg(gspca_dev, D_PROBE, "Forcing sensor type to: %d\n",
483 			  sd->sensor_type);
484 	}
485 
486 	return 0;
487 }
488 
489 /* this function is called at probe and resume time */
490 static int sd_init(struct gspca_dev *gspca_dev)
491 {
492 	return 0;
493 }
494 
495 static int start_cif_cam(struct gspca_dev *gspca_dev)
496 {
497 	struct sd *sd = (struct sd *) gspca_dev;
498 	__u8 *data = gspca_dev->usb_buf;
499 	int err_code;
500 	static const __u8 startup_string[] = {
501 		0x00,
502 		0x0d,
503 		0x01,
504 		0x00, /* Hsize/8 for 352 or 320 */
505 		0x00, /* Vsize/4 for 288 or 240 */
506 		0x13, /* or 0xbb, depends on sensor */
507 		0x00, /* Hstart, depends on res. */
508 		0x00, /* reserved ? */
509 		0x00, /* Vstart, depends on res. and sensor */
510 		0x50, /* 0x54 to get 176 or 160 */
511 		0xc0
512 	};
513 
514 	/* Note: Some of the above descriptions guessed from MR97113A driver */
515 
516 	memcpy(data, startup_string, 11);
517 	if (sd->sensor_type)
518 		data[5] = 0xbb;
519 
520 	switch (gspca_dev->pixfmt.width) {
521 	case 160:
522 		data[9] |= 0x04;  /* reg 8, 2:1 scale down from 320 */
523 		/* fall through */
524 	case 320:
525 	default:
526 		data[3] = 0x28;			   /* reg 2, H size/8 */
527 		data[4] = 0x3c;			   /* reg 3, V size/4 */
528 		data[6] = 0x14;			   /* reg 5, H start  */
529 		data[8] = 0x1a + sd->sensor_type;  /* reg 7, V start  */
530 		break;
531 	case 176:
532 		data[9] |= 0x04;  /* reg 8, 2:1 scale down from 352 */
533 		/* fall through */
534 	case 352:
535 		data[3] = 0x2c;			   /* reg 2, H size/8 */
536 		data[4] = 0x48;			   /* reg 3, V size/4 */
537 		data[6] = 0x06;			   /* reg 5, H start  */
538 		data[8] = 0x06 - sd->sensor_type;  /* reg 7, V start  */
539 		break;
540 	}
541 	err_code = mr_write(gspca_dev, 11);
542 	if (err_code < 0)
543 		return err_code;
544 
545 	if (!sd->sensor_type) {
546 		static const struct sensor_w_data cif_sensor0_init_data[] = {
547 			{0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01,
548 				      0x0f, 0x14, 0x0f, 0x10}, 8},
549 			{0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5},
550 			{0x12, 0x00, {0x07}, 1},
551 			{0x1f, 0x00, {0x06}, 1},
552 			{0x27, 0x00, {0x04}, 1},
553 			{0x29, 0x00, {0x0c}, 1},
554 			{0x40, 0x00, {0x40, 0x00, 0x04}, 3},
555 			{0x50, 0x00, {0x60}, 1},
556 			{0x60, 0x00, {0x06}, 1},
557 			{0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6},
558 			{0x72, 0x00, {0x1e, 0x56}, 2},
559 			{0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02,
560 				      0x31, 0x80, 0x00}, 9},
561 			{0x11, 0x00, {0x01}, 1},
562 			{0, 0, {0}, 0}
563 		};
564 		err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data,
565 					 ARRAY_SIZE(cif_sensor0_init_data));
566 	} else {	/* sd->sensor_type = 1 */
567 		static const struct sensor_w_data cif_sensor1_init_data[] = {
568 			/* Reg 3,4, 7,8 get set by the controls */
569 			{0x02, 0x00, {0x10}, 1},
570 			{0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */
571 			{0x06, 0x01, {0x00}, 1},
572 			{0x09, 0x02, {0x0e}, 1},
573 			{0x0a, 0x02, {0x05}, 1},
574 			{0x0b, 0x02, {0x05}, 1},
575 			{0x0c, 0x02, {0x0f}, 1},
576 			{0x0d, 0x02, {0x07}, 1},
577 			{0x0e, 0x02, {0x0c}, 1},
578 			{0x0f, 0x00, {0x00}, 1},
579 			{0x10, 0x00, {0x06}, 1},
580 			{0x11, 0x00, {0x07}, 1},
581 			{0x12, 0x00, {0x00}, 1},
582 			{0x13, 0x00, {0x01}, 1},
583 			{0, 0, {0}, 0}
584 		};
585 		/* Without this command the cam won't work with USB-UHCI */
586 		gspca_dev->usb_buf[0] = 0x0a;
587 		gspca_dev->usb_buf[1] = 0x00;
588 		err_code = mr_write(gspca_dev, 2);
589 		if (err_code < 0)
590 			return err_code;
591 		err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
592 					 ARRAY_SIZE(cif_sensor1_init_data));
593 	}
594 	return err_code;
595 }
596 
597 static int start_vga_cam(struct gspca_dev *gspca_dev)
598 {
599 	struct sd *sd = (struct sd *) gspca_dev;
600 	__u8 *data = gspca_dev->usb_buf;
601 	int err_code;
602 	static const __u8 startup_string[] =
603 		{0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b, 0x00, 0x00,
604 		 0x00, 0x50, 0xc0};
605 	/* What some of these mean is explained in start_cif_cam(), above */
606 
607 	memcpy(data, startup_string, 11);
608 	if (!sd->sensor_type) {
609 		data[5]  = 0x00;
610 		data[10] = 0x91;
611 	}
612 	if (sd->sensor_type == 2) {
613 		data[5]  = 0x00;
614 		data[10] = 0x18;
615 	}
616 
617 	switch (gspca_dev->pixfmt.width) {
618 	case 160:
619 		data[9] |= 0x0c;  /* reg 8, 4:1 scale down */
620 		/* fall through */
621 	case 320:
622 		data[9] |= 0x04;  /* reg 8, 2:1 scale down */
623 		/* fall through */
624 	case 640:
625 	default:
626 		data[3] = 0x50;  /* reg 2, H size/8 */
627 		data[4] = 0x78;  /* reg 3, V size/4 */
628 		data[6] = 0x04;  /* reg 5, H start */
629 		data[8] = 0x03;  /* reg 7, V start */
630 		if (sd->sensor_type == 2) {
631 			data[6] = 2;
632 			data[8] = 1;
633 		}
634 		if (sd->do_lcd_stop)
635 			data[8] = 0x04;  /* Bayer tile shifted */
636 		break;
637 
638 	case 176:
639 		data[9] |= 0x04;  /* reg 8, 2:1 scale down */
640 		/* fall through */
641 	case 352:
642 		data[3] = 0x2c;  /* reg 2, H size */
643 		data[4] = 0x48;  /* reg 3, V size */
644 		data[6] = 0x94;  /* reg 5, H start */
645 		data[8] = 0x63;  /* reg 7, V start */
646 		if (sd->do_lcd_stop)
647 			data[8] = 0x64;  /* Bayer tile shifted */
648 		break;
649 	}
650 
651 	err_code = mr_write(gspca_dev, 11);
652 	if (err_code < 0)
653 		return err_code;
654 
655 	if (!sd->sensor_type) {
656 		static const struct sensor_w_data vga_sensor0_init_data[] = {
657 			{0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
658 			{0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
659 			{0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
660 			{0x25, 0x00, {0x03, 0xa9, 0x80}, 3},
661 			{0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4},
662 			{0, 0, {0}, 0}
663 		};
664 		err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
665 					 ARRAY_SIZE(vga_sensor0_init_data));
666 	} else if (sd->sensor_type == 1) {
667 		static const struct sensor_w_data color_adj[] = {
668 			{0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
669 				/* adjusted blue, green, red gain correct
670 				   too much blue from the Sakar Digital */
671 				0x05, 0x01, 0x04}, 8}
672 		};
673 
674 		static const struct sensor_w_data color_no_adj[] = {
675 			{0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
676 				/* default blue, green, red gain settings */
677 				0x07, 0x00, 0x01}, 8}
678 		};
679 
680 		static const struct sensor_w_data vga_sensor1_init_data[] = {
681 			{0x11, 0x04, {0x01}, 1},
682 			{0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01,
683 			/* These settings may be better for some cameras */
684 			/* {0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01, */
685 				0x00, 0x0a}, 7},
686 			{0x11, 0x04, {0x01}, 1},
687 			{0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
688 			{0x11, 0x04, {0x01}, 1},
689 			{0, 0, {0}, 0}
690 		};
691 
692 		if (sd->adj_colors)
693 			err_code = sensor_write_regs(gspca_dev, color_adj,
694 					 ARRAY_SIZE(color_adj));
695 		else
696 			err_code = sensor_write_regs(gspca_dev, color_no_adj,
697 					 ARRAY_SIZE(color_no_adj));
698 
699 		if (err_code < 0)
700 			return err_code;
701 
702 		err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
703 					 ARRAY_SIZE(vga_sensor1_init_data));
704 	} else {	/* sensor type == 2 */
705 		static const struct sensor_w_data vga_sensor2_init_data[] = {
706 
707 			{0x01, 0x00, {0x48}, 1},
708 			{0x02, 0x00, {0x22}, 1},
709 			/* Reg 3 msb and 4 is lsb of the exposure setting*/
710 			{0x05, 0x00, {0x10}, 1},
711 			{0x06, 0x00, {0x00}, 1},
712 			{0x07, 0x00, {0x00}, 1},
713 			{0x08, 0x00, {0x00}, 1},
714 			{0x09, 0x00, {0x00}, 1},
715 			/* The following are used in the gain control
716 			 * which is BTW completely borked in the OEM driver
717 			 * The values for each color go from 0 to 0x7ff
718 			 *{0x0a, 0x00, {0x01}, 1},  green1 gain msb
719 			 *{0x0b, 0x00, {0x10}, 1},  green1 gain lsb
720 			 *{0x0c, 0x00, {0x01}, 1},  red gain msb
721 			 *{0x0d, 0x00, {0x10}, 1},  red gain lsb
722 			 *{0x0e, 0x00, {0x01}, 1},  blue gain msb
723 			 *{0x0f, 0x00, {0x10}, 1},  blue gain lsb
724 			 *{0x10, 0x00, {0x01}, 1}, green2 gain msb
725 			 *{0x11, 0x00, {0x10}, 1}, green2 gain lsb
726 			 */
727 			{0x12, 0x00, {0x00}, 1},
728 			{0x13, 0x00, {0x04}, 1}, /* weird effect on colors */
729 			{0x14, 0x00, {0x00}, 1},
730 			{0x15, 0x00, {0x06}, 1},
731 			{0x16, 0x00, {0x01}, 1},
732 			{0x17, 0x00, {0xe2}, 1}, /* vertical alignment */
733 			{0x18, 0x00, {0x02}, 1},
734 			{0x19, 0x00, {0x82}, 1}, /* don't mess with */
735 			{0x1a, 0x00, {0x00}, 1},
736 			{0x1b, 0x00, {0x20}, 1},
737 			/* {0x1c, 0x00, {0x17}, 1}, contrast control */
738 			{0x1d, 0x00, {0x80}, 1}, /* moving causes a mess */
739 			{0x1e, 0x00, {0x08}, 1}, /* moving jams the camera */
740 			{0x1f, 0x00, {0x0c}, 1},
741 			{0x20, 0x00, {0x00}, 1},
742 			{0, 0, {0}, 0}
743 		};
744 		err_code = sensor_write_regs(gspca_dev, vga_sensor2_init_data,
745 					 ARRAY_SIZE(vga_sensor2_init_data));
746 	}
747 	return err_code;
748 }
749 
750 static int sd_start(struct gspca_dev *gspca_dev)
751 {
752 	struct sd *sd = (struct sd *) gspca_dev;
753 	int err_code;
754 
755 	sd->sof_read = 0;
756 
757 	/* Some of the VGA cameras require the memory pointer
758 	 * to be set to 0 again. We have been forced to start the
759 	 * stream in sd_config() to detect the hardware, and closed it.
760 	 * Thus, we need here to do a completely fresh and clean start. */
761 	err_code = zero_the_pointer(gspca_dev);
762 	if (err_code < 0)
763 		return err_code;
764 
765 	err_code = stream_start(gspca_dev);
766 	if (err_code < 0)
767 		return err_code;
768 
769 	if (sd->cam_type == CAM_TYPE_CIF) {
770 		err_code = start_cif_cam(gspca_dev);
771 	} else {
772 		err_code = start_vga_cam(gspca_dev);
773 	}
774 	if (err_code < 0)
775 		return err_code;
776 
777 	return isoc_enable(gspca_dev);
778 }
779 
780 static void sd_stopN(struct gspca_dev *gspca_dev)
781 {
782 	struct sd *sd = (struct sd *) gspca_dev;
783 
784 	stream_stop(gspca_dev);
785 	/* Not all the cams need this, but even if not, probably a good idea */
786 	zero_the_pointer(gspca_dev);
787 	if (sd->do_lcd_stop)
788 		lcd_stop(gspca_dev);
789 }
790 
791 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
792 {
793 	struct sd *sd = (struct sd *) gspca_dev;
794 	u8 sign_reg = 7;  /* This reg and the next one used on CIF cams. */
795 	u8 value_reg = 8; /* VGA cams seem to use regs 0x0b and 0x0c */
796 	static const u8 quick_clix_table[] =
797 	/*	  0  1  2   3  4  5  6  7  8  9  10  11  12  13  14  15 */
798 		{ 0, 4, 8, 12, 1, 2, 3, 5, 6, 9,  7, 10, 13, 11, 14, 15};
799 	if (sd->cam_type == CAM_TYPE_VGA) {
800 		sign_reg += 4;
801 		value_reg += 4;
802 	}
803 
804 	/* Note register 7 is also seen as 0x8x or 0xCx in some dumps */
805 	if (val > 0) {
806 		sensor_write1(gspca_dev, sign_reg, 0x00);
807 	} else {
808 		sensor_write1(gspca_dev, sign_reg, 0x01);
809 		val = 257 - val;
810 	}
811 	/* Use lookup table for funky Argus QuickClix brightness */
812 	if (sd->do_lcd_stop)
813 		val = quick_clix_table[val];
814 
815 	sensor_write1(gspca_dev, value_reg, val);
816 }
817 
818 static void setexposure(struct gspca_dev *gspca_dev, s32 expo, s32 min_clockdiv)
819 {
820 	struct sd *sd = (struct sd *) gspca_dev;
821 	int exposure = MR97310A_EXPOSURE_DEFAULT;
822 	u8 buf[2];
823 
824 	if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1) {
825 		/* This cam does not like exposure settings < 300,
826 		   so scale 0 - 4095 to 300 - 4095 */
827 		exposure = (expo * 9267) / 10000 + 300;
828 		sensor_write1(gspca_dev, 3, exposure >> 4);
829 		sensor_write1(gspca_dev, 4, exposure & 0x0f);
830 	} else if (sd->sensor_type == 2) {
831 		exposure = expo;
832 		exposure >>= 3;
833 		sensor_write1(gspca_dev, 3, exposure >> 8);
834 		sensor_write1(gspca_dev, 4, exposure & 0xff);
835 	} else {
836 		/* We have both a clock divider and an exposure register.
837 		   We first calculate the clock divider, as that determines
838 		   the maximum exposure and then we calculate the exposure
839 		   register setting (which goes from 0 - 511).
840 
841 		   Note our 0 - 4095 exposure is mapped to 0 - 511
842 		   milliseconds exposure time */
843 		u8 clockdiv = (60 * expo + 7999) / 8000;
844 
845 		/* Limit framerate to not exceed usb bandwidth */
846 		if (clockdiv < min_clockdiv && gspca_dev->pixfmt.width >= 320)
847 			clockdiv = min_clockdiv;
848 		else if (clockdiv < 2)
849 			clockdiv = 2;
850 
851 		if (sd->cam_type == CAM_TYPE_VGA && clockdiv < 4)
852 			clockdiv = 4;
853 
854 		/* Frame exposure time in ms = 1000 * clockdiv / 60 ->
855 		exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */
856 		exposure = (60 * 511 * expo) / (8000 * clockdiv);
857 		if (exposure > 511)
858 			exposure = 511;
859 
860 		/* exposure register value is reversed! */
861 		exposure = 511 - exposure;
862 
863 		buf[0] = exposure & 0xff;
864 		buf[1] = exposure >> 8;
865 		sensor_write_reg(gspca_dev, 0x0e, 0, buf, 2);
866 		sensor_write1(gspca_dev, 0x02, clockdiv);
867 	}
868 }
869 
870 static void setgain(struct gspca_dev *gspca_dev, s32 val)
871 {
872 	struct sd *sd = (struct sd *) gspca_dev;
873 	u8 gainreg;
874 
875 	if (sd->cam_type == CAM_TYPE_CIF && sd->sensor_type == 1)
876 		sensor_write1(gspca_dev, 0x0e, val);
877 	else if (sd->cam_type == CAM_TYPE_VGA && sd->sensor_type == 2)
878 		for (gainreg = 0x0a; gainreg < 0x11; gainreg += 2) {
879 			sensor_write1(gspca_dev, gainreg, val >> 8);
880 			sensor_write1(gspca_dev, gainreg + 1, val & 0xff);
881 		}
882 	else
883 		sensor_write1(gspca_dev, 0x10, val);
884 }
885 
886 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
887 {
888 	sensor_write1(gspca_dev, 0x1c, val);
889 }
890 
891 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
892 {
893 	struct gspca_dev *gspca_dev =
894 		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
895 	struct sd *sd = (struct sd *)gspca_dev;
896 
897 	gspca_dev->usb_err = 0;
898 
899 	if (!gspca_dev->streaming)
900 		return 0;
901 
902 	switch (ctrl->id) {
903 	case V4L2_CID_BRIGHTNESS:
904 		setbrightness(gspca_dev, ctrl->val);
905 		break;
906 	case V4L2_CID_CONTRAST:
907 		setcontrast(gspca_dev, ctrl->val);
908 		break;
909 	case V4L2_CID_EXPOSURE:
910 		setexposure(gspca_dev, sd->exposure->val,
911 			    sd->min_clockdiv ? sd->min_clockdiv->val : 0);
912 		break;
913 	case V4L2_CID_GAIN:
914 		setgain(gspca_dev, ctrl->val);
915 		break;
916 	}
917 	return gspca_dev->usb_err;
918 }
919 
920 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
921 	.s_ctrl = sd_s_ctrl,
922 };
923 
924 static int sd_init_controls(struct gspca_dev *gspca_dev)
925 {
926 	struct sd *sd = (struct sd *)gspca_dev;
927 	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
928 	static const struct v4l2_ctrl_config clockdiv = {
929 		.ops = &sd_ctrl_ops,
930 		.id = MR97310A_CID_CLOCKDIV,
931 		.type = V4L2_CTRL_TYPE_INTEGER,
932 		.name = "Minimum Clock Divider",
933 		.min = MR97310A_MIN_CLOCKDIV_MIN,
934 		.max = MR97310A_MIN_CLOCKDIV_MAX,
935 		.step = 1,
936 		.def = MR97310A_MIN_CLOCKDIV_DEFAULT,
937 	};
938 	bool has_brightness = false;
939 	bool has_argus_brightness = false;
940 	bool has_contrast = false;
941 	bool has_gain = false;
942 	bool has_cs_gain = false;
943 	bool has_exposure = false;
944 	bool has_clockdiv = false;
945 
946 	gspca_dev->vdev.ctrl_handler = hdl;
947 	v4l2_ctrl_handler_init(hdl, 4);
948 
949 	/* Setup controls depending on camera type */
950 	if (sd->cam_type == CAM_TYPE_CIF) {
951 		/* No brightness for sensor_type 0 */
952 		if (sd->sensor_type == 0)
953 			has_exposure = has_gain = has_clockdiv = true;
954 		else
955 			has_exposure = has_gain = has_brightness = true;
956 	} else {
957 		/* All controls need to be disabled if VGA sensor_type is 0 */
958 		if (sd->sensor_type == 0)
959 			; /* no controls! */
960 		else if (sd->sensor_type == 2)
961 			has_exposure = has_cs_gain = has_contrast = true;
962 		else if (sd->do_lcd_stop)
963 			has_exposure = has_gain = has_argus_brightness =
964 				has_clockdiv = true;
965 		else
966 			has_exposure = has_gain = has_brightness =
967 				has_clockdiv = true;
968 	}
969 
970 	/* Separate brightness control description for Argus QuickClix as it has
971 	 * different limits from the other mr97310a cameras, and separate gain
972 	 * control for Sakar CyberPix camera. */
973 	/*
974 	 * This control is disabled for CIF type 1 and VGA type 0 cameras.
975 	 * It does not quite act linearly for the Argus QuickClix camera,
976 	 * but it does control brightness. The values are 0 - 15 only, and
977 	 * the table above makes them act consecutively.
978 	 */
979 	if (has_brightness)
980 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
981 			V4L2_CID_BRIGHTNESS, -254, 255, 1,
982 			MR97310A_BRIGHTNESS_DEFAULT);
983 	else if (has_argus_brightness)
984 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
985 			V4L2_CID_BRIGHTNESS, 0, 15, 1,
986 			MR97310A_BRIGHTNESS_DEFAULT);
987 	if (has_contrast)
988 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
989 			V4L2_CID_CONTRAST, MR97310A_CONTRAST_MIN,
990 			MR97310A_CONTRAST_MAX, 1, MR97310A_CONTRAST_DEFAULT);
991 	if (has_gain)
992 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
993 			V4L2_CID_GAIN, MR97310A_GAIN_MIN, MR97310A_GAIN_MAX,
994 			1, MR97310A_GAIN_DEFAULT);
995 	else if (has_cs_gain)
996 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_GAIN,
997 			MR97310A_CS_GAIN_MIN, MR97310A_CS_GAIN_MAX,
998 			1, MR97310A_CS_GAIN_DEFAULT);
999 	if (has_exposure)
1000 		sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1001 			V4L2_CID_EXPOSURE, MR97310A_EXPOSURE_MIN,
1002 			MR97310A_EXPOSURE_MAX, 1, MR97310A_EXPOSURE_DEFAULT);
1003 	if (has_clockdiv)
1004 		sd->min_clockdiv = v4l2_ctrl_new_custom(hdl, &clockdiv, NULL);
1005 
1006 	if (hdl->error) {
1007 		pr_err("Could not initialize controls\n");
1008 		return hdl->error;
1009 	}
1010 	if (has_exposure && has_clockdiv)
1011 		v4l2_ctrl_cluster(2, &sd->exposure);
1012 	return 0;
1013 }
1014 
1015 /* Include pac common sof detection functions */
1016 #include "pac_common.h"
1017 
1018 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1019 			u8 *data,		/* isoc packet */
1020 			int len)		/* iso packet length */
1021 {
1022 	struct sd *sd = (struct sd *) gspca_dev;
1023 	unsigned char *sof;
1024 
1025 	sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
1026 	if (sof) {
1027 		int n;
1028 
1029 		/* finish decoding current frame */
1030 		n = sof - data;
1031 		if (n > sizeof pac_sof_marker)
1032 			n -= sizeof pac_sof_marker;
1033 		else
1034 			n = 0;
1035 		gspca_frame_add(gspca_dev, LAST_PACKET,
1036 					data, n);
1037 		/* Start next frame. */
1038 		gspca_frame_add(gspca_dev, FIRST_PACKET,
1039 			pac_sof_marker, sizeof pac_sof_marker);
1040 		len -= sof - data;
1041 		data = sof;
1042 	}
1043 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1044 }
1045 
1046 /* sub-driver description */
1047 static const struct sd_desc sd_desc = {
1048 	.name = MODULE_NAME,
1049 	.config = sd_config,
1050 	.init = sd_init,
1051 	.init_controls = sd_init_controls,
1052 	.start = sd_start,
1053 	.stopN = sd_stopN,
1054 	.pkt_scan = sd_pkt_scan,
1055 };
1056 
1057 /* -- module initialisation -- */
1058 static const struct usb_device_id device_table[] = {
1059 	{USB_DEVICE(0x08ca, 0x0110)},	/* Trust Spyc@m 100 */
1060 	{USB_DEVICE(0x08ca, 0x0111)},	/* Aiptek Pencam VGA+ */
1061 	{USB_DEVICE(0x093a, 0x010f)},	/* All other known MR97310A VGA cams */
1062 	{USB_DEVICE(0x093a, 0x010e)},	/* All known MR97310A CIF cams */
1063 	{}
1064 };
1065 MODULE_DEVICE_TABLE(usb, device_table);
1066 
1067 /* -- device connect -- */
1068 static int sd_probe(struct usb_interface *intf,
1069 		    const struct usb_device_id *id)
1070 {
1071 	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1072 			       THIS_MODULE);
1073 }
1074 
1075 static struct usb_driver sd_driver = {
1076 	.name = MODULE_NAME,
1077 	.id_table = device_table,
1078 	.probe = sd_probe,
1079 	.disconnect = gspca_disconnect,
1080 #ifdef CONFIG_PM
1081 	.suspend = gspca_suspend,
1082 	.resume = gspca_resume,
1083 	.reset_resume = gspca_resume,
1084 #endif
1085 };
1086 
1087 module_usb_driver(sd_driver);
1088