kernel/drivers/media/usb/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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #define MODULE_NAME "mars"
  25
  26 #include "gspca.h"
  27 #include "jpeg.h"
  28
  29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
  30 MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
  31 MODULE_LICENSE("GPL");
  32
  33 #define QUALITY 50
  34
  35 /* specific webcam descriptor */
  36 struct sd {
  37         struct gspca_dev gspca_dev;     /* !! must be the first item */
  38
  39         struct v4l2_ctrl *brightness;
  40         struct v4l2_ctrl *saturation;
  41         struct v4l2_ctrl *sharpness;
  42         struct v4l2_ctrl *gamma;
  43         struct { /* illuminator control cluster */
  44                 struct v4l2_ctrl *illum_top;
  45                 struct v4l2_ctrl *illum_bottom;
  46         };
  47         u8 jpeg_hdr[JPEG_HDR_SZ];
  48 };
  49
  50 /* V4L2 controls supported by the driver */
  51 static void setbrightness(struct gspca_dev *gspca_dev, s32 val);
  52 static void setcolors(struct gspca_dev *gspca_dev, s32 val);
  53 static void setgamma(struct gspca_dev *gspca_dev, s32 val);
  54 static void setsharpness(struct gspca_dev *gspca_dev, s32 val);
  55
  56 static const struct v4l2_pix_format vga_mode[] = {
  57         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  58                 .bytesperline = 320,
  59                 .sizeimage = 320 * 240 * 3 / 8 + 590,
  60                 .colorspace = V4L2_COLORSPACE_JPEG,
  61                 .priv = 2},
  62         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  63                 .bytesperline = 640,
  64                 .sizeimage = 640 * 480 * 3 / 8 + 590,
  65                 .colorspace = V4L2_COLORSPACE_JPEG,
  66                 .priv = 1},
  67 };
  68
  69 static const __u8 mi_data[0x20] = {
  70 /*       01    02   03     04    05    06    07    08 */
  71         0x48, 0x22, 0x01, 0x47, 0x10, 0x00, 0x00, 0x00,
  72 /*       09    0a   0b     0c    0d    0e    0f    10 */
  73         0x00, 0x01, 0x30, 0x01, 0x30, 0x01, 0x30, 0x01,
  74 /*       11    12   13     14    15    16    17    18 */
  75         0x30, 0x00, 0x04, 0x00, 0x06, 0x01, 0xe2, 0x02,
  76 /*       19    1a   1b     1c    1d    1e    1f    20 */
  77         0x82, 0x00, 0x20, 0x17, 0x80, 0x08, 0x0c, 0x00
  78 };
  79
  80 /* write <len> bytes from gspca_dev->usb_buf */
  81 static void reg_w(struct gspca_dev *gspca_dev,
  82                  int len)
  83 {
  84         int alen, ret;
  85
  86         if (gspca_dev->usb_err < 0)
  87                 return;
  88
  89         ret = usb_bulk_msg(gspca_dev->dev,
  90                         usb_sndbulkpipe(gspca_dev->dev, 4),
  91                         gspca_dev->usb_buf,
  92                         len,
  93                         &alen,
  94                         500);   /* timeout in milliseconds */
  95         if (ret < 0) {
  96                 pr_err("reg write [%02x] error %d\n",
  97                        gspca_dev->usb_buf[0], ret);
  98                 gspca_dev->usb_err = ret;
  99         }
 100 }
 101
 102 static void mi_w(struct gspca_dev *gspca_dev,
 103                  u8 addr,
 104                  u8 value)
 105 {
 106         gspca_dev->usb_buf[0] = 0x1f;
 107         gspca_dev->usb_buf[1] = 0;                      /* control byte */
 108         gspca_dev->usb_buf[2] = addr;
 109         gspca_dev->usb_buf[3] = value;
 110
 111         reg_w(gspca_dev, 4);
 112 }
 113
 114 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
 115 {
 116         gspca_dev->usb_buf[0] = 0x61;
 117         gspca_dev->usb_buf[1] = val;
 118         reg_w(gspca_dev, 2);
 119 }
 120
 121 static void setcolors(struct gspca_dev *gspca_dev, s32 val)
 122 {
 123         gspca_dev->usb_buf[0] = 0x5f;
 124         gspca_dev->usb_buf[1] = val << 3;
 125         gspca_dev->usb_buf[2] = ((val >> 2) & 0xf8) | 0x04;
 126         reg_w(gspca_dev, 3);
 127 }
 128
 129 static void setgamma(struct gspca_dev *gspca_dev, s32 val)
 130 {
 131         gspca_dev->usb_buf[0] = 0x06;
 132         gspca_dev->usb_buf[1] = val * 0x40;
 133         reg_w(gspca_dev, 2);
 134 }
 135
 136 static void setsharpness(struct gspca_dev *gspca_dev, s32 val)
 137 {
 138         gspca_dev->usb_buf[0] = 0x67;
 139         gspca_dev->usb_buf[1] = val * 4 + 3;
 140         reg_w(gspca_dev, 2);
 141 }
 142
 143 static void setilluminators(struct gspca_dev *gspca_dev, bool top, bool bottom)
 144 {
 145         /* both are off if not streaming */
 146         gspca_dev->usb_buf[0] = 0x22;
 147         if (top)
 148                 gspca_dev->usb_buf[1] = 0x76;
 149         else if (bottom)
 150                 gspca_dev->usb_buf[1] = 0x7a;
 151         else
 152                 gspca_dev->usb_buf[1] = 0x7e;
 153         reg_w(gspca_dev, 2);
 154 }
 155
 156 static int mars_s_ctrl(struct v4l2_ctrl *ctrl)
 157 {
 158         struct gspca_dev *gspca_dev =
 159                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 160         struct sd *sd = (struct sd *)gspca_dev;
 161
 162         gspca_dev->usb_err = 0;
 163
 164         if (ctrl->id == V4L2_CID_ILLUMINATORS_1) {
 165                 /* only one can be on at a time */
 166                 if (ctrl->is_new && ctrl->val)
 167                         sd->illum_bottom->val = 0;
 168                 if (sd->illum_bottom->is_new && sd->illum_bottom->val)
 169                         sd->illum_top->val = 0;
 170         }
 171
 172         if (!gspca_dev->streaming)
 173                 return 0;
 174
 175         switch (ctrl->id) {
 176         case V4L2_CID_BRIGHTNESS:
 177                 setbrightness(gspca_dev, ctrl->val);
 178                 break;
 179         case V4L2_CID_SATURATION:
 180                 setcolors(gspca_dev, ctrl->val);
 181                 break;
 182         case V4L2_CID_GAMMA:
 183                 setgamma(gspca_dev, ctrl->val);
 184                 break;
 185         case V4L2_CID_ILLUMINATORS_1:
 186                 setilluminators(gspca_dev, sd->illum_top->val,
 187                                            sd->illum_bottom->val);
 188                 break;
 189         case V4L2_CID_SHARPNESS:
 190                 setsharpness(gspca_dev, ctrl->val);
 191                 break;
 192         default:
 193                 return -EINVAL;
 194         }
 195         return gspca_dev->usb_err;
 196 }
 197
 198 static const struct v4l2_ctrl_ops mars_ctrl_ops = {
 199         .s_ctrl = mars_s_ctrl,
 200 };
 201
 202 /* this function is called at probe time */
 203 static int sd_init_controls(struct gspca_dev *gspca_dev)
 204 {
 205         struct sd *sd = (struct sd *) gspca_dev;
 206         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 207
 208         gspca_dev->vdev.ctrl_handler = hdl;
 209         v4l2_ctrl_handler_init(hdl, 6);
 210         sd->brightness = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
 211                         V4L2_CID_BRIGHTNESS, 0, 30, 1, 15);
 212         sd->saturation = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
 213                         V4L2_CID_SATURATION, 0, 255, 1, 200);
 214         sd->gamma = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
 215                         V4L2_CID_GAMMA, 0, 3, 1, 1);
 216         sd->sharpness = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
 217                         V4L2_CID_SHARPNESS, 0, 2, 1, 1);
 218         sd->illum_top = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
 219                         V4L2_CID_ILLUMINATORS_1, 0, 1, 1, 0);
 220         sd->illum_top->flags |= V4L2_CTRL_FLAG_UPDATE;
 221         sd->illum_bottom = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
 222                         V4L2_CID_ILLUMINATORS_2, 0, 1, 1, 0);
 223         sd->illum_bottom->flags |= V4L2_CTRL_FLAG_UPDATE;
 224         if (hdl->error) {
 225                 pr_err("Could not initialize controls\n");
 226                 return hdl->error;
 227         }
 228         v4l2_ctrl_cluster(2, &sd->illum_top);
 229         return 0;
 230 }
 231
 232 /* this function is called at probe time */
 233 static int sd_config(struct gspca_dev *gspca_dev,
 234                         const struct usb_device_id *id)
 235 {
 236         struct cam *cam;
 237
 238         cam = &gspca_dev->cam;
 239         cam->cam_mode = vga_mode;
 240         cam->nmodes = ARRAY_SIZE(vga_mode);
 241         return 0;
 242 }
 243
 244 /* this function is called at probe and resume time */
 245 static int sd_init(struct gspca_dev *gspca_dev)
 246 {
 247         return 0;
 248 }
 249
 250 static int sd_start(struct gspca_dev *gspca_dev)
 251 {
 252         struct sd *sd = (struct sd *) gspca_dev;
 253         u8 *data;
 254         int i;
 255
 256         /* create the JPEG header */
 257         jpeg_define(sd->jpeg_hdr, gspca_dev->pixfmt.height,
 258                         gspca_dev->pixfmt.width,
 259                         0x21);          /* JPEG 422 */
 260         jpeg_set_qual(sd->jpeg_hdr, QUALITY);
 261
 262         data = gspca_dev->usb_buf;
 263
 264         data[0] = 0x01;         /* address */
 265         data[1] = 0x01;
 266         reg_w(gspca_dev, 2);
 267
 268         /*
 269            Initialize the MR97113 chip register
 270          */
 271         data[0] = 0x00;         /* address */
 272         data[1] = 0x0c | 0x01;  /* reg 0 */
 273         data[2] = 0x01;         /* reg 1 */
 274         data[3] = gspca_dev->pixfmt.width / 8;  /* h_size , reg 2 */
 275         data[4] = gspca_dev->pixfmt.height / 8; /* v_size , reg 3 */
 276         data[5] = 0x30;         /* reg 4, MI, PAS5101 :
 277                                  *      0x30 for 24mhz , 0x28 for 12mhz */
 278         data[6] = 0x02;         /* reg 5, H start - was 0x04 */
 279         data[7] = v4l2_ctrl_g_ctrl(sd->gamma) * 0x40;   /* reg 0x06: gamma */
 280         data[8] = 0x01;         /* reg 7, V start - was 0x03 */
 281 /*      if (h_size == 320 ) */
 282 /*              data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
 283 /*      else */
 284         data[9] = 0x52;         /* reg 8, 24MHz, no scale down */
 285 /*jfm: from win trace*/
 286         data[10] = 0x18;
 287
 288         reg_w(gspca_dev, 11);
 289
 290         data[0] = 0x23;         /* address */
 291         data[1] = 0x09;         /* reg 35, append frame header */
 292
 293         reg_w(gspca_dev, 2);
 294
 295         data[0] = 0x3c;         /* address */
 296 /*      if (gspca_dev->width == 1280) */
 297 /*              data[1] = 200;   * reg 60, pc-cam frame size
 298                                  *      (unit: 4KB) 800KB */
 299 /*      else */
 300         data[1] = 50;           /* 50 reg 60, pc-cam frame size
 301                                  *      (unit: 4KB) 200KB */
 302         reg_w(gspca_dev, 2);
 303
 304         /* auto dark-gain */
 305         data[0] = 0x5e;         /* address */
 306         data[1] = 0;            /* reg 94, Y Gain (auto) */
 307 /*jfm: from win trace*/
 308                                 /* reg 0x5f/0x60 (LE) = saturation */
 309                                 /* h (60): xxxx x100
 310                                  * l (5f): xxxx x000 */
 311         data[2] = v4l2_ctrl_g_ctrl(sd->saturation) << 3;
 312         data[3] = ((v4l2_ctrl_g_ctrl(sd->saturation) >> 2) & 0xf8) | 0x04;
 313         data[4] = v4l2_ctrl_g_ctrl(sd->brightness); /* reg 0x61 = brightness */
 314         data[5] = 0x00;
 315
 316         reg_w(gspca_dev, 6);
 317
 318         data[0] = 0x67;
 319 /*jfm: from win trace*/
 320         data[1] = v4l2_ctrl_g_ctrl(sd->sharpness) * 4 + 3;
 321         data[2] = 0x14;
 322         reg_w(gspca_dev, 3);
 323
 324         data[0] = 0x69;
 325         data[1] = 0x2f;
 326         data[2] = 0x28;
 327         data[3] = 0x42;
 328         reg_w(gspca_dev, 4);
 329
 330         data[0] = 0x63;
 331         data[1] = 0x07;
 332         reg_w(gspca_dev, 2);
 333 /*jfm: win trace - many writes here to reg 0x64*/
 334
 335         /* initialize the MI sensor */
 336         for (i = 0; i < sizeof mi_data; i++)
 337                 mi_w(gspca_dev, i + 1, mi_data[i]);
 338
 339         data[0] = 0x00;
 340         data[1] = 0x4d;         /* ISOC transferring enable... */
 341         reg_w(gspca_dev, 2);
 342
 343         setilluminators(gspca_dev, v4l2_ctrl_g_ctrl(sd->illum_top),
 344                                    v4l2_ctrl_g_ctrl(sd->illum_bottom));
 345
 346         return gspca_dev->usb_err;
 347 }
 348
 349 static void sd_stopN(struct gspca_dev *gspca_dev)
 350 {
 351         struct sd *sd = (struct sd *) gspca_dev;
 352
 353         if (v4l2_ctrl_g_ctrl(sd->illum_top) ||
 354             v4l2_ctrl_g_ctrl(sd->illum_bottom)) {
 355                 setilluminators(gspca_dev, false, false);
 356                 msleep(20);
 357         }
 358
 359         gspca_dev->usb_buf[0] = 1;
 360         gspca_dev->usb_buf[1] = 0;
 361         reg_w(gspca_dev, 2);
 362 }
 363
 364 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 365                         u8 *data,                       /* isoc packet */
 366                         int len)                        /* iso packet length */
 367 {
 368         struct sd *sd = (struct sd *) gspca_dev;
 369         int p;
 370
 371         if (len < 6) {
 372 /*              gspca_dev->last_packet_type = DISCARD_PACKET; */
 373                 return;
 374         }
 375         for (p = 0; p < len - 6; p++) {
 376                 if (data[0 + p] == 0xff
 377                     && data[1 + p] == 0xff
 378                     && data[2 + p] == 0x00
 379                     && data[3 + p] == 0xff
 380                     && data[4 + p] == 0x96) {
 381                         if (data[5 + p] == 0x64
 382                             || data[5 + p] == 0x65
 383                             || data[5 + p] == 0x66
 384                             || data[5 + p] == 0x67) {
 385                                 PDEBUG(D_PACK, "sof offset: %d len: %d",
 386                                         p, len);
 387                                 gspca_frame_add(gspca_dev, LAST_PACKET,
 388                                                 data, p);
 389
 390                                 /* put the JPEG header */
 391                                 gspca_frame_add(gspca_dev, FIRST_PACKET,
 392                                         sd->jpeg_hdr, JPEG_HDR_SZ);
 393                                 data += p + 16;
 394                                 len -= p + 16;
 395                                 break;
 396                         }
 397                 }
 398         }
 399         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 400 }
 401
 402 /* sub-driver description */
 403 static const struct sd_desc sd_desc = {
 404         .name = MODULE_NAME,
 405         .config = sd_config,
 406         .init = sd_init,
 407         .init_controls = sd_init_controls,
 408         .start = sd_start,
 409         .stopN = sd_stopN,
 410         .pkt_scan = sd_pkt_scan,
 411 };
 412
 413 /* -- module initialisation -- */
 414 static const struct usb_device_id device_table[] = {
 415         {USB_DEVICE(0x093a, 0x050f)},
 416         {}
 417 };
 418 MODULE_DEVICE_TABLE(usb, device_table);
 419
 420 /* -- device connect -- */
 421 static int sd_probe(struct usb_interface *intf,
 422                         const struct usb_device_id *id)
 423 {
 424         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 425                                 THIS_MODULE);
 426 }
 427
 428 static struct usb_driver sd_driver = {
 429         .name = MODULE_NAME,
 430         .id_table = device_table,
 431         .probe = sd_probe,
 432         .disconnect = gspca_disconnect,
 433 #ifdef CONFIG_PM
 434         .suspend = gspca_suspend,
 435         .resume = gspca_resume,
 436         .reset_resume = gspca_resume,
 437 #endif
 438 };
 439
 440 module_usb_driver(sd_driver);