root/drivers/media/usb/gspca/stk1135.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. reg_r
  2. reg_w
  3. reg_w_mask
  4. sd_config
  5. stk1135_serial_wait_ready
  6. sensor_read_8
  7. sensor_read_16
  8. sensor_write_8
  9. sensor_write_16
  10. sensor_set_page
  11. sensor_read
  12. sensor_write
  13. sensor_write_mask
  14. stk1135_configure_mt9m112
  15. stk1135_configure_clock
  16. stk1135_camera_disable
  17. sd_init
  18. sd_start
  19. sd_stopN
  20. sd_pkt_scan
  21. sethflip
  22. setvflip
  23. stk1135_dq_callback
  24. sd_s_ctrl
  25. sd_init_controls
  26. stk1135_try_fmt
  27. stk1135_enum_framesizes
  28. sd_probe
   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 
  18 MODULE_AUTHOR("Ondrej Zary");
  19 MODULE_DESCRIPTION("Syntek STK1135 USB Camera Driver");
  20 MODULE_LICENSE("GPL");
  21 
  22 
  23 /* specific webcam descriptor */
  24 struct 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 
  37 static 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 -- */
  46 static 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 -- */
  73 static 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 
  95 static 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 */
 102 static 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 
 110 static 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 
 127 static 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 
 141 static 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 
 147 static 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 
 161 static 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 
 167 static 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 
 177 static 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 
 183 static 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 
 189 static 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 
 196 struct sensor_val {
 197         u16 reg;
 198         u16 val;
 199 };
 200 
 201 /* configure MT9M112 sensor */
 202 static 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 
 326 static 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 
 357 static 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 */
 382 static 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 -- */
 430 static 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 
 471 static 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 
 482 static 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 
 532 static 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 
 541 static 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 
 550 static 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 
 561 static 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 
 583 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 584         .s_ctrl = sd_s_ctrl,
 585 };
 586 
 587 static 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 
 606 static 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 
 618 static 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 */
 636 static 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 -- */
 650 static const struct usb_device_id device_table[] = {
 651         {USB_DEVICE(0x174f, 0x6a31)},   /* ASUS laptop, MT9M112 sensor */
 652         {}
 653 };
 654 MODULE_DEVICE_TABLE(usb, device_table);
 655 
 656 /* -- device connect -- */
 657 static 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 
 664 static 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 
 676 module_usb_driver(sd_driver);
/* [<][>][^][v][top][bottom][index][help] */