drivers/media/usb/gspca/stk1135.c

   1 /*
   2  * Syntek STK1135 subdriver
   3  *
   4  * Copyright (c) 2013 Ondrej Zary
   5  *
   6  * Based on Syntekdriver (stk11xx) by Nicolas VIVIEN:
   7  *   http://syntekdriver.sourceforge.net
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26 #define MODULE_NAME "stk1135"
  27
  28 #include "gspca.h"
  29 #include "stk1135.h"
  30
  31 MODULE_AUTHOR("Ondrej Zary");
  32 MODULE_DESCRIPTION("Syntek STK1135 USB Camera Driver");
  33 MODULE_LICENSE("GPL");
  34
  35
  36 /* specific webcam descriptor */
  37 struct sd {
  38         struct gspca_dev gspca_dev;     /* !! must be the first item */
  39
  40         u8 pkt_seq;
  41         u8 sensor_page;
  42
  43         bool flip_status;
  44         u8 flip_debounce;
  45
  46         struct v4l2_ctrl *hflip;
  47         struct v4l2_ctrl *vflip;
  48 };
  49
  50 static const struct v4l2_pix_format stk1135_modes[] = {
  51         {160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  52                 .bytesperline = 160,
  53                 .sizeimage = 160 * 120,
  54                 .colorspace = V4L2_COLORSPACE_SRGB},
  55         {176, 144, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  56                 .bytesperline = 176,
  57                 .sizeimage = 176 * 144,
  58                 .colorspace = V4L2_COLORSPACE_SRGB},
  59         {320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  60                 .bytesperline = 320,
  61                 .sizeimage = 320 * 240,
  62                 .colorspace = V4L2_COLORSPACE_SRGB},
  63         {352, 288, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  64                 .bytesperline = 352,
  65                 .sizeimage = 352 * 288,
  66                 .colorspace = V4L2_COLORSPACE_SRGB},
  67         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  68                 .bytesperline = 640,
  69                 .sizeimage = 640 * 480,
  70                 .colorspace = V4L2_COLORSPACE_SRGB},
  71         {720, 576, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  72                 .bytesperline = 720,
  73                 .sizeimage = 720 * 576,
  74                 .colorspace = V4L2_COLORSPACE_SRGB},
  75         {800, 600, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  76                 .bytesperline = 800,
  77                 .sizeimage = 800 * 600,
  78                 .colorspace = V4L2_COLORSPACE_SRGB},
  79         {1024, 768, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  80                 .bytesperline = 1024,
  81                 .sizeimage = 1024 * 768,
  82                 .colorspace = V4L2_COLORSPACE_SRGB},
  83         {1280, 1024, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
  84                 .bytesperline = 1280,
  85                 .sizeimage = 1280 * 1024,
  86                 .colorspace = V4L2_COLORSPACE_SRGB},
  87 };
  88
  89 /* -- read a register -- */
  90 static u8 reg_r(struct gspca_dev *gspca_dev, u16 index)
  91 {
  92         struct usb_device *dev = gspca_dev->dev;
  93         int ret;
  94
  95         if (gspca_dev->usb_err < 0)
  96                 return 0;
  97         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  98                         0x00,
  99                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 100                         0x00,
 101                         index,
 102                         gspca_dev->usb_buf, 1,
 103                         500);
 104
 105         PDEBUG(D_USBI, "reg_r 0x%x=0x%02x", index, gspca_dev->usb_buf[0]);
 106         if (ret < 0) {
 107                 pr_err("reg_r 0x%x err %d\n", index, ret);
 108                 gspca_dev->usb_err = ret;
 109                 return 0;
 110         }
 111
 112         return gspca_dev->usb_buf[0];
 113 }
 114
 115 /* -- write a register -- */
 116 static void reg_w(struct gspca_dev *gspca_dev, u16 index, u8 val)
 117 {
 118         int ret;
 119         struct usb_device *dev = gspca_dev->dev;
 120
 121         if (gspca_dev->usb_err < 0)
 122                 return;
 123         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 124                         0x01,
 125                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 126                         val,
 127                         index,
 128                         NULL,
 129                         0,
 130                         500);
 131         PDEBUG(D_USBO, "reg_w 0x%x:=0x%02x", index, val);
 132         if (ret < 0) {
 133                 pr_err("reg_w 0x%x err %d\n", index, ret);
 134                 gspca_dev->usb_err = ret;
 135         }
 136 }
 137
 138 static void reg_w_mask(struct gspca_dev *gspca_dev, u16 index, u8 val, u8 mask)
 139 {
 140         val = (reg_r(gspca_dev, index) & ~mask) | (val & mask);
 141         reg_w(gspca_dev, index, val);
 142 }
 143
 144 /* this function is called at probe time */
 145 static int sd_config(struct gspca_dev *gspca_dev,
 146                         const struct usb_device_id *id)
 147 {
 148         gspca_dev->cam.cam_mode = stk1135_modes;
 149         gspca_dev->cam.nmodes = ARRAY_SIZE(stk1135_modes);
 150         return 0;
 151 }
 152
 153 static int stk1135_serial_wait_ready(struct gspca_dev *gspca_dev)
 154 {
 155         int i = 0;
 156         u8 val;
 157
 158         do {
 159                 val = reg_r(gspca_dev, STK1135_REG_SICTL + 1);
 160                 if (i++ > 500) { /* maximum retry count */
 161                         pr_err("serial bus timeout: status=0x%02x\n", val);
 162                         return -1;
 163                 }
 164         /* repeat if BUSY or WRITE/READ not finished */
 165         } while ((val & 0x10) || !(val & 0x05));
 166
 167         return 0;
 168 }
 169
 170 static u8 sensor_read_8(struct gspca_dev *gspca_dev, u8 addr)
 171 {
 172         reg_w(gspca_dev, STK1135_REG_SBUSR, addr);
 173         /* begin read */
 174         reg_w(gspca_dev, STK1135_REG_SICTL, 0x20);
 175         /* wait until finished */
 176         if (stk1135_serial_wait_ready(gspca_dev)) {
 177                 pr_err("Sensor read failed\n");
 178                 return 0;
 179         }
 180
 181         return reg_r(gspca_dev, STK1135_REG_SBUSR + 1);
 182 }
 183
 184 static u16 sensor_read_16(struct gspca_dev *gspca_dev, u8 addr)
 185 {
 186         return (sensor_read_8(gspca_dev, addr) << 8) |
 187                 sensor_read_8(gspca_dev, 0xf1);
 188 }
 189
 190 static void sensor_write_8(struct gspca_dev *gspca_dev, u8 addr, u8 data)
 191 {
 192         /* load address and data registers */
 193         reg_w(gspca_dev, STK1135_REG_SBUSW, addr);
 194         reg_w(gspca_dev, STK1135_REG_SBUSW + 1, data);
 195         /* begin write */
 196         reg_w(gspca_dev, STK1135_REG_SICTL, 0x01);
 197         /* wait until finished */
 198         if (stk1135_serial_wait_ready(gspca_dev)) {
 199                 pr_err("Sensor write failed\n");
 200                 return;
 201         }
 202 }
 203
 204 static void sensor_write_16(struct gspca_dev *gspca_dev, u8 addr, u16 data)
 205 {
 206         sensor_write_8(gspca_dev, addr, data >> 8);
 207         sensor_write_8(gspca_dev, 0xf1, data & 0xff);
 208 }
 209
 210 static void sensor_set_page(struct gspca_dev *gspca_dev, u8 page)
 211 {
 212         struct sd *sd = (struct sd *) gspca_dev;
 213
 214         if (page != sd->sensor_page) {
 215                 sensor_write_16(gspca_dev, 0xf0, page);
 216                 sd->sensor_page = page;
 217         }
 218 }
 219
 220 static u16 sensor_read(struct gspca_dev *gspca_dev, u16 reg)
 221 {
 222         sensor_set_page(gspca_dev, reg >> 8);
 223         return sensor_read_16(gspca_dev, reg & 0xff);
 224 }
 225
 226 static void sensor_write(struct gspca_dev *gspca_dev, u16 reg, u16 val)
 227 {
 228         sensor_set_page(gspca_dev, reg >> 8);
 229         sensor_write_16(gspca_dev, reg & 0xff, val);
 230 }
 231
 232 static void sensor_write_mask(struct gspca_dev *gspca_dev,
 233                         u16 reg, u16 val, u16 mask)
 234 {
 235         val = (sensor_read(gspca_dev, reg) & ~mask) | (val & mask);
 236         sensor_write(gspca_dev, reg, val);
 237 }
 238
 239 struct sensor_val {
 240         u16 reg;
 241         u16 val;
 242 };
 243
 244 /* configure MT9M112 sensor */
 245 static void stk1135_configure_mt9m112(struct gspca_dev *gspca_dev)
 246 {
 247         static const struct sensor_val cfg[] = {
 248                 /* restart&reset, chip enable, reserved */
 249                 { 0x00d, 0x000b }, { 0x00d, 0x0008 }, { 0x035, 0x0022 },
 250                 /* mode ctl: AWB on, AE both, clip aper corr, defect corr, AE */
 251                 { 0x106, 0x700e },
 252
 253                 { 0x2dd, 0x18e0 }, /* B-R thresholds, */
 254
 255                 /* AWB */
 256                 { 0x21f, 0x0180 }, /* Cb and Cr limits */
 257                 { 0x220, 0xc814 }, { 0x221, 0x8080 }, /* lum limits, RGB gain */
 258                 { 0x222, 0xa078 }, { 0x223, 0xa078 }, /* R, B limit */
 259                 { 0x224, 0x5f20 }, { 0x228, 0xea02 }, /* mtx adj lim, adv ctl */
 260                 { 0x229, 0x867a }, /* wide gates */
 261
 262                 /* Color correction */
 263                 /* imager gains base, delta, delta signs */
 264                 { 0x25e, 0x594c }, { 0x25f, 0x4d51 }, { 0x260, 0x0002 },
 265                 /* AWB adv ctl 2, gain offs */
 266                 { 0x2ef, 0x0008 }, { 0x2f2, 0x0000 },
 267                 /* base matrix signs, scale K1-5, K6-9 */
 268                 { 0x202, 0x00ee }, { 0x203, 0x3923 }, { 0x204, 0x0724 },
 269                 /* base matrix coef */
 270                 { 0x209, 0x00cd }, { 0x20a, 0x0093 }, { 0x20b, 0x0004 },/*K1-3*/
 271                 { 0x20c, 0x005c }, { 0x20d, 0x00d9 }, { 0x20e, 0x0053 },/*K4-6*/
 272                 { 0x20f, 0x0008 }, { 0x210, 0x0091 }, { 0x211, 0x00cf },/*K7-9*/
 273                 { 0x215, 0x0000 }, /* delta mtx signs */
 274                 /* delta matrix coef */
 275                 { 0x216, 0x0000 }, { 0x217, 0x0000 }, { 0x218, 0x0000 },/*D1-3*/
 276                 { 0x219, 0x0000 }, { 0x21a, 0x0000 }, { 0x21b, 0x0000 },/*D4-6*/
 277                 { 0x21c, 0x0000 }, { 0x21d, 0x0000 }, { 0x21e, 0x0000 },/*D7-9*/
 278                 /* enable & disable manual WB to apply color corr. settings */
 279                 { 0x106, 0xf00e }, { 0x106, 0x700e },
 280
 281                 /* Lens shading correction */
 282                 { 0x180, 0x0007 }, /* control */
 283                 /* vertical knee 0, 2+1, 4+3 */
 284                 { 0x181, 0xde13 }, { 0x182, 0xebe2 }, { 0x183, 0x00f6 }, /* R */
 285                 { 0x184, 0xe114 }, { 0x185, 0xeadd }, { 0x186, 0xfdf6 }, /* G */
 286                 { 0x187, 0xe511 }, { 0x188, 0xede6 }, { 0x189, 0xfbf7 }, /* B */
 287                 /* horizontal knee 0, 2+1, 4+3, 5 */
 288                 { 0x18a, 0xd613 }, { 0x18b, 0xedec }, /* R .. */
 289                 { 0x18c, 0xf9f2 }, { 0x18d, 0x0000 }, /* .. R */
 290                 { 0x18e, 0xd815 }, { 0x18f, 0xe9ea }, /* G .. */
 291                 { 0x190, 0xf9f1 }, { 0x191, 0x0002 }, /* .. G */
 292                 { 0x192, 0xde10 }, { 0x193, 0xefef }, /* B .. */
 293                 { 0x194, 0xfbf4 }, { 0x195, 0x0002 }, /* .. B */
 294                 /* vertical knee 6+5, 8+7 */
 295                 { 0x1b6, 0x0e06 }, { 0x1b7, 0x2713 }, /* R */
 296                 { 0x1b8, 0x1106 }, { 0x1b9, 0x2713 }, /* G */
 297                 { 0x1ba, 0x0c03 }, { 0x1bb, 0x2a0f }, /* B */
 298                 /* horizontal knee 7+6, 9+8, 10 */
 299                 { 0x1bc, 0x1208 }, { 0x1bd, 0x1a16 }, { 0x1be, 0x0022 }, /* R */
 300                 { 0x1bf, 0x150a }, { 0x1c0, 0x1c1a }, { 0x1c1, 0x002d }, /* G */
 301                 { 0x1c2, 0x1109 }, { 0x1c3, 0x1414 }, { 0x1c4, 0x002a }, /* B */
 302                 { 0x106, 0x740e }, /* enable lens shading correction */
 303
 304                 /* Gamma correction - context A */
 305                 { 0x153, 0x0b03 }, { 0x154, 0x4722 }, { 0x155, 0xac82 },
 306                 { 0x156, 0xdac7 }, { 0x157, 0xf5e9 }, { 0x158, 0xff00 },
 307                 /* Gamma correction - context B */
 308                 { 0x1dc, 0x0b03 }, { 0x1dd, 0x4722 }, { 0x1de, 0xac82 },
 309                 { 0x1df, 0xdac7 }, { 0x1e0, 0xf5e9 }, { 0x1e1, 0xff00 },
 310
 311                 /* output format: RGB, invert output pixclock, output bayer */
 312                 { 0x13a, 0x4300 }, { 0x19b, 0x4300 }, /* for context A, B */
 313                 { 0x108, 0x0180 }, /* format control - enable bayer row flip */
 314
 315                 { 0x22f, 0xd100 }, { 0x29c, 0xd100 }, /* AE A, B */
 316
 317                 /* default prg conf, prg ctl - by 0x2d2, prg advance - PA1 */
 318                 { 0x2d2, 0x0000 }, { 0x2cc, 0x0004 }, { 0x2cb, 0x0001 },
 319
 320                 { 0x22e, 0x0c3c }, { 0x267, 0x1010 }, /* AE tgt ctl, gain lim */
 321
 322                 /* PLL */
 323                 { 0x065, 0xa000 }, /* clk ctl - enable PLL (clear bit 14) */
 324                 { 0x066, 0x2003 }, { 0x067, 0x0501 }, /* PLL M=128, N=3, P=1 */
 325                 { 0x065, 0x2000 }, /* disable PLL bypass (clear bit 15) */
 326
 327                 { 0x005, 0x01b8 }, { 0x007, 0x00d8 }, /* horiz blanking B, A */
 328
 329                 /* AE line size, shutter delay limit */
 330                 { 0x239, 0x06c0 }, { 0x23b, 0x040e }, /* for context A */
 331                 { 0x23a, 0x06c0 }, { 0x23c, 0x0564 }, /* for context B */
 332                 /* shutter width basis 60Hz, 50Hz */
 333                 { 0x257, 0x0208 }, { 0x258, 0x0271 }, /* for context A */
 334                 { 0x259, 0x0209 }, { 0x25a, 0x0271 }, /* for context B */
 335
 336                 { 0x25c, 0x120d }, { 0x25d, 0x1712 }, /* flicker 60Hz, 50Hz */
 337                 { 0x264, 0x5e1c }, /* reserved */
 338                 /* flicker, AE gain limits, gain zone limits */
 339                 { 0x25b, 0x0003 }, { 0x236, 0x7810 }, { 0x237, 0x8304 },
 340
 341                 { 0x008, 0x0021 }, /* vert blanking A */
 342         };
 343         int i;
 344         u16 width, height;
 345
 346         for (i = 0; i < ARRAY_SIZE(cfg); i++)
 347                 sensor_write(gspca_dev, cfg[i].reg, cfg[i].val);
 348
 349         /* set output size */
 350         width = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].width;
 351         height = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].height;
 352         if (width <= 640) { /* use context A (half readout speed by default) */
 353                 sensor_write(gspca_dev, 0x1a7, width);
 354                 sensor_write(gspca_dev, 0x1aa, height);
 355                 /* set read mode context A */
 356                 sensor_write(gspca_dev, 0x0c8, 0x0000);
 357                 /* set resize, read mode, vblank, hblank context A */
 358                 sensor_write(gspca_dev, 0x2c8, 0x0000);
 359         } else { /* use context B (full readout speed by default) */
 360                 sensor_write(gspca_dev, 0x1a1, width);
 361                 sensor_write(gspca_dev, 0x1a4, height);
 362                 /* set read mode context B */
 363                 sensor_write(gspca_dev, 0x0c8, 0x0008);
 364                 /* set resize, read mode, vblank, hblank context B */
 365                 sensor_write(gspca_dev, 0x2c8, 0x040b);
 366         }
 367 }
 368
 369 static void stk1135_configure_clock(struct gspca_dev *gspca_dev)
 370 {
 371         /* configure SCLKOUT */
 372         reg_w(gspca_dev, STK1135_REG_TMGEN, 0x12);
 373         /* set 1 clock per pixel */
 374         /* and positive edge clocked pulse high when pixel counter = 0 */
 375         reg_w(gspca_dev, STK1135_REG_TCP1 + 0, 0x41);
 376         reg_w(gspca_dev, STK1135_REG_TCP1 + 1, 0x00);
 377         reg_w(gspca_dev, STK1135_REG_TCP1 + 2, 0x00);
 378         reg_w(gspca_dev, STK1135_REG_TCP1 + 3, 0x00);
 379
 380         /* enable CLKOUT for sensor */
 381         reg_w(gspca_dev, STK1135_REG_SENSO + 0, 0x10);
 382         /* disable STOP clock */
 383         reg_w(gspca_dev, STK1135_REG_SENSO + 1, 0x00);
 384         /* set lower 8 bits of PLL feedback divider */
 385         reg_w(gspca_dev, STK1135_REG_SENSO + 3, 0x07);
 386         /* set other PLL parameters */
 387         reg_w(gspca_dev, STK1135_REG_PLLFD, 0x06);
 388         /* enable timing generator */
 389         reg_w(gspca_dev, STK1135_REG_TMGEN, 0x80);
 390         /* enable PLL */
 391         reg_w(gspca_dev, STK1135_REG_SENSO + 2, 0x04);
 392
 393         /* set serial interface clock divider (30MHz/0x1f*16+2) = 60240 kHz) */
 394         reg_w(gspca_dev, STK1135_REG_SICTL + 2, 0x1f);
 395 }
 396
 397 static void stk1135_camera_disable(struct gspca_dev *gspca_dev)
 398 {
 399         /* set capture end Y position to 0 */
 400         reg_w(gspca_dev, STK1135_REG_CIEPO + 2, 0x00);
 401         reg_w(gspca_dev, STK1135_REG_CIEPO + 3, 0x00);
 402         /* disable capture */
 403         reg_w_mask(gspca_dev, STK1135_REG_SCTRL, 0x00, 0x80);
 404
 405         /* enable sensor standby and diasble chip enable */
 406         sensor_write_mask(gspca_dev, 0x00d, 0x0004, 0x000c);
 407
 408         /* disable PLL */
 409         reg_w_mask(gspca_dev, STK1135_REG_SENSO + 2, 0x00, 0x01);
 410         /* disable timing generator */
 411         reg_w(gspca_dev, STK1135_REG_TMGEN, 0x00);
 412         /* enable STOP clock */
 413         reg_w(gspca_dev, STK1135_REG_SENSO + 1, 0x20);
 414         /* disable CLKOUT for sensor */
 415         reg_w(gspca_dev, STK1135_REG_SENSO, 0x00);
 416
 417         /* disable sensor (GPIO5) and enable GPIO0,3,6 (?) - sensor standby? */
 418         reg_w(gspca_dev, STK1135_REG_GCTRL, 0x49);
 419 }
 420
 421 /* this function is called at probe and resume time */
 422 static int sd_init(struct gspca_dev *gspca_dev)
 423 {
 424         u16 sensor_id;
 425         char *sensor_name;
 426         struct sd *sd = (struct sd *) gspca_dev;
 427
 428         /* set GPIO3,4,5,6 direction to output */
 429         reg_w(gspca_dev, STK1135_REG_GCTRL + 2, 0x78);
 430         /* enable sensor (GPIO5) */
 431         reg_w(gspca_dev, STK1135_REG_GCTRL, (1 << 5));
 432         /* disable ROM interface */
 433         reg_w(gspca_dev, STK1135_REG_GCTRL + 3, 0x80);
 434         /* enable interrupts from GPIO8 (flip sensor) and GPIO9 (???) */
 435         reg_w(gspca_dev, STK1135_REG_ICTRL + 1, 0x00);
 436         reg_w(gspca_dev, STK1135_REG_ICTRL + 3, 0x03);
 437         /* enable remote wakeup from GPIO9 (???) */
 438         reg_w(gspca_dev, STK1135_REG_RMCTL + 1, 0x00);
 439         reg_w(gspca_dev, STK1135_REG_RMCTL + 3, 0x02);
 440
 441         /* reset serial interface */
 442         reg_w(gspca_dev, STK1135_REG_SICTL, 0x80);
 443         reg_w(gspca_dev, STK1135_REG_SICTL, 0x00);
 444         /* set sensor address */
 445         reg_w(gspca_dev, STK1135_REG_SICTL + 3, 0xba);
 446         /* disable alt 2-wire serial interface */
 447         reg_w(gspca_dev, STK1135_REG_ASIC + 3, 0x00);
 448
 449         stk1135_configure_clock(gspca_dev);
 450
 451         /* read sensor ID */
 452         sd->sensor_page = 0xff;
 453         sensor_id = sensor_read(gspca_dev, 0x000);
 454
 455         switch (sensor_id) {
 456         case 0x148c:
 457                 sensor_name = "MT9M112";
 458                 break;
 459         default:
 460                 sensor_name = "unknown";
 461         }
 462         pr_info("Detected sensor type %s (0x%x)\n", sensor_name, sensor_id);
 463
 464         stk1135_camera_disable(gspca_dev);
 465
 466         return gspca_dev->usb_err;
 467 }
 468
 469 /* -- start the camera -- */
 470 static int sd_start(struct gspca_dev *gspca_dev)
 471 {
 472         struct sd *sd = (struct sd *) gspca_dev;
 473         u16 width, height;
 474
 475         /* enable sensor (GPIO5) */
 476         reg_w(gspca_dev, STK1135_REG_GCTRL, (1 << 5));
 477
 478         stk1135_configure_clock(gspca_dev);
 479
 480         /* set capture start position X = 0, Y = 0 */
 481         reg_w(gspca_dev, STK1135_REG_CISPO + 0, 0x00);
 482         reg_w(gspca_dev, STK1135_REG_CISPO + 1, 0x00);
 483         reg_w(gspca_dev, STK1135_REG_CISPO + 2, 0x00);
 484         reg_w(gspca_dev, STK1135_REG_CISPO + 3, 0x00);
 485
 486         /* set capture end position */
 487         width = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].width;
 488         height = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].height;
 489         reg_w(gspca_dev, STK1135_REG_CIEPO + 0, width & 0xff);
 490         reg_w(gspca_dev, STK1135_REG_CIEPO + 1, width >> 8);
 491         reg_w(gspca_dev, STK1135_REG_CIEPO + 2, height & 0xff);
 492         reg_w(gspca_dev, STK1135_REG_CIEPO + 3, height >> 8);
 493
 494         /* set 8-bit mode */
 495         reg_w(gspca_dev, STK1135_REG_SCTRL, 0x20);
 496
 497         stk1135_configure_mt9m112(gspca_dev);
 498
 499         /* enable capture */
 500         reg_w_mask(gspca_dev, STK1135_REG_SCTRL, 0x80, 0x80);
 501
 502         if (gspca_dev->usb_err >= 0)
 503                 PDEBUG(D_STREAM, "camera started alt: 0x%02x",
 504                                 gspca_dev->alt);
 505
 506         sd->pkt_seq = 0;
 507
 508         return gspca_dev->usb_err;
 509 }
 510
 511 static void sd_stopN(struct gspca_dev *gspca_dev)
 512 {
 513         struct usb_device *dev = gspca_dev->dev;
 514
 515         usb_set_interface(dev, gspca_dev->iface, 0);
 516
 517         stk1135_camera_disable(gspca_dev);
 518
 519         PDEBUG(D_STREAM, "camera stopped");
 520 }
 521
 522 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 523                         u8 *data,                       /* isoc packet */
 524                         int len)                        /* iso packet length */
 525 {
 526         struct sd *sd = (struct sd *) gspca_dev;
 527         int skip = sizeof(struct stk1135_pkt_header);
 528         bool flip;
 529         enum gspca_packet_type pkt_type = INTER_PACKET;
 530         struct stk1135_pkt_header *hdr = (void *)data;
 531         u8 seq;
 532
 533         if (len < 4) {
 534                 PDEBUG(D_PACK, "received short packet (less than 4 bytes)");
 535                 return;
 536         }
 537
 538         /* GPIO 8 is flip sensor (1 = normal position, 0 = flipped to back) */
 539         flip = !(le16_to_cpu(hdr->gpio) & (1 << 8));
 540         /* it's a switch, needs software debounce */
 541         if (sd->flip_status != flip)
 542                 sd->flip_debounce++;
 543         else
 544                 sd->flip_debounce = 0;
 545
 546         /* check sequence number (not present in new frame packets) */
 547         if (!(hdr->flags & STK1135_HDR_FRAME_START)) {
 548                 seq = hdr->seq & STK1135_HDR_SEQ_MASK;
 549                 if (seq != sd->pkt_seq) {
 550                         PDEBUG(D_PACK, "received out-of-sequence packet");
 551                         /* resync sequence and discard packet */
 552                         sd->pkt_seq = seq;
 553                         gspca_dev->last_packet_type = DISCARD_PACKET;
 554                         return;
 555                 }
 556         }
 557         sd->pkt_seq++;
 558         if (sd->pkt_seq > STK1135_HDR_SEQ_MASK)
 559                 sd->pkt_seq = 0;
 560
 561         if (len == sizeof(struct stk1135_pkt_header))
 562                 return;
 563
 564         if (hdr->flags & STK1135_HDR_FRAME_START) { /* new frame */
 565                 skip = 8;       /* the header is longer */
 566                 gspca_frame_add(gspca_dev, LAST_PACKET, data, 0);
 567                 pkt_type = FIRST_PACKET;
 568         }
 569         gspca_frame_add(gspca_dev, pkt_type, data + skip, len - skip);
 570 }
 571
 572 static void sethflip(struct gspca_dev *gspca_dev, s32 val)
 573 {
 574         struct sd *sd = (struct sd *) gspca_dev;
 575
 576         if (sd->flip_status)
 577                 val = !val;
 578         sensor_write_mask(gspca_dev, 0x020, val ? 0x0002 : 0x0000 , 0x0002);
 579 }
 580
 581 static void setvflip(struct gspca_dev *gspca_dev, s32 val)
 582 {
 583         struct sd *sd = (struct sd *) gspca_dev;
 584
 585         if (sd->flip_status)
 586                 val = !val;
 587         sensor_write_mask(gspca_dev, 0x020, val ? 0x0001 : 0x0000 , 0x0001);
 588 }
 589
 590 static void stk1135_dq_callback(struct gspca_dev *gspca_dev)
 591 {
 592         struct sd *sd = (struct sd *) gspca_dev;
 593
 594         if (sd->flip_debounce > 100) {
 595                 sd->flip_status = !sd->flip_status;
 596                 sethflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip));
 597                 setvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->vflip));
 598         }
 599 }
 600
 601 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 602 {
 603         struct gspca_dev *gspca_dev =
 604                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 605
 606         gspca_dev->usb_err = 0;
 607
 608         if (!gspca_dev->streaming)
 609                 return 0;
 610
 611         switch (ctrl->id) {
 612         case V4L2_CID_HFLIP:
 613                 sethflip(gspca_dev, ctrl->val);
 614                 break;
 615         case V4L2_CID_VFLIP:
 616                 setvflip(gspca_dev, ctrl->val);
 617                 break;
 618         }
 619
 620         return gspca_dev->usb_err;
 621 }
 622
 623 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 624         .s_ctrl = sd_s_ctrl,
 625 };
 626
 627 static int sd_init_controls(struct gspca_dev *gspca_dev)
 628 {
 629         struct sd *sd = (struct sd *) gspca_dev;
 630         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 631
 632         gspca_dev->vdev.ctrl_handler = hdl;
 633         v4l2_ctrl_handler_init(hdl, 2);
 634         sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 635                         V4L2_CID_HFLIP, 0, 1, 1, 0);
 636         sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 637                         V4L2_CID_VFLIP, 0, 1, 1, 0);
 638
 639         if (hdl->error) {
 640                 pr_err("Could not initialize controls\n");
 641                 return hdl->error;
 642         }
 643         return 0;
 644 }
 645
 646 /* sub-driver description */
 647 static const struct sd_desc sd_desc = {
 648         .name = MODULE_NAME,
 649         .config = sd_config,
 650         .init = sd_init,
 651         .init_controls = sd_init_controls,
 652         .start = sd_start,
 653         .stopN = sd_stopN,
 654         .pkt_scan = sd_pkt_scan,
 655         .dq_callback = stk1135_dq_callback,
 656 };
 657
 658 /* -- module initialisation -- */
 659 static const struct usb_device_id device_table[] = {
 660         {USB_DEVICE(0x174f, 0x6a31)},   /* ASUS laptop, MT9M112 sensor */
 661         {}
 662 };
 663 MODULE_DEVICE_TABLE(usb, device_table);
 664
 665 /* -- device connect -- */
 666 static int sd_probe(struct usb_interface *intf,
 667                         const struct usb_device_id *id)
 668 {
 669         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 670                                 THIS_MODULE);
 671 }
 672
 673 static struct usb_driver sd_driver = {
 674         .name = MODULE_NAME,
 675         .id_table = device_table,
 676         .probe = sd_probe,
 677         .disconnect = gspca_disconnect,
 678 #ifdef CONFIG_PM
 679         .suspend = gspca_suspend,
 680         .resume = gspca_resume,
 681         .reset_resume = gspca_resume,
 682 #endif
 683 };
 684
 685 module_usb_driver(sd_driver);