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

source code of linux/drivers/media/usb/gspca/stk1135.c