Version:  2.0.40 2.2.26 2.4.37 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 3.17 3.18

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

  1 /*
  2  * Sunplus spca561 subdriver
  3  *
  4  * Copyright (C) 2004 Michel Xhaard mxhaard@magic.fr
  5  *
  6  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 21  */
 22 
 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 24 
 25 #define MODULE_NAME "spca561"
 26 
 27 #include <linux/input.h>
 28 #include "gspca.h"
 29 
 30 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
 31 MODULE_DESCRIPTION("GSPCA/SPCA561 USB Camera Driver");
 32 MODULE_LICENSE("GPL");
 33 
 34 #define EXPOSURE_MAX (2047 + 325)
 35 
 36 /* specific webcam descriptor */
 37 struct sd {
 38         struct gspca_dev gspca_dev;     /* !! must be the first item */
 39 
 40         struct { /* hue/contrast control cluster */
 41                 struct v4l2_ctrl *contrast;
 42                 struct v4l2_ctrl *hue;
 43         };
 44         struct v4l2_ctrl *autogain;
 45 
 46 #define EXPO12A_DEF 3
 47         __u8 expo12a;           /* expo/gain? for rev 12a */
 48 
 49         __u8 chip_revision;
 50 #define Rev012A 0
 51 #define Rev072A 1
 52 
 53         signed char ag_cnt;
 54 #define AG_CNT_START 13
 55 };
 56 
 57 static const struct v4l2_pix_format sif_012a_mode[] = {
 58         {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
 59                 .bytesperline = 160,
 60                 .sizeimage = 160 * 120,
 61                 .colorspace = V4L2_COLORSPACE_SRGB,
 62                 .priv = 3},
 63         {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
 64                 .bytesperline = 176,
 65                 .sizeimage = 176 * 144,
 66                 .colorspace = V4L2_COLORSPACE_SRGB,
 67                 .priv = 2},
 68         {320, 240, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
 69                 .bytesperline = 320,
 70                 .sizeimage = 320 * 240 * 4 / 8,
 71                 .colorspace = V4L2_COLORSPACE_SRGB,
 72                 .priv = 1},
 73         {352, 288, V4L2_PIX_FMT_SPCA561, V4L2_FIELD_NONE,
 74                 .bytesperline = 352,
 75                 .sizeimage = 352 * 288 * 4 / 8,
 76                 .colorspace = V4L2_COLORSPACE_SRGB,
 77                 .priv = 0},
 78 };
 79 
 80 static const struct v4l2_pix_format sif_072a_mode[] = {
 81         {160, 120, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
 82                 .bytesperline = 160,
 83                 .sizeimage = 160 * 120,
 84                 .colorspace = V4L2_COLORSPACE_SRGB,
 85                 .priv = 3},
 86         {176, 144, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
 87                 .bytesperline = 176,
 88                 .sizeimage = 176 * 144,
 89                 .colorspace = V4L2_COLORSPACE_SRGB,
 90                 .priv = 2},
 91         {320, 240, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
 92                 .bytesperline = 320,
 93                 .sizeimage = 320 * 240,
 94                 .colorspace = V4L2_COLORSPACE_SRGB,
 95                 .priv = 1},
 96         {352, 288, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
 97                 .bytesperline = 352,
 98                 .sizeimage = 352 * 288,
 99                 .colorspace = V4L2_COLORSPACE_SRGB,
100                 .priv = 0},
101 };
102 
103 /*
104  * Initialization data
105  * I'm not very sure how to split initialization from open data
106  * chunks. For now, we'll consider everything as initialization
107  */
108 /* Frame packet header offsets for the spca561 */
109 #define SPCA561_OFFSET_SNAP 1
110 #define SPCA561_OFFSET_TYPE 2
111 #define SPCA561_OFFSET_COMPRESS 3
112 #define SPCA561_OFFSET_FRAMSEQ   4
113 #define SPCA561_OFFSET_GPIO 5
114 #define SPCA561_OFFSET_USBBUFF 6
115 #define SPCA561_OFFSET_WIN2GRAVE 7
116 #define SPCA561_OFFSET_WIN2RAVE 8
117 #define SPCA561_OFFSET_WIN2BAVE 9
118 #define SPCA561_OFFSET_WIN2GBAVE 10
119 #define SPCA561_OFFSET_WIN1GRAVE 11
120 #define SPCA561_OFFSET_WIN1RAVE 12
121 #define SPCA561_OFFSET_WIN1BAVE 13
122 #define SPCA561_OFFSET_WIN1GBAVE 14
123 #define SPCA561_OFFSET_FREQ 15
124 #define SPCA561_OFFSET_VSYNC 16
125 #define SPCA561_INDEX_I2C_BASE 0x8800
126 #define SPCA561_SNAPBIT 0x20
127 #define SPCA561_SNAPCTRL 0x40
128 
129 static const u16 rev72a_reset[][2] = {
130         {0x0000, 0x8114},       /* Software GPIO output data */
131         {0x0001, 0x8114},       /* Software GPIO output data */
132         {0x0000, 0x8112},       /* Some kind of reset */
133         {}
134 };
135 static const __u16 rev72a_init_data1[][2] = {
136         {0x0003, 0x8701},       /* PCLK clock delay adjustment */
137         {0x0001, 0x8703},       /* HSYNC from cmos inverted */
138         {0x0011, 0x8118},       /* Enable and conf sensor */
139         {0x0001, 0x8118},       /* Conf sensor */
140         {0x0092, 0x8804},       /* I know nothing about these */
141         {0x0010, 0x8802},       /* 0x88xx registers, so I won't */
142         {}
143 };
144 static const u16 rev72a_init_sensor1[][2] = {
145         {0x0001, 0x000d},
146         {0x0002, 0x0018},
147         {0x0004, 0x0165},
148         {0x0005, 0x0021},
149         {0x0007, 0x00aa},
150         {0x0020, 0x1504},
151         {0x0039, 0x0002},
152         {0x0035, 0x0010},
153         {0x0009, 0x1049},
154         {0x0028, 0x000b},
155         {0x003b, 0x000f},
156         {0x003c, 0x0000},
157         {}
158 };
159 static const __u16 rev72a_init_data2[][2] = {
160         {0x0018, 0x8601},       /* Pixel/line selection for color separation */
161         {0x0000, 0x8602},       /* Optical black level for user setting */
162         {0x0060, 0x8604},       /* Optical black horizontal offset */
163         {0x0002, 0x8605},       /* Optical black vertical offset */
164         {0x0000, 0x8603},       /* Non-automatic optical black level */
165         {0x0002, 0x865b},       /* Horizontal offset for valid pixels */
166         {0x0000, 0x865f},       /* Vertical valid pixels window (x2) */
167         {0x00b0, 0x865d},       /* Horizontal valid pixels window (x2) */
168         {0x0090, 0x865e},       /* Vertical valid lines window (x2) */
169         {0x00e0, 0x8406},       /* Memory buffer threshold */
170         {0x0000, 0x8660},       /* Compensation memory stuff */
171         {0x0002, 0x8201},       /* Output address for r/w serial EEPROM */
172         {0x0008, 0x8200},       /* Clear valid bit for serial EEPROM */
173         {0x0001, 0x8200},       /* OprMode to be executed by hardware */
174 /* from ms-win */
175         {0x0000, 0x8611},       /* R offset for white balance */
176         {0x00fd, 0x8612},       /* Gr offset for white balance */
177         {0x0003, 0x8613},       /* B offset for white balance */
178         {0x0000, 0x8614},       /* Gb offset for white balance */
179 /* from ms-win */
180         {0x0035, 0x8651},       /* R gain for white balance */
181         {0x0040, 0x8652},       /* Gr gain for white balance */
182         {0x005f, 0x8653},       /* B gain for white balance */
183         {0x0040, 0x8654},       /* Gb gain for white balance */
184         {0x0002, 0x8502},       /* Maximum average bit rate stuff */
185         {0x0011, 0x8802},
186 
187         {0x0087, 0x8700},       /* Set master clock (96Mhz????) */
188         {0x0081, 0x8702},       /* Master clock output enable */
189 
190         {0x0000, 0x8500},       /* Set image type (352x288 no compression) */
191         /* Originally was 0x0010 (352x288 compression) */
192 
193         {0x0002, 0x865b},       /* Horizontal offset for valid pixels */
194         {0x0003, 0x865c},       /* Vertical offset for valid lines */
195         {}
196 };
197 static const u16 rev72a_init_sensor2[][2] = {
198         {0x0003, 0x0121},
199         {0x0004, 0x0165},
200         {0x0005, 0x002f},       /* blanking control column */
201         {0x0006, 0x0000},       /* blanking mode row*/
202         {0x000a, 0x0002},
203         {0x0009, 0x1061},       /* setexposure times && pixel clock
204                                  * 0001 0 | 000 0110 0001 */
205         {0x0035, 0x0014},
206         {}
207 };
208 
209 /******************** QC Express etch2 stuff ********************/
210 static const __u16 Pb100_1map8300[][2] = {
211         /* reg, value */
212         {0x8320, 0x3304},
213 
214         {0x8303, 0x0125},       /* image area */
215         {0x8304, 0x0169},
216         {0x8328, 0x000b},
217         {0x833c, 0x0001},               /*fixme: win:07*/
218 
219         {0x832f, 0x1904},               /*fixme: was 0419*/
220         {0x8307, 0x00aa},
221         {0x8301, 0x0003},
222         {0x8302, 0x000e},
223         {}
224 };
225 static const __u16 Pb100_2map8300[][2] = {
226         /* reg, value */
227         {0x8339, 0x0000},
228         {0x8307, 0x00aa},
229         {}
230 };
231 
232 static const __u16 spca561_161rev12A_data1[][2] = {
233         {0x29, 0x8118},         /* Control register (various enable bits) */
234         {0x08, 0x8114},         /* GPIO: Led off */
235         {0x0e, 0x8112},         /* 0x0e stream off 0x3e stream on */
236         {0x00, 0x8102},         /* white balance - new */
237         {0x92, 0x8804},
238         {0x04, 0x8802},         /* windows uses 08 */
239         {}
240 };
241 static const __u16 spca561_161rev12A_data2[][2] = {
242         {0x21, 0x8118},
243         {0x10, 0x8500},
244         {0x07, 0x8601},
245         {0x07, 0x8602},
246         {0x04, 0x8501},
247 
248         {0x07, 0x8201},         /* windows uses 02 */
249         {0x08, 0x8200},
250         {0x01, 0x8200},
251 
252         {0x90, 0x8604},
253         {0x00, 0x8605},
254         {0xb0, 0x8603},
255 
256         /* sensor gains */
257         {0x07, 0x8601},         /* white balance - new */
258         {0x07, 0x8602},         /* white balance - new */
259         {0x00, 0x8610},         /* *red */
260         {0x00, 0x8611},         /* 3f   *green */
261         {0x00, 0x8612},         /* green *blue */
262         {0x00, 0x8613},         /* blue *green */
263         {0x43, 0x8614},         /* green *red - white balance - was 0x35 */
264         {0x40, 0x8615},         /* 40   *green - white balance - was 0x35 */
265         {0x71, 0x8616},         /* 7a   *blue - white balance - was 0x35 */
266         {0x40, 0x8617},         /* 40   *green - white balance - was 0x35 */
267 
268         {0x0c, 0x8620},         /* 0c */
269         {0xc8, 0x8631},         /* c8 */
270         {0xc8, 0x8634},         /* c8 */
271         {0x23, 0x8635},         /* 23 */
272         {0x1f, 0x8636},         /* 1f */
273         {0xdd, 0x8637},         /* dd */
274         {0xe1, 0x8638},         /* e1 */
275         {0x1d, 0x8639},         /* 1d */
276         {0x21, 0x863a},         /* 21 */
277         {0xe3, 0x863b},         /* e3 */
278         {0xdf, 0x863c},         /* df */
279         {0xf0, 0x8505},
280         {0x32, 0x850a},
281 /*      {0x99, 0x8700},          * - white balance - new (removed) */
282         /* HDG we used to do this in stop0, making the init state and the state
283            after a start / stop different, so do this here instead. */
284         {0x29, 0x8118},
285         {}
286 };
287 
288 static void reg_w_val(struct gspca_dev *gspca_dev, __u16 index, __u8 value)
289 {
290         int ret;
291         struct usb_device *dev = gspca_dev->dev;
292 
293         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
294                               0,                /* request */
295                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
296                               value, index, NULL, 0, 500);
297         PDEBUG(D_USBO, "reg write: 0x%02x:0x%02x", index, value);
298         if (ret < 0)
299                 pr_err("reg write: error %d\n", ret);
300 }
301 
302 static void write_vector(struct gspca_dev *gspca_dev,
303                         const __u16 data[][2])
304 {
305         int i;
306 
307         i = 0;
308         while (data[i][1] != 0) {
309                 reg_w_val(gspca_dev, data[i][1], data[i][0]);
310                 i++;
311         }
312 }
313 
314 /* read 'len' bytes to gspca_dev->usb_buf */
315 static void reg_r(struct gspca_dev *gspca_dev,
316                   __u16 index, __u16 length)
317 {
318         usb_control_msg(gspca_dev->dev,
319                         usb_rcvctrlpipe(gspca_dev->dev, 0),
320                         0,                      /* request */
321                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
322                         0,                      /* value */
323                         index, gspca_dev->usb_buf, length, 500);
324 }
325 
326 /* write 'len' bytes from gspca_dev->usb_buf */
327 static void reg_w_buf(struct gspca_dev *gspca_dev,
328                       __u16 index, __u16 len)
329 {
330         usb_control_msg(gspca_dev->dev,
331                         usb_sndctrlpipe(gspca_dev->dev, 0),
332                         0,                      /* request */
333                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
334                         0,                      /* value */
335                         index, gspca_dev->usb_buf, len, 500);
336 }
337 
338 static void i2c_write(struct gspca_dev *gspca_dev, __u16 value, __u16 reg)
339 {
340         int retry = 60;
341 
342         reg_w_val(gspca_dev, 0x8801, reg);
343         reg_w_val(gspca_dev, 0x8805, value);
344         reg_w_val(gspca_dev, 0x8800, value >> 8);
345         do {
346                 reg_r(gspca_dev, 0x8803, 1);
347                 if (!gspca_dev->usb_buf[0])
348                         return;
349                 msleep(10);
350         } while (--retry);
351 }
352 
353 static int i2c_read(struct gspca_dev *gspca_dev, __u16 reg, __u8 mode)
354 {
355         int retry = 60;
356         __u8 value;
357 
358         reg_w_val(gspca_dev, 0x8804, 0x92);
359         reg_w_val(gspca_dev, 0x8801, reg);
360         reg_w_val(gspca_dev, 0x8802, mode | 0x01);
361         do {
362                 reg_r(gspca_dev, 0x8803, 1);
363                 if (!gspca_dev->usb_buf[0]) {
364                         reg_r(gspca_dev, 0x8800, 1);
365                         value = gspca_dev->usb_buf[0];
366                         reg_r(gspca_dev, 0x8805, 1);
367                         return ((int) value << 8) | gspca_dev->usb_buf[0];
368                 }
369                 msleep(10);
370         } while (--retry);
371         return -1;
372 }
373 
374 static void sensor_mapwrite(struct gspca_dev *gspca_dev,
375                             const __u16 (*sensormap)[2])
376 {
377         while ((*sensormap)[0]) {
378                 gspca_dev->usb_buf[0] = (*sensormap)[1];
379                 gspca_dev->usb_buf[1] = (*sensormap)[1] >> 8;
380                 reg_w_buf(gspca_dev, (*sensormap)[0], 2);
381                 sensormap++;
382         }
383 }
384 
385 static void write_sensor_72a(struct gspca_dev *gspca_dev,
386                             const __u16 (*sensor)[2])
387 {
388         while ((*sensor)[0]) {
389                 i2c_write(gspca_dev, (*sensor)[1], (*sensor)[0]);
390                 sensor++;
391         }
392 }
393 
394 static void init_161rev12A(struct gspca_dev *gspca_dev)
395 {
396         write_vector(gspca_dev, spca561_161rev12A_data1);
397         sensor_mapwrite(gspca_dev, Pb100_1map8300);
398 /*fixme: should be in sd_start*/
399         write_vector(gspca_dev, spca561_161rev12A_data2);
400         sensor_mapwrite(gspca_dev, Pb100_2map8300);
401 }
402 
403 /* this function is called at probe time */
404 static int sd_config(struct gspca_dev *gspca_dev,
405                      const struct usb_device_id *id)
406 {
407         struct sd *sd = (struct sd *) gspca_dev;
408         struct cam *cam;
409         __u16 vendor, product;
410         __u8 data1, data2;
411 
412         /* Read frm global register the USB product and vendor IDs, just to
413          * prove that we can communicate with the device.  This works, which
414          * confirms at we are communicating properly and that the device
415          * is a 561. */
416         reg_r(gspca_dev, 0x8104, 1);
417         data1 = gspca_dev->usb_buf[0];
418         reg_r(gspca_dev, 0x8105, 1);
419         data2 = gspca_dev->usb_buf[0];
420         vendor = (data2 << 8) | data1;
421         reg_r(gspca_dev, 0x8106, 1);
422         data1 = gspca_dev->usb_buf[0];
423         reg_r(gspca_dev, 0x8107, 1);
424         data2 = gspca_dev->usb_buf[0];
425         product = (data2 << 8) | data1;
426         if (vendor != id->idVendor || product != id->idProduct) {
427                 PDEBUG(D_PROBE, "Bad vendor / product from device");
428                 return -EINVAL;
429         }
430 
431         cam = &gspca_dev->cam;
432         cam->needs_full_bandwidth = 1;
433 
434         sd->chip_revision = id->driver_info;
435         if (sd->chip_revision == Rev012A) {
436                 cam->cam_mode = sif_012a_mode;
437                 cam->nmodes = ARRAY_SIZE(sif_012a_mode);
438         } else {
439                 cam->cam_mode = sif_072a_mode;
440                 cam->nmodes = ARRAY_SIZE(sif_072a_mode);
441         }
442         sd->expo12a = EXPO12A_DEF;
443         return 0;
444 }
445 
446 /* this function is called at probe and resume time */
447 static int sd_init_12a(struct gspca_dev *gspca_dev)
448 {
449         PDEBUG(D_STREAM, "Chip revision: 012a");
450         init_161rev12A(gspca_dev);
451         return 0;
452 }
453 static int sd_init_72a(struct gspca_dev *gspca_dev)
454 {
455         PDEBUG(D_STREAM, "Chip revision: 072a");
456         write_vector(gspca_dev, rev72a_reset);
457         msleep(200);
458         write_vector(gspca_dev, rev72a_init_data1);
459         write_sensor_72a(gspca_dev, rev72a_init_sensor1);
460         write_vector(gspca_dev, rev72a_init_data2);
461         write_sensor_72a(gspca_dev, rev72a_init_sensor2);
462         reg_w_val(gspca_dev, 0x8112, 0x30);
463         return 0;
464 }
465 
466 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
467 {
468         struct sd *sd = (struct sd *) gspca_dev;
469         __u16 reg;
470 
471         if (sd->chip_revision == Rev012A)
472                 reg = 0x8610;
473         else
474                 reg = 0x8611;
475 
476         reg_w_val(gspca_dev, reg + 0, val);             /* R */
477         reg_w_val(gspca_dev, reg + 1, val);             /* Gr */
478         reg_w_val(gspca_dev, reg + 2, val);             /* B */
479         reg_w_val(gspca_dev, reg + 3, val);             /* Gb */
480 }
481 
482 static void setwhite(struct gspca_dev *gspca_dev, s32 white, s32 contrast)
483 {
484         struct sd *sd = (struct sd *) gspca_dev;
485         __u8 blue, red;
486         __u16 reg;
487 
488         /* try to emulate MS-win as possible */
489         red = 0x20 + white * 3 / 8;
490         blue = 0x90 - white * 5 / 8;
491         if (sd->chip_revision == Rev012A) {
492                 reg = 0x8614;
493         } else {
494                 reg = 0x8651;
495                 red += contrast - 0x20;
496                 blue += contrast - 0x20;
497                 reg_w_val(gspca_dev, 0x8652, contrast + 0x20); /* Gr */
498                 reg_w_val(gspca_dev, 0x8654, contrast + 0x20); /* Gb */
499         }
500         reg_w_val(gspca_dev, reg, red);
501         reg_w_val(gspca_dev, reg + 2, blue);
502 }
503 
504 /* rev 12a only */
505 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
506 {
507         int i, expo = 0;
508 
509         /* Register 0x8309 controls exposure for the spca561,
510            the basic exposure setting goes from 1-2047, where 1 is completely
511            dark and 2047 is very bright. It not only influences exposure but
512            also the framerate (to allow for longer exposure) from 1 - 300 it
513            only raises the exposure time then from 300 - 600 it halves the
514            framerate to be able to further raise the exposure time and for every
515            300 more it halves the framerate again. This allows for a maximum
516            exposure time of circa 0.2 - 0.25 seconds (30 / (2000/3000) fps).
517            Sometimes this is not enough, the 1-2047 uses bits 0-10, bits 11-12
518            configure a divider for the base framerate which us used at the
519            exposure setting of 1-300. These bits configure the base framerate
520            according to the following formula: fps = 60 / (value + 2) */
521 
522         /* We choose to use the high bits setting the fixed framerate divisor
523            asap, as setting high basic exposure setting without the fixed
524            divider in combination with high gains makes the cam stop */
525         int table[] =  { 0, 450, 550, 625, EXPOSURE_MAX };
526 
527         for (i = 0; i < ARRAY_SIZE(table) - 1; i++) {
528                 if (val <= table[i + 1]) {
529                         expo  = val - table[i];
530                         if (i)
531                                 expo += 300;
532                         expo |= i << 11;
533                         break;
534                 }
535         }
536 
537         gspca_dev->usb_buf[0] = expo;
538         gspca_dev->usb_buf[1] = expo >> 8;
539         reg_w_buf(gspca_dev, 0x8309, 2);
540 }
541 
542 /* rev 12a only */
543 static void setgain(struct gspca_dev *gspca_dev, s32 val)
544 {
545         /* gain reg low 6 bits  0-63 gain, bit 6 and 7, both double the
546            sensitivity when set, so 31 + one of them set == 63, and 15
547            with both of them set == 63 */
548         if (val < 64)
549                 gspca_dev->usb_buf[0] = val;
550         else if (val < 128)
551                 gspca_dev->usb_buf[0] = (val / 2) | 0x40;
552         else
553                 gspca_dev->usb_buf[0] = (val / 4) | 0xc0;
554 
555         gspca_dev->usb_buf[1] = 0;
556         reg_w_buf(gspca_dev, 0x8335, 2);
557 }
558 
559 static void setautogain(struct gspca_dev *gspca_dev, s32 val)
560 {
561         struct sd *sd = (struct sd *) gspca_dev;
562 
563         if (val)
564                 sd->ag_cnt = AG_CNT_START;
565         else
566                 sd->ag_cnt = -1;
567 }
568 
569 static int sd_start_12a(struct gspca_dev *gspca_dev)
570 {
571         int mode;
572         static const __u8 Reg8391[8] =
573                 {0x92, 0x30, 0x20, 0x00, 0x0c, 0x00, 0x00, 0x00};
574 
575         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
576         if (mode <= 1) {
577                 /* Use compression on 320x240 and above */
578                 reg_w_val(gspca_dev, 0x8500, 0x10 | mode);
579         } else {
580                 /* I couldn't get the compression to work below 320x240
581                  * Fortunately at these resolutions the bandwidth
582                  * is sufficient to push raw frames at ~20fps */
583                 reg_w_val(gspca_dev, 0x8500, mode);
584         }               /* -- qq@kuku.eu.org */
585 
586         gspca_dev->usb_buf[0] = 0xaa;
587         gspca_dev->usb_buf[1] = 0x00;
588         reg_w_buf(gspca_dev, 0x8307, 2);
589         /* clock - lower 0x8X values lead to fps > 30 */
590         reg_w_val(gspca_dev, 0x8700, 0x8a);
591                                         /* 0x8f 0x85 0x27 clock */
592         reg_w_val(gspca_dev, 0x8112, 0x1e | 0x20);
593         reg_w_val(gspca_dev, 0x850b, 0x03);
594         memcpy(gspca_dev->usb_buf, Reg8391, 8);
595         reg_w_buf(gspca_dev, 0x8391, 8);
596         reg_w_buf(gspca_dev, 0x8390, 8);
597 
598         /* Led ON (bit 3 -> 0 */
599         reg_w_val(gspca_dev, 0x8114, 0x00);
600         return 0;
601 }
602 static int sd_start_72a(struct gspca_dev *gspca_dev)
603 {
604         struct sd *sd = (struct sd *) gspca_dev;
605         int Clck;
606         int mode;
607 
608         write_vector(gspca_dev, rev72a_reset);
609         msleep(200);
610         write_vector(gspca_dev, rev72a_init_data1);
611         write_sensor_72a(gspca_dev, rev72a_init_sensor1);
612 
613         mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
614         switch (mode) {
615         default:
616         case 0:
617                 Clck = 0x27;            /* ms-win 0x87 */
618                 break;
619         case 1:
620                 Clck = 0x25;
621                 break;
622         case 2:
623                 Clck = 0x22;
624                 break;
625         case 3:
626                 Clck = 0x21;
627                 break;
628         }
629         reg_w_val(gspca_dev, 0x8700, Clck);     /* 0x27 clock */
630         reg_w_val(gspca_dev, 0x8702, 0x81);
631         reg_w_val(gspca_dev, 0x8500, mode);     /* mode */
632         write_sensor_72a(gspca_dev, rev72a_init_sensor2);
633         setwhite(gspca_dev, v4l2_ctrl_g_ctrl(sd->hue),
634                         v4l2_ctrl_g_ctrl(sd->contrast));
635 /*      setbrightness(gspca_dev);        * fixme: bad values */
636         setautogain(gspca_dev, v4l2_ctrl_g_ctrl(sd->autogain));
637         reg_w_val(gspca_dev, 0x8112, 0x10 | 0x20);
638         return 0;
639 }
640 
641 static void sd_stopN(struct gspca_dev *gspca_dev)
642 {
643         struct sd *sd = (struct sd *) gspca_dev;
644 
645         if (sd->chip_revision == Rev012A) {
646                 reg_w_val(gspca_dev, 0x8112, 0x0e);
647                 /* Led Off (bit 3 -> 1 */
648                 reg_w_val(gspca_dev, 0x8114, 0x08);
649         } else {
650                 reg_w_val(gspca_dev, 0x8112, 0x20);
651 /*              reg_w_val(gspca_dev, 0x8102, 0x00); ?? */
652         }
653 }
654 
655 static void do_autogain(struct gspca_dev *gspca_dev)
656 {
657         struct sd *sd = (struct sd *) gspca_dev;
658         int expotimes;
659         int pixelclk;
660         int gainG;
661         __u8 R, Gr, Gb, B;
662         int y;
663         __u8 luma_mean = 110;
664         __u8 luma_delta = 20;
665         __u8 spring = 4;
666 
667         if (sd->ag_cnt < 0)
668                 return;
669         if (--sd->ag_cnt >= 0)
670                 return;
671         sd->ag_cnt = AG_CNT_START;
672 
673         switch (sd->chip_revision) {
674         case Rev072A:
675                 reg_r(gspca_dev, 0x8621, 1);
676                 Gr = gspca_dev->usb_buf[0];
677                 reg_r(gspca_dev, 0x8622, 1);
678                 R = gspca_dev->usb_buf[0];
679                 reg_r(gspca_dev, 0x8623, 1);
680                 B = gspca_dev->usb_buf[0];
681                 reg_r(gspca_dev, 0x8624, 1);
682                 Gb = gspca_dev->usb_buf[0];
683                 y = (77 * R + 75 * (Gr + Gb) + 29 * B) >> 8;
684                 /* u= (128*B-(43*(Gr+Gb+R))) >> 8; */
685                 /* v= (128*R-(53*(Gr+Gb))-21*B) >> 8; */
686                 /* PDEBUG(D_CONF,"reading Y %d U %d V %d ",y,u,v); */
687 
688                 if (y < luma_mean - luma_delta ||
689                     y > luma_mean + luma_delta) {
690                         expotimes = i2c_read(gspca_dev, 0x09, 0x10);
691                         pixelclk = 0x0800;
692                         expotimes = expotimes & 0x07ff;
693                         /* PDEBUG(D_PACK,
694                                 "Exposition Times 0x%03X Clock 0x%04X ",
695                                 expotimes,pixelclk); */
696                         gainG = i2c_read(gspca_dev, 0x35, 0x10);
697                         /* PDEBUG(D_PACK,
698                                 "reading Gain register %d", gainG); */
699 
700                         expotimes += (luma_mean - y) >> spring;
701                         gainG += (luma_mean - y) / 50;
702                         /* PDEBUG(D_PACK,
703                                 "compute expotimes %d gain %d",
704                                 expotimes,gainG); */
705 
706                         if (gainG > 0x3f)
707                                 gainG = 0x3f;
708                         else if (gainG < 3)
709                                 gainG = 3;
710                         i2c_write(gspca_dev, gainG, 0x35);
711 
712                         if (expotimes > 0x0256)
713                                 expotimes = 0x0256;
714                         else if (expotimes < 3)
715                                 expotimes = 3;
716                         i2c_write(gspca_dev, expotimes | pixelclk, 0x09);
717                 }
718                 break;
719         }
720 }
721 
722 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
723                         u8 *data,               /* isoc packet */
724                         int len)                /* iso packet length */
725 {
726         struct sd *sd = (struct sd *) gspca_dev;
727 
728         len--;
729         switch (*data++) {                      /* sequence number */
730         case 0:                                 /* start of frame */
731                 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
732 
733                 /* This should never happen */
734                 if (len < 2) {
735                         PERR("Short SOF packet, ignoring");
736                         gspca_dev->last_packet_type = DISCARD_PACKET;
737                         return;
738                 }
739 
740 #if IS_ENABLED(CONFIG_INPUT)
741                 if (data[0] & 0x20) {
742                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
743                         input_sync(gspca_dev->input_dev);
744                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
745                         input_sync(gspca_dev->input_dev);
746                 }
747 #endif
748 
749                 if (data[1] & 0x10) {
750                         /* compressed bayer */
751                         gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
752                 } else {
753                         /* raw bayer (with a header, which we skip) */
754                         if (sd->chip_revision == Rev012A) {
755                                 data += 20;
756                                 len -= 20;
757                         } else {
758                                 data += 16;
759                                 len -= 16;
760                         }
761                         gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
762                 }
763                 return;
764         case 0xff:                      /* drop (empty mpackets) */
765                 return;
766         }
767         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
768 }
769 
770 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
771 {
772         struct gspca_dev *gspca_dev =
773                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
774         struct sd *sd = (struct sd *)gspca_dev;
775 
776         gspca_dev->usb_err = 0;
777 
778         if (!gspca_dev->streaming)
779                 return 0;
780 
781         switch (ctrl->id) {
782         case V4L2_CID_BRIGHTNESS:
783                 setbrightness(gspca_dev, ctrl->val);
784                 break;
785         case V4L2_CID_CONTRAST:
786                 /* hue/contrast control cluster for 72a */
787                 setwhite(gspca_dev, sd->hue->val, ctrl->val);
788                 break;
789         case V4L2_CID_HUE:
790                 /* just plain hue control for 12a */
791                 setwhite(gspca_dev, ctrl->val, 0);
792                 break;
793         case V4L2_CID_EXPOSURE:
794                 setexposure(gspca_dev, ctrl->val);
795                 break;
796         case V4L2_CID_GAIN:
797                 setgain(gspca_dev, ctrl->val);
798                 break;
799         case V4L2_CID_AUTOGAIN:
800                 setautogain(gspca_dev, ctrl->val);
801                 break;
802         }
803         return gspca_dev->usb_err;
804 }
805 
806 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
807         .s_ctrl = sd_s_ctrl,
808 };
809 
810 static int sd_init_controls_12a(struct gspca_dev *gspca_dev)
811 {
812         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
813 
814         gspca_dev->vdev.ctrl_handler = hdl;
815         v4l2_ctrl_handler_init(hdl, 3);
816         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
817                         V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
818         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
819                         V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
820         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
821                         V4L2_CID_EXPOSURE, 1, EXPOSURE_MAX, 1, 700);
822         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
823                         V4L2_CID_GAIN, 0, 255, 1, 63);
824 
825         if (hdl->error) {
826                 pr_err("Could not initialize controls\n");
827                 return hdl->error;
828         }
829         return 0;
830 }
831 
832 static int sd_init_controls_72a(struct gspca_dev *gspca_dev)
833 {
834         struct sd *sd = (struct sd *)gspca_dev;
835         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
836 
837         gspca_dev->vdev.ctrl_handler = hdl;
838         v4l2_ctrl_handler_init(hdl, 4);
839         sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
840                         V4L2_CID_CONTRAST, 0, 0x3f, 1, 0x20);
841         sd->hue = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
842                         V4L2_CID_HUE, 1, 0x7f, 1, 0x40);
843         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
844                         V4L2_CID_BRIGHTNESS, 0, 0x3f, 1, 0x20);
845         sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
846                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
847 
848         if (hdl->error) {
849                 pr_err("Could not initialize controls\n");
850                 return hdl->error;
851         }
852         v4l2_ctrl_cluster(2, &sd->contrast);
853         return 0;
854 }
855 
856 /* sub-driver description */
857 static const struct sd_desc sd_desc_12a = {
858         .name = MODULE_NAME,
859         .init_controls = sd_init_controls_12a,
860         .config = sd_config,
861         .init = sd_init_12a,
862         .start = sd_start_12a,
863         .stopN = sd_stopN,
864         .pkt_scan = sd_pkt_scan,
865 #if IS_ENABLED(CONFIG_INPUT)
866         .other_input = 1,
867 #endif
868 };
869 static const struct sd_desc sd_desc_72a = {
870         .name = MODULE_NAME,
871         .init_controls = sd_init_controls_72a,
872         .config = sd_config,
873         .init = sd_init_72a,
874         .start = sd_start_72a,
875         .stopN = sd_stopN,
876         .pkt_scan = sd_pkt_scan,
877         .dq_callback = do_autogain,
878 #if IS_ENABLED(CONFIG_INPUT)
879         .other_input = 1,
880 #endif
881 };
882 static const struct sd_desc *sd_desc[2] = {
883         &sd_desc_12a,
884         &sd_desc_72a
885 };
886 
887 /* -- module initialisation -- */
888 static const struct usb_device_id device_table[] = {
889         {USB_DEVICE(0x041e, 0x401a), .driver_info = Rev072A},
890         {USB_DEVICE(0x041e, 0x403b), .driver_info = Rev012A},
891         {USB_DEVICE(0x0458, 0x7004), .driver_info = Rev072A},
892         {USB_DEVICE(0x0461, 0x0815), .driver_info = Rev072A},
893         {USB_DEVICE(0x046d, 0x0928), .driver_info = Rev012A},
894         {USB_DEVICE(0x046d, 0x0929), .driver_info = Rev012A},
895         {USB_DEVICE(0x046d, 0x092a), .driver_info = Rev012A},
896         {USB_DEVICE(0x046d, 0x092b), .driver_info = Rev012A},
897         {USB_DEVICE(0x046d, 0x092c), .driver_info = Rev012A},
898         {USB_DEVICE(0x046d, 0x092d), .driver_info = Rev012A},
899         {USB_DEVICE(0x046d, 0x092e), .driver_info = Rev012A},
900         {USB_DEVICE(0x046d, 0x092f), .driver_info = Rev012A},
901         {USB_DEVICE(0x04fc, 0x0561), .driver_info = Rev072A},
902         {USB_DEVICE(0x060b, 0xa001), .driver_info = Rev072A},
903         {USB_DEVICE(0x10fd, 0x7e50), .driver_info = Rev072A},
904         {USB_DEVICE(0xabcd, 0xcdee), .driver_info = Rev072A},
905         {}
906 };
907 
908 MODULE_DEVICE_TABLE(usb, device_table);
909 
910 /* -- device connect -- */
911 static int sd_probe(struct usb_interface *intf,
912                     const struct usb_device_id *id)
913 {
914         return gspca_dev_probe(intf, id,
915                                 sd_desc[id->driver_info],
916                                 sizeof(struct sd),
917                                THIS_MODULE);
918 }
919 
920 static struct usb_driver sd_driver = {
921         .name = MODULE_NAME,
922         .id_table = device_table,
923         .probe = sd_probe,
924         .disconnect = gspca_disconnect,
925 #ifdef CONFIG_PM
926         .suspend = gspca_suspend,
927         .resume = gspca_resume,
928         .reset_resume = gspca_resume,
929 #endif
930 };
931 
932 module_usb_driver(sd_driver);
933 

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