?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.32.60
[linux-2.6.32.60-moxart.git] / drivers / media / video / gspca / mr97310a.c
blobd61767cd7a519b1698c0e9b541e4eaea44843040
1 /*
2 * Mars MR97310A library
3 *
4 * Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
5 *
6 * Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+
7 * and for the routines for detecting and classifying these various cameras,
8 *
9 * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
10 *
11 * Acknowledgements:
12 *
13 * The MR97311A support in gspca/mars.c has been helpful in understanding some
14 * of the registers in these cameras.
15 *
16 * Hans de Goede <hdgoede@redhat.com> and
17 * Thomas Kaiser <thomas@kaiser-linux.li>
18 * have assisted with their experience. Each of them has also helped by
19 * testing a previously unsupported camera.
20 *
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License as published by
23 * the Free Software Foundation; either version 2 of the License, or
24 * any later version.
25 *
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
30 *
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 */
35
36 #define MODULE_NAME "mr97310a"
37
38 #include "gspca.h"
39
40 #define CAM_TYPE_CIF 0
41 #define CAM_TYPE_VGA 1
42
43 #define MR97310A_BRIGHTNESS_MIN -254
44 #define MR97310A_BRIGHTNESS_MAX 255
45 #define MR97310A_BRIGHTNESS_DEFAULT 0
46
47 #define MR97310A_EXPOSURE_MIN 300
48 #define MR97310A_EXPOSURE_MAX 4095
49 #define MR97310A_EXPOSURE_DEFAULT 1000
50
51 #define MR97310A_GAIN_MIN 0
52 #define MR97310A_GAIN_MAX 31
53 #define MR97310A_GAIN_DEFAULT 25
54
55 MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,"
56 "Theodore Kilgore <kilgota@auburn.edu>");
57 MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver");
58 MODULE_LICENSE("GPL");
59
60 /* global parameters */
61 int force_sensor_type = -1;
62 module_param(force_sensor_type, int, 0644);
63 MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)");
64
65 /* specific webcam descriptor */
66 struct sd {
67 struct gspca_dev gspca_dev; /* !! must be the first item */
68 u8 sof_read;
69 u8 cam_type; /* 0 is CIF and 1 is VGA */
70 u8 sensor_type; /* We use 0 and 1 here, too. */
71 u8 do_lcd_stop;
72
73 int brightness;
74 u16 exposure;
75 u8 gain;
76 };
77
78 struct sensor_w_data {
79 u8 reg;
80 u8 flags;
81 u8 data[16];
82 int len;
83 };
84
85 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
86 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
87 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
88 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
89 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
90 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
91 static void setbrightness(struct gspca_dev *gspca_dev);
92 static void setexposure(struct gspca_dev *gspca_dev);
93 static void setgain(struct gspca_dev *gspca_dev);
94
95 /* V4L2 controls supported by the driver */
96 static struct ctrl sd_ctrls[] = {
97 {
98 #define BRIGHTNESS_IDX 0
99 {
100 .id = V4L2_CID_BRIGHTNESS,
101 .type = V4L2_CTRL_TYPE_INTEGER,
102 .name = "Brightness",
103 .minimum = MR97310A_BRIGHTNESS_MIN,
104 .maximum = MR97310A_BRIGHTNESS_MAX,
105 .step = 1,
106 .default_value = MR97310A_BRIGHTNESS_DEFAULT,
107 .flags = 0,
108 },
109 .set = sd_setbrightness,
110 .get = sd_getbrightness,
111 },
112 {
113 #define EXPOSURE_IDX 1
114 {
115 .id = V4L2_CID_EXPOSURE,
116 .type = V4L2_CTRL_TYPE_INTEGER,
117 .name = "Exposure",
118 .minimum = MR97310A_EXPOSURE_MIN,
119 .maximum = MR97310A_EXPOSURE_MAX,
120 .step = 1,
121 .default_value = MR97310A_EXPOSURE_DEFAULT,
122 .flags = 0,
123 },
124 .set = sd_setexposure,
125 .get = sd_getexposure,
126 },
127 {
128 #define GAIN_IDX 2
129 {
130 .id = V4L2_CID_GAIN,
131 .type = V4L2_CTRL_TYPE_INTEGER,
132 .name = "Gain",
133 .minimum = MR97310A_GAIN_MIN,
134 .maximum = MR97310A_GAIN_MAX,
135 .step = 1,
136 .default_value = MR97310A_GAIN_DEFAULT,
137 .flags = 0,
138 },
139 .set = sd_setgain,
140 .get = sd_getgain,
141 },
142 };
143
144 static const struct v4l2_pix_format vga_mode[] = {
145 {160, 120, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
146 .bytesperline = 160,
147 .sizeimage = 160 * 120,
148 .colorspace = V4L2_COLORSPACE_SRGB,
149 .priv = 4},
150 {176, 144, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
151 .bytesperline = 176,
152 .sizeimage = 176 * 144,
153 .colorspace = V4L2_COLORSPACE_SRGB,
154 .priv = 3},
155 {320, 240, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
156 .bytesperline = 320,
157 .sizeimage = 320 * 240,
158 .colorspace = V4L2_COLORSPACE_SRGB,
159 .priv = 2},
160 {352, 288, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
161 .bytesperline = 352,
162 .sizeimage = 352 * 288,
163 .colorspace = V4L2_COLORSPACE_SRGB,
164 .priv = 1},
165 {640, 480, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
166 .bytesperline = 640,
167 .sizeimage = 640 * 480,
168 .colorspace = V4L2_COLORSPACE_SRGB,
169 .priv = 0},
170 };
171
172 /* the bytes to write are in gspca_dev->usb_buf */
173 static int mr_write(struct gspca_dev *gspca_dev, int len)
174 {
175 int rc;
176
177 rc = usb_bulk_msg(gspca_dev->dev,
178 usb_sndbulkpipe(gspca_dev->dev, 4),
179 gspca_dev->usb_buf, len, NULL, 500);
180 if (rc < 0)
181 PDEBUG(D_ERR, "reg write [%02x] error %d",
182 gspca_dev->usb_buf[0], rc);
183 return rc;
184 }
185
186 /* the bytes are read into gspca_dev->usb_buf */
187 static int mr_read(struct gspca_dev *gspca_dev, int len)
188 {
189 int rc;
190
191 rc = usb_bulk_msg(gspca_dev->dev,
192 usb_rcvbulkpipe(gspca_dev->dev, 3),
193 gspca_dev->usb_buf, len, NULL, 500);
194 if (rc < 0)
195 PDEBUG(D_ERR, "reg read [%02x] error %d",
196 gspca_dev->usb_buf[0], rc);
197 return rc;
198 }
199
200 static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags,
201 const u8 *data, int len)
202 {
203 gspca_dev->usb_buf[0] = 0x1f;
204 gspca_dev->usb_buf[1] = flags;
205 gspca_dev->usb_buf[2] = reg;
206 memcpy(gspca_dev->usb_buf + 3, data, len);
207
208 return mr_write(gspca_dev, len + 3);
209 }
210
211 static int sensor_write_regs(struct gspca_dev *gspca_dev,
212 const struct sensor_w_data *data, int len)
213 {
214 int i, rc;
215
216 for (i = 0; i < len; i++) {
217 rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags,
218 data[i].data, data[i].len);
219 if (rc < 0)
220 return rc;
221 }
222
223 return 0;
224 }
225
226 static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data)
227 {
228 struct sd *sd = (struct sd *) gspca_dev;
229 u8 buf, confirm_reg;
230 int rc;
231
232 buf = data;
233 rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);
234 if (rc < 0)
235 return rc;
236
237 buf = 0x01;
238 confirm_reg = sd->sensor_type ? 0x13 : 0x11;
239 rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1);
240 if (rc < 0)
241 return rc;
242
243 return 0;
244 }
245
246 static int cam_get_response16(struct gspca_dev *gspca_dev)
247 {
248 __u8 *data = gspca_dev->usb_buf;
249 int err_code;
250
251 data[0] = 0x21;
252 err_code = mr_write(gspca_dev, 1);
253 if (err_code < 0)
254 return err_code;
255
256 err_code = mr_read(gspca_dev, 16);
257 return err_code;
258 }
259
260 static int zero_the_pointer(struct gspca_dev *gspca_dev)
261 {
262 __u8 *data = gspca_dev->usb_buf;
263 int err_code;
264 u8 status = 0;
265 int tries = 0;
266
267 err_code = cam_get_response16(gspca_dev);
268 if (err_code < 0)
269 return err_code;
270
271 err_code = mr_write(gspca_dev, 1);
272 data[0] = 0x19;
273 data[1] = 0x51;
274 err_code = mr_write(gspca_dev, 2);
275 if (err_code < 0)
276 return err_code;
277
278 err_code = cam_get_response16(gspca_dev);
279 if (err_code < 0)
280 return err_code;
281
282 data[0] = 0x19;
283 data[1] = 0xba;
284 err_code = mr_write(gspca_dev, 2);
285 if (err_code < 0)
286 return err_code;
287
288 err_code = cam_get_response16(gspca_dev);
289 if (err_code < 0)
290 return err_code;
291
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);
299 if (err_code < 0)
300 return err_code;
301
302 data[0] = 0x19;
303 data[1] = 0x00;
304 err_code = mr_write(gspca_dev, 2);
305 if (err_code < 0)
306 return err_code;
307
308 while (status != 0x0a && tries < 256) {
309 err_code = cam_get_response16(gspca_dev);
310 status = data[0];
311 tries++;
312 if (err_code < 0)
313 return err_code;
314 }
315 if (status != 0x0a)
316 PDEBUG(D_ERR, "status is %02x", status);
317
318 tries = 0;
319 while (tries < 4) {
320 data[0] = 0x19;
321 data[1] = 0x00;
322 err_code = mr_write(gspca_dev, 2);
323 if (err_code < 0)
324 return err_code;
325
326 err_code = cam_get_response16(gspca_dev);
327 status = data[0];
328 tries++;
329 if (err_code < 0)
330 return err_code;
331 }
332
333 data[0] = 0x19;
334 err_code = mr_write(gspca_dev, 1);
335 if (err_code < 0)
336 return err_code;
337
338 err_code = mr_read(gspca_dev, 16);
339 if (err_code < 0)
340 return err_code;
341
342 return 0;
343 }
344
345 static u8 get_sensor_id(struct gspca_dev *gspca_dev)
346 {
347 int err_code;
348
349 gspca_dev->usb_buf[0] = 0x1e;
350 err_code = mr_write(gspca_dev, 1);
351 if (err_code < 0)
352 return err_code;
353
354 err_code = mr_read(gspca_dev, 16);
355 if (err_code < 0)
356 return err_code;
357
358 PDEBUG(D_PROBE, "Byte zero reported is %01x", gspca_dev->usb_buf[0]);
359
360 return gspca_dev->usb_buf[0];
361 }
362
363 /* this function is called at probe time */
364 static int sd_config(struct gspca_dev *gspca_dev,
365 const struct usb_device_id *id)
366 {
367 struct sd *sd = (struct sd *) gspca_dev;
368 struct cam *cam;
369 __u8 *data = gspca_dev->usb_buf;
370 int err_code;
371
372 cam = &gspca_dev->cam;
373 cam->cam_mode = vga_mode;
374 cam->nmodes = ARRAY_SIZE(vga_mode);
375
376 if (id->idProduct == 0x010e) {
377 sd->cam_type = CAM_TYPE_CIF;
378 cam->nmodes--;
379
380 data[0] = 0x01;
381 data[1] = 0x01;
382 err_code = mr_write(gspca_dev, 2);
383 if (err_code < 0)
384 return err_code;
385
386 msleep(200);
387 data[0] = get_sensor_id(gspca_dev);
388 /*
389 * Known CIF cameras. If you have another to report, please do
390 *
391 * Name byte just read sd->sensor_type
392 * reported by
393 * Sakar Spy-shot 0x28 T. Kilgore 0
394 * Innovage 0xf5 (unstable) T. Kilgore 0
395 * Vivitar Mini 0x53 H. De Goede 0
396 * Vivitar Mini 0x04 / 0x24 E. Rodriguez 0
397 * Vivitar Mini 0x08 T. Kilgore 1
398 * Elta-Media 8212dc 0x23 T. Kaiser 1
399 * Philips dig. keych. 0x37 T. Kilgore 1
400 */
401 if ((data[0] & 0x78) == 8 ||
402 ((data[0] & 0x2) == 0x2 && data[0] != 0x53))
403 sd->sensor_type = 1;
404 else
405 sd->sensor_type = 0;
406
407 PDEBUG(D_PROBE, "MR97310A CIF camera detected, sensor: %d",
408 sd->sensor_type);
409
410 if (force_sensor_type != -1) {
411 sd->sensor_type = !! force_sensor_type;
412 PDEBUG(D_PROBE, "Forcing sensor type to: %d",
413 sd->sensor_type);
414 }
415
416 if (sd->sensor_type == 0)
417 gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX);
418 } else {
419 sd->cam_type = CAM_TYPE_VGA;
420 PDEBUG(D_PROBE, "MR97310A VGA camera detected");
421 gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX) |
422 (1 << EXPOSURE_IDX) | (1 << GAIN_IDX);
423 }
424
425 sd->brightness = MR97310A_BRIGHTNESS_DEFAULT;
426 sd->exposure = MR97310A_EXPOSURE_DEFAULT;
427 sd->gain = MR97310A_GAIN_DEFAULT;
428
429 return 0;
430 }
431
432 /* this function is called at probe and resume time */
433 static int sd_init(struct gspca_dev *gspca_dev)
434 {
435 return 0;
436 }
437
438 static int start_cif_cam(struct gspca_dev *gspca_dev)
439 {
440 struct sd *sd = (struct sd *) gspca_dev;
441 __u8 *data = gspca_dev->usb_buf;
442 int err_code;
443 const __u8 startup_string[] = {
444 0x00,
445 0x0d,
446 0x01,
447 0x00, /* Hsize/8 for 352 or 320 */
448 0x00, /* Vsize/4 for 288 or 240 */
449 0x13, /* or 0xbb, depends on sensor */
450 0x00, /* Hstart, depends on res. */
451 0x00, /* reserved ? */
452 0x00, /* Vstart, depends on res. and sensor */
453 0x50, /* 0x54 to get 176 or 160 */
454 0xc0
455 };
456
457 /* Note: Some of the above descriptions guessed from MR97113A driver */
458 data[0] = 0x01;
459 data[1] = 0x01;
460 err_code = mr_write(gspca_dev, 2);
461 if (err_code < 0)
462 return err_code;
463
464 memcpy(data, startup_string, 11);
465 if (sd->sensor_type)
466 data[5] = 0xbb;
467
468 switch (gspca_dev->width) {
469 case 160:
470 data[9] |= 0x04; /* reg 8, 2:1 scale down from 320 */
471 /* fall thru */
472 case 320:
473 default:
474 data[3] = 0x28; /* reg 2, H size/8 */
475 data[4] = 0x3c; /* reg 3, V size/4 */
476 data[6] = 0x14; /* reg 5, H start */
477 data[8] = 0x1a + sd->sensor_type; /* reg 7, V start */
478 break;
479 case 176:
480 data[9] |= 0x04; /* reg 8, 2:1 scale down from 352 */
481 /* fall thru */
482 case 352:
483 data[3] = 0x2c; /* reg 2, H size/8 */
484 data[4] = 0x48; /* reg 3, V size/4 */
485 data[6] = 0x06; /* reg 5, H start */
486 data[8] = 0x06 - sd->sensor_type; /* reg 7, V start */
487 break;
488 }
489 err_code = mr_write(gspca_dev, 11);
490 if (err_code < 0)
491 return err_code;
492
493 if (!sd->sensor_type) {
494 const struct sensor_w_data cif_sensor0_init_data[] = {
495 {0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01,
496 0x0f, 0x14, 0x0f, 0x10}, 8},
497 {0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5},
498 {0x12, 0x00, {0x07}, 1},
499 {0x1f, 0x00, {0x06}, 1},
500 {0x27, 0x00, {0x04}, 1},
501 {0x29, 0x00, {0x0c}, 1},
502 {0x40, 0x00, {0x40, 0x00, 0x04}, 3},
503 {0x50, 0x00, {0x60}, 1},
504 {0x60, 0x00, {0x06}, 1},
505 {0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6},
506 {0x72, 0x00, {0x1e, 0x56}, 2},
507 {0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02,
508 0x31, 0x80, 0x00}, 9},
509 {0x11, 0x00, {0x01}, 1},
510 {0, 0, {0}, 0}
511 };
512 err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data,
513 ARRAY_SIZE(cif_sensor0_init_data));
514 } else { /* sd->sensor_type = 1 */
515 const struct sensor_w_data cif_sensor1_init_data[] = {
516 /* Reg 3,4, 7,8 get set by the controls */
517 {0x02, 0x00, {0x10}, 1},
518 {0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */
519 {0x06, 0x01, {0x00}, 1},
520 {0x09, 0x02, {0x0e}, 1},
521 {0x0a, 0x02, {0x05}, 1},
522 {0x0b, 0x02, {0x05}, 1},
523 {0x0c, 0x02, {0x0f}, 1},
524 {0x0d, 0x02, {0x07}, 1},
525 {0x0e, 0x02, {0x0c}, 1},
526 {0x0f, 0x00, {0x00}, 1},
527 {0x10, 0x00, {0x06}, 1},
528 {0x11, 0x00, {0x07}, 1},
529 {0x12, 0x00, {0x00}, 1},
530 {0x13, 0x00, {0x01}, 1},
531 {0, 0, {0}, 0}
532 };
533 /* Without this command the cam won't work with USB-UHCI */
534 gspca_dev->usb_buf[0] = 0x0a;
535 gspca_dev->usb_buf[1] = 0x00;
536 err_code = mr_write(gspca_dev, 2);
537 if (err_code < 0)
538 return err_code;
539 err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
540 ARRAY_SIZE(cif_sensor1_init_data));
541 }
542 if (err_code < 0)
543 return err_code;
544
545 setbrightness(gspca_dev);
546 setexposure(gspca_dev);
547 setgain(gspca_dev);
548
549 msleep(200);
550
551 data[0] = 0x00;
552 data[1] = 0x4d; /* ISOC transfering enable... */
553 err_code = mr_write(gspca_dev, 2);
554 if (err_code < 0)
555 return err_code;
556
557 return 0;
558 }
559
560 static int start_vga_cam(struct gspca_dev *gspca_dev)
561 {
562 struct sd *sd = (struct sd *) gspca_dev;
563 __u8 *data = gspca_dev->usb_buf;
564 int err_code;
565 const __u8 startup_string[] = {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b,
566 0x00, 0x00, 0x00, 0x50, 0xc0};
567
568 /* What some of these mean is explained in start_cif_cam(), above */
569 sd->sof_read = 0;
570
571 /*
572 * We have to know which camera we have, because the register writes
573 * depend upon the camera. This test, run before we actually enter
574 * the initialization routine, distinguishes most of the cameras, If
575 * needed, another routine is done later, too.
576 */
577 memset(data, 0, 16);
578 data[0] = 0x20;
579 err_code = mr_write(gspca_dev, 1);
580 if (err_code < 0)
581 return err_code;
582
583 err_code = mr_read(gspca_dev, 16);
584 if (err_code < 0)
585 return err_code;
586
587 PDEBUG(D_PROBE, "Byte reported is %02x", data[0]);
588
589 msleep(200);
590 /*
591 * Known VGA cameras. If you have another to report, please do
592 *
593 * Name byte just read sd->sensor_type
594 * sd->do_lcd_stop
595 * Aiptek Pencam VGA+ 0x31 0 1
596 * ION digital 0x31 0 1
597 * Argus DC-1620 0x30 1 0
598 * Argus QuickClix 0x30 1 1 (not caught here)
599 */
600 sd->sensor_type = data[0] & 1;
601 sd->do_lcd_stop = (~data[0]) & 1;
602
603
604
605 /* Streaming setup begins here. */
606
607
608 data[0] = 0x01;
609 data[1] = 0x01;
610 err_code = mr_write(gspca_dev, 2);
611 if (err_code < 0)
612 return err_code;
613
614 /*
615 * A second test can now resolve any remaining ambiguity in the
616 * identification of the camera type,
617 */
618 if (!sd->sensor_type) {
619 data[0] = get_sensor_id(gspca_dev);
620 if (data[0] == 0x7f) {
621 sd->sensor_type = 1;
622 PDEBUG(D_PROBE, "sensor_type corrected to 1");
623 }
624 msleep(200);
625 }
626
627 if (force_sensor_type != -1) {
628 sd->sensor_type = !! force_sensor_type;
629 PDEBUG(D_PROBE, "Forcing sensor type to: %d",
630 sd->sensor_type);
631 }
632
633 /*
634 * Known VGA cameras.
635 * This test is only run if the previous test returned 0x30, but
636 * here is the information for all others, too, just for reference.
637 *
638 * Name byte just read sd->sensor_type
639 *
640 * Aiptek Pencam VGA+ 0xfb (this test not run) 1
641 * ION digital 0xbd (this test not run) 1
642 * Argus DC-1620 0xe5 (no change) 0
643 * Argus QuickClix 0x7f (reclassified) 1
644 */
645 memcpy(data, startup_string, 11);
646 if (!sd->sensor_type) {
647 data[5] = 0x00;
648 data[10] = 0x91;
649 }
650
651 switch (gspca_dev->width) {
652 case 160:
653 data[9] |= 0x0c; /* reg 8, 4:1 scale down */
654 /* fall thru */
655 case 320:
656 data[9] |= 0x04; /* reg 8, 2:1 scale down */
657 /* fall thru */
658 case 640:
659 default:
660 data[3] = 0x50; /* reg 2, H size/8 */
661 data[4] = 0x78; /* reg 3, V size/4 */
662 data[6] = 0x04; /* reg 5, H start */
663 data[8] = 0x03; /* reg 7, V start */
664 if (sd->do_lcd_stop)
665 data[8] = 0x04; /* Bayer tile shifted */
666 break;
667
668 case 176:
669 data[9] |= 0x04; /* reg 8, 2:1 scale down */
670 /* fall thru */
671 case 352:
672 data[3] = 0x2c; /* reg 2, H size */
673 data[4] = 0x48; /* reg 3, V size */
674 data[6] = 0x94; /* reg 5, H start */
675 data[8] = 0x63; /* reg 7, V start */
676 if (sd->do_lcd_stop)
677 data[8] = 0x64; /* Bayer tile shifted */
678 break;
679 }
680
681 err_code = mr_write(gspca_dev, 11);
682 if (err_code < 0)
683 return err_code;
684
685 if (!sd->sensor_type) {
686 /* The only known sensor_type 0 cam is the Argus DC-1620 */
687 const struct sensor_w_data vga_sensor0_init_data[] = {
688 {0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
689 {0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
690 {0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
691 {0x25, 0x00, {0x03, 0xa9, 0x80}, 3},
692 {0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4},
693 {0, 0, {0}, 0}
694 };
695 err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
696 ARRAY_SIZE(vga_sensor0_init_data));
697 } else { /* sd->sensor_type = 1 */
698 const struct sensor_w_data vga_sensor1_init_data[] = {
699 {0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
700 0x07, 0x00, 0x01}, 8},
701 {0x11, 0x04, {0x01}, 1},
702 /*{0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01, */
703 {0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01,
704 0x00, 0x0a}, 7},
705 {0x11, 0x04, {0x01}, 1},
706 {0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
707 {0x11, 0x04, {0x01}, 1},
708 {0, 0, {0}, 0}
709 };
710 err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
711 ARRAY_SIZE(vga_sensor1_init_data));
712 }
713 if (err_code < 0)
714 return err_code;
715
716 msleep(200);
717 data[0] = 0x00;
718 data[1] = 0x4d; /* ISOC transfering enable... */
719 err_code = mr_write(gspca_dev, 2);
720
721 return err_code;
722 }
723
724 static int sd_start(struct gspca_dev *gspca_dev)
725 {
726 struct sd *sd = (struct sd *) gspca_dev;
727 int err_code;
728 struct cam *cam;
729
730 cam = &gspca_dev->cam;
731 sd->sof_read = 0;
732 /*
733 * Some of the supported cameras require the memory pointer to be
734 * set to 0, or else they will not stream.
735 */
736 zero_the_pointer(gspca_dev);
737 msleep(200);
738 if (sd->cam_type == CAM_TYPE_CIF) {
739 err_code = start_cif_cam(gspca_dev);
740 } else {
741 err_code = start_vga_cam(gspca_dev);
742 }
743 return err_code;
744 }
745
746 static void sd_stopN(struct gspca_dev *gspca_dev)
747 {
748 struct sd *sd = (struct sd *) gspca_dev;
749 int result;
750
751 gspca_dev->usb_buf[0] = 1;
752 gspca_dev->usb_buf[1] = 0;
753 result = mr_write(gspca_dev, 2);
754 if (result < 0)
755 PDEBUG(D_ERR, "Camera Stop failed");
756
757 /* Not all the cams need this, but even if not, probably a good idea */
758 zero_the_pointer(gspca_dev);
759 if (sd->do_lcd_stop) {
760 gspca_dev->usb_buf[0] = 0x19;
761 gspca_dev->usb_buf[1] = 0x54;
762 result = mr_write(gspca_dev, 2);
763 if (result < 0)
764 PDEBUG(D_ERR, "Camera Stop failed");
765 }
766 }
767
768 static void setbrightness(struct gspca_dev *gspca_dev)
769 {
770 struct sd *sd = (struct sd *) gspca_dev;
771 u8 val;
772
773 if (gspca_dev->ctrl_dis & (1 << BRIGHTNESS_IDX))
774 return;
775
776 /* Note register 7 is also seen as 0x8x or 0xCx in dumps */
777 if (sd->brightness > 0) {
778 sensor_write1(gspca_dev, 7, 0x00);
779 val = sd->brightness;
780 } else {
781 sensor_write1(gspca_dev, 7, 0x01);
782 val = 257 - sd->brightness;
783 }
784 sensor_write1(gspca_dev, 8, val);
785 }
786
787 static void setexposure(struct gspca_dev *gspca_dev)
788 {
789 struct sd *sd = (struct sd *) gspca_dev;
790 u8 val;
791
792 if (gspca_dev->ctrl_dis & (1 << EXPOSURE_IDX))
793 return;
794
795 if (sd->sensor_type) {
796 val = sd->exposure >> 4;
797 sensor_write1(gspca_dev, 3, val);
798 val = sd->exposure & 0xf;
799 sensor_write1(gspca_dev, 4, val);
800 } else {
801 u8 clockdiv;
802 int exposure;
803
804 /* We have both a clock divider and an exposure register.
805 We first calculate the clock divider, as that determines
806 the maximum exposure and then we calculayte the exposure
807 register setting (which goes from 0 - 511).
808
809 Note our 0 - 4095 exposure is mapped to 0 - 511
810 milliseconds exposure time */
811 clockdiv = (60 * sd->exposure + 7999) / 8000;
812
813 /* Limit framerate to not exceed usb bandwidth */
814 if (clockdiv < 3 && gspca_dev->width >= 320)
815 clockdiv = 3;
816 else if (clockdiv < 2)
817 clockdiv = 2;
818
819 /* Frame exposure time in ms = 1000 * clockdiv / 60 ->
820 exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */
821 exposure = (60 * 511 * sd->exposure) / (8000 * clockdiv);
822 if (exposure > 511)
823 exposure = 511;
824
825 /* exposure register value is reversed! */
826 exposure = 511 - exposure;
827
828 sensor_write1(gspca_dev, 0x02, clockdiv);
829 sensor_write1(gspca_dev, 0x0e, exposure & 0xff);
830 sensor_write1(gspca_dev, 0x0f, exposure >> 8);
831 }
832 }
833
834 static void setgain(struct gspca_dev *gspca_dev)
835 {
836 struct sd *sd = (struct sd *) gspca_dev;
837
838 if (gspca_dev->ctrl_dis & (1 << GAIN_IDX))
839 return;
840
841 if (sd->sensor_type) {
842 sensor_write1(gspca_dev, 0x0e, sd->gain);
843 } else {
844 sensor_write1(gspca_dev, 0x10, sd->gain);
845 }
846 }
847
848 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
849 {
850 struct sd *sd = (struct sd *) gspca_dev;
851
852 sd->brightness = val;
853 if (gspca_dev->streaming)
854 setbrightness(gspca_dev);
855 return 0;
856 }
857
858 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
859 {
860 struct sd *sd = (struct sd *) gspca_dev;
861
862 *val = sd->brightness;
863 return 0;
864 }
865
866 static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
867 {
868 struct sd *sd = (struct sd *) gspca_dev;
869
870 sd->exposure = val;
871 if (gspca_dev->streaming)
872 setexposure(gspca_dev);
873 return 0;
874 }
875
876 static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
877 {
878 struct sd *sd = (struct sd *) gspca_dev;
879
880 *val = sd->exposure;
881 return 0;
882 }
883
884 static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
885 {
886 struct sd *sd = (struct sd *) gspca_dev;
887
888 sd->gain = val;
889 if (gspca_dev->streaming)
890 setgain(gspca_dev);
891 return 0;
892 }
893
894 static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
895 {
896 struct sd *sd = (struct sd *) gspca_dev;
897
898 *val = sd->gain;
899 return 0;
900 }
901
902 /* Include pac common sof detection functions */
903 #include "pac_common.h"
904
905 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
906 struct gspca_frame *frame, /* target */
907 __u8 *data, /* isoc packet */
908 int len) /* iso packet length */
909 {
910 unsigned char *sof;
911
912 sof = pac_find_sof(gspca_dev, data, len);
913 if (sof) {
914 int n;
915
916 /* finish decoding current frame */
917 n = sof - data;
918 if (n > sizeof pac_sof_marker)
919 n -= sizeof pac_sof_marker;
920 else
921 n = 0;
922 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
923 data, n);
924 /* Start next frame. */
925 gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
926 pac_sof_marker, sizeof pac_sof_marker);
927 len -= sof - data;
928 data = sof;
929 }
930 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
931 }
932
933 /* sub-driver description */
934 static const struct sd_desc sd_desc = {
935 .name = MODULE_NAME,
936 .ctrls = sd_ctrls,
937 .nctrls = ARRAY_SIZE(sd_ctrls),
938 .config = sd_config,
939 .init = sd_init,
940 .start = sd_start,
941 .stopN = sd_stopN,
942 .pkt_scan = sd_pkt_scan,
943 };
944
945 /* -- module initialisation -- */
946 static const __devinitdata struct usb_device_id device_table[] = {
947 {USB_DEVICE(0x08ca, 0x0111)}, /* Aiptek Pencam VGA+ */
948 {USB_DEVICE(0x093a, 0x010f)}, /* All other known MR97310A VGA cams */
949 {USB_DEVICE(0x093a, 0x010e)}, /* All known MR97310A CIF cams */
950 {}
951 };
952 MODULE_DEVICE_TABLE(usb, device_table);
953
954 /* -- device connect -- */
955 static int sd_probe(struct usb_interface *intf,
956 const struct usb_device_id *id)
957 {
958 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
959 THIS_MODULE);
960 }
961
962 static struct usb_driver sd_driver = {
963 .name = MODULE_NAME,
964 .id_table = device_table,
965 .probe = sd_probe,
966 .disconnect = gspca_disconnect,
967 #ifdef CONFIG_PM
968 .suspend = gspca_suspend,
969 .resume = gspca_resume,
970 #endif
971 };
972
973 /* -- module insert / remove -- */
974 static int __init sd_mod_init(void)
975 {
976 int ret;
977
978 ret = usb_register(&sd_driver);
979 if (ret < 0)
980 return ret;
981 PDEBUG(D_PROBE, "registered");
982 return 0;
983 }
984 static void __exit sd_mod_exit(void)
985 {
986 usb_deregister(&sd_driver);
987 PDEBUG(D_PROBE, "deregistered");
988 }
989
990 module_init(sd_mod_init);
991 module_exit(sd_mod_exit);
Linux ARM platform port for MOXA ART SoC