Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/media/usb/gspca/stk1135.c

  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[] = {
 51         /* default mode (this driver supports variable resolution) */
 52         {640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
 53                 .bytesperline = 640,
 54                 .sizeimage = 640 * 480,
 55                 .colorspace = V4L2_COLORSPACE_SRGB},
 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 */
319         width = gspca_dev->pixfmt.width;
320         height = gspca_dev->pixfmt.height;
321         if (width <= 640 && height <= 512) { /* context A (half readout speed)*/
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);
328         } else { /* context B (full readout speed) */
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);
364 
365         /* wait a while for sensor to catch up */
366         udelay(1000);
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 */
459         width = gspca_dev->pixfmt.width;
460         height = gspca_dev->pixfmt.height;
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 
618 static void stk1135_try_fmt(struct gspca_dev *gspca_dev, struct v4l2_format *fmt)
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 
630 static int stk1135_enum_framesizes(struct gspca_dev *gspca_dev,
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 
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,
657         .try_fmt = stk1135_try_fmt,
658         .enum_framesizes = stk1135_enum_framesizes,
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);
689 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us