2 * Syntek STK1135 subdriver
4 * Copyright (c) 2013 Ondrej Zary
6 * Based on Syntekdriver (stk11xx) by Nicolas VIVIEN:
7 * http://syntekdriver.sourceforge.net
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
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.
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #define MODULE_NAME "stk1135"
27 MODULE_AUTHOR("Ondrej Zary");
28 MODULE_DESCRIPTION("Syntek STK1135 USB Camera Driver");
29 MODULE_LICENSE("GPL");
32 /* specific webcam descriptor */
34 struct gspca_dev gspca_dev
; /* !! must be the first item */
42 struct v4l2_ctrl
*hflip
;
43 struct v4l2_ctrl
*vflip
;
46 static const struct v4l2_pix_format stk1135_modes
[] = {
47 /* default mode (this driver supports variable resolution) */
48 {640, 480, V4L2_PIX_FMT_SBGGR8
, V4L2_FIELD_NONE
,
50 .sizeimage
= 640 * 480,
51 .colorspace
= V4L2_COLORSPACE_SRGB
},
54 /* -- read a register -- */
55 static u8
reg_r(struct gspca_dev
*gspca_dev
, u16 index
)
57 struct usb_device
*dev
= gspca_dev
->dev
;
60 if (gspca_dev
->usb_err
< 0)
62 ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
64 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
67 gspca_dev
->usb_buf
, 1,
70 PDEBUG(D_USBI
, "reg_r 0x%x=0x%02x", index
, gspca_dev
->usb_buf
[0]);
72 pr_err("reg_r 0x%x err %d\n", index
, ret
);
73 gspca_dev
->usb_err
= ret
;
77 return gspca_dev
->usb_buf
[0];
80 /* -- write a register -- */
81 static void reg_w(struct gspca_dev
*gspca_dev
, u16 index
, u8 val
)
84 struct usb_device
*dev
= gspca_dev
->dev
;
86 if (gspca_dev
->usb_err
< 0)
88 ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
90 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
96 PDEBUG(D_USBO
, "reg_w 0x%x:=0x%02x", index
, val
);
98 pr_err("reg_w 0x%x err %d\n", index
, ret
);
99 gspca_dev
->usb_err
= ret
;
103 static void reg_w_mask(struct gspca_dev
*gspca_dev
, u16 index
, u8 val
, u8 mask
)
105 val
= (reg_r(gspca_dev
, index
) & ~mask
) | (val
& mask
);
106 reg_w(gspca_dev
, index
, val
);
109 /* this function is called at probe time */
110 static int sd_config(struct gspca_dev
*gspca_dev
,
111 const struct usb_device_id
*id
)
113 gspca_dev
->cam
.cam_mode
= stk1135_modes
;
114 gspca_dev
->cam
.nmodes
= ARRAY_SIZE(stk1135_modes
);
118 static int stk1135_serial_wait_ready(struct gspca_dev
*gspca_dev
)
124 val
= reg_r(gspca_dev
, STK1135_REG_SICTL
+ 1);
125 if (i
++ > 500) { /* maximum retry count */
126 pr_err("serial bus timeout: status=0x%02x\n", val
);
129 /* repeat if BUSY or WRITE/READ not finished */
130 } while ((val
& 0x10) || !(val
& 0x05));
135 static u8
sensor_read_8(struct gspca_dev
*gspca_dev
, u8 addr
)
137 reg_w(gspca_dev
, STK1135_REG_SBUSR
, addr
);
139 reg_w(gspca_dev
, STK1135_REG_SICTL
, 0x20);
140 /* wait until finished */
141 if (stk1135_serial_wait_ready(gspca_dev
)) {
142 pr_err("Sensor read failed\n");
146 return reg_r(gspca_dev
, STK1135_REG_SBUSR
+ 1);
149 static u16
sensor_read_16(struct gspca_dev
*gspca_dev
, u8 addr
)
151 return (sensor_read_8(gspca_dev
, addr
) << 8) |
152 sensor_read_8(gspca_dev
, 0xf1);
155 static void sensor_write_8(struct gspca_dev
*gspca_dev
, u8 addr
, u8 data
)
157 /* load address and data registers */
158 reg_w(gspca_dev
, STK1135_REG_SBUSW
, addr
);
159 reg_w(gspca_dev
, STK1135_REG_SBUSW
+ 1, data
);
161 reg_w(gspca_dev
, STK1135_REG_SICTL
, 0x01);
162 /* wait until finished */
163 if (stk1135_serial_wait_ready(gspca_dev
)) {
164 pr_err("Sensor write failed\n");
169 static void sensor_write_16(struct gspca_dev
*gspca_dev
, u8 addr
, u16 data
)
171 sensor_write_8(gspca_dev
, addr
, data
>> 8);
172 sensor_write_8(gspca_dev
, 0xf1, data
& 0xff);
175 static void sensor_set_page(struct gspca_dev
*gspca_dev
, u8 page
)
177 struct sd
*sd
= (struct sd
*) gspca_dev
;
179 if (page
!= sd
->sensor_page
) {
180 sensor_write_16(gspca_dev
, 0xf0, page
);
181 sd
->sensor_page
= page
;
185 static u16
sensor_read(struct gspca_dev
*gspca_dev
, u16 reg
)
187 sensor_set_page(gspca_dev
, reg
>> 8);
188 return sensor_read_16(gspca_dev
, reg
& 0xff);
191 static void sensor_write(struct gspca_dev
*gspca_dev
, u16 reg
, u16 val
)
193 sensor_set_page(gspca_dev
, reg
>> 8);
194 sensor_write_16(gspca_dev
, reg
& 0xff, val
);
197 static void sensor_write_mask(struct gspca_dev
*gspca_dev
,
198 u16 reg
, u16 val
, u16 mask
)
200 val
= (sensor_read(gspca_dev
, reg
) & ~mask
) | (val
& mask
);
201 sensor_write(gspca_dev
, reg
, val
);
209 /* configure MT9M112 sensor */
210 static void stk1135_configure_mt9m112(struct gspca_dev
*gspca_dev
)
212 static const struct sensor_val cfg
[] = {
213 /* restart&reset, chip enable, reserved */
214 { 0x00d, 0x000b }, { 0x00d, 0x0008 }, { 0x035, 0x0022 },
215 /* mode ctl: AWB on, AE both, clip aper corr, defect corr, AE */
218 { 0x2dd, 0x18e0 }, /* B-R thresholds, */
221 { 0x21f, 0x0180 }, /* Cb and Cr limits */
222 { 0x220, 0xc814 }, { 0x221, 0x8080 }, /* lum limits, RGB gain */
223 { 0x222, 0xa078 }, { 0x223, 0xa078 }, /* R, B limit */
224 { 0x224, 0x5f20 }, { 0x228, 0xea02 }, /* mtx adj lim, adv ctl */
225 { 0x229, 0x867a }, /* wide gates */
227 /* Color correction */
228 /* imager gains base, delta, delta signs */
229 { 0x25e, 0x594c }, { 0x25f, 0x4d51 }, { 0x260, 0x0002 },
230 /* AWB adv ctl 2, gain offs */
231 { 0x2ef, 0x0008 }, { 0x2f2, 0x0000 },
232 /* base matrix signs, scale K1-5, K6-9 */
233 { 0x202, 0x00ee }, { 0x203, 0x3923 }, { 0x204, 0x0724 },
234 /* base matrix coef */
235 { 0x209, 0x00cd }, { 0x20a, 0x0093 }, { 0x20b, 0x0004 },/*K1-3*/
236 { 0x20c, 0x005c }, { 0x20d, 0x00d9 }, { 0x20e, 0x0053 },/*K4-6*/
237 { 0x20f, 0x0008 }, { 0x210, 0x0091 }, { 0x211, 0x00cf },/*K7-9*/
238 { 0x215, 0x0000 }, /* delta mtx signs */
239 /* delta matrix coef */
240 { 0x216, 0x0000 }, { 0x217, 0x0000 }, { 0x218, 0x0000 },/*D1-3*/
241 { 0x219, 0x0000 }, { 0x21a, 0x0000 }, { 0x21b, 0x0000 },/*D4-6*/
242 { 0x21c, 0x0000 }, { 0x21d, 0x0000 }, { 0x21e, 0x0000 },/*D7-9*/
243 /* enable & disable manual WB to apply color corr. settings */
244 { 0x106, 0xf00e }, { 0x106, 0x700e },
246 /* Lens shading correction */
247 { 0x180, 0x0007 }, /* control */
248 /* vertical knee 0, 2+1, 4+3 */
249 { 0x181, 0xde13 }, { 0x182, 0xebe2 }, { 0x183, 0x00f6 }, /* R */
250 { 0x184, 0xe114 }, { 0x185, 0xeadd }, { 0x186, 0xfdf6 }, /* G */
251 { 0x187, 0xe511 }, { 0x188, 0xede6 }, { 0x189, 0xfbf7 }, /* B */
252 /* horizontal knee 0, 2+1, 4+3, 5 */
253 { 0x18a, 0xd613 }, { 0x18b, 0xedec }, /* R .. */
254 { 0x18c, 0xf9f2 }, { 0x18d, 0x0000 }, /* .. R */
255 { 0x18e, 0xd815 }, { 0x18f, 0xe9ea }, /* G .. */
256 { 0x190, 0xf9f1 }, { 0x191, 0x0002 }, /* .. G */
257 { 0x192, 0xde10 }, { 0x193, 0xefef }, /* B .. */
258 { 0x194, 0xfbf4 }, { 0x195, 0x0002 }, /* .. B */
259 /* vertical knee 6+5, 8+7 */
260 { 0x1b6, 0x0e06 }, { 0x1b7, 0x2713 }, /* R */
261 { 0x1b8, 0x1106 }, { 0x1b9, 0x2713 }, /* G */
262 { 0x1ba, 0x0c03 }, { 0x1bb, 0x2a0f }, /* B */
263 /* horizontal knee 7+6, 9+8, 10 */
264 { 0x1bc, 0x1208 }, { 0x1bd, 0x1a16 }, { 0x1be, 0x0022 }, /* R */
265 { 0x1bf, 0x150a }, { 0x1c0, 0x1c1a }, { 0x1c1, 0x002d }, /* G */
266 { 0x1c2, 0x1109 }, { 0x1c3, 0x1414 }, { 0x1c4, 0x002a }, /* B */
267 { 0x106, 0x740e }, /* enable lens shading correction */
269 /* Gamma correction - context A */
270 { 0x153, 0x0b03 }, { 0x154, 0x4722 }, { 0x155, 0xac82 },
271 { 0x156, 0xdac7 }, { 0x157, 0xf5e9 }, { 0x158, 0xff00 },
272 /* Gamma correction - context B */
273 { 0x1dc, 0x0b03 }, { 0x1dd, 0x4722 }, { 0x1de, 0xac82 },
274 { 0x1df, 0xdac7 }, { 0x1e0, 0xf5e9 }, { 0x1e1, 0xff00 },
276 /* output format: RGB, invert output pixclock, output bayer */
277 { 0x13a, 0x4300 }, { 0x19b, 0x4300 }, /* for context A, B */
278 { 0x108, 0x0180 }, /* format control - enable bayer row flip */
280 { 0x22f, 0xd100 }, { 0x29c, 0xd100 }, /* AE A, B */
282 /* default prg conf, prg ctl - by 0x2d2, prg advance - PA1 */
283 { 0x2d2, 0x0000 }, { 0x2cc, 0x0004 }, { 0x2cb, 0x0001 },
285 { 0x22e, 0x0c3c }, { 0x267, 0x1010 }, /* AE tgt ctl, gain lim */
288 { 0x065, 0xa000 }, /* clk ctl - enable PLL (clear bit 14) */
289 { 0x066, 0x2003 }, { 0x067, 0x0501 }, /* PLL M=128, N=3, P=1 */
290 { 0x065, 0x2000 }, /* disable PLL bypass (clear bit 15) */
292 { 0x005, 0x01b8 }, { 0x007, 0x00d8 }, /* horiz blanking B, A */
294 /* AE line size, shutter delay limit */
295 { 0x239, 0x06c0 }, { 0x23b, 0x040e }, /* for context A */
296 { 0x23a, 0x06c0 }, { 0x23c, 0x0564 }, /* for context B */
297 /* shutter width basis 60Hz, 50Hz */
298 { 0x257, 0x0208 }, { 0x258, 0x0271 }, /* for context A */
299 { 0x259, 0x0209 }, { 0x25a, 0x0271 }, /* for context B */
301 { 0x25c, 0x120d }, { 0x25d, 0x1712 }, /* flicker 60Hz, 50Hz */
302 { 0x264, 0x5e1c }, /* reserved */
303 /* flicker, AE gain limits, gain zone limits */
304 { 0x25b, 0x0003 }, { 0x236, 0x7810 }, { 0x237, 0x8304 },
306 { 0x008, 0x0021 }, /* vert blanking A */
311 for (i
= 0; i
< ARRAY_SIZE(cfg
); i
++)
312 sensor_write(gspca_dev
, cfg
[i
].reg
, cfg
[i
].val
);
314 /* set output size */
315 width
= gspca_dev
->pixfmt
.width
;
316 height
= gspca_dev
->pixfmt
.height
;
317 if (width
<= 640 && height
<= 512) { /* context A (half readout speed)*/
318 sensor_write(gspca_dev
, 0x1a7, width
);
319 sensor_write(gspca_dev
, 0x1aa, height
);
320 /* set read mode context A */
321 sensor_write(gspca_dev
, 0x0c8, 0x0000);
322 /* set resize, read mode, vblank, hblank context A */
323 sensor_write(gspca_dev
, 0x2c8, 0x0000);
324 } else { /* context B (full readout speed) */
325 sensor_write(gspca_dev
, 0x1a1, width
);
326 sensor_write(gspca_dev
, 0x1a4, height
);
327 /* set read mode context B */
328 sensor_write(gspca_dev
, 0x0c8, 0x0008);
329 /* set resize, read mode, vblank, hblank context B */
330 sensor_write(gspca_dev
, 0x2c8, 0x040b);
334 static void stk1135_configure_clock(struct gspca_dev
*gspca_dev
)
336 /* configure SCLKOUT */
337 reg_w(gspca_dev
, STK1135_REG_TMGEN
, 0x12);
338 /* set 1 clock per pixel */
339 /* and positive edge clocked pulse high when pixel counter = 0 */
340 reg_w(gspca_dev
, STK1135_REG_TCP1
+ 0, 0x41);
341 reg_w(gspca_dev
, STK1135_REG_TCP1
+ 1, 0x00);
342 reg_w(gspca_dev
, STK1135_REG_TCP1
+ 2, 0x00);
343 reg_w(gspca_dev
, STK1135_REG_TCP1
+ 3, 0x00);
345 /* enable CLKOUT for sensor */
346 reg_w(gspca_dev
, STK1135_REG_SENSO
+ 0, 0x10);
347 /* disable STOP clock */
348 reg_w(gspca_dev
, STK1135_REG_SENSO
+ 1, 0x00);
349 /* set lower 8 bits of PLL feedback divider */
350 reg_w(gspca_dev
, STK1135_REG_SENSO
+ 3, 0x07);
351 /* set other PLL parameters */
352 reg_w(gspca_dev
, STK1135_REG_PLLFD
, 0x06);
353 /* enable timing generator */
354 reg_w(gspca_dev
, STK1135_REG_TMGEN
, 0x80);
356 reg_w(gspca_dev
, STK1135_REG_SENSO
+ 2, 0x04);
358 /* set serial interface clock divider (30MHz/0x1f*16+2) = 60240 kHz) */
359 reg_w(gspca_dev
, STK1135_REG_SICTL
+ 2, 0x1f);
361 /* wait a while for sensor to catch up */
365 static void stk1135_camera_disable(struct gspca_dev
*gspca_dev
)
367 /* set capture end Y position to 0 */
368 reg_w(gspca_dev
, STK1135_REG_CIEPO
+ 2, 0x00);
369 reg_w(gspca_dev
, STK1135_REG_CIEPO
+ 3, 0x00);
370 /* disable capture */
371 reg_w_mask(gspca_dev
, STK1135_REG_SCTRL
, 0x00, 0x80);
373 /* enable sensor standby and diasble chip enable */
374 sensor_write_mask(gspca_dev
, 0x00d, 0x0004, 0x000c);
377 reg_w_mask(gspca_dev
, STK1135_REG_SENSO
+ 2, 0x00, 0x01);
378 /* disable timing generator */
379 reg_w(gspca_dev
, STK1135_REG_TMGEN
, 0x00);
380 /* enable STOP clock */
381 reg_w(gspca_dev
, STK1135_REG_SENSO
+ 1, 0x20);
382 /* disable CLKOUT for sensor */
383 reg_w(gspca_dev
, STK1135_REG_SENSO
, 0x00);
385 /* disable sensor (GPIO5) and enable GPIO0,3,6 (?) - sensor standby? */
386 reg_w(gspca_dev
, STK1135_REG_GCTRL
, 0x49);
389 /* this function is called at probe and resume time */
390 static int sd_init(struct gspca_dev
*gspca_dev
)
394 struct sd
*sd
= (struct sd
*) gspca_dev
;
396 /* set GPIO3,4,5,6 direction to output */
397 reg_w(gspca_dev
, STK1135_REG_GCTRL
+ 2, 0x78);
398 /* enable sensor (GPIO5) */
399 reg_w(gspca_dev
, STK1135_REG_GCTRL
, (1 << 5));
400 /* disable ROM interface */
401 reg_w(gspca_dev
, STK1135_REG_GCTRL
+ 3, 0x80);
402 /* enable interrupts from GPIO8 (flip sensor) and GPIO9 (???) */
403 reg_w(gspca_dev
, STK1135_REG_ICTRL
+ 1, 0x00);
404 reg_w(gspca_dev
, STK1135_REG_ICTRL
+ 3, 0x03);
405 /* enable remote wakeup from GPIO9 (???) */
406 reg_w(gspca_dev
, STK1135_REG_RMCTL
+ 1, 0x00);
407 reg_w(gspca_dev
, STK1135_REG_RMCTL
+ 3, 0x02);
409 /* reset serial interface */
410 reg_w(gspca_dev
, STK1135_REG_SICTL
, 0x80);
411 reg_w(gspca_dev
, STK1135_REG_SICTL
, 0x00);
412 /* set sensor address */
413 reg_w(gspca_dev
, STK1135_REG_SICTL
+ 3, 0xba);
414 /* disable alt 2-wire serial interface */
415 reg_w(gspca_dev
, STK1135_REG_ASIC
+ 3, 0x00);
417 stk1135_configure_clock(gspca_dev
);
420 sd
->sensor_page
= 0xff;
421 sensor_id
= sensor_read(gspca_dev
, 0x000);
425 sensor_name
= "MT9M112";
428 sensor_name
= "unknown";
430 pr_info("Detected sensor type %s (0x%x)\n", sensor_name
, sensor_id
);
432 stk1135_camera_disable(gspca_dev
);
434 return gspca_dev
->usb_err
;
437 /* -- start the camera -- */
438 static int sd_start(struct gspca_dev
*gspca_dev
)
440 struct sd
*sd
= (struct sd
*) gspca_dev
;
443 /* enable sensor (GPIO5) */
444 reg_w(gspca_dev
, STK1135_REG_GCTRL
, (1 << 5));
446 stk1135_configure_clock(gspca_dev
);
448 /* set capture start position X = 0, Y = 0 */
449 reg_w(gspca_dev
, STK1135_REG_CISPO
+ 0, 0x00);
450 reg_w(gspca_dev
, STK1135_REG_CISPO
+ 1, 0x00);
451 reg_w(gspca_dev
, STK1135_REG_CISPO
+ 2, 0x00);
452 reg_w(gspca_dev
, STK1135_REG_CISPO
+ 3, 0x00);
454 /* set capture end position */
455 width
= gspca_dev
->pixfmt
.width
;
456 height
= gspca_dev
->pixfmt
.height
;
457 reg_w(gspca_dev
, STK1135_REG_CIEPO
+ 0, width
& 0xff);
458 reg_w(gspca_dev
, STK1135_REG_CIEPO
+ 1, width
>> 8);
459 reg_w(gspca_dev
, STK1135_REG_CIEPO
+ 2, height
& 0xff);
460 reg_w(gspca_dev
, STK1135_REG_CIEPO
+ 3, height
>> 8);
463 reg_w(gspca_dev
, STK1135_REG_SCTRL
, 0x20);
465 stk1135_configure_mt9m112(gspca_dev
);
468 reg_w_mask(gspca_dev
, STK1135_REG_SCTRL
, 0x80, 0x80);
470 if (gspca_dev
->usb_err
>= 0)
471 PDEBUG(D_STREAM
, "camera started alt: 0x%02x",
476 return gspca_dev
->usb_err
;
479 static void sd_stopN(struct gspca_dev
*gspca_dev
)
481 struct usb_device
*dev
= gspca_dev
->dev
;
483 usb_set_interface(dev
, gspca_dev
->iface
, 0);
485 stk1135_camera_disable(gspca_dev
);
487 PDEBUG(D_STREAM
, "camera stopped");
490 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
,
491 u8
*data
, /* isoc packet */
492 int len
) /* iso packet length */
494 struct sd
*sd
= (struct sd
*) gspca_dev
;
495 int skip
= sizeof(struct stk1135_pkt_header
);
497 enum gspca_packet_type pkt_type
= INTER_PACKET
;
498 struct stk1135_pkt_header
*hdr
= (void *)data
;
502 PDEBUG(D_PACK
, "received short packet (less than 4 bytes)");
506 /* GPIO 8 is flip sensor (1 = normal position, 0 = flipped to back) */
507 flip
= !(le16_to_cpu(hdr
->gpio
) & (1 << 8));
508 /* it's a switch, needs software debounce */
509 if (sd
->flip_status
!= flip
)
512 sd
->flip_debounce
= 0;
514 /* check sequence number (not present in new frame packets) */
515 if (!(hdr
->flags
& STK1135_HDR_FRAME_START
)) {
516 seq
= hdr
->seq
& STK1135_HDR_SEQ_MASK
;
517 if (seq
!= sd
->pkt_seq
) {
518 PDEBUG(D_PACK
, "received out-of-sequence packet");
519 /* resync sequence and discard packet */
521 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
526 if (sd
->pkt_seq
> STK1135_HDR_SEQ_MASK
)
529 if (len
== sizeof(struct stk1135_pkt_header
))
532 if (hdr
->flags
& STK1135_HDR_FRAME_START
) { /* new frame */
533 skip
= 8; /* the header is longer */
534 gspca_frame_add(gspca_dev
, LAST_PACKET
, data
, 0);
535 pkt_type
= FIRST_PACKET
;
537 gspca_frame_add(gspca_dev
, pkt_type
, data
+ skip
, len
- skip
);
540 static void sethflip(struct gspca_dev
*gspca_dev
, s32 val
)
542 struct sd
*sd
= (struct sd
*) gspca_dev
;
546 sensor_write_mask(gspca_dev
, 0x020, val
? 0x0002 : 0x0000 , 0x0002);
549 static void setvflip(struct gspca_dev
*gspca_dev
, s32 val
)
551 struct sd
*sd
= (struct sd
*) gspca_dev
;
555 sensor_write_mask(gspca_dev
, 0x020, val
? 0x0001 : 0x0000 , 0x0001);
558 static void stk1135_dq_callback(struct gspca_dev
*gspca_dev
)
560 struct sd
*sd
= (struct sd
*) gspca_dev
;
562 if (sd
->flip_debounce
> 100) {
563 sd
->flip_status
= !sd
->flip_status
;
564 sethflip(gspca_dev
, v4l2_ctrl_g_ctrl(sd
->hflip
));
565 setvflip(gspca_dev
, v4l2_ctrl_g_ctrl(sd
->vflip
));
569 static int sd_s_ctrl(struct v4l2_ctrl
*ctrl
)
571 struct gspca_dev
*gspca_dev
=
572 container_of(ctrl
->handler
, struct gspca_dev
, ctrl_handler
);
574 gspca_dev
->usb_err
= 0;
576 if (!gspca_dev
->streaming
)
581 sethflip(gspca_dev
, ctrl
->val
);
584 setvflip(gspca_dev
, ctrl
->val
);
588 return gspca_dev
->usb_err
;
591 static const struct v4l2_ctrl_ops sd_ctrl_ops
= {
595 static int sd_init_controls(struct gspca_dev
*gspca_dev
)
597 struct sd
*sd
= (struct sd
*) gspca_dev
;
598 struct v4l2_ctrl_handler
*hdl
= &gspca_dev
->ctrl_handler
;
600 gspca_dev
->vdev
.ctrl_handler
= hdl
;
601 v4l2_ctrl_handler_init(hdl
, 2);
602 sd
->hflip
= v4l2_ctrl_new_std(hdl
, &sd_ctrl_ops
,
603 V4L2_CID_HFLIP
, 0, 1, 1, 0);
604 sd
->vflip
= v4l2_ctrl_new_std(hdl
, &sd_ctrl_ops
,
605 V4L2_CID_VFLIP
, 0, 1, 1, 0);
608 pr_err("Could not initialize controls\n");
614 static void stk1135_try_fmt(struct gspca_dev
*gspca_dev
, struct v4l2_format
*fmt
)
616 fmt
->fmt
.pix
.width
= clamp(fmt
->fmt
.pix
.width
, 32U, 1280U);
617 fmt
->fmt
.pix
.height
= clamp(fmt
->fmt
.pix
.height
, 32U, 1024U);
618 /* round up to even numbers */
619 fmt
->fmt
.pix
.width
+= (fmt
->fmt
.pix
.width
& 1);
620 fmt
->fmt
.pix
.height
+= (fmt
->fmt
.pix
.height
& 1);
622 fmt
->fmt
.pix
.bytesperline
= fmt
->fmt
.pix
.width
;
623 fmt
->fmt
.pix
.sizeimage
= fmt
->fmt
.pix
.width
* fmt
->fmt
.pix
.height
;
626 static int stk1135_enum_framesizes(struct gspca_dev
*gspca_dev
,
627 struct v4l2_frmsizeenum
*fsize
)
629 if (fsize
->index
!= 0 || fsize
->pixel_format
!= V4L2_PIX_FMT_SBGGR8
)
632 fsize
->type
= V4L2_FRMSIZE_TYPE_STEPWISE
;
633 fsize
->stepwise
.min_width
= 32;
634 fsize
->stepwise
.min_height
= 32;
635 fsize
->stepwise
.max_width
= 1280;
636 fsize
->stepwise
.max_height
= 1024;
637 fsize
->stepwise
.step_width
= 2;
638 fsize
->stepwise
.step_height
= 2;
643 /* sub-driver description */
644 static const struct sd_desc sd_desc
= {
648 .init_controls
= sd_init_controls
,
651 .pkt_scan
= sd_pkt_scan
,
652 .dq_callback
= stk1135_dq_callback
,
653 .try_fmt
= stk1135_try_fmt
,
654 .enum_framesizes
= stk1135_enum_framesizes
,
657 /* -- module initialisation -- */
658 static const struct usb_device_id device_table
[] = {
659 {USB_DEVICE(0x174f, 0x6a31)}, /* ASUS laptop, MT9M112 sensor */
662 MODULE_DEVICE_TABLE(usb
, device_table
);
664 /* -- device connect -- */
665 static int sd_probe(struct usb_interface
*intf
,
666 const struct usb_device_id
*id
)
668 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
672 static struct usb_driver sd_driver
= {
674 .id_table
= device_table
,
676 .disconnect
= gspca_disconnect
,
678 .suspend
= gspca_suspend
,
679 .resume
= gspca_resume
,
680 .reset_resume
= gspca_resume
,
684 module_usb_driver(sd_driver
);