xref: /openbmc/linux/drivers/media/usb/gspca/pac7311.c (revision e23feb16)
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 				PERR("Incorrect variable sequence");
266 				return;
267 			}
268 			while (len > 0) {
269 				if (len < 8) {
270 					reg_w_buf(gspca_dev,
271 						index, seq, len);
272 					seq += len;
273 					break;
274 				}
275 				reg_w_buf(gspca_dev, index, seq, 8);
276 				seq += 8;
277 				index += 8;
278 				len -= 8;
279 			}
280 		}
281 	}
282 	/* not reached */
283 }
284 
285 /* this function is called at probe time for pac7311 */
286 static int sd_config(struct gspca_dev *gspca_dev,
287 			const struct usb_device_id *id)
288 {
289 	struct cam *cam = &gspca_dev->cam;
290 
291 	cam->cam_mode = vga_mode;
292 	cam->nmodes = ARRAY_SIZE(vga_mode);
293 	cam->input_flags = V4L2_IN_ST_VFLIP;
294 
295 	return 0;
296 }
297 
298 static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
299 {
300 	reg_w(gspca_dev, 0xff, 0x04);
301 	reg_w(gspca_dev, 0x10, val);
302 	/* load registers to sensor (Bit 0, auto clear) */
303 	reg_w(gspca_dev, 0x11, 0x01);
304 }
305 
306 static void setgain(struct gspca_dev *gspca_dev, s32 val)
307 {
308 	reg_w(gspca_dev, 0xff, 0x04);			/* page 4 */
309 	reg_w(gspca_dev, 0x0e, 0x00);
310 	reg_w(gspca_dev, 0x0f, gspca_dev->gain->maximum - val + 1);
311 
312 	/* load registers to sensor (Bit 0, auto clear) */
313 	reg_w(gspca_dev, 0x11, 0x01);
314 }
315 
316 static void setexposure(struct gspca_dev *gspca_dev, s32 val)
317 {
318 	reg_w(gspca_dev, 0xff, 0x04);			/* page 4 */
319 	reg_w(gspca_dev, 0x02, val);
320 
321 	/* load registers to sensor (Bit 0, auto clear) */
322 	reg_w(gspca_dev, 0x11, 0x01);
323 
324 	/*
325 	 * Page 1 register 8 must always be 0x08 except when not in
326 	 *  640x480 mode and page 4 reg 2 <= 3 then it must be 9
327 	 */
328 	reg_w(gspca_dev, 0xff, 0x01);
329 	if (gspca_dev->width != 640 && val <= 3)
330 		reg_w(gspca_dev, 0x08, 0x09);
331 	else
332 		reg_w(gspca_dev, 0x08, 0x08);
333 
334 	/*
335 	 * Page1 register 80 sets the compression balance, normally we
336 	 * want / use 0x1c, but for 640x480@30fps we must allow the
337 	 * camera to use higher compression or we may run out of
338 	 * bandwidth.
339 	 */
340 	if (gspca_dev->width == 640 && val == 2)
341 		reg_w(gspca_dev, 0x80, 0x01);
342 	else
343 		reg_w(gspca_dev, 0x80, 0x1c);
344 
345 	/* load registers to sensor (Bit 0, auto clear) */
346 	reg_w(gspca_dev, 0x11, 0x01);
347 }
348 
349 static void sethvflip(struct gspca_dev *gspca_dev, s32 hflip, s32 vflip)
350 {
351 	__u8 data;
352 
353 	reg_w(gspca_dev, 0xff, 0x04);			/* page 4 */
354 	data = (hflip ? 0x04 : 0x00) |
355 	       (vflip ? 0x08 : 0x00);
356 	reg_w(gspca_dev, 0x21, data);
357 
358 	/* load registers to sensor (Bit 0, auto clear) */
359 	reg_w(gspca_dev, 0x11, 0x01);
360 }
361 
362 /* this function is called at probe and resume time for pac7311 */
363 static int sd_init(struct gspca_dev *gspca_dev)
364 {
365 	reg_w_seq(gspca_dev, init_7311, sizeof(init_7311)/2);
366 	return gspca_dev->usb_err;
367 }
368 
369 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
370 {
371 	struct gspca_dev *gspca_dev =
372 		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
373 	struct sd *sd = (struct sd *)gspca_dev;
374 
375 	gspca_dev->usb_err = 0;
376 
377 	if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
378 		/* when switching to autogain set defaults to make sure
379 		   we are on a valid point of the autogain gain /
380 		   exposure knee graph, and give this change time to
381 		   take effect before doing autogain. */
382 		gspca_dev->exposure->val    = PAC7311_EXPOSURE_DEFAULT;
383 		gspca_dev->gain->val        = PAC7311_GAIN_DEFAULT;
384 		sd->autogain_ignore_frames  = PAC_AUTOGAIN_IGNORE_FRAMES;
385 	}
386 
387 	if (!gspca_dev->streaming)
388 		return 0;
389 
390 	switch (ctrl->id) {
391 	case V4L2_CID_CONTRAST:
392 		setcontrast(gspca_dev, ctrl->val);
393 		break;
394 	case V4L2_CID_AUTOGAIN:
395 		if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
396 			setexposure(gspca_dev, gspca_dev->exposure->val);
397 		if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
398 			setgain(gspca_dev, gspca_dev->gain->val);
399 		break;
400 	case V4L2_CID_HFLIP:
401 		sethvflip(gspca_dev, sd->hflip->val, 1);
402 		break;
403 	default:
404 		return -EINVAL;
405 	}
406 	return gspca_dev->usb_err;
407 }
408 
409 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
410 	.s_ctrl = sd_s_ctrl,
411 };
412 
413 /* this function is called at probe time */
414 static int sd_init_controls(struct gspca_dev *gspca_dev)
415 {
416 	struct sd *sd = (struct sd *) gspca_dev;
417 	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
418 
419 	gspca_dev->vdev.ctrl_handler = hdl;
420 	v4l2_ctrl_handler_init(hdl, 5);
421 
422 	sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
423 					V4L2_CID_CONTRAST, 0, 15, 1, 7);
424 	gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
425 					V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
426 	gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
427 					V4L2_CID_EXPOSURE, 2, 63, 1,
428 					PAC7311_EXPOSURE_DEFAULT);
429 	gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
430 					V4L2_CID_GAIN, 0, 244, 1,
431 					PAC7311_GAIN_DEFAULT);
432 	sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
433 		V4L2_CID_HFLIP, 0, 1, 1, 0);
434 
435 	if (hdl->error) {
436 		pr_err("Could not initialize controls\n");
437 		return hdl->error;
438 	}
439 
440 	v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
441 	return 0;
442 }
443 
444 /* -- start the camera -- */
445 static int sd_start(struct gspca_dev *gspca_dev)
446 {
447 	struct sd *sd = (struct sd *) gspca_dev;
448 
449 	sd->sof_read = 0;
450 
451 	reg_w_var(gspca_dev, start_7311,
452 		page4_7311, sizeof(page4_7311));
453 	setcontrast(gspca_dev, v4l2_ctrl_g_ctrl(sd->contrast));
454 	setgain(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->gain));
455 	setexposure(gspca_dev, v4l2_ctrl_g_ctrl(gspca_dev->exposure));
456 	sethvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip), 1);
457 
458 	/* set correct resolution */
459 	switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
460 	case 2:					/* 160x120 */
461 		reg_w(gspca_dev, 0xff, 0x01);
462 		reg_w(gspca_dev, 0x17, 0x20);
463 		reg_w(gspca_dev, 0x87, 0x10);
464 		break;
465 	case 1:					/* 320x240 */
466 		reg_w(gspca_dev, 0xff, 0x01);
467 		reg_w(gspca_dev, 0x17, 0x30);
468 		reg_w(gspca_dev, 0x87, 0x11);
469 		break;
470 	case 0:					/* 640x480 */
471 		reg_w(gspca_dev, 0xff, 0x01);
472 		reg_w(gspca_dev, 0x17, 0x00);
473 		reg_w(gspca_dev, 0x87, 0x12);
474 		break;
475 	}
476 
477 	sd->sof_read = 0;
478 	sd->autogain_ignore_frames = 0;
479 	atomic_set(&sd->avg_lum, -1);
480 
481 	/* start stream */
482 	reg_w(gspca_dev, 0xff, 0x01);
483 	reg_w(gspca_dev, 0x78, 0x05);
484 
485 	return gspca_dev->usb_err;
486 }
487 
488 static void sd_stopN(struct gspca_dev *gspca_dev)
489 {
490 	reg_w(gspca_dev, 0xff, 0x04);
491 	reg_w(gspca_dev, 0x27, 0x80);
492 	reg_w(gspca_dev, 0x28, 0xca);
493 	reg_w(gspca_dev, 0x29, 0x53);
494 	reg_w(gspca_dev, 0x2a, 0x0e);
495 	reg_w(gspca_dev, 0xff, 0x01);
496 	reg_w(gspca_dev, 0x3e, 0x20);
497 	reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_6=LED */
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 }
501 
502 static void do_autogain(struct gspca_dev *gspca_dev)
503 {
504 	struct sd *sd = (struct sd *) gspca_dev;
505 	int avg_lum = atomic_read(&sd->avg_lum);
506 	int desired_lum, deadzone;
507 
508 	if (avg_lum == -1)
509 		return;
510 
511 	desired_lum = 170;
512 	deadzone = 20;
513 
514 	if (sd->autogain_ignore_frames > 0)
515 		sd->autogain_ignore_frames--;
516 	else if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
517 						    desired_lum, deadzone))
518 		sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
519 }
520 
521 /* JPEG header, part 1 */
522 static const unsigned char pac_jpeg_header1[] = {
523   0xff, 0xd8,		/* SOI: Start of Image */
524 
525   0xff, 0xc0,		/* SOF0: Start of Frame (Baseline DCT) */
526   0x00, 0x11,		/* length = 17 bytes (including this length field) */
527   0x08			/* Precision: 8 */
528   /* 2 bytes is placed here: number of image lines */
529   /* 2 bytes is placed here: samples per line */
530 };
531 
532 /* JPEG header, continued */
533 static const unsigned char pac_jpeg_header2[] = {
534   0x03,			/* Number of image components: 3 */
535   0x01, 0x21, 0x00,	/* ID=1, Subsampling 1x1, Quantization table: 0 */
536   0x02, 0x11, 0x01,	/* ID=2, Subsampling 2x1, Quantization table: 1 */
537   0x03, 0x11, 0x01,	/* ID=3, Subsampling 2x1, Quantization table: 1 */
538 
539   0xff, 0xda,		/* SOS: Start Of Scan */
540   0x00, 0x0c,		/* length = 12 bytes (including this length field) */
541   0x03,			/* number of components: 3 */
542   0x01, 0x00,		/* selector 1, table 0x00 */
543   0x02, 0x11,		/* selector 2, table 0x11 */
544   0x03, 0x11,		/* selector 3, table 0x11 */
545   0x00, 0x3f,		/* Spectral selection: 0 .. 63 */
546   0x00			/* Successive approximation: 0 */
547 };
548 
549 static void pac_start_frame(struct gspca_dev *gspca_dev,
550 		__u16 lines, __u16 samples_per_line)
551 {
552 	unsigned char tmpbuf[4];
553 
554 	gspca_frame_add(gspca_dev, FIRST_PACKET,
555 		pac_jpeg_header1, sizeof(pac_jpeg_header1));
556 
557 	tmpbuf[0] = lines >> 8;
558 	tmpbuf[1] = lines & 0xff;
559 	tmpbuf[2] = samples_per_line >> 8;
560 	tmpbuf[3] = samples_per_line & 0xff;
561 
562 	gspca_frame_add(gspca_dev, INTER_PACKET,
563 		tmpbuf, sizeof(tmpbuf));
564 	gspca_frame_add(gspca_dev, INTER_PACKET,
565 		pac_jpeg_header2, sizeof(pac_jpeg_header2));
566 }
567 
568 /* this function is run at interrupt level */
569 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
570 			u8 *data,			/* isoc packet */
571 			int len)			/* iso packet length */
572 {
573 	struct sd *sd = (struct sd *) gspca_dev;
574 	u8 *image;
575 	unsigned char *sof;
576 
577 	sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
578 	if (sof) {
579 		int n, lum_offset, footer_length;
580 
581 		/*
582 		 * 6 bytes after the FF D9 EOF marker a number of lumination
583 		 * bytes are send corresponding to different parts of the
584 		 * image, the 14th and 15th byte after the EOF seem to
585 		 * correspond to the center of the image.
586 		 */
587 		lum_offset = 24 + sizeof pac_sof_marker;
588 		footer_length = 26;
589 
590 		/* Finish decoding current frame */
591 		n = (sof - data) - (footer_length + sizeof pac_sof_marker);
592 		if (n < 0) {
593 			gspca_dev->image_len += n;
594 			n = 0;
595 		} else {
596 			gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
597 		}
598 		image = gspca_dev->image;
599 		if (image != NULL
600 		 && image[gspca_dev->image_len - 2] == 0xff
601 		 && image[gspca_dev->image_len - 1] == 0xd9)
602 			gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
603 
604 		n = sof - data;
605 		len -= n;
606 		data = sof;
607 
608 		/* Get average lumination */
609 		if (gspca_dev->last_packet_type == LAST_PACKET &&
610 				n >= lum_offset)
611 			atomic_set(&sd->avg_lum, data[-lum_offset] +
612 						data[-lum_offset + 1]);
613 		else
614 			atomic_set(&sd->avg_lum, -1);
615 
616 		/* Start the new frame with the jpeg header */
617 		pac_start_frame(gspca_dev,
618 			gspca_dev->height, gspca_dev->width);
619 	}
620 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
621 }
622 
623 #if IS_ENABLED(CONFIG_INPUT)
624 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
625 			u8 *data,		/* interrupt packet data */
626 			int len)		/* interrupt packet length */
627 {
628 	int ret = -EINVAL;
629 	u8 data0, data1;
630 
631 	if (len == 2) {
632 		data0 = data[0];
633 		data1 = data[1];
634 		if ((data0 == 0x00 && data1 == 0x11) ||
635 		    (data0 == 0x22 && data1 == 0x33) ||
636 		    (data0 == 0x44 && data1 == 0x55) ||
637 		    (data0 == 0x66 && data1 == 0x77) ||
638 		    (data0 == 0x88 && data1 == 0x99) ||
639 		    (data0 == 0xaa && data1 == 0xbb) ||
640 		    (data0 == 0xcc && data1 == 0xdd) ||
641 		    (data0 == 0xee && data1 == 0xff)) {
642 			input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
643 			input_sync(gspca_dev->input_dev);
644 			input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
645 			input_sync(gspca_dev->input_dev);
646 			ret = 0;
647 		}
648 	}
649 
650 	return ret;
651 }
652 #endif
653 
654 static const struct sd_desc sd_desc = {
655 	.name = MODULE_NAME,
656 	.config = sd_config,
657 	.init = sd_init,
658 	.init_controls = sd_init_controls,
659 	.start = sd_start,
660 	.stopN = sd_stopN,
661 	.pkt_scan = sd_pkt_scan,
662 	.dq_callback = do_autogain,
663 #if IS_ENABLED(CONFIG_INPUT)
664 	.int_pkt_scan = sd_int_pkt_scan,
665 #endif
666 };
667 
668 /* -- module initialisation -- */
669 static const struct usb_device_id device_table[] = {
670 	{USB_DEVICE(0x093a, 0x2600)},
671 	{USB_DEVICE(0x093a, 0x2601)},
672 	{USB_DEVICE(0x093a, 0x2603)},
673 	{USB_DEVICE(0x093a, 0x2608)},
674 	{USB_DEVICE(0x093a, 0x260e)},
675 	{USB_DEVICE(0x093a, 0x260f)},
676 	{}
677 };
678 MODULE_DEVICE_TABLE(usb, device_table);
679 
680 /* -- device connect -- */
681 static int sd_probe(struct usb_interface *intf,
682 			const struct usb_device_id *id)
683 {
684 	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
685 				THIS_MODULE);
686 }
687 
688 static struct usb_driver sd_driver = {
689 	.name = MODULE_NAME,
690 	.id_table = device_table,
691 	.probe = sd_probe,
692 	.disconnect = gspca_disconnect,
693 #ifdef CONFIG_PM
694 	.suspend = gspca_suspend,
695 	.resume = gspca_resume,
696 	.reset_resume = gspca_resume,
697 #endif
698 };
699 
700 module_usb_driver(sd_driver);
701