← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/media/video/gspca/se401.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/video/gspca/se401.c
 
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);