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