Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 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[] = { |
Ondrej Zary | 76e0598 | 2013-08-30 17:54:25 -0300 | [diff] [blame] | 51 | /* default mode (this driver supports variable resolution) */ |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 52 | {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE, |
| 53 | .bytesperline = 640, |
| 54 | .sizeimage = 640 * 480, |
| 55 | .colorspace = V4L2_COLORSPACE_SRGB}, |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 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 */ |
Ondrej Zary | 1966bc2 | 2013-08-30 17:54:23 -0300 | [diff] [blame] | 319 | width = gspca_dev->pixfmt.width; |
| 320 | height = gspca_dev->pixfmt.height; |
Ondrej Zary | 76e0598 | 2013-08-30 17:54:25 -0300 | [diff] [blame] | 321 | if (width <= 640 && height <= 512) { /* context A (half readout speed)*/ |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 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); |
Ondrej Zary | 76e0598 | 2013-08-30 17:54:25 -0300 | [diff] [blame] | 328 | } else { /* context B (full readout speed) */ |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 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 | |
| 366 | static void stk1135_camera_disable(struct gspca_dev *gspca_dev) |
| 367 | { |
| 368 | /* set capture end Y position to 0 */ |
| 369 | reg_w(gspca_dev, STK1135_REG_CIEPO + 2, 0x00); |
| 370 | reg_w(gspca_dev, STK1135_REG_CIEPO + 3, 0x00); |
| 371 | /* disable capture */ |
| 372 | reg_w_mask(gspca_dev, STK1135_REG_SCTRL, 0x00, 0x80); |
| 373 | |
| 374 | /* enable sensor standby and diasble chip enable */ |
| 375 | sensor_write_mask(gspca_dev, 0x00d, 0x0004, 0x000c); |
| 376 | |
| 377 | /* disable PLL */ |
| 378 | reg_w_mask(gspca_dev, STK1135_REG_SENSO + 2, 0x00, 0x01); |
| 379 | /* disable timing generator */ |
| 380 | reg_w(gspca_dev, STK1135_REG_TMGEN, 0x00); |
| 381 | /* enable STOP clock */ |
| 382 | reg_w(gspca_dev, STK1135_REG_SENSO + 1, 0x20); |
| 383 | /* disable CLKOUT for sensor */ |
| 384 | reg_w(gspca_dev, STK1135_REG_SENSO, 0x00); |
| 385 | |
| 386 | /* disable sensor (GPIO5) and enable GPIO0,3,6 (?) - sensor standby? */ |
| 387 | reg_w(gspca_dev, STK1135_REG_GCTRL, 0x49); |
| 388 | } |
| 389 | |
| 390 | /* this function is called at probe and resume time */ |
| 391 | static int sd_init(struct gspca_dev *gspca_dev) |
| 392 | { |
| 393 | u16 sensor_id; |
| 394 | char *sensor_name; |
| 395 | struct sd *sd = (struct sd *) gspca_dev; |
| 396 | |
| 397 | /* set GPIO3,4,5,6 direction to output */ |
| 398 | reg_w(gspca_dev, STK1135_REG_GCTRL + 2, 0x78); |
| 399 | /* enable sensor (GPIO5) */ |
| 400 | reg_w(gspca_dev, STK1135_REG_GCTRL, (1 << 5)); |
| 401 | /* disable ROM interface */ |
| 402 | reg_w(gspca_dev, STK1135_REG_GCTRL + 3, 0x80); |
| 403 | /* enable interrupts from GPIO8 (flip sensor) and GPIO9 (???) */ |
| 404 | reg_w(gspca_dev, STK1135_REG_ICTRL + 1, 0x00); |
| 405 | reg_w(gspca_dev, STK1135_REG_ICTRL + 3, 0x03); |
| 406 | /* enable remote wakeup from GPIO9 (???) */ |
| 407 | reg_w(gspca_dev, STK1135_REG_RMCTL + 1, 0x00); |
| 408 | reg_w(gspca_dev, STK1135_REG_RMCTL + 3, 0x02); |
| 409 | |
| 410 | /* reset serial interface */ |
| 411 | reg_w(gspca_dev, STK1135_REG_SICTL, 0x80); |
| 412 | reg_w(gspca_dev, STK1135_REG_SICTL, 0x00); |
| 413 | /* set sensor address */ |
| 414 | reg_w(gspca_dev, STK1135_REG_SICTL + 3, 0xba); |
| 415 | /* disable alt 2-wire serial interface */ |
| 416 | reg_w(gspca_dev, STK1135_REG_ASIC + 3, 0x00); |
| 417 | |
| 418 | stk1135_configure_clock(gspca_dev); |
| 419 | |
| 420 | /* read sensor ID */ |
| 421 | sd->sensor_page = 0xff; |
| 422 | sensor_id = sensor_read(gspca_dev, 0x000); |
| 423 | |
| 424 | switch (sensor_id) { |
| 425 | case 0x148c: |
| 426 | sensor_name = "MT9M112"; |
| 427 | break; |
| 428 | default: |
| 429 | sensor_name = "unknown"; |
| 430 | } |
| 431 | pr_info("Detected sensor type %s (0x%x)\n", sensor_name, sensor_id); |
| 432 | |
| 433 | stk1135_camera_disable(gspca_dev); |
| 434 | |
| 435 | return gspca_dev->usb_err; |
| 436 | } |
| 437 | |
| 438 | /* -- start the camera -- */ |
| 439 | static int sd_start(struct gspca_dev *gspca_dev) |
| 440 | { |
| 441 | struct sd *sd = (struct sd *) gspca_dev; |
| 442 | u16 width, height; |
| 443 | |
| 444 | /* enable sensor (GPIO5) */ |
| 445 | reg_w(gspca_dev, STK1135_REG_GCTRL, (1 << 5)); |
| 446 | |
| 447 | stk1135_configure_clock(gspca_dev); |
| 448 | |
| 449 | /* set capture start position X = 0, Y = 0 */ |
| 450 | reg_w(gspca_dev, STK1135_REG_CISPO + 0, 0x00); |
| 451 | reg_w(gspca_dev, STK1135_REG_CISPO + 1, 0x00); |
| 452 | reg_w(gspca_dev, STK1135_REG_CISPO + 2, 0x00); |
| 453 | reg_w(gspca_dev, STK1135_REG_CISPO + 3, 0x00); |
| 454 | |
| 455 | /* set capture end position */ |
Ondrej Zary | 1966bc2 | 2013-08-30 17:54:23 -0300 | [diff] [blame] | 456 | width = gspca_dev->pixfmt.width; |
| 457 | height = gspca_dev->pixfmt.height; |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 458 | reg_w(gspca_dev, STK1135_REG_CIEPO + 0, width & 0xff); |
| 459 | reg_w(gspca_dev, STK1135_REG_CIEPO + 1, width >> 8); |
| 460 | reg_w(gspca_dev, STK1135_REG_CIEPO + 2, height & 0xff); |
| 461 | reg_w(gspca_dev, STK1135_REG_CIEPO + 3, height >> 8); |
| 462 | |
| 463 | /* set 8-bit mode */ |
| 464 | reg_w(gspca_dev, STK1135_REG_SCTRL, 0x20); |
| 465 | |
| 466 | stk1135_configure_mt9m112(gspca_dev); |
| 467 | |
| 468 | /* enable capture */ |
| 469 | reg_w_mask(gspca_dev, STK1135_REG_SCTRL, 0x80, 0x80); |
| 470 | |
| 471 | if (gspca_dev->usb_err >= 0) |
| 472 | PDEBUG(D_STREAM, "camera started alt: 0x%02x", |
| 473 | gspca_dev->alt); |
| 474 | |
| 475 | sd->pkt_seq = 0; |
| 476 | |
| 477 | return gspca_dev->usb_err; |
| 478 | } |
| 479 | |
| 480 | static void sd_stopN(struct gspca_dev *gspca_dev) |
| 481 | { |
| 482 | struct usb_device *dev = gspca_dev->dev; |
| 483 | |
| 484 | usb_set_interface(dev, gspca_dev->iface, 0); |
| 485 | |
| 486 | stk1135_camera_disable(gspca_dev); |
| 487 | |
| 488 | PDEBUG(D_STREAM, "camera stopped"); |
| 489 | } |
| 490 | |
| 491 | static void sd_pkt_scan(struct gspca_dev *gspca_dev, |
| 492 | u8 *data, /* isoc packet */ |
| 493 | int len) /* iso packet length */ |
| 494 | { |
| 495 | struct sd *sd = (struct sd *) gspca_dev; |
| 496 | int skip = sizeof(struct stk1135_pkt_header); |
| 497 | bool flip; |
| 498 | enum gspca_packet_type pkt_type = INTER_PACKET; |
| 499 | struct stk1135_pkt_header *hdr = (void *)data; |
| 500 | u8 seq; |
| 501 | |
| 502 | if (len < 4) { |
| 503 | PDEBUG(D_PACK, "received short packet (less than 4 bytes)"); |
| 504 | return; |
| 505 | } |
| 506 | |
| 507 | /* GPIO 8 is flip sensor (1 = normal position, 0 = flipped to back) */ |
| 508 | flip = !(le16_to_cpu(hdr->gpio) & (1 << 8)); |
| 509 | /* it's a switch, needs software debounce */ |
| 510 | if (sd->flip_status != flip) |
| 511 | sd->flip_debounce++; |
| 512 | else |
| 513 | sd->flip_debounce = 0; |
| 514 | |
| 515 | /* check sequence number (not present in new frame packets) */ |
| 516 | if (!(hdr->flags & STK1135_HDR_FRAME_START)) { |
| 517 | seq = hdr->seq & STK1135_HDR_SEQ_MASK; |
| 518 | if (seq != sd->pkt_seq) { |
| 519 | PDEBUG(D_PACK, "received out-of-sequence packet"); |
| 520 | /* resync sequence and discard packet */ |
| 521 | sd->pkt_seq = seq; |
| 522 | gspca_dev->last_packet_type = DISCARD_PACKET; |
| 523 | return; |
| 524 | } |
| 525 | } |
| 526 | sd->pkt_seq++; |
| 527 | if (sd->pkt_seq > STK1135_HDR_SEQ_MASK) |
| 528 | sd->pkt_seq = 0; |
| 529 | |
| 530 | if (len == sizeof(struct stk1135_pkt_header)) |
| 531 | return; |
| 532 | |
| 533 | if (hdr->flags & STK1135_HDR_FRAME_START) { /* new frame */ |
| 534 | skip = 8; /* the header is longer */ |
| 535 | gspca_frame_add(gspca_dev, LAST_PACKET, data, 0); |
| 536 | pkt_type = FIRST_PACKET; |
| 537 | } |
| 538 | gspca_frame_add(gspca_dev, pkt_type, data + skip, len - skip); |
| 539 | } |
| 540 | |
| 541 | static void sethflip(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 ? 0x0002 : 0x0000 , 0x0002); |
| 548 | } |
| 549 | |
| 550 | static void setvflip(struct gspca_dev *gspca_dev, s32 val) |
| 551 | { |
| 552 | struct sd *sd = (struct sd *) gspca_dev; |
| 553 | |
| 554 | if (sd->flip_status) |
| 555 | val = !val; |
| 556 | sensor_write_mask(gspca_dev, 0x020, val ? 0x0001 : 0x0000 , 0x0001); |
| 557 | } |
| 558 | |
| 559 | static void stk1135_dq_callback(struct gspca_dev *gspca_dev) |
| 560 | { |
| 561 | struct sd *sd = (struct sd *) gspca_dev; |
| 562 | |
| 563 | if (sd->flip_debounce > 100) { |
| 564 | sd->flip_status = !sd->flip_status; |
| 565 | sethflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip)); |
| 566 | setvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->vflip)); |
| 567 | } |
| 568 | } |
| 569 | |
| 570 | static int sd_s_ctrl(struct v4l2_ctrl *ctrl) |
| 571 | { |
| 572 | struct gspca_dev *gspca_dev = |
| 573 | container_of(ctrl->handler, struct gspca_dev, ctrl_handler); |
| 574 | |
| 575 | gspca_dev->usb_err = 0; |
| 576 | |
| 577 | if (!gspca_dev->streaming) |
| 578 | return 0; |
| 579 | |
| 580 | switch (ctrl->id) { |
| 581 | case V4L2_CID_HFLIP: |
| 582 | sethflip(gspca_dev, ctrl->val); |
| 583 | break; |
| 584 | case V4L2_CID_VFLIP: |
| 585 | setvflip(gspca_dev, ctrl->val); |
| 586 | break; |
| 587 | } |
| 588 | |
| 589 | return gspca_dev->usb_err; |
| 590 | } |
| 591 | |
| 592 | static const struct v4l2_ctrl_ops sd_ctrl_ops = { |
| 593 | .s_ctrl = sd_s_ctrl, |
| 594 | }; |
| 595 | |
| 596 | static int sd_init_controls(struct gspca_dev *gspca_dev) |
| 597 | { |
| 598 | struct sd *sd = (struct sd *) gspca_dev; |
| 599 | struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; |
| 600 | |
| 601 | gspca_dev->vdev.ctrl_handler = hdl; |
| 602 | v4l2_ctrl_handler_init(hdl, 2); |
| 603 | sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, |
| 604 | V4L2_CID_HFLIP, 0, 1, 1, 0); |
| 605 | sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, |
| 606 | V4L2_CID_VFLIP, 0, 1, 1, 0); |
| 607 | |
| 608 | if (hdl->error) { |
| 609 | pr_err("Could not initialize controls\n"); |
| 610 | return hdl->error; |
| 611 | } |
| 612 | return 0; |
| 613 | } |
| 614 | |
Mauro Carvalho Chehab | cbbe1c0 | 2013-09-26 07:41:30 -0300 | [diff] [blame] | 615 | static void stk1135_try_fmt(struct gspca_dev *gspca_dev, struct v4l2_format *fmt) |
Ondrej Zary | 76e0598 | 2013-08-30 17:54:25 -0300 | [diff] [blame] | 616 | { |
| 617 | fmt->fmt.pix.width = clamp(fmt->fmt.pix.width, 32U, 1280U); |
| 618 | fmt->fmt.pix.height = clamp(fmt->fmt.pix.height, 32U, 1024U); |
| 619 | /* round up to even numbers */ |
| 620 | fmt->fmt.pix.width += (fmt->fmt.pix.width & 1); |
| 621 | fmt->fmt.pix.height += (fmt->fmt.pix.height & 1); |
| 622 | |
| 623 | fmt->fmt.pix.bytesperline = fmt->fmt.pix.width; |
| 624 | fmt->fmt.pix.sizeimage = fmt->fmt.pix.width * fmt->fmt.pix.height; |
| 625 | } |
| 626 | |
Mauro Carvalho Chehab | cbbe1c0 | 2013-09-26 07:41:30 -0300 | [diff] [blame] | 627 | static int stk1135_enum_framesizes(struct gspca_dev *gspca_dev, |
Ondrej Zary | 76e0598 | 2013-08-30 17:54:25 -0300 | [diff] [blame] | 628 | struct v4l2_frmsizeenum *fsize) |
| 629 | { |
| 630 | if (fsize->index != 0 || fsize->pixel_format != V4L2_PIX_FMT_SBGGR8) |
| 631 | return -EINVAL; |
| 632 | |
| 633 | fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE; |
| 634 | fsize->stepwise.min_width = 32; |
| 635 | fsize->stepwise.min_height = 32; |
| 636 | fsize->stepwise.max_width = 1280; |
| 637 | fsize->stepwise.max_height = 1024; |
| 638 | fsize->stepwise.step_width = 2; |
| 639 | fsize->stepwise.step_height = 2; |
| 640 | |
| 641 | return 0; |
| 642 | } |
| 643 | |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 644 | /* sub-driver description */ |
| 645 | static const struct sd_desc sd_desc = { |
| 646 | .name = MODULE_NAME, |
| 647 | .config = sd_config, |
| 648 | .init = sd_init, |
| 649 | .init_controls = sd_init_controls, |
| 650 | .start = sd_start, |
| 651 | .stopN = sd_stopN, |
| 652 | .pkt_scan = sd_pkt_scan, |
| 653 | .dq_callback = stk1135_dq_callback, |
Ondrej Zary | 76e0598 | 2013-08-30 17:54:25 -0300 | [diff] [blame] | 654 | .try_fmt = stk1135_try_fmt, |
| 655 | .enum_framesizes = stk1135_enum_framesizes, |
Ondrej Zary | 4ab0620 | 2013-08-20 10:03:59 -0300 | [diff] [blame] | 656 | }; |
| 657 | |
| 658 | /* -- module initialisation -- */ |
| 659 | static const struct usb_device_id device_table[] = { |
| 660 | {USB_DEVICE(0x174f, 0x6a31)}, /* ASUS laptop, MT9M112 sensor */ |
| 661 | {} |
| 662 | }; |
| 663 | MODULE_DEVICE_TABLE(usb, device_table); |
| 664 | |
| 665 | /* -- device connect -- */ |
| 666 | static int sd_probe(struct usb_interface *intf, |
| 667 | const struct usb_device_id *id) |
| 668 | { |
| 669 | return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), |
| 670 | THIS_MODULE); |
| 671 | } |
| 672 | |
| 673 | static struct usb_driver sd_driver = { |
| 674 | .name = MODULE_NAME, |
| 675 | .id_table = device_table, |
| 676 | .probe = sd_probe, |
| 677 | .disconnect = gspca_disconnect, |
| 678 | #ifdef CONFIG_PM |
| 679 | .suspend = gspca_suspend, |
| 680 | .resume = gspca_resume, |
| 681 | .reset_resume = gspca_resume, |
| 682 | #endif |
| 683 | }; |
| 684 | |
| 685 | module_usb_driver(sd_driver); |