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 -- */ |
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 | 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 -- */ |
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 | 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 | |
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 */ |
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 | |
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 | |
127 | static 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 | |
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, addr: 0xf1); |
145 | } |
146 | |
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, 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 | |
161 | static 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 | |
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, addr: 0xf0, data: page); |
173 | sd->sensor_page = page; |
174 | } |
175 | } |
176 | |
177 | static 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 | |
183 | static 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 | |
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 */ |
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, 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 | |
326 | static 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 | |
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, 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 */ |
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, 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 -- */ |
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, 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 | |
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, 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 | |
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, 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 | |
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, reg: 0x020, val: val ? 0x0002 : 0x0000 , mask: 0x0002); |
539 | } |
540 | |
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, reg: 0x020, val: val ? 0x0001 : 0x0000 , mask: 0x0001); |
548 | } |
549 | |
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, val: v4l2_ctrl_g_ctrl(ctrl: sd->hflip)); |
557 | setvflip(gspca_dev, val: v4l2_ctrl_g_ctrl(ctrl: sd->vflip)); |
558 | } |
559 | } |
560 | |
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, 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 | |
583 | static const struct v4l2_ctrl_ops sd_ctrl_ops = { |
584 | .s_ctrl = sd_s_ctrl, |
585 | }; |
586 | |
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, 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 | |
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 | |
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 -- */ |
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: &sd_desc, dev_size: 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 | |