drivers/media/video/gspca/mars.c

   1 /*
   2  *              Mars-Semi MR97311A library
   3  *              Copyright (C) 2005 <bradlch@hotmail.com>
   4  *
   5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21
  22 #define MODULE_NAME "mars"
  23
  24 #include "gspca.h"
  25 #define QUANT_VAL 1             /* quantization table */
  26 #include "jpeg.h"
  27
  28 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  29 MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
  30 MODULE_LICENSE("GPL");
  31
  32 /* specific webcam descriptor */
  33 struct sd {
  34         struct gspca_dev gspca_dev;     /* !! must be the first item */
  35 };
  36
  37 /* V4L2 controls supported by the driver */
  38 static struct ctrl sd_ctrls[] = {
  39 };
  40
  41 static const struct v4l2_pix_format vga_mode[] = {
  42         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  43                 .bytesperline = 320,
  44                 .sizeimage = 320 * 240 * 3 / 8 + 589,
  45                 .colorspace = V4L2_COLORSPACE_JPEG,
  46                 .priv = 2},
  47         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  48                 .bytesperline = 640,
  49                 .sizeimage = 640 * 480 * 3 / 8 + 590,
  50                 .colorspace = V4L2_COLORSPACE_JPEG,
  51                 .priv = 1},
  52 };
  53
  54 /* MI Register table //elvis */
  55 enum {
  56         REG_HW_MI_0,
  57         REG_HW_MI_1,
  58         REG_HW_MI_2,
  59         REG_HW_MI_3,
  60         REG_HW_MI_4,
  61         REG_HW_MI_5,
  62         REG_HW_MI_6,
  63         REG_HW_MI_7,
  64         REG_HW_MI_9 = 0x09,
  65         REG_HW_MI_B = 0x0B,
  66         REG_HW_MI_C,
  67         REG_HW_MI_D,
  68         REG_HW_MI_1E = 0x1E,
  69         REG_HW_MI_20 = 0x20,
  70         REG_HW_MI_2B = 0x2B,
  71         REG_HW_MI_2C,
  72         REG_HW_MI_2D,
  73         REG_HW_MI_2E,
  74         REG_HW_MI_35 = 0x35,
  75         REG_HW_MI_5F = 0x5f,
  76         REG_HW_MI_60,
  77         REG_HW_MI_61,
  78         REG_HW_MI_62,
  79         REG_HW_MI_63,
  80         REG_HW_MI_64,
  81         REG_HW_MI_F1 = 0xf1,
  82         ATTR_TOTAL_MI_REG = 0xf2
  83 };
  84
  85 /* the bytes to write are in gspca_dev->usb_buf */
  86 static int reg_w(struct gspca_dev *gspca_dev,
  87                  __u16 index, int len)
  88 {
  89         int rc;
  90
  91         rc = usb_control_msg(gspca_dev->dev,
  92                          usb_sndbulkpipe(gspca_dev->dev, 4),
  93                          0x12,
  94                          0xc8,          /* ?? */
  95                          0,             /* value */
  96                          index, gspca_dev->usb_buf, len, 500);
  97         if (rc < 0)
  98                 PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc);
  99         return rc;
 100 }
 101
 102 static void bulk_w(struct gspca_dev *gspca_dev,
 103                    __u16 *pch,
 104                    __u16 Address)
 105 {
 106         gspca_dev->usb_buf[0] = 0x1f;
 107         gspca_dev->usb_buf[1] = 0;                      /* control byte */
 108         gspca_dev->usb_buf[2] = Address;
 109         gspca_dev->usb_buf[3] = *pch >> 8;              /* high byte */
 110         gspca_dev->usb_buf[4] = *pch;                   /* low byte */
 111
 112         reg_w(gspca_dev, Address, 5);
 113 }
 114
 115 /* this function is called at probe time */
 116 static int sd_config(struct gspca_dev *gspca_dev,
 117                         const struct usb_device_id *id)
 118 {
 119         struct cam *cam;
 120
 121         cam = &gspca_dev->cam;
 122         cam->cam_mode = vga_mode;
 123         cam->nmodes = ARRAY_SIZE(vga_mode);
 124         return 0;
 125 }
 126
 127 /* this function is called at probe and resume time */
 128 static int sd_init(struct gspca_dev *gspca_dev)
 129 {
 130         return 0;
 131 }
 132
 133 static int sd_start(struct gspca_dev *gspca_dev)
 134 {
 135         int err_code;
 136         __u8 *data;
 137         __u16 *MI_buf;
 138         int h_size, v_size;
 139         int intpipe;
 140
 141         PDEBUG(D_STREAM, "camera start, iface %d, alt 8", gspca_dev->iface);
 142         err_code = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 8);
 143         if (err_code < 0) {
 144                 PDEBUG(D_ERR|D_STREAM, "Set packet size: set interface error");
 145                 return err_code;
 146         }
 147
 148         data = gspca_dev->usb_buf;
 149         data[0] = 0x01;         /* address */
 150         data[1] = 0x01;
 151
 152         err_code = reg_w(gspca_dev, data[0], 2);
 153         if (err_code < 0)
 154                 return err_code;
 155
 156         /*
 157            Initialize the MR97113 chip register
 158          */
 159         data[0] = 0x00;         /* address */
 160         data[1] = 0x0c | 0x01;  /* reg 0 */
 161         data[2] = 0x01;         /* reg 1 */
 162         h_size = gspca_dev->width;
 163         v_size = gspca_dev->height;
 164         data[3] = h_size / 8;   /* h_size , reg 2 */
 165         data[4] = v_size / 8;   /* v_size , reg 3 */
 166         data[5] = 0x30;         /* reg 4, MI, PAS5101 :
 167                                  *      0x30 for 24mhz , 0x28 for 12mhz */
 168         data[6] = 4;            /* reg 5, H start */
 169         data[7] = 0xc0;         /* reg 6, gamma 1.5 */
 170         data[8] = 3;            /* reg 7, V start */
 171 /*      if (h_size == 320 ) */
 172 /*              data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
 173 /*      else */
 174         data[9] = 0x52;         /* reg 8, 24MHz, no scale down */
 175         data[10] = 0x5d;        /* reg 9, I2C device address
 176                                  *      [for PAS5101 (0x40)] [for MI (0x5d)] */
 177
 178         err_code = reg_w(gspca_dev, data[0], 11);
 179         if (err_code < 0)
 180                 return err_code;
 181
 182         data[0] = 0x23;         /* address */
 183         data[1] = 0x09;         /* reg 35, append frame header */
 184
 185         err_code = reg_w(gspca_dev, data[0], 2);
 186         if (err_code < 0)
 187                 return err_code;
 188
 189         data[0] = 0x3c;         /* address */
 190 /*      if (gspca_dev->width == 1280) */
 191 /*              data[1] = 200;   * reg 60, pc-cam frame size
 192                                  *      (unit: 4KB) 800KB */
 193 /*      else */
 194         data[1] = 50;           /* 50 reg 60, pc-cam frame size
 195                                  *      (unit: 4KB) 200KB */
 196         err_code = reg_w(gspca_dev, data[0], 2);
 197         if (err_code < 0)
 198                 return err_code;
 199
 200         if (0) {                        /* fixed dark-gain */
 201                 data[1] = 0;            /* reg 94, Y Gain (1.75) */
 202                 data[2] = 0;            /* reg 95, UV Gain (1.75) */
 203                 data[3] = 0x3f;         /* reg 96, Y Gain/UV Gain/disable
 204                                          *      auto dark-gain */
 205                 data[4] = 0;            /* reg 97, set fixed dark level */
 206                 data[5] = 0;            /* reg 98, don't care */
 207         } else {                        /* auto dark-gain */
 208                 data[1] = 0;            /* reg 94, Y Gain (auto) */
 209                 data[2] = 0;            /* reg 95, UV Gain (1.75) */
 210                 data[3] = 0x78;         /* reg 96, Y Gain/UV Gain/disable
 211                                          *      auto dark-gain */
 212                 switch (gspca_dev->width) {
 213 /*              case 1280: */
 214 /*                      data[4] = 154;
 215                                  * reg 97, %3 shadow point (unit: 256 pixel) */
 216 /*                      data[5] = 51;
 217                                  * reg 98, %1 highlight point
 218                                  *      (uint: 256 pixel) */
 219 /*                      break; */
 220                 default:
 221 /*              case 640: */
 222                         data[4] = 36;   /* reg 97, %3 shadow point
 223                                          *      (unit: 256 pixel) */
 224                         data[5] = 12;   /* reg 98, %1 highlight point
 225                                          *      (uint: 256 pixel) */
 226                         break;
 227                 case 320:
 228                         data[4] = 9;    /* reg 97, %3 shadow point
 229                                          *      (unit: 256 pixel) */
 230                         data[5] = 3;    /* reg 98, %1 highlight point
 231                                          *      (uint: 256 pixel) */
 232                         break;
 233                 }
 234         }
 235         /* auto dark-gain */
 236         data[0] = 0x5e;         /* address */
 237
 238         err_code = reg_w(gspca_dev, data[0], 6);
 239         if (err_code < 0)
 240                 return err_code;
 241
 242         data[0] = 0x67;
 243         data[1] = 0x13;         /* reg 103, first pixel B, disable sharpness */
 244         err_code = reg_w(gspca_dev, data[0], 2);
 245         if (err_code < 0)
 246                 return err_code;
 247
 248         /*
 249          * initialize the value of MI sensor...
 250          */
 251         MI_buf = kzalloc(ATTR_TOTAL_MI_REG * sizeof *MI_buf, GFP_KERNEL);
 252         MI_buf[REG_HW_MI_1] = 0x000a;
 253         MI_buf[REG_HW_MI_2] = 0x000c;
 254         MI_buf[REG_HW_MI_3] = 0x0405;
 255         MI_buf[REG_HW_MI_4] = 0x0507;
 256         /* mi_Attr_Reg_[REG_HW_MI_5]     = 0x01ff;//13 */
 257         MI_buf[REG_HW_MI_5] = 0x0013;   /* 13 */
 258         MI_buf[REG_HW_MI_6] = 0x001f;   /* vertical blanking */
 259         /* mi_Attr_Reg_[REG_HW_MI_6]     = 0x0400;  // vertical blanking */
 260         MI_buf[REG_HW_MI_7] = 0x0002;
 261         /* mi_Attr_Reg_[REG_HW_MI_9]     = 0x015f; */
 262         /* mi_Attr_Reg_[REG_HW_MI_9]     = 0x030f; */
 263         MI_buf[REG_HW_MI_9] = 0x0374;
 264         MI_buf[REG_HW_MI_B] = 0x0000;
 265         MI_buf[REG_HW_MI_C] = 0x0000;
 266         MI_buf[REG_HW_MI_D] = 0x0000;
 267         MI_buf[REG_HW_MI_1E] = 0x8000;
 268 /* mi_Attr_Reg_[REG_HW_MI_20]     = 0x1104; */
 269         MI_buf[REG_HW_MI_20] = 0x1104;  /* 0x111c; */
 270         MI_buf[REG_HW_MI_2B] = 0x0008;
 271 /* mi_Attr_Reg_[REG_HW_MI_2C]     = 0x000f; */
 272         MI_buf[REG_HW_MI_2C] = 0x001f;  /* lita suggest */
 273         MI_buf[REG_HW_MI_2D] = 0x0008;
 274         MI_buf[REG_HW_MI_2E] = 0x0008;
 275         MI_buf[REG_HW_MI_35] = 0x0051;
 276         MI_buf[REG_HW_MI_5F] = 0x0904;  /* fail to write */
 277         MI_buf[REG_HW_MI_60] = 0x0000;
 278         MI_buf[REG_HW_MI_61] = 0x0000;
 279         MI_buf[REG_HW_MI_62] = 0x0498;
 280         MI_buf[REG_HW_MI_63] = 0x0000;
 281         MI_buf[REG_HW_MI_64] = 0x0000;
 282         MI_buf[REG_HW_MI_F1] = 0x0001;
 283         /* changing while setting up the different value of dx/dy */
 284
 285         if (gspca_dev->width != 1280) {
 286                 MI_buf[0x01] = 0x010a;
 287                 MI_buf[0x02] = 0x014c;
 288                 MI_buf[0x03] = 0x01e5;
 289                 MI_buf[0x04] = 0x0287;
 290         }
 291         MI_buf[0x20] = 0x1104;
 292
 293         bulk_w(gspca_dev, MI_buf + 1, 1);
 294         bulk_w(gspca_dev, MI_buf + 2, 2);
 295         bulk_w(gspca_dev, MI_buf + 3, 3);
 296         bulk_w(gspca_dev, MI_buf + 4, 4);
 297         bulk_w(gspca_dev, MI_buf + 5, 5);
 298         bulk_w(gspca_dev, MI_buf + 6, 6);
 299         bulk_w(gspca_dev, MI_buf + 7, 7);
 300         bulk_w(gspca_dev, MI_buf + 9, 9);
 301         bulk_w(gspca_dev, MI_buf + 0x0b, 0x0b);
 302         bulk_w(gspca_dev, MI_buf + 0x0c, 0x0c);
 303         bulk_w(gspca_dev, MI_buf + 0x0d, 0x0d);
 304         bulk_w(gspca_dev, MI_buf + 0x1e, 0x1e);
 305         bulk_w(gspca_dev, MI_buf + 0x20, 0x20);
 306         bulk_w(gspca_dev, MI_buf + 0x2b, 0x2b);
 307         bulk_w(gspca_dev, MI_buf + 0x2c, 0x2c);
 308         bulk_w(gspca_dev, MI_buf + 0x2d, 0x2d);
 309         bulk_w(gspca_dev, MI_buf + 0x2e, 0x2e);
 310         bulk_w(gspca_dev, MI_buf + 0x35, 0x35);
 311         bulk_w(gspca_dev, MI_buf + 0x5f, 0x5f);
 312         bulk_w(gspca_dev, MI_buf + 0x60, 0x60);
 313         bulk_w(gspca_dev, MI_buf + 0x61, 0x61);
 314         bulk_w(gspca_dev, MI_buf + 0x62, 0x62);
 315         bulk_w(gspca_dev, MI_buf + 0x63, 0x63);
 316         bulk_w(gspca_dev, MI_buf + 0x64, 0x64);
 317         bulk_w(gspca_dev, MI_buf + 0xf1, 0xf1);
 318         kfree(MI_buf);
 319
 320         intpipe = usb_sndintpipe(gspca_dev->dev, 0);
 321         err_code = usb_clear_halt(gspca_dev->dev, intpipe);
 322
 323         data[0] = 0x00;
 324         data[1] = 0x4d;         /* ISOC transfering enable... */
 325         reg_w(gspca_dev, data[0], 2);
 326         return err_code;
 327 }
 328
 329 static void sd_stopN(struct gspca_dev *gspca_dev)
 330 {
 331         int result;
 332
 333         gspca_dev->usb_buf[0] = 1;
 334         gspca_dev->usb_buf[1] = 0;
 335         result = reg_w(gspca_dev, gspca_dev->usb_buf[0], 2);
 336         if (result < 0)
 337                 PDEBUG(D_ERR, "Camera Stop failed");
 338 }
 339
 340 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 341                         struct gspca_frame *frame,      /* target */
 342                         __u8 *data,                     /* isoc packet */
 343                         int len)                        /* iso packet length */
 344 {
 345         int p;
 346
 347         if (len < 6) {
 348 /*              gspca_dev->last_packet_type = DISCARD_PACKET; */
 349                 return;
 350         }
 351         for (p = 0; p < len - 6; p++) {
 352                 if (data[0 + p] == 0xff
 353                     && data[1 + p] == 0xff
 354                     && data[2 + p] == 0x00
 355                     && data[3 + p] == 0xff
 356                     && data[4 + p] == 0x96) {
 357                         if (data[5 + p] == 0x64
 358                             || data[5 + p] == 0x65
 359                             || data[5 + p] == 0x66
 360                             || data[5 + p] == 0x67) {
 361                                 PDEBUG(D_PACK, "sof offset: %d leng: %d",
 362                                         p, len);
 363                                 frame = gspca_frame_add(gspca_dev, LAST_PACKET,
 364                                                         frame, data, 0);
 365
 366                                 /* put the JPEG header */
 367                                 jpeg_put_header(gspca_dev, frame, 0x21);
 368                                 data += 16;
 369                                 len -= 16;
 370                                 break;
 371                         }
 372                 }
 373         }
 374         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
 375 }
 376
 377 /* sub-driver description */
 378 static const struct sd_desc sd_desc = {
 379         .name = MODULE_NAME,
 380         .ctrls = sd_ctrls,
 381         .nctrls = ARRAY_SIZE(sd_ctrls),
 382         .config = sd_config,
 383         .init = sd_init,
 384         .start = sd_start,
 385         .stopN = sd_stopN,
 386         .pkt_scan = sd_pkt_scan,
 387 };
 388
 389 /* -- module initialisation -- */
 390 static const __devinitdata struct usb_device_id device_table[] = {
 391         {USB_DEVICE(0x093a, 0x050f)},
 392         {}
 393 };
 394 MODULE_DEVICE_TABLE(usb, device_table);
 395
 396 /* -- device connect -- */
 397 static int sd_probe(struct usb_interface *intf,
 398                         const struct usb_device_id *id)
 399 {
 400         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 401                                 THIS_MODULE);
 402 }
 403
 404 static struct usb_driver sd_driver = {
 405         .name = MODULE_NAME,
 406         .id_table = device_table,
 407         .probe = sd_probe,
 408         .disconnect = gspca_disconnect,
 409 #ifdef CONFIG_PM
 410         .suspend = gspca_suspend,
 411         .resume = gspca_resume,
 412 #endif
 413 };
 414
 415 /* -- module insert / remove -- */
 416 static int __init sd_mod_init(void)
 417 {
 418         int ret;
 419         ret = usb_register(&sd_driver);
 420         if (ret < 0)
 421                 return ret;
 422         PDEBUG(D_PROBE, "registered");
 423         return 0;
 424 }
 425 static void __exit sd_mod_exit(void)
 426 {
 427         usb_deregister(&sd_driver);
 428         PDEBUG(D_PROBE, "deregistered");
 429 }
 430
 431 module_init(sd_mod_init);
 432 module_exit(sd_mod_exit);