LXR linux/drivers/media/usb/gspca/stk1135.c

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