Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/media/usb/gspca/mr97310a.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us