projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus-3.6' of git://dev.laptop.org/users/dilinger/linux-olpc
[deliverable/linux.git] / drivers / media / video / gspca / pac7311.c
1 /*
2 * Pixart PAC7311 library
3 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
4 *
5 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* Some documentation about various registers as determined by trial and error.
23 *
24 * Register page 1:
25 *
26 * Address Description
27 * 0x08 Unknown compressor related, must always be 8 except when not
28 * in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 !
29 * 0x1b Auto white balance related, bit 0 is AWB enable (inverted)
30 * bits 345 seem to toggle per color gains on/off (inverted)
31 * 0x78 Global control, bit 6 controls the LED (inverted)
32 * 0x80 Compression balance, interesting settings:
33 * 0x01 Use this to allow the camera to switch to higher compr.
34 * on the fly. Needed to stay within bandwidth @ 640x480@30
35 * 0x1c From usb captures under Windows for 640x480
36 * 0x2a Values >= this switch the camera to a lower compression,
37 * using the same table for both luminance and chrominance.
38 * This gives a sharper picture. Usable only at 640x480@ <
39 * 15 fps or 320x240 / 160x120. Note currently the driver
40 * does not use this as the quality gain is small and the
41 * generated JPG-s are only understood by v4l-utils >= 0.8.9
42 * 0x3f From usb captures under Windows for 320x240
43 * 0x69 From usb captures under Windows for 160x120
44 *
45 * Register page 4:
46 *
47 * Address Description
48 * 0x02 Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on
49 * the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
50 * 0x0f Master gain 1-245, low value = high gain
51 * 0x10 Another gain 0-15, limited influence (1-2x gain I guess)
52 * 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
53 * Note setting vflip disabled leads to a much lower image quality,
54 * so we always vflip, and tell userspace to flip it back
55 * 0x27 Seems to toggle various gains on / off, Setting bit 7 seems to
56 * completely disable the analog amplification block. Set to 0x68
57 * for max gain, 0x14 for minimal gain.
58 */
59
60 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
61
62 #define MODULE_NAME "pac7311"
63
64 #include <linux/input.h>
65 #include "gspca.h"
66 /* Include pac common sof detection functions */
67 #include "pac_common.h"
68
69 #define PAC7311_GAIN_DEFAULT 122
70 #define PAC7311_EXPOSURE_DEFAULT 3 /* 20 fps, avoid using high compr. */
71
72 MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
73 MODULE_DESCRIPTION("Pixart PAC7311");
74 MODULE_LICENSE("GPL");
75
76 struct sd {
77 struct gspca_dev gspca_dev; /* !! must be the first item */
78
79 struct v4l2_ctrl *contrast;
80 struct v4l2_ctrl *hflip;
81
82 u8 sof_read;
83 u8 autogain_ignore_frames;
84
85 atomic_t avg_lum;
86 };
87
88 static const struct v4l2_pix_format vga_mode[] = {
89 {160, 120, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
90 .bytesperline = 160,
91 .sizeimage = 160 * 120 * 3 / 8 + 590,
92 .colorspace = V4L2_COLORSPACE_JPEG,
93 .priv = 2},
94 {320, 240, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
95 .bytesperline = 320,
96 .sizeimage = 320 * 240 * 3 / 8 + 590,
97 .colorspace = V4L2_COLORSPACE_JPEG,
98 .priv = 1},
99 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
100 .bytesperline = 640,
101 .sizeimage = 640 * 480 * 3 / 8 + 590,
102 .colorspace = V4L2_COLORSPACE_JPEG,
103 .priv = 0},
104 };
105
106 #define LOAD_PAGE4 254
107 #define END_OF_SEQUENCE 0
108
109 static const __u8 init_7311[] = {
110 0xff, 0x01,
111 0x78, 0x40, /* Bit_0=start stream, Bit_6=LED */
112 0x78, 0x40, /* Bit_0=start stream, Bit_6=LED */
113 0x78, 0x44, /* Bit_0=start stream, Bit_6=LED */
114 0xff, 0x04,
115 0x27, 0x80,
116 0x28, 0xca,
117 0x29, 0x53,
118 0x2a, 0x0e,
119 0xff, 0x01,
120 0x3e, 0x20,
121 };
122
123 static const __u8 start_7311[] = {
124 /* index, len, [value]* */
125 0xff, 1, 0x01, /* page 1 */
126 0x02, 43, 0x48, 0x0a, 0x40, 0x08, 0x00, 0x00, 0x08, 0x00,
127 0x06, 0xff, 0x11, 0xff, 0x5a, 0x30, 0x90, 0x4c,
128 0x00, 0x07, 0x00, 0x0a, 0x10, 0x00, 0xa0, 0x10,
129 0x02, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x00,
130 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
131 0x00, 0x00, 0x00,
132 0x3e, 42, 0x00, 0x00, 0x78, 0x52, 0x4a, 0x52, 0x78, 0x6e,
133 0x48, 0x46, 0x48, 0x6e, 0x5f, 0x49, 0x42, 0x49,
134 0x5f, 0x5f, 0x49, 0x42, 0x49, 0x5f, 0x6e, 0x48,
135 0x46, 0x48, 0x6e, 0x78, 0x52, 0x4a, 0x52, 0x78,
136 0x00, 0x00, 0x09, 0x1b, 0x34, 0x49, 0x5c, 0x9b,
137 0xd0, 0xff,
138 0x78, 6, 0x44, 0x00, 0xf2, 0x01, 0x01, 0x80,
139 0x7f, 18, 0x2a, 0x1c, 0x00, 0xc8, 0x02, 0x58, 0x03, 0x84,
140 0x12, 0x00, 0x1a, 0x04, 0x08, 0x0c, 0x10, 0x14,
141 0x18, 0x20,
142 0x96, 3, 0x01, 0x08, 0x04,
143 0xa0, 4, 0x44, 0x44, 0x44, 0x04,
144 0xf0, 13, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0x00,
145 0x3f, 0x00, 0x0a, 0x01, 0x00,
146 0xff, 1, 0x04, /* page 4 */
147 0, LOAD_PAGE4, /* load the page 4 */
148 0x11, 1, 0x01,
149 0, END_OF_SEQUENCE /* end of sequence */
150 };
151
152 #define SKIP 0xaa
153 /* page 4 - the value SKIP says skip the index - see reg_w_page() */
154 static const __u8 page4_7311[] = {
155 SKIP, SKIP, 0x04, 0x54, 0x07, 0x2b, 0x09, 0x0f,
156 0x09, 0x00, SKIP, SKIP, 0x07, 0x00, 0x00, 0x62,
157 0x08, SKIP, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
158 0x00, 0x00, 0x00, 0x03, 0xa0, 0x01, 0xf4, SKIP,
159 SKIP, 0x00, 0x08, SKIP, 0x03, SKIP, 0x00, 0x68,
160 0xca, 0x10, 0x06, 0x78, 0x00, 0x00, 0x00, 0x00,
161 0x23, 0x28, 0x04, 0x11, 0x00, 0x00
162 };
163
164 static void reg_w_buf(struct gspca_dev *gspca_dev,
165 __u8 index,
166 const u8 *buffer, int len)
167 {
168 int ret;
169
170 if (gspca_dev->usb_err < 0)
171 return;
172 memcpy(gspca_dev->usb_buf, buffer, len);
173 ret = usb_control_msg(gspca_dev->dev,
174 usb_sndctrlpipe(gspca_dev->dev, 0),
175 0, /* request */
176 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
177 0, /* value */
178 index, gspca_dev->usb_buf, len,
179 500);
180 if (ret < 0) {
181 pr_err("reg_w_buf() failed index 0x%02x, error %d\n",
182 index, ret);
183 gspca_dev->usb_err = ret;
184 }
185 }
186
187
188 static void reg_w(struct gspca_dev *gspca_dev,
189 __u8 index,
190 __u8 value)
191 {
192 int ret;
193
194 if (gspca_dev->usb_err < 0)
195 return;
196 gspca_dev->usb_buf[0] = value;
197 ret = usb_control_msg(gspca_dev->dev,
198 usb_sndctrlpipe(gspca_dev->dev, 0),
199 0, /* request */
200 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
201 0, index, gspca_dev->usb_buf, 1,
202 500);
203 if (ret < 0) {
204 pr_err("reg_w() failed index 0x%02x, value 0x%02x, error %d\n",
205 index, value, ret);
206 gspca_dev->usb_err = ret;
207 }
208 }
209
210 static void reg_w_seq(struct gspca_dev *gspca_dev,
211 const __u8 *seq, int len)
212 {
213 while (--len >= 0) {
214 reg_w(gspca_dev, seq[0], seq[1]);
215 seq += 2;
216 }
217 }
218
219 /* load the beginning of a page */
220 static void reg_w_page(struct gspca_dev *gspca_dev,
221 const __u8 *page, int len)
222 {
223 int index;
224 int ret = 0;
225
226 if (gspca_dev->usb_err < 0)
227 return;
228 for (index = 0; index < len; index++) {
229 if (page[index] == SKIP) /* skip this index */
230 continue;
231 gspca_dev->usb_buf[0] = page[index];
232 ret = usb_control_msg(gspca_dev->dev,
233 usb_sndctrlpipe(gspca_dev->dev, 0),
234 0, /* request */
235 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
236 0, index, gspca_dev->usb_buf, 1,
237 500);
238 if (ret < 0) {
239 pr_err("reg_w_page() failed index 0x%02x, value 0x%02x, error %d\n",
240 index, page[index], ret);
241 gspca_dev->usb_err = ret;
242 break;
243 }
244 }
245 }
246
247 /* output a variable sequence */
248 static void reg_w_var(struct gspca_dev *gspca_dev,
249 const __u8 *seq,
250 const __u8 *page4, unsigned int page4_len)
251 {
252 int index, len;
253
254 for (;;) {
255 index = *seq++;
256 len = *seq++;
257 switch (len) {
258 case END_OF_SEQUENCE:
259 return;
260 case LOAD_PAGE4:
261 reg_w_page(gspca_dev, page4, page4_len);
262 break;
263 default:
264 if (len > USB_BUF_SZ) {
265 PDEBUG(D_ERR|D_STREAM,
266 "Incorrect variable sequence");
267 return;
268 }
269 while (len > 0) {
270 if (len < 8) {
271 reg_w_buf(gspca_dev,
272 index, seq, len);
273 seq += len;
274 break;
275 }
276 reg_w_buf(gspca_dev, index, seq, 8);
277 seq += 8;
278 index += 8;
279 len -= 8;
280 }
281 }
282 }
283 /* not reached */
284 }
285
286 /* this function is called at probe time for pac7311 */
287 static int sd_config(struct gspca_dev *gspca_dev,
288 const struct usb_device_id *id)
289 {
290 struct cam *cam = &gspca_dev->cam;
291
292 cam->cam_mode = vga_mode;
293 cam->nmodes = ARRAY_SIZE(vga_mode);
294 cam->input_flags = V4L2_IN_ST_VFLIP;
295
296 return 0;
297 }
298
299 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
300 {
301 reg_w(gspca_dev, 0xff, 0x04);
302 reg_w(gspca_dev, 0x10, val);
303 /* load registers to sensor (Bit 0, auto clear) */
304 reg_w(gspca_dev, 0x11, 0x01);
305 }
306
307 static void setgain(struct gspca_dev *gspca_dev, s32 val)
308 {
309 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */
310 reg_w(gspca_dev, 0x0e, 0x00);
311 reg_w(gspca_dev, 0x0f, gspca_dev->gain->maximum - val + 1);
312
313 /* load registers to sensor (Bit 0, auto clear) */
314 reg_w(gspca_dev, 0x11, 0x01);
315 }
316
317 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
318 {
319 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */
320 reg_w(gspca_dev, 0x02, val);
321
322 /* load registers to sensor (Bit 0, auto clear) */
323 reg_w(gspca_dev, 0x11, 0x01);
324
325 /*
326 * Page 1 register 8 must always be 0x08 except when not in
327 * 640x480 mode and page 4 reg 2 <= 3 then it must be 9
328 */
329 reg_w(gspca_dev, 0xff, 0x01);
330 if (gspca_dev->width != 640 && val <= 3)
331 reg_w(gspca_dev, 0x08, 0x09);
332 else
333 reg_w(gspca_dev, 0x08, 0x08);
334
335 /*
336 * Page1 register 80 sets the compression balance, normally we
337 * want / use 0x1c, but for 640x480@30fps we must allow the
338 * camera to use higher compression or we may run out of
339 * bandwidth.
340 */
341 if (gspca_dev->width == 640 && val == 2)
342 reg_w(gspca_dev, 0x80, 0x01);
343 else
344 reg_w(gspca_dev, 0x80, 0x1c);
345
346 /* load registers to sensor (Bit 0, auto clear) */
347 reg_w(gspca_dev, 0x11, 0x01);
348 }
349
350 static void sethvflip(struct gspca_dev *gspca_dev, s32 hflip, s32 vflip)
351 {
352 __u8 data;
353
354 reg_w(gspca_dev, 0xff, 0x04); /* page 4 */
355 data = (hflip ? 0x04 : 0x00) |
356 (vflip ? 0x08 : 0x00);
357 reg_w(gspca_dev, 0x21, data);
358
359 /* load registers to sensor (Bit 0, auto clear) */
360 reg_w(gspca_dev, 0x11, 0x01);
361 }
362
363 /* this function is called at probe and resume time for pac7311 */
364 static int sd_init(struct gspca_dev *gspca_dev)
365 {
366 reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2);
367 return gspca_dev->usb_err;
368 }
369
370 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
371 {
372 struct gspca_dev *gspca_dev =
373 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
374 struct sd *sd = (struct sd *)gspca_dev;
375
376 gspca_dev->usb_err = 0;
377
378 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
379 /* when switching to autogain set defaults to make sure
380 we are on a valid point of the autogain gain /
381 exposure knee graph, and give this change time to
382 take effect before doing autogain. */
383 gspca_dev->exposure->val = PAC7311_EXPOSURE_DEFAULT;
384 gspca_dev->gain->val = PAC7311_GAIN_DEFAULT;
385 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
386 }
387
388 if (!gspca_dev->streaming)
389 return 0;
390
391 switch (ctrl->id) {
392 case V4L2_CID_CONTRAST:
393 setcontrast(gspca_dev, ctrl->val);
394 break;
395 case V4L2_CID_AUTOGAIN:
396 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
397 setexposure(gspca_dev, gspca_dev->exposure->val);
398 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
399 setgain(gspca_dev, gspca_dev->gain->val);
400 break;
401 case V4L2_CID_HFLIP:
402 sethvflip(gspca_dev, sd->hflip->val, 1);
403 break;
404 default:
405 return -EINVAL;
406 }
407 return gspca_dev->usb_err;
408 }
409
410 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
411 .s_ctrl = sd_s_ctrl,
412 };
413
414 /* this function is called at probe time */
415 static int sd_init_controls(struct gspca_dev *gspca_dev)
416 {
417 struct sd *sd = (struct sd *) gspca_dev;
418 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
419
420 gspca_dev->vdev.ctrl_handler = hdl;
421 v4l2_ctrl_handler_init(hdl, 5);
422
423 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
424 V4L2_CID_CONTRAST, 0, 15, 1, 7);
425 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
426 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
427 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
428 V4L2_CID_EXPOSURE, 2, 63, 1,
429 PAC7311_EXPOSURE_DEFAULT);
430 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
431 V4L2_CID_GAIN, 0, 244, 1,
432 PAC7311_GAIN_DEFAULT);
433 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
434 V4L2_CID_HFLIP, 0, 1, 1, 0);
435
436 if (hdl->error) {
437 pr_err("Could not initialize controls\n");
438 return hdl->error;
439 }
440
441 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
442 return 0;
443 }
444
445 /* -- start the camera -- */
446 static int sd_start(struct gspca_dev *gspca_dev)
447 {
448 struct sd *sd = (struct sd *) gspca_dev;
449
450 sd->sof_read = 0;
451
452 reg_w_var(gspca_dev, start_7311,
453 page4_7311, sizeof(page4_7311));
454 setcontrast(gspca_dev, v4l2_ctrl_g_ctrl(sd->contrast));
455 setgain(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->gain));
456 setexposure(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->exposure));
457 sethvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip), 1);
458
459 /* set correct resolution */
460 switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
461 case 2: /* 160x120 */
462 reg_w(gspca_dev, 0xff, 0x01);
463 reg_w(gspca_dev, 0x17, 0x20);
464 reg_w(gspca_dev, 0x87, 0x10);
465 break;
466 case 1: /* 320x240 */
467 reg_w(gspca_dev, 0xff, 0x01);
468 reg_w(gspca_dev, 0x17, 0x30);
469 reg_w(gspca_dev, 0x87, 0x11);
470 break;
471 case 0: /* 640x480 */
472 reg_w(gspca_dev, 0xff, 0x01);
473 reg_w(gspca_dev, 0x17, 0x00);
474 reg_w(gspca_dev, 0x87, 0x12);
475 break;
476 }
477
478 sd->sof_read = 0;
479 sd->autogain_ignore_frames = 0;
480 atomic_set(&sd->avg_lum, -1);
481
482 /* start stream */
483 reg_w(gspca_dev, 0xff, 0x01);
484 reg_w(gspca_dev, 0x78, 0x05);
485
486 return gspca_dev->usb_err;
487 }
488
489 static void sd_stopN(struct gspca_dev *gspca_dev)
490 {
491 reg_w(gspca_dev, 0xff, 0x04);
492 reg_w(gspca_dev, 0x27, 0x80);
493 reg_w(gspca_dev, 0x28, 0xca);
494 reg_w(gspca_dev, 0x29, 0x53);
495 reg_w(gspca_dev, 0x2a, 0x0e);
496 reg_w(gspca_dev, 0xff, 0x01);
497 reg_w(gspca_dev, 0x3e, 0x20);
498 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
499 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
500 reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
501 }
502
503 static void do_autogain(struct gspca_dev *gspca_dev)
504 {
505 struct sd *sd = (struct sd *) gspca_dev;
506 int avg_lum = atomic_read(&sd->avg_lum);
507 int desired_lum, deadzone;
508
509 if (avg_lum == -1)
510 return;
511
512 desired_lum = 170;
513 deadzone = 20;
514
515 if (sd->autogain_ignore_frames > 0)
516 sd->autogain_ignore_frames--;
517 else if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
518 desired_lum, deadzone))
519 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
520 }
521
522 /* JPEG header, part 1 */
523 static const unsigned char pac_jpeg_header1[] = {
524 0xff, 0xd8, /* SOI: Start of Image */
525
526 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */
527 0x00, 0x11, /* length = 17 bytes (including this length field) */
528 0x08 /* Precision: 8 */
529 /* 2 bytes is placed here: number of image lines */
530 /* 2 bytes is placed here: samples per line */
531 };
532
533 /* JPEG header, continued */
534 static const unsigned char pac_jpeg_header2[] = {
535 0x03, /* Number of image components: 3 */
536 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
537 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
538 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
539
540 0xff, 0xda, /* SOS: Start Of Scan */
541 0x00, 0x0c, /* length = 12 bytes (including this length field) */
542 0x03, /* number of components: 3 */
543 0x01, 0x00, /* selector 1, table 0x00 */
544 0x02, 0x11, /* selector 2, table 0x11 */
545 0x03, 0x11, /* selector 3, table 0x11 */
546 0x00, 0x3f, /* Spectral selection: 0 .. 63 */
547 0x00 /* Successive approximation: 0 */
548 };
549
550 static void pac_start_frame(struct gspca_dev *gspca_dev,
551 __u16 lines, __u16 samples_per_line)
552 {
553 unsigned char tmpbuf[4];
554
555 gspca_frame_add(gspca_dev, FIRST_PACKET,
556 pac_jpeg_header1, sizeof(pac_jpeg_header1));
557
558 tmpbuf[0] = lines >> 8;
559 tmpbuf[1] = lines & 0xff;
560 tmpbuf[2] = samples_per_line >> 8;
561 tmpbuf[3] = samples_per_line & 0xff;
562
563 gspca_frame_add(gspca_dev, INTER_PACKET,
564 tmpbuf, sizeof(tmpbuf));
565 gspca_frame_add(gspca_dev, INTER_PACKET,
566 pac_jpeg_header2, sizeof(pac_jpeg_header2));
567 }
568
569 /* this function is run at interrupt level */
570 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
571 u8 *data, /* isoc packet */
572 int len) /* iso packet length */
573 {
574 struct sd *sd = (struct sd *) gspca_dev;
575 u8 *image;
576 unsigned char *sof;
577
578 sof = pac_find_sof(&sd->sof_read, data, len);
579 if (sof) {
580 int n, lum_offset, footer_length;
581
582 /*
583 * 6 bytes after the FF D9 EOF marker a number of lumination
584 * bytes are send corresponding to different parts of the
585 * image, the 14th and 15th byte after the EOF seem to
586 * correspond to the center of the image.
587 */
588 lum_offset = 24 + sizeof pac_sof_marker;
589 footer_length = 26;
590
591 /* Finish decoding current frame */
592 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
593 if (n < 0) {
594 gspca_dev->image_len += n;
595 n = 0;
596 } else {
597 gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
598 }
599 image = gspca_dev->image;
600 if (image != NULL
601 && image[gspca_dev->image_len - 2] == 0xff
602 && image[gspca_dev->image_len - 1] == 0xd9)
603 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
604
605 n = sof - data;
606 len -= n;
607 data = sof;
608
609 /* Get average lumination */
610 if (gspca_dev->last_packet_type == LAST_PACKET &&
611 n >= lum_offset)
612 atomic_set(&sd->avg_lum, data[-lum_offset] +
613 data[-lum_offset + 1]);
614 else
615 atomic_set(&sd->avg_lum, -1);
616
617 /* Start the new frame with the jpeg header */
618 pac_start_frame(gspca_dev,
619 gspca_dev->height, gspca_dev->width);
620 }
621 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
622 }
623
624 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
625 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
626 u8 *data, /* interrupt packet data */
627 int len) /* interrupt packet length */
628 {
629 int ret = -EINVAL;
630 u8 data0, data1;
631
632 if (len == 2) {
633 data0 = data[0];
634 data1 = data[1];
635 if ((data0 == 0x00 && data1 == 0x11) ||
636 (data0 == 0x22 && data1 == 0x33) ||
637 (data0 == 0x44 && data1 == 0x55) ||
638 (data0 == 0x66 && data1 == 0x77) ||
639 (data0 == 0x88 && data1 == 0x99) ||
640 (data0 == 0xaa && data1 == 0xbb) ||
641 (data0 == 0xcc && data1 == 0xdd) ||
642 (data0 == 0xee && data1 == 0xff)) {
643 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
644 input_sync(gspca_dev->input_dev);
645 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
646 input_sync(gspca_dev->input_dev);
647 ret = 0;
648 }
649 }
650
651 return ret;
652 }
653 #endif
654
655 static const struct sd_desc sd_desc = {
656 .name = MODULE_NAME,
657 .config = sd_config,
658 .init = sd_init,
659 .init_controls = sd_init_controls,
660 .start = sd_start,
661 .stopN = sd_stopN,
662 .pkt_scan = sd_pkt_scan,
663 .dq_callback = do_autogain,
664 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
665 .int_pkt_scan = sd_int_pkt_scan,
666 #endif
667 };
668
669 /* -- module initialisation -- */
670 static const struct usb_device_id device_table[] = {
671 {USB_DEVICE(0x093a, 0x2600)},
672 {USB_DEVICE(0x093a, 0x2601)},
673 {USB_DEVICE(0x093a, 0x2603)},
674 {USB_DEVICE(0x093a, 0x2608)},
675 {USB_DEVICE(0x093a, 0x260e)},
676 {USB_DEVICE(0x093a, 0x260f)},
677 {}
678 };
679 MODULE_DEVICE_TABLE(usb, device_table);
680
681 /* -- device connect -- */
682 static int sd_probe(struct usb_interface *intf,
683 const struct usb_device_id *id)
684 {
685 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
686 THIS_MODULE);
687 }
688
689 static struct usb_driver sd_driver = {
690 .name = MODULE_NAME,
691 .id_table = device_table,
692 .probe = sd_probe,
693 .disconnect = gspca_disconnect,
694 #ifdef CONFIG_PM
695 .suspend = gspca_suspend,
696 .resume = gspca_resume,
697 .reset_resume = gspca_resume,
698 #endif
699 };
700
701 module_usb_driver(sd_driver);
Linux kernel - Deliverables
This page took 0.048601 seconds and 6 git commands to generate.