drivers/media/usb/gspca/mr97310a.c

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

DEFINITIONS
