xref: /openbmc/linux/drivers/media/usb/gspca/stk1135.c (revision fd9871f7)
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 -- */
reg_r(struct gspca_dev * gspca_dev,u16 index)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 -- */
reg_w(struct gspca_dev * gspca_dev,u16 index,u8 val)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 
reg_w_mask(struct gspca_dev * gspca_dev,u16 index,u8 val,u8 mask)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 */
sd_config(struct gspca_dev * gspca_dev,const struct usb_device_id * id)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 
stk1135_serial_wait_ready(struct gspca_dev * gspca_dev)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 
sensor_read_8(struct gspca_dev * gspca_dev,u8 addr)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 
sensor_read_16(struct gspca_dev * gspca_dev,u8 addr)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 
sensor_write_8(struct gspca_dev * gspca_dev,u8 addr,u8 data)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 
sensor_write_16(struct gspca_dev * gspca_dev,u8 addr,u16 data)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 
sensor_set_page(struct gspca_dev * gspca_dev,u8 page)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 
sensor_read(struct gspca_dev * gspca_dev,u16 reg)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 
sensor_write(struct gspca_dev * gspca_dev,u16 reg,u16 val)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 
sensor_write_mask(struct gspca_dev * gspca_dev,u16 reg,u16 val,u16 mask)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 */
stk1135_configure_mt9m112(struct gspca_dev * gspca_dev)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 
stk1135_configure_clock(struct gspca_dev * gspca_dev)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 
stk1135_camera_disable(struct gspca_dev * gspca_dev)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 */
sd_init(struct gspca_dev * gspca_dev)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 -- */
sd_start(struct gspca_dev * gspca_dev)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 
sd_stopN(struct gspca_dev * gspca_dev)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 
sd_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)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 
sethflip(struct gspca_dev * gspca_dev,s32 val)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 
setvflip(struct gspca_dev * gspca_dev,s32 val)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 
stk1135_dq_callback(struct gspca_dev * gspca_dev)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 
sd_s_ctrl(struct v4l2_ctrl * ctrl)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 
sd_init_controls(struct gspca_dev * gspca_dev)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 
stk1135_try_fmt(struct gspca_dev * gspca_dev,struct v4l2_format * fmt)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 
stk1135_enum_framesizes(struct gspca_dev * gspca_dev,struct v4l2_frmsizeenum * fsize)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 -- */
sd_probe(struct usb_interface * intf,const struct usb_device_id * id)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);
677