Version:  2.0.40 2.2.26 2.4.37 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 3.19 4.0 4.1 4.2

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

  1 /*
  2  * SN9C2028 library
  3  *
  4  * Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation; either version 2 of the License, or
  9  * any later version.
 10  *
 11  * This program is distributed in the hope that it will be useful,
 12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 14  * GNU General Public License for more details.
 15  *
 16  * You should have received a copy of the GNU General Public License
 17  * along with this program; if not, write to the Free Software
 18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 19  */
 20 
 21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 22 
 23 #define MODULE_NAME "sn9c2028"
 24 
 25 #include "gspca.h"
 26 
 27 MODULE_AUTHOR("Theodore Kilgore");
 28 MODULE_DESCRIPTION("Sonix SN9C2028 USB Camera Driver");
 29 MODULE_LICENSE("GPL");
 30 
 31 /* specific webcam descriptor */
 32 struct sd {
 33         struct gspca_dev gspca_dev;  /* !! must be the first item */
 34         u8 sof_read;
 35         u16 model;
 36 
 37 #define MIN_AVG_LUM 8500
 38 #define MAX_AVG_LUM 10000
 39         int avg_lum;
 40         u8 avg_lum_l;
 41 
 42         struct { /* autogain and gain control cluster */
 43                 struct v4l2_ctrl *autogain;
 44                 struct v4l2_ctrl *gain;
 45         };
 46 };
 47 
 48 struct init_command {
 49         unsigned char instruction[6];
 50         unsigned char to_read; /* length to read. 0 means no reply requested */
 51 };
 52 
 53 /* How to change the resolution of any of the VGA cams is unknown */
 54 static const struct v4l2_pix_format vga_mode[] = {
 55         {640, 480, V4L2_PIX_FMT_SN9C2028, V4L2_FIELD_NONE,
 56                 .bytesperline = 640,
 57                 .sizeimage = 640 * 480 * 3 / 4,
 58                 .colorspace = V4L2_COLORSPACE_SRGB,
 59                 .priv = 0},
 60 };
 61 
 62 /* No way to change the resolution of the CIF cams is known */
 63 static const struct v4l2_pix_format cif_mode[] = {
 64         {352, 288, V4L2_PIX_FMT_SN9C2028, V4L2_FIELD_NONE,
 65                 .bytesperline = 352,
 66                 .sizeimage = 352 * 288 * 3 / 4,
 67                 .colorspace = V4L2_COLORSPACE_SRGB,
 68                 .priv = 0},
 69 };
 70 
 71 /* the bytes to write are in gspca_dev->usb_buf */
 72 static int sn9c2028_command(struct gspca_dev *gspca_dev, u8 *command)
 73 {
 74         int rc;
 75 
 76         PDEBUG(D_USBO, "sending command %02x%02x%02x%02x%02x%02x", command[0],
 77                command[1], command[2], command[3], command[4], command[5]);
 78 
 79         memcpy(gspca_dev->usb_buf, command, 6);
 80         rc = usb_control_msg(gspca_dev->dev,
 81                         usb_sndctrlpipe(gspca_dev->dev, 0),
 82                         USB_REQ_GET_CONFIGURATION,
 83                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
 84                         2, 0, gspca_dev->usb_buf, 6, 500);
 85         if (rc < 0) {
 86                 pr_err("command write [%02x] error %d\n",
 87                        gspca_dev->usb_buf[0], rc);
 88                 return rc;
 89         }
 90 
 91         return 0;
 92 }
 93 
 94 static int sn9c2028_read1(struct gspca_dev *gspca_dev)
 95 {
 96         int rc;
 97 
 98         rc = usb_control_msg(gspca_dev->dev,
 99                         usb_rcvctrlpipe(gspca_dev->dev, 0),
100                         USB_REQ_GET_STATUS,
101                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
102                         1, 0, gspca_dev->usb_buf, 1, 500);
103         if (rc != 1) {
104                 pr_err("read1 error %d\n", rc);
105                 return (rc < 0) ? rc : -EIO;
106         }
107         PDEBUG(D_USBI, "read1 response %02x", gspca_dev->usb_buf[0]);
108         return gspca_dev->usb_buf[0];
109 }
110 
111 static int sn9c2028_read4(struct gspca_dev *gspca_dev, u8 *reading)
112 {
113         int rc;
114         rc = usb_control_msg(gspca_dev->dev,
115                         usb_rcvctrlpipe(gspca_dev->dev, 0),
116                         USB_REQ_GET_STATUS,
117                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
118                         4, 0, gspca_dev->usb_buf, 4, 500);
119         if (rc != 4) {
120                 pr_err("read4 error %d\n", rc);
121                 return (rc < 0) ? rc : -EIO;
122         }
123         memcpy(reading, gspca_dev->usb_buf, 4);
124         PDEBUG(D_USBI, "read4 response %02x%02x%02x%02x", reading[0],
125                reading[1], reading[2], reading[3]);
126         return rc;
127 }
128 
129 static int sn9c2028_long_command(struct gspca_dev *gspca_dev, u8 *command)
130 {
131         int i, status;
132         __u8 reading[4];
133 
134         status = sn9c2028_command(gspca_dev, command);
135         if (status < 0)
136                 return status;
137 
138         status = -1;
139         for (i = 0; i < 256 && status < 2; i++)
140                 status = sn9c2028_read1(gspca_dev);
141         if (status < 0) {
142                 pr_err("long command status read error %d\n", status);
143                 return (status < 0) ? status : -EIO;
144         }
145 
146         memset(reading, 0, 4);
147         status = sn9c2028_read4(gspca_dev, reading);
148         if (status < 0)
149                 return status;
150 
151         /* in general, the first byte of the response is the first byte of
152          * the command, or'ed with 8 */
153         status = sn9c2028_read1(gspca_dev);
154         if (status < 0)
155                 return status;
156 
157         return 0;
158 }
159 
160 static int sn9c2028_short_command(struct gspca_dev *gspca_dev, u8 *command)
161 {
162         int err_code;
163 
164         err_code = sn9c2028_command(gspca_dev, command);
165         if (err_code < 0)
166                 return err_code;
167 
168         err_code = sn9c2028_read1(gspca_dev);
169         if (err_code < 0)
170                 return err_code;
171 
172         return 0;
173 }
174 
175 /* this function is called at probe time */
176 static int sd_config(struct gspca_dev *gspca_dev,
177                      const struct usb_device_id *id)
178 {
179         struct sd *sd = (struct sd *) gspca_dev;
180         struct cam *cam = &gspca_dev->cam;
181 
182         PDEBUG(D_PROBE, "SN9C2028 camera detected (vid/pid 0x%04X:0x%04X)",
183                id->idVendor, id->idProduct);
184 
185         sd->model = id->idProduct;
186 
187         switch (sd->model) {
188         case 0x7005:
189                 PDEBUG(D_PROBE, "Genius Smart 300 camera");
190                 break;
191         case 0x7003:
192                 PDEBUG(D_PROBE, "Genius Videocam Live v2");
193                 break;
194         case 0x8000:
195                 PDEBUG(D_PROBE, "DC31VC");
196                 break;
197         case 0x8001:
198                 PDEBUG(D_PROBE, "Spy camera");
199                 break;
200         case 0x8003:
201                 PDEBUG(D_PROBE, "CIF camera");
202                 break;
203         case 0x8008:
204                 PDEBUG(D_PROBE, "Mini-Shotz ms-350 camera");
205                 break;
206         case 0x800a:
207                 PDEBUG(D_PROBE, "Vivitar 3350b type camera");
208                 cam->input_flags = V4L2_IN_ST_VFLIP | V4L2_IN_ST_HFLIP;
209                 break;
210         }
211 
212         switch (sd->model) {
213         case 0x8000:
214         case 0x8001:
215         case 0x8003:
216                 cam->cam_mode = cif_mode;
217                 cam->nmodes = ARRAY_SIZE(cif_mode);
218                 break;
219         default:
220                 cam->cam_mode = vga_mode;
221                 cam->nmodes = ARRAY_SIZE(vga_mode);
222         }
223         return 0;
224 }
225 
226 /* this function is called at probe and resume time */
227 static int sd_init(struct gspca_dev *gspca_dev)
228 {
229         int status = -1;
230 
231         sn9c2028_read1(gspca_dev);
232         sn9c2028_read1(gspca_dev);
233         status = sn9c2028_read1(gspca_dev);
234 
235         return (status < 0) ? status : 0;
236 }
237 
238 static int run_start_commands(struct gspca_dev *gspca_dev,
239                               struct init_command *cam_commands, int n)
240 {
241         int i, err_code = -1;
242 
243         for (i = 0; i < n; i++) {
244                 switch (cam_commands[i].to_read) {
245                 case 4:
246                         err_code = sn9c2028_long_command(gspca_dev,
247                                         cam_commands[i].instruction);
248                         break;
249                 case 1:
250                         err_code = sn9c2028_short_command(gspca_dev,
251                                         cam_commands[i].instruction);
252                         break;
253                 case 0:
254                         err_code = sn9c2028_command(gspca_dev,
255                                         cam_commands[i].instruction);
256                         break;
257                 }
258                 if (err_code < 0)
259                         return err_code;
260         }
261         return 0;
262 }
263 
264 static void set_gain(struct gspca_dev *gspca_dev, s32 g)
265 {
266         struct sd *sd = (struct sd *) gspca_dev;
267 
268         struct init_command genius_vcam_live_gain_cmds[] = {
269                 {{0x1d, 0x25, 0x10 /* This byte is gain */,
270                   0x20, 0xab, 0x00}, 0},
271         };
272         if (!gspca_dev->streaming)
273                 return;
274 
275         switch (sd->model) {
276         case 0x7003:
277                 genius_vcam_live_gain_cmds[0].instruction[2] = g;
278                 run_start_commands(gspca_dev, genius_vcam_live_gain_cmds,
279                                    ARRAY_SIZE(genius_vcam_live_gain_cmds));
280                 break;
281         default:
282                 break;
283         }
284 }
285 
286 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
287 {
288         struct gspca_dev *gspca_dev =
289                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
290         struct sd *sd = (struct sd *)gspca_dev;
291 
292         gspca_dev->usb_err = 0;
293 
294         if (!gspca_dev->streaming)
295                 return 0;
296 
297         switch (ctrl->id) {
298         /* standalone gain control */
299         case V4L2_CID_GAIN:
300                 set_gain(gspca_dev, ctrl->val);
301                 break;
302         /* autogain */
303         case V4L2_CID_AUTOGAIN:
304                 set_gain(gspca_dev, sd->gain->val);
305                 break;
306         }
307         return gspca_dev->usb_err;
308 }
309 
310 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
311         .s_ctrl = sd_s_ctrl,
312 };
313 
314 
315 static int sd_init_controls(struct gspca_dev *gspca_dev)
316 {
317         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
318         struct sd *sd = (struct sd *)gspca_dev;
319 
320         gspca_dev->vdev.ctrl_handler = hdl;
321         v4l2_ctrl_handler_init(hdl, 2);
322 
323         switch (sd->model) {
324         case 0x7003:
325                 sd->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
326                         V4L2_CID_GAIN, 0, 20, 1, 0);
327                 sd->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
328                         V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
329                 break;
330         default:
331                 break;
332         }
333 
334         return 0;
335 }
336 static int start_spy_cam(struct gspca_dev *gspca_dev)
337 {
338         struct init_command spy_start_commands[] = {
339                 {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
340                 {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
341                 {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
342                 {{0x13, 0x22, 0x01, 0x04, 0x00, 0x00}, 4},
343                 {{0x13, 0x23, 0x01, 0x03, 0x00, 0x00}, 4},
344                 {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
345                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4}, /* width  352 */
346                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4}, /* height 288 */
347                 /* {{0x13, 0x27, 0x01, 0x28, 0x00, 0x00}, 4}, */
348                 {{0x13, 0x27, 0x01, 0x68, 0x00, 0x00}, 4},
349                 {{0x13, 0x28, 0x01, 0x09, 0x00, 0x00}, 4}, /* red gain ?*/
350                 /* {{0x13, 0x28, 0x01, 0x00, 0x00, 0x00}, 4}, */
351                 {{0x13, 0x29, 0x01, 0x00, 0x00, 0x00}, 4},
352                 /* {{0x13, 0x29, 0x01, 0x0c, 0x00, 0x00}, 4}, */
353                 {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
354                 {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
355                 /* {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4}, */
356                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
357                 {{0x13, 0x2d, 0x01, 0x02, 0x00, 0x00}, 4},
358                 /* {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4}, */
359                 {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4},
360                 {{0x13, 0x2f, 0x01, 0x07, 0x00, 0x00}, 4},
361                 {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
362                 {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
363                 {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
364                 {{0x11, 0x02, 0x06, 0x00, 0x00, 0x00}, 4},
365                 {{0x11, 0x03, 0x13, 0x00, 0x00, 0x00}, 4}, /*don't mess with*/
366                 /*{{0x11, 0x04, 0x06, 0x00, 0x00, 0x00}, 4}, observed */
367                 {{0x11, 0x04, 0x00, 0x00, 0x00, 0x00}, 4}, /* brighter */
368                 /*{{0x11, 0x05, 0x65, 0x00, 0x00, 0x00}, 4}, observed */
369                 {{0x11, 0x05, 0x00, 0x00, 0x00, 0x00}, 4}, /* brighter */
370                 {{0x11, 0x06, 0xb1, 0x00, 0x00, 0x00}, 4}, /* observed */
371                 {{0x11, 0x07, 0x00, 0x00, 0x00, 0x00}, 4},
372                 /*{{0x11, 0x08, 0x06, 0x00, 0x00, 0x00}, 4}, observed */
373                 {{0x11, 0x08, 0x0b, 0x00, 0x00, 0x00}, 4},
374                 {{0x11, 0x09, 0x01, 0x00, 0x00, 0x00}, 4},
375                 {{0x11, 0x0a, 0x01, 0x00, 0x00, 0x00}, 4},
376                 {{0x11, 0x0b, 0x01, 0x00, 0x00, 0x00}, 4},
377                 {{0x11, 0x0c, 0x01, 0x00, 0x00, 0x00}, 4},
378                 {{0x11, 0x0d, 0x00, 0x00, 0x00, 0x00}, 4},
379                 {{0x11, 0x0e, 0x04, 0x00, 0x00, 0x00}, 4},
380                 /* {{0x11, 0x0f, 0x00, 0x00, 0x00, 0x00}, 4}, */
381                 /* brightness or gain. 0 is default. 4 is good
382                  * indoors at night with incandescent lighting */
383                 {{0x11, 0x0f, 0x04, 0x00, 0x00, 0x00}, 4},
384                 {{0x11, 0x10, 0x06, 0x00, 0x00, 0x00}, 4}, /*hstart or hoffs*/
385                 {{0x11, 0x11, 0x06, 0x00, 0x00, 0x00}, 4},
386                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
387                 {{0x11, 0x14, 0x02, 0x00, 0x00, 0x00}, 4},
388                 {{0x11, 0x13, 0x01, 0x00, 0x00, 0x00}, 4},
389                 /* {{0x1b, 0x02, 0x06, 0x00, 0x00, 0x00}, 1}, observed */
390                 {{0x1b, 0x02, 0x11, 0x00, 0x00, 0x00}, 1}, /* brighter */
391                 /* {{0x1b, 0x13, 0x01, 0x00, 0x00, 0x00}, 1}, observed */
392                 {{0x1b, 0x13, 0x11, 0x00, 0x00, 0x00}, 1},
393                 {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 1}, /* compresses */
394                 /* Camera should start to capture now. */
395         };
396 
397         return run_start_commands(gspca_dev, spy_start_commands,
398                                   ARRAY_SIZE(spy_start_commands));
399 }
400 
401 static int start_cif_cam(struct gspca_dev *gspca_dev)
402 {
403         struct init_command cif_start_commands[] = {
404                 {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
405                 /* The entire sequence below seems redundant */
406                 /* {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
407                 {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
408                 {{0x13, 0x22, 0x01, 0x06, 0x00, 0x00}, 4},
409                 {{0x13, 0x23, 0x01, 0x02, 0x00, 0x00}, 4},
410                 {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
411                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4}, width?
412                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4}, height?
413                 {{0x13, 0x27, 0x01, 0x68, 0x00, 0x00}, 4}, subsample?
414                 {{0x13, 0x28, 0x01, 0x00, 0x00, 0x00}, 4},
415                 {{0x13, 0x29, 0x01, 0x20, 0x00, 0x00}, 4},
416                 {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
417                 {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
418                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
419                 {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
420                 {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
421                 {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
422                 {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
423                 {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
424                 {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},*/
425                 {{0x1b, 0x21, 0x00, 0x00, 0x00, 0x00}, 1},
426                 {{0x1b, 0x17, 0x00, 0x00, 0x00, 0x00}, 1},
427                 {{0x1b, 0x19, 0x00, 0x00, 0x00, 0x00}, 1},
428                 {{0x1b, 0x02, 0x06, 0x00, 0x00, 0x00}, 1},
429                 {{0x1b, 0x03, 0x5a, 0x00, 0x00, 0x00}, 1},
430                 {{0x1b, 0x04, 0x27, 0x00, 0x00, 0x00}, 1},
431                 {{0x1b, 0x05, 0x01, 0x00, 0x00, 0x00}, 1},
432                 {{0x1b, 0x12, 0x14, 0x00, 0x00, 0x00}, 1},
433                 {{0x1b, 0x13, 0x00, 0x00, 0x00, 0x00}, 1},
434                 {{0x1b, 0x14, 0x00, 0x00, 0x00, 0x00}, 1},
435                 {{0x1b, 0x15, 0x00, 0x00, 0x00, 0x00}, 1},
436                 {{0x1b, 0x16, 0x00, 0x00, 0x00, 0x00}, 1},
437                 {{0x1b, 0x77, 0xa2, 0x00, 0x00, 0x00}, 1},
438                 {{0x1b, 0x06, 0x0f, 0x00, 0x00, 0x00}, 1},
439                 {{0x1b, 0x07, 0x14, 0x00, 0x00, 0x00}, 1},
440                 {{0x1b, 0x08, 0x0f, 0x00, 0x00, 0x00}, 1},
441                 {{0x1b, 0x09, 0x10, 0x00, 0x00, 0x00}, 1},
442                 {{0x1b, 0x0e, 0x00, 0x00, 0x00, 0x00}, 1},
443                 {{0x1b, 0x0f, 0x00, 0x00, 0x00, 0x00}, 1},
444                 {{0x1b, 0x12, 0x07, 0x00, 0x00, 0x00}, 1},
445                 {{0x1b, 0x10, 0x1f, 0x00, 0x00, 0x00}, 1},
446                 {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 1},
447                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 1}, /* width/8 */
448                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 1}, /* height/8 */
449                 /* {{0x13, 0x27, 0x01, 0x68, 0x00, 0x00}, 4}, subsample?
450                  * {{0x13, 0x28, 0x01, 0x1e, 0x00, 0x00}, 4}, does nothing
451                  * {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4}, */
452                 /* {{0x13, 0x29, 0x01, 0x22, 0x00, 0x00}, 4},
453                  * causes subsampling
454                  * but not a change in the resolution setting! */
455                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
456                 {{0x13, 0x2d, 0x01, 0x01, 0x00, 0x00}, 4},
457                 {{0x13, 0x2e, 0x01, 0x08, 0x00, 0x00}, 4},
458                 {{0x13, 0x2f, 0x01, 0x06, 0x00, 0x00}, 4},
459                 {{0x13, 0x28, 0x01, 0x00, 0x00, 0x00}, 4},
460                 {{0x1b, 0x04, 0x6d, 0x00, 0x00, 0x00}, 1},
461                 {{0x1b, 0x05, 0x03, 0x00, 0x00, 0x00}, 1},
462                 {{0x20, 0x36, 0x06, 0x00, 0x00, 0x00}, 1},
463                 {{0x1b, 0x0e, 0x01, 0x00, 0x00, 0x00}, 1},
464                 {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 4},
465                 {{0x1b, 0x0f, 0x00, 0x00, 0x00, 0x00}, 1},
466                 {{0x20, 0x36, 0x05, 0x00, 0x00, 0x00}, 1},
467                 {{0x1b, 0x10, 0x0f, 0x00, 0x00, 0x00}, 1},
468                 {{0x1b, 0x02, 0x06, 0x00, 0x00, 0x00}, 1},
469                 {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 1},
470                 {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 1},/* use compression */
471                 /* Camera should start to capture now. */
472         };
473 
474         return run_start_commands(gspca_dev, cif_start_commands,
475                                   ARRAY_SIZE(cif_start_commands));
476 }
477 
478 static int start_ms350_cam(struct gspca_dev *gspca_dev)
479 {
480         struct init_command ms350_start_commands[] = {
481                 {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
482                 {{0x16, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
483                 {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
484                 {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
485                 {{0x13, 0x22, 0x01, 0x04, 0x00, 0x00}, 4},
486                 {{0x13, 0x23, 0x01, 0x03, 0x00, 0x00}, 4},
487                 {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
488                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4},
489                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4},
490                 {{0x13, 0x27, 0x01, 0x28, 0x00, 0x00}, 4},
491                 {{0x13, 0x28, 0x01, 0x09, 0x00, 0x00}, 4},
492                 {{0x13, 0x29, 0x01, 0x00, 0x00, 0x00}, 4},
493                 {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
494                 {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
495                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
496                 {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
497                 {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
498                 {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
499                 {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
500                 {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
501                 {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
502                 {{0x11, 0x00, 0x01, 0x00, 0x00, 0x00}, 4},
503                 {{0x11, 0x01, 0x70, 0x00, 0x00, 0x00}, 4},
504                 {{0x11, 0x02, 0x05, 0x00, 0x00, 0x00}, 4},
505                 {{0x11, 0x03, 0x5d, 0x00, 0x00, 0x00}, 4},
506                 {{0x11, 0x04, 0x07, 0x00, 0x00, 0x00}, 4},
507                 {{0x11, 0x05, 0x25, 0x00, 0x00, 0x00}, 4},
508                 {{0x11, 0x06, 0x00, 0x00, 0x00, 0x00}, 4},
509                 {{0x11, 0x07, 0x09, 0x00, 0x00, 0x00}, 4},
510                 {{0x11, 0x08, 0x01, 0x00, 0x00, 0x00}, 4},
511                 {{0x11, 0x09, 0x00, 0x00, 0x00, 0x00}, 4},
512                 {{0x11, 0x0a, 0x00, 0x00, 0x00, 0x00}, 4},
513                 {{0x11, 0x0b, 0x01, 0x00, 0x00, 0x00}, 4},
514                 {{0x11, 0x0c, 0x00, 0x00, 0x00, 0x00}, 4},
515                 {{0x11, 0x0d, 0x0c, 0x00, 0x00, 0x00}, 4},
516                 {{0x11, 0x0e, 0x01, 0x00, 0x00, 0x00}, 4},
517                 {{0x11, 0x0f, 0x00, 0x00, 0x00, 0x00}, 4},
518                 {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
519                 {{0x11, 0x11, 0x00, 0x00, 0x00, 0x00}, 4},
520                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
521                 {{0x11, 0x13, 0x63, 0x00, 0x00, 0x00}, 4},
522                 {{0x11, 0x15, 0x70, 0x00, 0x00, 0x00}, 4},
523                 {{0x11, 0x18, 0x00, 0x00, 0x00, 0x00}, 4},
524                 {{0x11, 0x11, 0x01, 0x00, 0x00, 0x00}, 4},
525                 {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4}, /* width  */
526                 {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4}, /* height */
527                 {{0x13, 0x28, 0x01, 0x09, 0x00, 0x00}, 4}, /* vstart? */
528                 {{0x13, 0x27, 0x01, 0x28, 0x00, 0x00}, 4},
529                 {{0x13, 0x29, 0x01, 0x40, 0x00, 0x00}, 4}, /* hstart? */
530                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
531                 {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
532                 {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
533                 {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
534                 {{0x1b, 0x02, 0x05, 0x00, 0x00, 0x00}, 1},
535                 {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 1},
536                 {{0x20, 0x18, 0x00, 0x00, 0x00, 0x00}, 1},
537                 {{0x1b, 0x02, 0x0a, 0x00, 0x00, 0x00}, 1},
538                 {{0x1b, 0x11, 0x01, 0x00, 0x00, 0x00}, 0},
539                 /* Camera should start to capture now. */
540         };
541 
542         return run_start_commands(gspca_dev, ms350_start_commands,
543                                   ARRAY_SIZE(ms350_start_commands));
544 }
545 
546 static int start_genius_cam(struct gspca_dev *gspca_dev)
547 {
548         struct init_command genius_start_commands[] = {
549                 {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
550                 {{0x16, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
551                 {{0x10, 0x00, 0x00, 0x00, 0x00, 0x00}, 4},
552                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4},
553                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4},
554                 /* "preliminary" width and height settings */
555                 {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
556                 {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
557                 {{0x13, 0x29, 0x01, 0x22, 0x00, 0x00}, 4},
558                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
559                 {{0x13, 0x2d, 0x01, 0x02, 0x00, 0x00}, 4},
560                 {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4},
561                 {{0x13, 0x2f, 0x01, 0x07, 0x00, 0x00}, 4},
562                 {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
563                 {{0x11, 0x21, 0x2d, 0x00, 0x00, 0x00}, 4},
564                 {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
565                 {{0x11, 0x23, 0x03, 0x00, 0x00, 0x00}, 4},
566                 {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
567                 {{0x11, 0x11, 0x64, 0x00, 0x00, 0x00}, 4},
568                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
569                 {{0x11, 0x13, 0x91, 0x00, 0x00, 0x00}, 4},
570                 {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
571                 {{0x11, 0x15, 0x20, 0x00, 0x00, 0x00}, 4},
572                 {{0x11, 0x16, 0x01, 0x00, 0x00, 0x00}, 4},
573                 {{0x11, 0x17, 0x60, 0x00, 0x00, 0x00}, 4},
574                 {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
575                 {{0x11, 0x21, 0x2d, 0x00, 0x00, 0x00}, 4},
576                 {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
577                 {{0x11, 0x23, 0x03, 0x00, 0x00, 0x00}, 4},
578                 {{0x11, 0x25, 0x00, 0x00, 0x00, 0x00}, 4},
579                 {{0x11, 0x26, 0x02, 0x00, 0x00, 0x00}, 4},
580                 {{0x11, 0x27, 0x88, 0x00, 0x00, 0x00}, 4},
581                 {{0x11, 0x30, 0x38, 0x00, 0x00, 0x00}, 4},
582                 {{0x11, 0x31, 0x2a, 0x00, 0x00, 0x00}, 4},
583                 {{0x11, 0x32, 0x2a, 0x00, 0x00, 0x00}, 4},
584                 {{0x11, 0x33, 0x2a, 0x00, 0x00, 0x00}, 4},
585                 {{0x11, 0x34, 0x02, 0x00, 0x00, 0x00}, 4},
586                 {{0x11, 0x5b, 0x0a, 0x00, 0x00, 0x00}, 4},
587                 {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4}, /* real width */
588                 {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4}, /* real height */
589                 {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
590                 {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
591                 {{0x13, 0x29, 0x01, 0x62, 0x00, 0x00}, 4},
592                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
593                 {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
594                 {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
595                 {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
596                 {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
597                 {{0x11, 0x21, 0x2a, 0x00, 0x00, 0x00}, 4},
598                 {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
599                 {{0x11, 0x23, 0x28, 0x00, 0x00, 0x00}, 4},
600                 {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
601                 {{0x11, 0x11, 0x04, 0x00, 0x00, 0x00}, 4},
602                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
603                 {{0x11, 0x13, 0x03, 0x00, 0x00, 0x00}, 4},
604                 {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
605                 {{0x11, 0x15, 0xe0, 0x00, 0x00, 0x00}, 4},
606                 {{0x11, 0x16, 0x02, 0x00, 0x00, 0x00}, 4},
607                 {{0x11, 0x17, 0x80, 0x00, 0x00, 0x00}, 4},
608                 {{0x1c, 0x20, 0x00, 0x2a, 0x00, 0x00}, 1},
609                 {{0x1c, 0x20, 0x00, 0x2a, 0x00, 0x00}, 1},
610                 {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 0}
611                 /* Camera should start to capture now. */
612         };
613 
614         return run_start_commands(gspca_dev, genius_start_commands,
615                                   ARRAY_SIZE(genius_start_commands));
616 }
617 
618 static int start_genius_videocam_live(struct gspca_dev *gspca_dev)
619 {
620         int r;
621         struct sd *sd = (struct sd *) gspca_dev;
622         struct init_command genius_vcam_live_start_commands[] = {
623                 {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 0},
624                 {{0x16, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
625                 {{0x10, 0x00, 0x00, 0x00, 0x00, 0x00}, 4},
626                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4},
627                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4},
628 
629                 {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
630                 {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
631                 {{0x13, 0x29, 0x01, 0x22, 0x00, 0x00}, 4},
632                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
633                 {{0x13, 0x2d, 0x01, 0x02, 0x00, 0x00}, 4},
634                 {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4},
635                 {{0x13, 0x2f, 0x01, 0x07, 0x00, 0x00}, 4},
636                 {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
637                 {{0x11, 0x21, 0x2d, 0x00, 0x00, 0x00}, 4},
638                 {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
639                 {{0x11, 0x23, 0x03, 0x00, 0x00, 0x00}, 4},
640                 {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
641                 {{0x11, 0x11, 0x64, 0x00, 0x00, 0x00}, 4},
642                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
643                 {{0x11, 0x13, 0x91, 0x00, 0x00, 0x00}, 4},
644                 {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
645                 {{0x11, 0x15, 0x20, 0x00, 0x00, 0x00}, 4},
646                 {{0x11, 0x16, 0x01, 0x00, 0x00, 0x00}, 4},
647                 {{0x11, 0x17, 0x60, 0x00, 0x00, 0x00}, 4},
648                 {{0x1c, 0x20, 0x00, 0x2d, 0x00, 0x00}, 4},
649                 {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
650                 {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
651                 {{0x13, 0x22, 0x01, 0x00, 0x00, 0x00}, 4},
652                 {{0x13, 0x23, 0x01, 0x01, 0x00, 0x00}, 4},
653                 {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
654                 {{0x13, 0x25, 0x01, 0x16, 0x00, 0x00}, 4},
655                 {{0x13, 0x26, 0x01, 0x12, 0x00, 0x00}, 4},
656                 {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
657                 {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
658                 {{0x13, 0x29, 0x01, 0x22, 0x00, 0x00}, 4},
659                 {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
660                 {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
661                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
662                 {{0x13, 0x2d, 0x01, 0x02, 0x00, 0x00}, 4},
663                 {{0x13, 0x2e, 0x01, 0x09, 0x00, 0x00}, 4},
664                 {{0x13, 0x2f, 0x01, 0x07, 0x00, 0x00}, 4},
665                 {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
666                 {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
667                 {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
668                 {{0x11, 0x01, 0x04, 0x00, 0x00, 0x00}, 4},
669                 {{0x11, 0x02, 0x92, 0x00, 0x00, 0x00}, 4},
670                 {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
671                 {{0x11, 0x11, 0x64, 0x00, 0x00, 0x00}, 4},
672                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
673                 {{0x11, 0x13, 0x91, 0x00, 0x00, 0x00}, 4},
674                 {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
675                 {{0x11, 0x15, 0x20, 0x00, 0x00, 0x00}, 4},
676                 {{0x11, 0x16, 0x01, 0x00, 0x00, 0x00}, 4},
677                 {{0x11, 0x17, 0x60, 0x00, 0x00, 0x00}, 4},
678                 {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
679                 {{0x11, 0x21, 0x2d, 0x00, 0x00, 0x00}, 4},
680                 {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
681                 {{0x11, 0x23, 0x03, 0x00, 0x00, 0x00}, 4},
682                 {{0x11, 0x25, 0x00, 0x00, 0x00, 0x00}, 4},
683                 {{0x11, 0x26, 0x02, 0x00, 0x00, 0x00}, 4},
684                 {{0x11, 0x27, 0x88, 0x00, 0x00, 0x00}, 4},
685                 {{0x11, 0x30, 0x38, 0x00, 0x00, 0x00}, 4},
686                 {{0x11, 0x31, 0x2a, 0x00, 0x00, 0x00}, 4},
687                 {{0x11, 0x32, 0x2a, 0x00, 0x00, 0x00}, 4},
688                 {{0x11, 0x33, 0x2a, 0x00, 0x00, 0x00}, 4},
689                 {{0x11, 0x34, 0x02, 0x00, 0x00, 0x00}, 4},
690                 {{0x11, 0x5b, 0x0a, 0x00, 0x00, 0x00}, 4},
691                 {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4},
692                 {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4},
693                 {{0x13, 0x28, 0x01, 0x0e, 0x00, 0x00}, 4},
694                 {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
695                 {{0x13, 0x29, 0x01, 0x62, 0x00, 0x00}, 4},
696                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
697                 {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
698                 {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
699                 {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
700                 {{0x11, 0x20, 0x00, 0x00, 0x00, 0x00}, 4},
701                 {{0x11, 0x21, 0x2a, 0x00, 0x00, 0x00}, 4},
702                 {{0x11, 0x22, 0x00, 0x00, 0x00, 0x00}, 4},
703                 {{0x11, 0x23, 0x28, 0x00, 0x00, 0x00}, 4},
704                 {{0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 4},
705                 {{0x11, 0x11, 0x04, 0x00, 0x00, 0x00}, 4},
706                 {{0x11, 0x12, 0x00, 0x00, 0x00, 0x00}, 4},
707                 {{0x11, 0x13, 0x03, 0x00, 0x00, 0x00}, 4},
708                 {{0x11, 0x14, 0x01, 0x00, 0x00, 0x00}, 4},
709                 {{0x11, 0x15, 0xe0, 0x00, 0x00, 0x00}, 4},
710                 {{0x11, 0x16, 0x02, 0x00, 0x00, 0x00}, 4},
711                 {{0x11, 0x17, 0x80, 0x00, 0x00, 0x00}, 4},
712                 {{0x1c, 0x20, 0x00, 0x2a, 0x00, 0x00}, 1},
713                 {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 0},
714                 /* Camera should start to capture now. */
715                 {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 0},
716                 {{0x1b, 0x32, 0x26, 0x00, 0x00, 0x00}, 0},
717                 {{0x1d, 0x25, 0x10, 0x20, 0xab, 0x00}, 0},
718         };
719 
720         r = run_start_commands(gspca_dev, genius_vcam_live_start_commands,
721                                   ARRAY_SIZE(genius_vcam_live_start_commands));
722         if (r < 0)
723                 return r;
724 
725         if (sd->gain)
726                 set_gain(gspca_dev, v4l2_ctrl_g_ctrl(sd->gain));
727 
728         return r;
729 }
730 
731 static int start_vivitar_cam(struct gspca_dev *gspca_dev)
732 {
733         struct init_command vivitar_start_commands[] = {
734                 {{0x0c, 0x01, 0x00, 0x00, 0x00, 0x00}, 4},
735                 {{0x13, 0x20, 0x01, 0x00, 0x00, 0x00}, 4},
736                 {{0x13, 0x21, 0x01, 0x00, 0x00, 0x00}, 4},
737                 {{0x13, 0x22, 0x01, 0x01, 0x00, 0x00}, 4},
738                 {{0x13, 0x23, 0x01, 0x01, 0x00, 0x00}, 4},
739                 {{0x13, 0x24, 0x01, 0x00, 0x00, 0x00}, 4},
740                 {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4},
741                 {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4},
742                 {{0x13, 0x27, 0x01, 0x20, 0x00, 0x00}, 4},
743                 {{0x13, 0x28, 0x01, 0x0a, 0x00, 0x00}, 4},
744                 /*
745                  * Above is changed from OEM 0x0b. Fixes Bayer tiling.
746                  * Presumably gives a vertical shift of one row.
747                  */
748                 {{0x13, 0x29, 0x01, 0x20, 0x00, 0x00}, 4},
749                 /* Above seems to do horizontal shift. */
750                 {{0x13, 0x2a, 0x01, 0x00, 0x00, 0x00}, 4},
751                 {{0x13, 0x2b, 0x01, 0x00, 0x00, 0x00}, 4},
752                 {{0x13, 0x2c, 0x01, 0x02, 0x00, 0x00}, 4},
753                 {{0x13, 0x2d, 0x01, 0x03, 0x00, 0x00}, 4},
754                 {{0x13, 0x2e, 0x01, 0x0f, 0x00, 0x00}, 4},
755                 {{0x13, 0x2f, 0x01, 0x0c, 0x00, 0x00}, 4},
756                 /* Above three commands seem to relate to brightness. */
757                 {{0x12, 0x34, 0x01, 0x00, 0x00, 0x00}, 4},
758                 {{0x13, 0x34, 0x01, 0xa1, 0x00, 0x00}, 4},
759                 {{0x13, 0x35, 0x01, 0x00, 0x00, 0x00}, 4},
760                 {{0x1b, 0x12, 0x80, 0x00, 0x00, 0x00}, 1},
761                 {{0x1b, 0x01, 0x77, 0x00, 0x00, 0x00}, 1},
762                 {{0x1b, 0x02, 0x3a, 0x00, 0x00, 0x00}, 1},
763                 {{0x1b, 0x12, 0x78, 0x00, 0x00, 0x00}, 1},
764                 {{0x1b, 0x13, 0x00, 0x00, 0x00, 0x00}, 1},
765                 {{0x1b, 0x14, 0x80, 0x00, 0x00, 0x00}, 1},
766                 {{0x1b, 0x15, 0x34, 0x00, 0x00, 0x00}, 1},
767                 {{0x1b, 0x1b, 0x04, 0x00, 0x00, 0x00}, 1},
768                 {{0x1b, 0x20, 0x44, 0x00, 0x00, 0x00}, 1},
769                 {{0x1b, 0x23, 0xee, 0x00, 0x00, 0x00}, 1},
770                 {{0x1b, 0x26, 0xa0, 0x00, 0x00, 0x00}, 1},
771                 {{0x1b, 0x27, 0x9a, 0x00, 0x00, 0x00}, 1},
772                 {{0x1b, 0x28, 0xa0, 0x00, 0x00, 0x00}, 1},
773                 {{0x1b, 0x29, 0x30, 0x00, 0x00, 0x00}, 1},
774                 {{0x1b, 0x2a, 0x80, 0x00, 0x00, 0x00}, 1},
775                 {{0x1b, 0x2b, 0x00, 0x00, 0x00, 0x00}, 1},
776                 {{0x1b, 0x2f, 0x3d, 0x00, 0x00, 0x00}, 1},
777                 {{0x1b, 0x30, 0x24, 0x00, 0x00, 0x00}, 1},
778                 {{0x1b, 0x32, 0x86, 0x00, 0x00, 0x00}, 1},
779                 {{0x1b, 0x60, 0xa9, 0x00, 0x00, 0x00}, 1},
780                 {{0x1b, 0x61, 0x42, 0x00, 0x00, 0x00}, 1},
781                 {{0x1b, 0x65, 0x00, 0x00, 0x00, 0x00}, 1},
782                 {{0x1b, 0x69, 0x38, 0x00, 0x00, 0x00}, 1},
783                 {{0x1b, 0x6f, 0x88, 0x00, 0x00, 0x00}, 1},
784                 {{0x1b, 0x70, 0x0b, 0x00, 0x00, 0x00}, 1},
785                 {{0x1b, 0x71, 0x00, 0x00, 0x00, 0x00}, 1},
786                 {{0x1b, 0x74, 0x21, 0x00, 0x00, 0x00}, 1},
787                 {{0x1b, 0x75, 0x86, 0x00, 0x00, 0x00}, 1},
788                 {{0x1b, 0x76, 0x00, 0x00, 0x00, 0x00}, 1},
789                 {{0x1b, 0x7d, 0xf3, 0x00, 0x00, 0x00}, 1},
790                 {{0x1b, 0x17, 0x1c, 0x00, 0x00, 0x00}, 1},
791                 {{0x1b, 0x18, 0xc0, 0x00, 0x00, 0x00}, 1},
792                 {{0x1b, 0x19, 0x05, 0x00, 0x00, 0x00}, 1},
793                 {{0x1b, 0x1a, 0xf6, 0x00, 0x00, 0x00}, 1},
794                 /* {{0x13, 0x25, 0x01, 0x28, 0x00, 0x00}, 4},
795                 {{0x13, 0x26, 0x01, 0x1e, 0x00, 0x00}, 4},
796                 {{0x13, 0x28, 0x01, 0x0b, 0x00, 0x00}, 4}, */
797                 {{0x20, 0x36, 0x06, 0x00, 0x00, 0x00}, 1},
798                 {{0x1b, 0x10, 0x26, 0x00, 0x00, 0x00}, 1},
799                 {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 4},
800                 {{0x1b, 0x76, 0x03, 0x00, 0x00, 0x00}, 1},
801                 {{0x20, 0x36, 0x05, 0x00, 0x00, 0x00}, 1},
802                 {{0x1b, 0x00, 0x3f, 0x00, 0x00, 0x00}, 1},
803                 /* Above is brightness; OEM driver setting is 0x10 */
804                 {{0x12, 0x27, 0x01, 0x00, 0x00, 0x00}, 4},
805                 {{0x20, 0x29, 0x30, 0x00, 0x00, 0x00}, 1},
806                 {{0x20, 0x34, 0xa1, 0x00, 0x00, 0x00}, 1}
807         };
808 
809         return run_start_commands(gspca_dev, vivitar_start_commands,
810                                   ARRAY_SIZE(vivitar_start_commands));
811 }
812 
813 static int sd_start(struct gspca_dev *gspca_dev)
814 {
815         struct sd *sd = (struct sd *) gspca_dev;
816         int err_code;
817 
818         sd->sof_read = 0;
819 
820         switch (sd->model) {
821         case 0x7005:
822                 err_code = start_genius_cam(gspca_dev);
823                 break;
824         case 0x7003:
825                 err_code = start_genius_videocam_live(gspca_dev);
826                 break;
827         case 0x8001:
828                 err_code = start_spy_cam(gspca_dev);
829                 break;
830         case 0x8003:
831                 err_code = start_cif_cam(gspca_dev);
832                 break;
833         case 0x8008:
834                 err_code = start_ms350_cam(gspca_dev);
835                 break;
836         case 0x800a:
837                 err_code = start_vivitar_cam(gspca_dev);
838                 break;
839         default:
840                 pr_err("Starting unknown camera, please report this\n");
841                 return -ENXIO;
842         }
843 
844         sd->avg_lum = -1;
845 
846         return err_code;
847 }
848 
849 static void sd_stopN(struct gspca_dev *gspca_dev)
850 {
851         int result;
852         __u8 data[6];
853 
854         result = sn9c2028_read1(gspca_dev);
855         if (result < 0)
856                 PERR("Camera Stop read failed");
857 
858         memset(data, 0, 6);
859         data[0] = 0x14;
860         result = sn9c2028_command(gspca_dev, data);
861         if (result < 0)
862                 PERR("Camera Stop command failed");
863 }
864 
865 static void do_autogain(struct gspca_dev *gspca_dev, int avg_lum)
866 {
867         struct sd *sd = (struct sd *) gspca_dev;
868         s32 cur_gain = v4l2_ctrl_g_ctrl(sd->gain);
869 
870         if (avg_lum == -1)
871                 return;
872 
873         if (avg_lum < MIN_AVG_LUM) {
874                 if (cur_gain == sd->gain->maximum)
875                         return;
876                 cur_gain++;
877                 v4l2_ctrl_s_ctrl(sd->gain, cur_gain);
878         }
879         if (avg_lum > MAX_AVG_LUM) {
880                 if (cur_gain == sd->gain->minimum)
881                         return;
882                 cur_gain--;
883                 v4l2_ctrl_s_ctrl(sd->gain, cur_gain);
884         }
885 
886 }
887 
888 static void sd_dqcallback(struct gspca_dev *gspca_dev)
889 {
890         struct sd *sd = (struct sd *) gspca_dev;
891 
892         if (sd->autogain == NULL || !v4l2_ctrl_g_ctrl(sd->autogain))
893                 return;
894 
895         do_autogain(gspca_dev, sd->avg_lum);
896 }
897 
898 /* Include sn9c2028 sof detection functions */
899 #include "sn9c2028.h"
900 
901 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
902                         __u8 *data,                     /* isoc packet */
903                         int len)                        /* iso packet length */
904 {
905         unsigned char *sof;
906 
907         sof = sn9c2028_find_sof(gspca_dev, data, len);
908         if (sof) {
909                 int n;
910 
911                 /* finish decoding current frame */
912                 n = sof - data;
913                 if (n > sizeof sn9c2028_sof_marker)
914                         n -= sizeof sn9c2028_sof_marker;
915                 else
916                         n = 0;
917                 gspca_frame_add(gspca_dev, LAST_PACKET, data, n);
918                 /* Start next frame. */
919                 gspca_frame_add(gspca_dev, FIRST_PACKET,
920                         sn9c2028_sof_marker, sizeof sn9c2028_sof_marker);
921                 len -= sof - data;
922                 data = sof;
923         }
924         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
925 }
926 
927 /* sub-driver description */
928 static const struct sd_desc sd_desc = {
929         .name = MODULE_NAME,
930         .config = sd_config,
931         .init = sd_init,
932         .init_controls = sd_init_controls,
933         .start = sd_start,
934         .stopN = sd_stopN,
935         .dq_callback = sd_dqcallback,
936         .pkt_scan = sd_pkt_scan,
937 };
938 
939 /* -- module initialisation -- */
940 static const struct usb_device_id device_table[] = {
941         {USB_DEVICE(0x0458, 0x7005)}, /* Genius Smart 300, version 2 */
942         {USB_DEVICE(0x0458, 0x7003)}, /* Genius Videocam Live v2  */
943         /* The Genius Smart is untested. I can't find an owner ! */
944         /* {USB_DEVICE(0x0c45, 0x8000)}, DC31VC, Don't know this camera */
945         {USB_DEVICE(0x0c45, 0x8001)}, /* Wild Planet digital spy cam */
946         {USB_DEVICE(0x0c45, 0x8003)}, /* Several small CIF cameras */
947         /* {USB_DEVICE(0x0c45, 0x8006)}, Unknown VGA camera */
948         {USB_DEVICE(0x0c45, 0x8008)}, /* Mini-Shotz ms-350 */
949         {USB_DEVICE(0x0c45, 0x800a)}, /* Vivicam 3350B */
950         {}
951 };
952 MODULE_DEVICE_TABLE(usb, device_table);
953 
954 /* -- device connect -- */
955 static int sd_probe(struct usb_interface *intf,
956                         const struct usb_device_id *id)
957 {
958         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
959                                THIS_MODULE);
960 }
961 
962 static struct usb_driver sd_driver = {
963         .name = MODULE_NAME,
964         .id_table = device_table,
965         .probe = sd_probe,
966         .disconnect = gspca_disconnect,
967 #ifdef CONFIG_PM
968         .suspend = gspca_suspend,
969         .resume = gspca_resume,
970         .reset_resume = gspca_resume,
971 #endif
972 };
973 
974 module_usb_driver(sd_driver);
975 

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