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