LXR linux/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
  31MODULE_AUTHOR("Ondrej Zary");
  32MODULE_DESCRIPTION("Syntek STK1135 USB Camera Driver");
  33MODULE_LICENSE("GPL");
  34
  35
  36/* specific webcam descriptor */
  37struct 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
  50static 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 -- */
  90static 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 -- */
 116static 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
 138static 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 */
 145static 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
 153static 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
 170static 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
 184static 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
 190static 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
 204static 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
 210static 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
 220static 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
 226static 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
 232static 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
 239struct sensor_val {
 240        u16 reg;
 241        u16 val;
 242};
 243
 244/* configure MT9M112 sensor */
 245static 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
 369static 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
 397static 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 */
 422static 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 -- */
 470static 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
 511static 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
 522static 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
 572static 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
 581static 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
 590static 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
 601static 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
 623static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 624        .s_ctrl = sd_s_ctrl,
 625};
 626
 627static 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 */
 647static 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 -- */
 659static const struct usb_device_id device_table[] = {
 660        {USB_DEVICE(0x174f, 0x6a31)},   /* ASUS laptop, MT9M112 sensor */
 661        {}
 662};
 663MODULE_DEVICE_TABLE(usb, device_table);
 664
 665/* -- device connect -- */
 666static 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
 673static 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
 685module_usb_driver(sd_driver);
 686