?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] gspca: Use current logging styles
[pohmelfs.git] / drivers / media / video / gspca / se401.c
blob3b71bbcd977add2e91847ec6799bdefae4cedf80
1 /*
2 * GSPCA Endpoints (formerly known as AOX) se401 USB Camera sub Driver
3 *
4 * Copyright (C) 2011 Hans de Goede <hdegoede@redhat.com>
5 *
6 * Based on the v4l1 se401 driver which is:
7 *
8 * Copyright (c) 2000 Jeroen B. Vreeken (pe1rxq@amsat.org)
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28 #define MODULE_NAME "se401"
29
30 #define BULK_SIZE 4096
31 #define PACKET_SIZE 1024
32 #define READ_REQ_SIZE 64
33 #define MAX_MODES ((READ_REQ_SIZE - 6) / 4)
34 /* The se401 compression algorithm uses a fixed quant factor, which
35 can be configured by setting the high nibble of the SE401_OPERATINGMODE
36 feature. This needs to exactly match what is in libv4l! */
37 #define SE401_QUANT_FACT 8
38
39 #include <linux/input.h>
40 #include <linux/slab.h>
41 #include "gspca.h"
42 #include "se401.h"
43
44 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
45 MODULE_DESCRIPTION("Endpoints se401");
46 MODULE_LICENSE("GPL");
47
48 /* controls */
49 enum e_ctrl {
50 BRIGHTNESS,
51 GAIN,
52 EXPOSURE,
53 FREQ,
54 NCTRL /* number of controls */
55 };
56
57 /* exposure change state machine states */
58 enum {
59 EXPO_CHANGED,
60 EXPO_DROP_FRAME,
61 EXPO_NO_CHANGE,
62 };
63
64 /* specific webcam descriptor */
65 struct sd {
66 struct gspca_dev gspca_dev; /* !! must be the first item */
67 struct gspca_ctrl ctrls[NCTRL];
68 struct v4l2_pix_format fmts[MAX_MODES];
69 int pixels_read;
70 int packet_read;
71 u8 packet[PACKET_SIZE];
72 u8 restart_stream;
73 u8 button_state;
74 u8 resetlevel;
75 u8 resetlevel_frame_count;
76 int resetlevel_adjust_dir;
77 int expo_change_state;
78 };
79
80 static void setbrightness(struct gspca_dev *gspca_dev);
81 static void setgain(struct gspca_dev *gspca_dev);
82 static void setexposure(struct gspca_dev *gspca_dev);
83
84 static const struct ctrl sd_ctrls[NCTRL] = {
85 [BRIGHTNESS] = {
86 {
87 .id = V4L2_CID_BRIGHTNESS,
88 .type = V4L2_CTRL_TYPE_INTEGER,
89 .name = "Brightness",
90 .minimum = 0,
91 .maximum = 255,
92 .step = 1,
93 .default_value = 15,
94 },
95 .set_control = setbrightness
96 },
97 [GAIN] = {
98 {
99 .id = V4L2_CID_GAIN,
100 .type = V4L2_CTRL_TYPE_INTEGER,
101 .name = "Gain",
102 .minimum = 0,
103 .maximum = 50, /* Really 63 but > 50 is not pretty */
104 .step = 1,
105 .default_value = 25,
106 },
107 .set_control = setgain
108 },
109 [EXPOSURE] = {
110 {
111 .id = V4L2_CID_EXPOSURE,
112 .type = V4L2_CTRL_TYPE_INTEGER,
113 .name = "Exposure",
114 .minimum = 0,
115 .maximum = 32767,
116 .step = 1,
117 .default_value = 15000,
118 },
119 .set_control = setexposure
120 },
121 [FREQ] = {
122 {
123 .id = V4L2_CID_POWER_LINE_FREQUENCY,
124 .type = V4L2_CTRL_TYPE_MENU,
125 .name = "Light frequency filter",
126 .minimum = 0,
127 .maximum = 2,
128 .step = 1,
129 .default_value = 0,
130 },
131 .set_control = setexposure
132 },
133 };
134
135 static void se401_write_req(struct gspca_dev *gspca_dev, u16 req, u16 value,
136 int silent)
137 {
138 int err;
139
140 if (gspca_dev->usb_err < 0)
141 return;
142
143 err = usb_control_msg(gspca_dev->dev,
144 usb_sndctrlpipe(gspca_dev->dev, 0), req,
145 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
146 value, 0, NULL, 0, 1000);
147 if (err < 0) {
148 if (!silent)
149 pr_err("write req failed req %#04x val %#04x error %d\n",
150 req, value, err);
151 gspca_dev->usb_err = err;
152 }
153 }
154
155 static void se401_read_req(struct gspca_dev *gspca_dev, u16 req, int silent)
156 {
157 int err;
158
159 if (gspca_dev->usb_err < 0)
160 return;
161
162 if (USB_BUF_SZ < READ_REQ_SIZE) {
163 pr_err("USB_BUF_SZ too small!!\n");
164 gspca_dev->usb_err = -ENOBUFS;
165 return;
166 }
167
168 err = usb_control_msg(gspca_dev->dev,
169 usb_rcvctrlpipe(gspca_dev->dev, 0), req,
170 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
171 0, 0, gspca_dev->usb_buf, READ_REQ_SIZE, 1000);
172 if (err < 0) {
173 if (!silent)
174 pr_err("read req failed req %#04x error %d\n",
175 req, err);
176 gspca_dev->usb_err = err;
177 }
178 }
179
180 static void se401_set_feature(struct gspca_dev *gspca_dev,
181 u16 selector, u16 param)
182 {
183 int err;
184
185 if (gspca_dev->usb_err < 0)
186 return;
187
188 err = usb_control_msg(gspca_dev->dev,
189 usb_sndctrlpipe(gspca_dev->dev, 0),
190 SE401_REQ_SET_EXT_FEATURE,
191 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
192 param, selector, NULL, 0, 1000);
193 if (err < 0) {
194 pr_err("set feature failed sel %#04x param %#04x error %d\n",
195 selector, param, err);
196 gspca_dev->usb_err = err;
197 }
198 }
199
200 static int se401_get_feature(struct gspca_dev *gspca_dev, u16 selector)
201 {
202 int err;
203
204 if (gspca_dev->usb_err < 0)
205 return gspca_dev->usb_err;
206
207 if (USB_BUF_SZ < 2) {
208 pr_err("USB_BUF_SZ too small!!\n");
209 gspca_dev->usb_err = -ENOBUFS;
210 return gspca_dev->usb_err;
211 }
212
213 err = usb_control_msg(gspca_dev->dev,
214 usb_rcvctrlpipe(gspca_dev->dev, 0),
215 SE401_REQ_GET_EXT_FEATURE,
216 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
217 0, selector, gspca_dev->usb_buf, 2, 1000);
218 if (err < 0) {
219 pr_err("get feature failed sel %#04x error %d\n",
220 selector, err);
221 gspca_dev->usb_err = err;
222 return err;
223 }
224 return gspca_dev->usb_buf[0] | (gspca_dev->usb_buf[1] << 8);
225 }
226
227 static void setbrightness(struct gspca_dev *gspca_dev)
228 {
229 struct sd *sd = (struct sd *) gspca_dev;
230
231 if (gspca_dev->ctrl_dis & (1 << BRIGHTNESS))
232 return;
233
234 /* HDG: this does not seem to do anything on my cam */
235 se401_write_req(gspca_dev, SE401_REQ_SET_BRT,
236 sd->ctrls[BRIGHTNESS].val, 0);
237 }
238
239 static void setgain(struct gspca_dev *gspca_dev)
240 {
241 struct sd *sd = (struct sd *) gspca_dev;
242 u16 gain = 63 - sd->ctrls[GAIN].val;
243
244 /* red color gain */
245 se401_set_feature(gspca_dev, HV7131_REG_ARCG, gain);
246 /* green color gain */
247 se401_set_feature(gspca_dev, HV7131_REG_AGCG, gain);
248 /* blue color gain */
249 se401_set_feature(gspca_dev, HV7131_REG_ABCG, gain);
250 }
251
252 static void setexposure(struct gspca_dev *gspca_dev)
253 {
254 struct sd *sd = (struct sd *) gspca_dev;
255 int integration = sd->ctrls[EXPOSURE].val << 6;
256 u8 expose_h, expose_m, expose_l;
257
258 /* Do this before the set_feature calls, for proper timing wrt
259 the interrupt driven pkt_scan. Note we may still race but that
260 is not a big issue, the expo change state machine is merely for
261 avoiding underexposed frames getting send out, if one sneaks
262 through so be it */
263 sd->expo_change_state = EXPO_CHANGED;
264
265 if (sd->ctrls[FREQ].val == V4L2_CID_POWER_LINE_FREQUENCY_50HZ)
266 integration = integration - integration % 106667;
267 if (sd->ctrls[FREQ].val == V4L2_CID_POWER_LINE_FREQUENCY_60HZ)
268 integration = integration - integration % 88889;
269
270 expose_h = (integration >> 16);
271 expose_m = (integration >> 8);
272 expose_l = integration;
273
274 /* integration time low */
275 se401_set_feature(gspca_dev, HV7131_REG_TITL, expose_l);
276 /* integration time mid */
277 se401_set_feature(gspca_dev, HV7131_REG_TITM, expose_m);
278 /* integration time high */
279 se401_set_feature(gspca_dev, HV7131_REG_TITU, expose_h);
280 }
281
282 static int sd_config(struct gspca_dev *gspca_dev,
283 const struct usb_device_id *id)
284 {
285 struct sd *sd = (struct sd *)gspca_dev;
286 struct cam *cam = &gspca_dev->cam;
287 u8 *cd = gspca_dev->usb_buf;
288 int i, j, n;
289 int widths[MAX_MODES], heights[MAX_MODES];
290
291 /* Read the camera descriptor */
292 se401_read_req(gspca_dev, SE401_REQ_GET_CAMERA_DESCRIPTOR, 1);
293 if (gspca_dev->usb_err) {
294 /* Sometimes after being idle for a while the se401 won't
295 respond and needs a good kicking */
296 usb_reset_device(gspca_dev->dev);
297 gspca_dev->usb_err = 0;
298 se401_read_req(gspca_dev, SE401_REQ_GET_CAMERA_DESCRIPTOR, 0);
299 }
300
301 /* Some cameras start with their LED on */
302 se401_write_req(gspca_dev, SE401_REQ_LED_CONTROL, 0, 0);
303 if (gspca_dev->usb_err)
304 return gspca_dev->usb_err;
305
306 if (cd[1] != 0x41) {
307 pr_err("Wrong descriptor type\n");
308 return -ENODEV;
309 }
310
311 if (!(cd[2] & SE401_FORMAT_BAYER)) {
312 pr_err("Bayer format not supported!\n");
313 return -ENODEV;
314 }
315
316 if (cd[3])
317 pr_info("ExtraFeatures: %d\n", cd[3]);
318
319 n = cd[4] | (cd[5] << 8);
320 if (n > MAX_MODES) {
321 pr_err("Too many frame sizes\n");
322 return -ENODEV;
323 }
324
325 for (i = 0; i < n ; i++) {
326 widths[i] = cd[6 + i * 4 + 0] | (cd[6 + i * 4 + 1] << 8);
327 heights[i] = cd[6 + i * 4 + 2] | (cd[6 + i * 4 + 3] << 8);
328 }
329
330 for (i = 0; i < n ; i++) {
331 sd->fmts[i].width = widths[i];
332 sd->fmts[i].height = heights[i];
333 sd->fmts[i].field = V4L2_FIELD_NONE;
334 sd->fmts[i].colorspace = V4L2_COLORSPACE_SRGB;
335 sd->fmts[i].priv = 1;
336
337 /* janggu compression only works for 1/4th or 1/16th res */
338 for (j = 0; j < n; j++) {
339 if (widths[j] / 2 == widths[i] &&
340 heights[j] / 2 == heights[i]) {
341 sd->fmts[i].priv = 2;
342 break;
343 }
344 }
345 /* 1/16th if available too is better then 1/4th, because
346 we then use a larger area of the sensor */
347 for (j = 0; j < n; j++) {
348 if (widths[j] / 4 == widths[i] &&
349 heights[j] / 4 == heights[i]) {
350 sd->fmts[i].priv = 4;
351 break;
352 }
353 }
354
355 if (sd->fmts[i].priv == 1) {
356 /* Not a 1/4th or 1/16th res, use bayer */
357 sd->fmts[i].pixelformat = V4L2_PIX_FMT_SBGGR8;
358 sd->fmts[i].bytesperline = widths[i];
359 sd->fmts[i].sizeimage = widths[i] * heights[i];
360 pr_info("Frame size: %dx%d bayer\n",
361 widths[i], heights[i]);
362 } else {
363 /* Found a match use janggu compression */
364 sd->fmts[i].pixelformat = V4L2_PIX_FMT_SE401;
365 sd->fmts[i].bytesperline = 0;
366 sd->fmts[i].sizeimage = widths[i] * heights[i] * 3;
367 pr_info("Frame size: %dx%d 1/%dth janggu\n",
368 widths[i], heights[i],
369 sd->fmts[i].priv * sd->fmts[i].priv);
370 }
371 }
372
373 cam->cam_mode = sd->fmts;
374 cam->nmodes = n;
375 cam->bulk = 1;
376 cam->bulk_size = BULK_SIZE;
377 cam->bulk_nurbs = 4;
378 cam->ctrls = sd->ctrls;
379 gspca_dev->nbalt = 1; /* Ignore the bogus isoc alt settings */
380 sd->resetlevel = 0x2d; /* Set initial resetlevel */
381
382 /* See if the camera supports brightness */
383 se401_read_req(gspca_dev, SE401_REQ_GET_BRT, 1);
384 if (gspca_dev->usb_err) {
385 gspca_dev->ctrl_dis = (1 << BRIGHTNESS);
386 gspca_dev->usb_err = 0;
387 }
388
389 return 0;
390 }
391
392 /* this function is called at probe and resume time */
393 static int sd_init(struct gspca_dev *gspca_dev)
394 {
395 return 0;
396 }
397
398 /* -- start the camera -- */
399 static int sd_start(struct gspca_dev *gspca_dev)
400 {
401 struct sd *sd = (struct sd *)gspca_dev;
402 int mult = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
403 int mode = 0;
404
405 se401_write_req(gspca_dev, SE401_REQ_CAMERA_POWER, 1, 1);
406 if (gspca_dev->usb_err) {
407 /* Sometimes after being idle for a while the se401 won't
408 respond and needs a good kicking */
409 usb_reset_device(gspca_dev->dev);
410 gspca_dev->usb_err = 0;
411 se401_write_req(gspca_dev, SE401_REQ_CAMERA_POWER, 1, 0);
412 }
413 se401_write_req(gspca_dev, SE401_REQ_LED_CONTROL, 1, 0);
414
415 se401_set_feature(gspca_dev, HV7131_REG_MODE_B, 0x05);
416
417 /* set size + mode */
418 se401_write_req(gspca_dev, SE401_REQ_SET_WIDTH,
419 gspca_dev->width * mult, 0);
420 se401_write_req(gspca_dev, SE401_REQ_SET_HEIGHT,
421 gspca_dev->height * mult, 0);
422 /*
423 * HDG: disabled this as it does not seem to do anything
424 * se401_write_req(gspca_dev, SE401_REQ_SET_OUTPUT_MODE,
425 * SE401_FORMAT_BAYER, 0);
426 */
427
428 switch (mult) {
429 case 1: /* Raw bayer */
430 mode = 0x03; break;
431 case 2: /* 1/4th janggu */
432 mode = SE401_QUANT_FACT << 4; break;
433 case 4: /* 1/16th janggu */
434 mode = (SE401_QUANT_FACT << 4) | 0x02; break;
435 }
436 se401_set_feature(gspca_dev, SE401_OPERATINGMODE, mode);
437
438 setbrightness(gspca_dev);
439 setgain(gspca_dev);
440 setexposure(gspca_dev);
441 se401_set_feature(gspca_dev, HV7131_REG_ARLV, sd->resetlevel);
442
443 sd->packet_read = 0;
444 sd->pixels_read = 0;
445 sd->restart_stream = 0;
446 sd->resetlevel_frame_count = 0;
447 sd->resetlevel_adjust_dir = 0;
448 sd->expo_change_state = EXPO_NO_CHANGE;
449
450 se401_write_req(gspca_dev, SE401_REQ_START_CONTINUOUS_CAPTURE, 0, 0);
451
452 return gspca_dev->usb_err;
453 }
454
455 static void sd_stopN(struct gspca_dev *gspca_dev)
456 {
457 se401_write_req(gspca_dev, SE401_REQ_STOP_CONTINUOUS_CAPTURE, 0, 0);
458 se401_write_req(gspca_dev, SE401_REQ_LED_CONTROL, 0, 0);
459 se401_write_req(gspca_dev, SE401_REQ_CAMERA_POWER, 0, 0);
460 }
461
462 static void sd_dq_callback(struct gspca_dev *gspca_dev)
463 {
464 struct sd *sd = (struct sd *)gspca_dev;
465 unsigned int ahrc, alrc;
466 int oldreset, adjust_dir;
467
468 /* Restart the stream if requested do so by pkt_scan */
469 if (sd->restart_stream) {
470 sd_stopN(gspca_dev);
471 sd_start(gspca_dev);
472 sd->restart_stream = 0;
473 }
474
475 /* Automatically adjust sensor reset level
476 Hyundai have some really nice docs about this and other sensor
477 related stuff on their homepage: www.hei.co.kr */
478 sd->resetlevel_frame_count++;
479 if (sd->resetlevel_frame_count < 20)
480 return;
481
482 /* For some reason this normally read-only register doesn't get reset
483 to zero after reading them just once... */
484 se401_get_feature(gspca_dev, HV7131_REG_HIREFNOH);
485 se401_get_feature(gspca_dev, HV7131_REG_HIREFNOL);
486 se401_get_feature(gspca_dev, HV7131_REG_LOREFNOH);
487 se401_get_feature(gspca_dev, HV7131_REG_LOREFNOL);
488 ahrc = 256*se401_get_feature(gspca_dev, HV7131_REG_HIREFNOH) +
489 se401_get_feature(gspca_dev, HV7131_REG_HIREFNOL);
490 alrc = 256*se401_get_feature(gspca_dev, HV7131_REG_LOREFNOH) +
491 se401_get_feature(gspca_dev, HV7131_REG_LOREFNOL);
492
493 /* Not an exact science, but it seems to work pretty well... */
494 oldreset = sd->resetlevel;
495 if (alrc > 10) {
496 while (alrc >= 10 && sd->resetlevel < 63) {
497 sd->resetlevel++;
498 alrc /= 2;
499 }
500 } else if (ahrc > 20) {
501 while (ahrc >= 20 && sd->resetlevel > 0) {
502 sd->resetlevel--;
503 ahrc /= 2;
504 }
505 }
506 /* Detect ping-pong-ing and halve adjustment to avoid overshoot */
507 if (sd->resetlevel > oldreset)
508 adjust_dir = 1;
509 else
510 adjust_dir = -1;
511 if (sd->resetlevel_adjust_dir &&
512 sd->resetlevel_adjust_dir != adjust_dir)
513 sd->resetlevel = oldreset + (sd->resetlevel - oldreset) / 2;
514
515 if (sd->resetlevel != oldreset) {
516 sd->resetlevel_adjust_dir = adjust_dir;
517 se401_set_feature(gspca_dev, HV7131_REG_ARLV, sd->resetlevel);
518 }
519
520 sd->resetlevel_frame_count = 0;
521 }
522
523 static void sd_complete_frame(struct gspca_dev *gspca_dev, u8 *data, int len)
524 {
525 struct sd *sd = (struct sd *)gspca_dev;
526
527 switch (sd->expo_change_state) {
528 case EXPO_CHANGED:
529 /* The exposure was changed while this frame
530 was being send, so this frame is ok */
531 sd->expo_change_state = EXPO_DROP_FRAME;
532 break;
533 case EXPO_DROP_FRAME:
534 /* The exposure was changed while this frame
535 was being captured, drop it! */
536 gspca_dev->last_packet_type = DISCARD_PACKET;
537 sd->expo_change_state = EXPO_NO_CHANGE;
538 break;
539 case EXPO_NO_CHANGE:
540 break;
541 }
542 gspca_frame_add(gspca_dev, LAST_PACKET, data, len);
543 }
544
545 static void sd_pkt_scan_janggu(struct gspca_dev *gspca_dev, u8 *data, int len)
546 {
547 struct sd *sd = (struct sd *)gspca_dev;
548 int imagesize = gspca_dev->width * gspca_dev->height;
549 int i, plen, bits, pixels, info, count;
550
551 if (sd->restart_stream)
552 return;
553
554 /* Sometimes a 1024 bytes garbage bulk packet is send between frames */
555 if (gspca_dev->last_packet_type == LAST_PACKET && len == 1024) {
556 gspca_dev->last_packet_type = DISCARD_PACKET;
557 return;
558 }
559
560 i = 0;
561 while (i < len) {
562 /* Read header if not already be present from prev bulk pkt */
563 if (sd->packet_read < 4) {
564 count = 4 - sd->packet_read;
565 if (count > len - i)
566 count = len - i;
567 memcpy(&sd->packet[sd->packet_read], &data[i], count);
568 sd->packet_read += count;
569 i += count;
570 if (sd->packet_read < 4)
571 break;
572 }
573 bits = sd->packet[3] + (sd->packet[2] << 8);
574 pixels = sd->packet[1] + ((sd->packet[0] & 0x3f) << 8);
575 info = (sd->packet[0] & 0xc0) >> 6;
576 plen = ((bits + 47) >> 4) << 1;
577 /* Sanity checks */
578 if (plen > 1024) {
579 pr_err("invalid packet len %d restarting stream\n",
580 plen);
581 goto error;
582 }
583 if (info == 3) {
584 pr_err("unknown frame info value restarting stream\n");
585 goto error;
586 }
587
588 /* Read (remainder of) packet contents */
589 count = plen - sd->packet_read;
590 if (count > len - i)
591 count = len - i;
592 memcpy(&sd->packet[sd->packet_read], &data[i], count);
593 sd->packet_read += count;
594 i += count;
595 if (sd->packet_read < plen)
596 break;
597
598 sd->pixels_read += pixels;
599 sd->packet_read = 0;
600
601 switch (info) {
602 case 0: /* Frame data */
603 gspca_frame_add(gspca_dev, INTER_PACKET, sd->packet,
604 plen);
605 break;
606 case 1: /* EOF */
607 if (sd->pixels_read != imagesize) {
608 pr_err("frame size %d expected %d\n",
609 sd->pixels_read, imagesize);
610 goto error;
611 }
612 sd_complete_frame(gspca_dev, sd->packet, plen);
613 return; /* Discard the rest of the bulk packet !! */
614 case 2: /* SOF */
615 gspca_frame_add(gspca_dev, FIRST_PACKET, sd->packet,
616 plen);
617 sd->pixels_read = pixels;
618 break;
619 }
620 }
621 return;
622
623 error:
624 sd->restart_stream = 1;
625 /* Give userspace a 0 bytes frame, so our dq callback gets
626 called and it can restart the stream */
627 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
628 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
629 }
630
631 static void sd_pkt_scan_bayer(struct gspca_dev *gspca_dev, u8 *data, int len)
632 {
633 struct cam *cam = &gspca_dev->cam;
634 int imagesize = cam->cam_mode[gspca_dev->curr_mode].sizeimage;
635
636 if (gspca_dev->image_len == 0) {
637 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
638 return;
639 }
640
641 if (gspca_dev->image_len + len >= imagesize) {
642 sd_complete_frame(gspca_dev, data, len);
643 return;
644 }
645
646 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
647 }
648
649 static void sd_pkt_scan(struct gspca_dev *gspca_dev, u8 *data, int len)
650 {
651 int mult = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
652
653 if (len == 0)
654 return;
655
656 if (mult == 1) /* mult == 1 means raw bayer */
657 sd_pkt_scan_bayer(gspca_dev, data, len);
658 else
659 sd_pkt_scan_janggu(gspca_dev, data, len);
660 }
661
662 static int sd_querymenu(struct gspca_dev *gspca_dev,
663 struct v4l2_querymenu *menu)
664 {
665 switch (menu->id) {
666 case V4L2_CID_POWER_LINE_FREQUENCY:
667 switch (menu->index) {
668 case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED:
669 strcpy((char *) menu->name, "NoFliker");
670 return 0;
671 case V4L2_CID_POWER_LINE_FREQUENCY_50HZ:
672 strcpy((char *) menu->name, "50 Hz");
673 return 0;
674 case V4L2_CID_POWER_LINE_FREQUENCY_60HZ:
675 strcpy((char *) menu->name, "60 Hz");
676 return 0;
677 }
678 break;
679 }
680 return -EINVAL;
681 }
682
683 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
684 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, u8 *data, int len)
685 {
686 struct sd *sd = (struct sd *)gspca_dev;
687 u8 state;
688
689 if (len != 2)
690 return -EINVAL;
691
692 switch (data[0]) {
693 case 0:
694 case 1:
695 state = data[0];
696 break;
697 default:
698 return -EINVAL;
699 }
700 if (sd->button_state != state) {
701 input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
702 input_sync(gspca_dev->input_dev);
703 sd->button_state = state;
704 }
705
706 return 0;
707 }
708 #endif
709
710 /* sub-driver description */
711 static const struct sd_desc sd_desc = {
712 .name = MODULE_NAME,
713 .ctrls = sd_ctrls,
714 .nctrls = ARRAY_SIZE(sd_ctrls),
715 .config = sd_config,
716 .init = sd_init,
717 .start = sd_start,
718 .stopN = sd_stopN,
719 .dq_callback = sd_dq_callback,
720 .pkt_scan = sd_pkt_scan,
721 .querymenu = sd_querymenu,
722 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
723 .int_pkt_scan = sd_int_pkt_scan,
724 #endif
725 };
726
727 /* -- module initialisation -- */
728 static const struct usb_device_id device_table[] = {
729 {USB_DEVICE(0x03e8, 0x0004)}, /* Endpoints/Aox SE401 */
730 {USB_DEVICE(0x0471, 0x030b)}, /* Philips PCVC665K */
731 {USB_DEVICE(0x047d, 0x5001)}, /* Kensington 67014 */
732 {USB_DEVICE(0x047d, 0x5002)}, /* Kensington 6701(5/7) */
733 {USB_DEVICE(0x047d, 0x5003)}, /* Kensington 67016 */
734 {}
735 };
736 MODULE_DEVICE_TABLE(usb, device_table);
737
738 /* -- device connect -- */
739 static int sd_probe(struct usb_interface *intf,
740 const struct usb_device_id *id)
741 {
742 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
743 THIS_MODULE);
744 }
745
746 static int sd_pre_reset(struct usb_interface *intf)
747 {
748 return 0;
749 }
750
751 static int sd_post_reset(struct usb_interface *intf)
752 {
753 return 0;
754 }
755
756 static struct usb_driver sd_driver = {
757 .name = MODULE_NAME,
758 .id_table = device_table,
759 .probe = sd_probe,
760 .disconnect = gspca_disconnect,
761 #ifdef CONFIG_PM
762 .suspend = gspca_suspend,
763 .resume = gspca_resume,
764 #endif
765 .pre_reset = sd_pre_reset,
766 .post_reset = sd_post_reset,
767 };
768
769 /* -- module insert / remove -- */
770 static int __init sd_mod_init(void)
771 {
772 return usb_register(&sd_driver);
773 }
774 static void __exit sd_mod_exit(void)
775 {
776 usb_deregister(&sd_driver);
777 }
778
779 module_init(sd_mod_init);
780 module_exit(sd_mod_exit);