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