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