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