1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Pixart PAC7302 driver
4 *
5 * Copyright (C) 2008-2012 Jean-Francois Moine <http://moinejf.free.fr>
6 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
7 *
8 * Separated from Pixart PAC7311 library by Márton Németh
9 * Camera button input handling by Márton Németh <nm127@freemail.hu>
10 * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
11 */
12
13 /*
14 * Some documentation about various registers as determined by trial and error.
15 *
16 * Register page 0:
17 *
18 * Address Description
19 * 0x01 Red balance control
20 * 0x02 Green balance control
21 * 0x03 Blue balance control
22 * The Windows driver uses a quadratic approach to map
23 * the settable values (0-200) on register values:
24 * min=0x20, default=0x40, max=0x80
25 * 0x0f-0x20 Color and saturation control
26 * 0xa2-0xab Brightness, contrast and gamma control
27 * 0xb6 Sharpness control (bits 0-4)
28 *
29 * Register page 1:
30 *
31 * Address Description
32 * 0x78 Global control, bit 6 controls the LED (inverted)
33 * 0x80 Compression balance, 2 interesting settings:
34 * 0x0f Default
35 * 0x50 Values >= this switch the camera to a lower compression,
36 * using the same table for both luminance and chrominance.
37 * This gives a sharper picture. Only usable when running
38 * at < 15 fps! Note currently the driver does not use this
39 * as the quality gain is small and the generated JPG-s are
40 * only understood by v4l-utils >= 0.8.9
41 *
42 * Register page 3:
43 *
44 * Address Description
45 * 0x02 Clock divider 3-63, fps = 90 / val. Must be a multiple of 3 on
46 * the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
47 * 0x03 Variable framerate ctrl reg2==3: 0 -> ~30 fps, 255 -> ~22fps
48 * 0x04 Another var framerate ctrl reg2==3, reg3==0: 0 -> ~30 fps,
49 * 63 -> ~27 fps, the 2 msb's must always be 1 !!
50 * 0x05 Another var framerate ctrl reg2==3, reg3==0, reg4==0xc0:
51 * 1 -> ~30 fps, 2 -> ~20 fps
52 * 0x0e Exposure bits 0-7, 0-448, 0 = use full frame time
53 * 0x0f Exposure bit 8, 0-448, 448 = no exposure at all
54 * 0x10 Gain 0-31
55 * 0x12 Another gain 0-31, unlike 0x10 this one seems to start with an
56 * amplification value of 1 rather then 0 at its lowest setting
57 * 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
58 * 0x80 Another framerate control, best left at 1, moving it from 1 to
59 * 2 causes the framerate to become 3/4th of what it was, and
60 * also seems to cause pixel averaging, resulting in an effective
61 * resolution of 320x240 and thus a much blockier image
62 *
63 * The registers are accessed in the following functions:
64 *
65 * Page | Register | Function
66 * -----+------------+---------------------------------------------------
67 * 0 | 0x01 | setredbalance()
68 * 0 | 0x03 | setbluebalance()
69 * 0 | 0x0f..0x20 | setcolors()
70 * 0 | 0xa2..0xab | setbrightcont()
71 * 0 | 0xb6 | setsharpness()
72 * 0 | 0xc6 | setwhitebalance()
73 * 0 | 0xdc | setbrightcont(), setcolors()
74 * 3 | 0x02 | setexposure()
75 * 3 | 0x10, 0x12 | setgain()
76 * 3 | 0x11 | setcolors(), setgain(), setexposure(), sethvflip()
77 * 3 | 0x21 | sethvflip()
78 */
79
80 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
81
82 #include <linux/input.h>
83 #include "gspca.h"
84 /* Include pac common sof detection functions */
85 #include "pac_common.h"
86
87 #define PAC7302_RGB_BALANCE_MIN 0
88 #define PAC7302_RGB_BALANCE_MAX 200
89 #define PAC7302_RGB_BALANCE_DEFAULT 100
90 #define PAC7302_GAIN_DEFAULT 15
91 #define PAC7302_GAIN_KNEE 42
92 #define PAC7302_EXPOSURE_DEFAULT 66 /* 33 ms / 30 fps */
93 #define PAC7302_EXPOSURE_KNEE 133 /* 66 ms / 15 fps */
94
95 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>, Thomas Kaiser thomas@kaiser-linux.li");
96 MODULE_DESCRIPTION("Pixart PAC7302");
97 MODULE_LICENSE("GPL");
98
99 struct sd {
100 struct gspca_dev gspca_dev; /* !! must be the first item */
101
102 struct { /* brightness / contrast cluster */
103 struct v4l2_ctrl *brightness;
104 struct v4l2_ctrl *contrast;
105 };
106 struct v4l2_ctrl *saturation;
107 struct v4l2_ctrl *white_balance;
108 struct v4l2_ctrl *red_balance;
109 struct v4l2_ctrl *blue_balance;
110 struct { /* flip cluster */
111 struct v4l2_ctrl *hflip;
112 struct v4l2_ctrl *vflip;
113 };
114 struct v4l2_ctrl *sharpness;
115 u8 flags;
116 #define FL_HFLIP 0x01 /* mirrored by default */
117 #define FL_VFLIP 0x02 /* vertical flipped by default */
118
119 u8 sof_read;
120 s8 autogain_ignore_frames;
121
122 atomic_t avg_lum;
123 };
124
125 static const struct v4l2_pix_format vga_mode[] = {
126 {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
127 .bytesperline = 640,
128 .sizeimage = 640 * 480 * 3 / 8 + 590,
129 .colorspace = V4L2_COLORSPACE_JPEG,
130 },
131 };
132
133 #define LOAD_PAGE3 255
134 #define END_OF_SEQUENCE 0
135
136 static const u8 init_7302[] = {
137 /* index,value */
138 0xff, 0x01, /* page 1 */
139 0x78, 0x00, /* deactivate */
140 0xff, 0x01,
141 0x78, 0x40, /* led off */
142 };
143 static const u8 start_7302[] = {
144 /* index, len, [value]* */
145 0xff, 1, 0x00, /* page 0 */
146 0x00, 12, 0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80,
147 0x00, 0x00, 0x00, 0x00,
148 0x0d, 24, 0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00,
149 0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7,
150 0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11,
151 0x26, 2, 0xaa, 0xaa,
152 0x2e, 1, 0x31,
153 0x38, 1, 0x01,
154 0x3a, 3, 0x14, 0xff, 0x5a,
155 0x43, 11, 0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11,
156 0x00, 0x54, 0x11,
157 0x55, 1, 0x00,
158 0x62, 4, 0x10, 0x1e, 0x1e, 0x18,
159 0x6b, 1, 0x00,
160 0x6e, 3, 0x08, 0x06, 0x00,
161 0x72, 3, 0x00, 0xff, 0x00,
162 0x7d, 23, 0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c,
163 0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50,
164 0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00,
165 0xa2, 10, 0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9,
166 0xd2, 0xeb,
167 0xaf, 1, 0x02,
168 0xb5, 2, 0x08, 0x08,
169 0xb8, 2, 0x08, 0x88,
170 0xc4, 4, 0xae, 0x01, 0x04, 0x01,
171 0xcc, 1, 0x00,
172 0xd1, 11, 0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9,
173 0xc1, 0xd7, 0xec,
174 0xdc, 1, 0x01,
175 0xff, 1, 0x01, /* page 1 */
176 0x12, 3, 0x02, 0x00, 0x01,
177 0x3e, 2, 0x00, 0x00,
178 0x76, 5, 0x01, 0x20, 0x40, 0x00, 0xf2,
179 0x7c, 1, 0x00,
180 0x7f, 10, 0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20,
181 0x02, 0x00,
182 0x96, 5, 0x01, 0x10, 0x04, 0x01, 0x04,
183 0xc8, 14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
184 0x07, 0x00, 0x01, 0x07, 0x04, 0x01,
185 0xd8, 1, 0x01,
186 0xdb, 2, 0x00, 0x01,
187 0xde, 7, 0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
188 0xe6, 4, 0x00, 0x00, 0x00, 0x01,
189 0xeb, 1, 0x00,
190 0xff, 1, 0x02, /* page 2 */
191 0x22, 1, 0x00,
192 0xff, 1, 0x03, /* page 3 */
193 0, LOAD_PAGE3, /* load the page 3 */
194 0x11, 1, 0x01,
195 0xff, 1, 0x02, /* page 2 */
196 0x13, 1, 0x00,
197 0x22, 4, 0x1f, 0xa4, 0xf0, 0x96,
198 0x27, 2, 0x14, 0x0c,
199 0x2a, 5, 0xc8, 0x00, 0x18, 0x12, 0x22,
200 0x64, 8, 0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44,
201 0x6e, 1, 0x08,
202 0xff, 1, 0x01, /* page 1 */
203 0x78, 1, 0x00,
204 0, END_OF_SEQUENCE /* end of sequence */
205 };
206
207 #define SKIP 0xaa
208 /* page 3 - the value SKIP says skip the index - see reg_w_page() */
209 static const u8 page3_7302[] = {
210 0x90, 0x40, 0x03, 0x00, 0xc0, 0x01, 0x14, 0x16,
211 0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
212 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
213 0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
214 0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21,
215 0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54,
216 0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
217 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218 0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
219 SKIP, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
220 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
221 0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
222 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
223 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8,
224 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,
225 0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00,
226 0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00,
227 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
228 0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00,
229 0x00
230 };
231
reg_w_buf(struct gspca_dev * gspca_dev,u8 index,const u8 * buffer,int len)232 static void reg_w_buf(struct gspca_dev *gspca_dev,
233 u8 index,
234 const u8 *buffer, int len)
235 {
236 int ret;
237
238 if (gspca_dev->usb_err < 0)
239 return;
240 memcpy(gspca_dev->usb_buf, buffer, len);
241 ret = usb_control_msg(gspca_dev->dev,
242 usb_sndctrlpipe(gspca_dev->dev, 0),
243 0, /* request */
244 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
245 0, /* value */
246 index, gspca_dev->usb_buf, len,
247 500);
248 if (ret < 0) {
249 pr_err("reg_w_buf failed i: %02x error %d\n",
250 index, ret);
251 gspca_dev->usb_err = ret;
252 }
253 }
254
255
reg_w(struct gspca_dev * gspca_dev,u8 index,u8 value)256 static void reg_w(struct gspca_dev *gspca_dev,
257 u8 index,
258 u8 value)
259 {
260 int ret;
261
262 if (gspca_dev->usb_err < 0)
263 return;
264 gspca_dev->usb_buf[0] = value;
265 ret = usb_control_msg(gspca_dev->dev,
266 usb_sndctrlpipe(gspca_dev->dev, 0),
267 0, /* request */
268 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
269 0, index, gspca_dev->usb_buf, 1,
270 500);
271 if (ret < 0) {
272 pr_err("reg_w() failed i: %02x v: %02x error %d\n",
273 index, value, ret);
274 gspca_dev->usb_err = ret;
275 }
276 }
277
reg_w_seq(struct gspca_dev * gspca_dev,const u8 * seq,int len)278 static void reg_w_seq(struct gspca_dev *gspca_dev,
279 const u8 *seq, int len)
280 {
281 while (--len >= 0) {
282 reg_w(gspca_dev, seq[0], seq[1]);
283 seq += 2;
284 }
285 }
286
287 /* load the beginning of a page */
reg_w_page(struct gspca_dev * gspca_dev,const u8 * page,int len)288 static void reg_w_page(struct gspca_dev *gspca_dev,
289 const u8 *page, int len)
290 {
291 int index;
292 int ret = 0;
293
294 if (gspca_dev->usb_err < 0)
295 return;
296 for (index = 0; index < len; index++) {
297 if (page[index] == SKIP) /* skip this index */
298 continue;
299 gspca_dev->usb_buf[0] = page[index];
300 ret = usb_control_msg(gspca_dev->dev,
301 usb_sndctrlpipe(gspca_dev->dev, 0),
302 0, /* request */
303 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
304 0, index, gspca_dev->usb_buf, 1,
305 500);
306 if (ret < 0) {
307 pr_err("reg_w_page() failed i: %02x v: %02x error %d\n",
308 index, page[index], ret);
309 gspca_dev->usb_err = ret;
310 break;
311 }
312 }
313 }
314
315 /* output a variable sequence */
reg_w_var(struct gspca_dev * gspca_dev,const u8 * seq,const u8 * page3,unsigned int page3_len)316 static void reg_w_var(struct gspca_dev *gspca_dev,
317 const u8 *seq,
318 const u8 *page3, unsigned int page3_len)
319 {
320 int index, len;
321
322 for (;;) {
323 index = *seq++;
324 len = *seq++;
325 switch (len) {
326 case END_OF_SEQUENCE:
327 return;
328 case LOAD_PAGE3:
329 reg_w_page(gspca_dev, page3, page3_len);
330 break;
331 default:
332 if (len > USB_BUF_SZ) {
333 gspca_err(gspca_dev, "Incorrect variable sequence\n");
334 return;
335 }
336 while (len > 0) {
337 if (len < 8) {
338 reg_w_buf(gspca_dev,
339 index, seq, len);
340 seq += len;
341 break;
342 }
343 reg_w_buf(gspca_dev, index, seq, 8);
344 seq += 8;
345 index += 8;
346 len -= 8;
347 }
348 }
349 }
350 /* not reached */
351 }
352
353 /* this function is called at probe time for pac7302 */
sd_config(struct gspca_dev * gspca_dev,const struct usb_device_id * id)354 static int sd_config(struct gspca_dev *gspca_dev,
355 const struct usb_device_id *id)
356 {
357 struct sd *sd = (struct sd *) gspca_dev;
358 struct cam *cam;
359
360 cam = &gspca_dev->cam;
361
362 cam->cam_mode = vga_mode; /* only 640x480 */
363 cam->nmodes = ARRAY_SIZE(vga_mode);
364
365 sd->flags = id->driver_info;
366 return 0;
367 }
368
setbrightcont(struct gspca_dev * gspca_dev)369 static void setbrightcont(struct gspca_dev *gspca_dev)
370 {
371 struct sd *sd = (struct sd *) gspca_dev;
372 int i, v;
373 static const u8 max[10] =
374 {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
375 0xd4, 0xec};
376 static const u8 delta[10] =
377 {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
378 0x11, 0x0b};
379
380 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
381 for (i = 0; i < 10; i++) {
382 v = max[i];
383 v += (sd->brightness->val - (s32)sd->brightness->maximum)
384 * 150 / (s32)sd->brightness->maximum; /* 200 ? */
385 v -= delta[i] * sd->contrast->val / (s32)sd->contrast->maximum;
386 if (v < 0)
387 v = 0;
388 else if (v > 0xff)
389 v = 0xff;
390 reg_w(gspca_dev, 0xa2 + i, v);
391 }
392 reg_w(gspca_dev, 0xdc, 0x01);
393 }
394
setcolors(struct gspca_dev * gspca_dev)395 static void setcolors(struct gspca_dev *gspca_dev)
396 {
397 struct sd *sd = (struct sd *) gspca_dev;
398 int i, v;
399 static const int a[9] =
400 {217, -212, 0, -101, 170, -67, -38, -315, 355};
401 static const int b[9] =
402 {19, 106, 0, 19, 106, 1, 19, 106, 1};
403
404 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
405 reg_w(gspca_dev, 0x11, 0x01);
406 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
407 for (i = 0; i < 9; i++) {
408 v = a[i] * sd->saturation->val / (s32)sd->saturation->maximum;
409 v += b[i];
410 reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
411 reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
412 }
413 reg_w(gspca_dev, 0xdc, 0x01);
414 }
415
setwhitebalance(struct gspca_dev * gspca_dev)416 static void setwhitebalance(struct gspca_dev *gspca_dev)
417 {
418 struct sd *sd = (struct sd *) gspca_dev;
419
420 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
421 reg_w(gspca_dev, 0xc6, sd->white_balance->val);
422
423 reg_w(gspca_dev, 0xdc, 0x01);
424 }
425
rgbbalance_ctrl_to_reg_value(s32 rgb_ctrl_val)426 static u8 rgbbalance_ctrl_to_reg_value(s32 rgb_ctrl_val)
427 {
428 const unsigned int k = 1000; /* precision factor */
429 unsigned int norm;
430
431 /* Normed value [0...k] */
432 norm = k * (rgb_ctrl_val - PAC7302_RGB_BALANCE_MIN)
433 / (PAC7302_RGB_BALANCE_MAX - PAC7302_RGB_BALANCE_MIN);
434 /* Qudratic apporach improves control at small (register) values: */
435 return 64 * norm * norm / (k*k) + 32 * norm / k + 32;
436 /* Y = 64*X*X + 32*X + 32
437 * => register values 0x20-0x80; Windows driver uses these limits */
438
439 /* NOTE: for full value range (0x00-0xff) use
440 * Y = 254*X*X + X
441 * => 254 * norm * norm / (k*k) + 1 * norm / k */
442 }
443
setredbalance(struct gspca_dev * gspca_dev)444 static void setredbalance(struct gspca_dev *gspca_dev)
445 {
446 struct sd *sd = (struct sd *) gspca_dev;
447
448 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
449 reg_w(gspca_dev, 0x01,
450 rgbbalance_ctrl_to_reg_value(sd->red_balance->val));
451
452 reg_w(gspca_dev, 0xdc, 0x01);
453 }
454
setbluebalance(struct gspca_dev * gspca_dev)455 static void setbluebalance(struct gspca_dev *gspca_dev)
456 {
457 struct sd *sd = (struct sd *) gspca_dev;
458
459 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
460 reg_w(gspca_dev, 0x03,
461 rgbbalance_ctrl_to_reg_value(sd->blue_balance->val));
462
463 reg_w(gspca_dev, 0xdc, 0x01);
464 }
465
setgain(struct gspca_dev * gspca_dev)466 static void setgain(struct gspca_dev *gspca_dev)
467 {
468 u8 reg10, reg12;
469
470 if (gspca_dev->gain->val < 32) {
471 reg10 = gspca_dev->gain->val;
472 reg12 = 0;
473 } else {
474 reg10 = 31;
475 reg12 = gspca_dev->gain->val - 31;
476 }
477
478 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
479 reg_w(gspca_dev, 0x10, reg10);
480 reg_w(gspca_dev, 0x12, reg12);
481
482 /* load registers to sensor (Bit 0, auto clear) */
483 reg_w(gspca_dev, 0x11, 0x01);
484 }
485
setexposure(struct gspca_dev * gspca_dev)486 static void setexposure(struct gspca_dev *gspca_dev)
487 {
488 u8 clockdiv;
489 u16 exposure;
490
491 /*
492 * Register 2 of frame 3 contains the clock divider configuring the
493 * no fps according to the formula: 90 / reg. sd->exposure is the
494 * desired exposure time in 0.5 ms.
495 */
496 clockdiv = (90 * gspca_dev->exposure->val + 1999) / 2000;
497
498 /*
499 * Note clockdiv = 3 also works, but when running at 30 fps, depending
500 * on the scene being recorded, the camera switches to another
501 * quantization table for certain JPEG blocks, and we don't know how
502 * to decompress these blocks. So we cap the framerate at 15 fps.
503 */
504 if (clockdiv < 6)
505 clockdiv = 6;
506 else if (clockdiv > 63)
507 clockdiv = 63;
508
509 /*
510 * Register 2 MUST be a multiple of 3, except when between 6 and 12?
511 * Always round up, otherwise we cannot get the desired frametime
512 * using the partial frame time exposure control.
513 */
514 if (clockdiv < 6 || clockdiv > 12)
515 clockdiv = ((clockdiv + 2) / 3) * 3;
516
517 /*
518 * frame exposure time in ms = 1000 * clockdiv / 90 ->
519 * exposure = (sd->exposure / 2) * 448 / (1000 * clockdiv / 90)
520 */
521 exposure = (gspca_dev->exposure->val * 45 * 448) / (1000 * clockdiv);
522 /* 0 = use full frametime, 448 = no exposure, reverse it */
523 exposure = 448 - exposure;
524
525 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
526 reg_w(gspca_dev, 0x02, clockdiv);
527 reg_w(gspca_dev, 0x0e, exposure & 0xff);
528 reg_w(gspca_dev, 0x0f, exposure >> 8);
529
530 /* load registers to sensor (Bit 0, auto clear) */
531 reg_w(gspca_dev, 0x11, 0x01);
532 }
533
sethvflip(struct gspca_dev * gspca_dev)534 static void sethvflip(struct gspca_dev *gspca_dev)
535 {
536 struct sd *sd = (struct sd *) gspca_dev;
537 u8 data, hflip, vflip;
538
539 hflip = sd->hflip->val;
540 if (sd->flags & FL_HFLIP)
541 hflip = !hflip;
542 vflip = sd->vflip->val;
543 if (sd->flags & FL_VFLIP)
544 vflip = !vflip;
545
546 reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
547 data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
548 reg_w(gspca_dev, 0x21, data);
549
550 /* load registers to sensor (Bit 0, auto clear) */
551 reg_w(gspca_dev, 0x11, 0x01);
552 }
553
setsharpness(struct gspca_dev * gspca_dev)554 static void setsharpness(struct gspca_dev *gspca_dev)
555 {
556 struct sd *sd = (struct sd *) gspca_dev;
557
558 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
559 reg_w(gspca_dev, 0xb6, sd->sharpness->val);
560
561 reg_w(gspca_dev, 0xdc, 0x01);
562 }
563
564 /* this function is called at probe and resume time for pac7302 */
sd_init(struct gspca_dev * gspca_dev)565 static int sd_init(struct gspca_dev *gspca_dev)
566 {
567 reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
568 return gspca_dev->usb_err;
569 }
570
sd_s_ctrl(struct v4l2_ctrl * ctrl)571 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
572 {
573 struct gspca_dev *gspca_dev =
574 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
575 struct sd *sd = (struct sd *)gspca_dev;
576
577 gspca_dev->usb_err = 0;
578
579 if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
580 /* when switching to autogain set defaults to make sure
581 we are on a valid point of the autogain gain /
582 exposure knee graph, and give this change time to
583 take effect before doing autogain. */
584 gspca_dev->exposure->val = PAC7302_EXPOSURE_DEFAULT;
585 gspca_dev->gain->val = PAC7302_GAIN_DEFAULT;
586 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
587 }
588
589 if (!gspca_dev->streaming)
590 return 0;
591
592 switch (ctrl->id) {
593 case V4L2_CID_BRIGHTNESS:
594 setbrightcont(gspca_dev);
595 break;
596 case V4L2_CID_SATURATION:
597 setcolors(gspca_dev);
598 break;
599 case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
600 setwhitebalance(gspca_dev);
601 break;
602 case V4L2_CID_RED_BALANCE:
603 setredbalance(gspca_dev);
604 break;
605 case V4L2_CID_BLUE_BALANCE:
606 setbluebalance(gspca_dev);
607 break;
608 case V4L2_CID_AUTOGAIN:
609 if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
610 setexposure(gspca_dev);
611 if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
612 setgain(gspca_dev);
613 break;
614 case V4L2_CID_HFLIP:
615 sethvflip(gspca_dev);
616 break;
617 case V4L2_CID_SHARPNESS:
618 setsharpness(gspca_dev);
619 break;
620 default:
621 return -EINVAL;
622 }
623 return gspca_dev->usb_err;
624 }
625
626 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
627 .s_ctrl = sd_s_ctrl,
628 };
629
630 /* this function is called at probe time */
sd_init_controls(struct gspca_dev * gspca_dev)631 static int sd_init_controls(struct gspca_dev *gspca_dev)
632 {
633 struct sd *sd = (struct sd *) gspca_dev;
634 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
635
636 gspca_dev->vdev.ctrl_handler = hdl;
637 v4l2_ctrl_handler_init(hdl, 12);
638
639 sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
640 V4L2_CID_BRIGHTNESS, 0, 32, 1, 16);
641 sd->contrast = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
642 V4L2_CID_CONTRAST, 0, 255, 1, 127);
643
644 sd->saturation = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
645 V4L2_CID_SATURATION, 0, 255, 1, 127);
646 sd->white_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
647 V4L2_CID_WHITE_BALANCE_TEMPERATURE,
648 0, 255, 1, 55);
649 sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
650 V4L2_CID_RED_BALANCE,
651 PAC7302_RGB_BALANCE_MIN,
652 PAC7302_RGB_BALANCE_MAX,
653 1, PAC7302_RGB_BALANCE_DEFAULT);
654 sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
655 V4L2_CID_BLUE_BALANCE,
656 PAC7302_RGB_BALANCE_MIN,
657 PAC7302_RGB_BALANCE_MAX,
658 1, PAC7302_RGB_BALANCE_DEFAULT);
659
660 gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
661 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
662 gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
663 V4L2_CID_EXPOSURE, 0, 1023, 1,
664 PAC7302_EXPOSURE_DEFAULT);
665 gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
666 V4L2_CID_GAIN, 0, 62, 1,
667 PAC7302_GAIN_DEFAULT);
668
669 sd->hflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
670 V4L2_CID_HFLIP, 0, 1, 1, 0);
671 sd->vflip = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
672 V4L2_CID_VFLIP, 0, 1, 1, 0);
673
674 sd->sharpness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
675 V4L2_CID_SHARPNESS, 0, 15, 1, 8);
676
677 if (hdl->error) {
678 pr_err("Could not initialize controls\n");
679 return hdl->error;
680 }
681
682 v4l2_ctrl_cluster(2, &sd->brightness);
683 v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
684 v4l2_ctrl_cluster(2, &sd->hflip);
685 return 0;
686 }
687
688 /* -- start the camera -- */
sd_start(struct gspca_dev * gspca_dev)689 static int sd_start(struct gspca_dev *gspca_dev)
690 {
691 struct sd *sd = (struct sd *) gspca_dev;
692
693 reg_w_var(gspca_dev, start_7302,
694 page3_7302, sizeof(page3_7302));
695
696 sd->sof_read = 0;
697 sd->autogain_ignore_frames = 0;
698 atomic_set(&sd->avg_lum, 270 + sd->brightness->val);
699
700 /* start stream */
701 reg_w(gspca_dev, 0xff, 0x01);
702 reg_w(gspca_dev, 0x78, 0x01);
703
704 return gspca_dev->usb_err;
705 }
706
sd_stopN(struct gspca_dev * gspca_dev)707 static void sd_stopN(struct gspca_dev *gspca_dev)
708 {
709
710 /* stop stream */
711 reg_w(gspca_dev, 0xff, 0x01);
712 reg_w(gspca_dev, 0x78, 0x00);
713 }
714
715 /* called on streamoff with alt 0 and on disconnect for pac7302 */
sd_stop0(struct gspca_dev * gspca_dev)716 static void sd_stop0(struct gspca_dev *gspca_dev)
717 {
718 if (!gspca_dev->present)
719 return;
720 reg_w(gspca_dev, 0xff, 0x01);
721 reg_w(gspca_dev, 0x78, 0x40);
722 }
723
do_autogain(struct gspca_dev * gspca_dev)724 static void do_autogain(struct gspca_dev *gspca_dev)
725 {
726 struct sd *sd = (struct sd *) gspca_dev;
727 int avg_lum = atomic_read(&sd->avg_lum);
728 int desired_lum;
729 const int deadzone = 30;
730
731 if (sd->autogain_ignore_frames < 0)
732 return;
733
734 if (sd->autogain_ignore_frames > 0) {
735 sd->autogain_ignore_frames--;
736 } else {
737 desired_lum = 270 + sd->brightness->val;
738
739 if (gspca_expo_autogain(gspca_dev, avg_lum, desired_lum,
740 deadzone, PAC7302_GAIN_KNEE,
741 PAC7302_EXPOSURE_KNEE))
742 sd->autogain_ignore_frames =
743 PAC_AUTOGAIN_IGNORE_FRAMES;
744 }
745 }
746
747 /* JPEG header */
748 static const u8 jpeg_header[] = {
749 0xff, 0xd8, /* SOI: Start of Image */
750
751 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */
752 0x00, 0x11, /* length = 17 bytes (including this length field) */
753 0x08, /* Precision: 8 */
754 0x02, 0x80, /* height = 640 (image rotated) */
755 0x01, 0xe0, /* width = 480 */
756 0x03, /* Number of image components: 3 */
757 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
758 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
759 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
760
761 0xff, 0xda, /* SOS: Start Of Scan */
762 0x00, 0x0c, /* length = 12 bytes (including this length field) */
763 0x03, /* number of components: 3 */
764 0x01, 0x00, /* selector 1, table 0x00 */
765 0x02, 0x11, /* selector 2, table 0x11 */
766 0x03, 0x11, /* selector 3, table 0x11 */
767 0x00, 0x3f, /* Spectral selection: 0 .. 63 */
768 0x00 /* Successive approximation: 0 */
769 };
770
771 /* this function is run at interrupt level */
sd_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)772 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
773 u8 *data, /* isoc packet */
774 int len) /* iso packet length */
775 {
776 struct sd *sd = (struct sd *) gspca_dev;
777 u8 *image;
778 u8 *sof;
779
780 sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
781 if (sof) {
782 int n, lum_offset, footer_length;
783
784 /*
785 * 6 bytes after the FF D9 EOF marker a number of lumination
786 * bytes are send corresponding to different parts of the
787 * image, the 14th and 15th byte after the EOF seem to
788 * correspond to the center of the image.
789 */
790 lum_offset = 61 + sizeof pac_sof_marker;
791 footer_length = 74;
792
793 /* Finish decoding current frame */
794 n = (sof - data) - (footer_length + sizeof pac_sof_marker);
795 if (n < 0) {
796 gspca_dev->image_len += n;
797 } else {
798 gspca_frame_add(gspca_dev, INTER_PACKET, data, n);
799 }
800
801 image = gspca_dev->image;
802 if (image != NULL
803 && image[gspca_dev->image_len - 2] == 0xff
804 && image[gspca_dev->image_len - 1] == 0xd9)
805 gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
806
807 n = sof - data;
808 len -= n;
809 data = sof;
810
811 /* Get average lumination */
812 if (gspca_dev->last_packet_type == LAST_PACKET &&
813 n >= lum_offset)
814 atomic_set(&sd->avg_lum, data[-lum_offset] +
815 data[-lum_offset + 1]);
816
817 /* Start the new frame with the jpeg header */
818 /* The PAC7302 has the image rotated 90 degrees */
819 gspca_frame_add(gspca_dev, FIRST_PACKET,
820 jpeg_header, sizeof jpeg_header);
821 }
822 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
823 }
824
825 #ifdef CONFIG_VIDEO_ADV_DEBUG
sd_dbg_s_register(struct gspca_dev * gspca_dev,const struct v4l2_dbg_register * reg)826 static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
827 const struct v4l2_dbg_register *reg)
828 {
829 u8 index;
830 u8 value;
831
832 /*
833 * reg->reg: bit0..15: reserved for register index (wIndex is 16bit
834 * long on the USB bus)
835 */
836 if (reg->match.addr == 0 &&
837 (reg->reg < 0x000000ff) &&
838 (reg->val <= 0x000000ff)
839 ) {
840 /* Currently writing to page 0 is only supported. */
841 /* reg_w() only supports 8bit index */
842 index = reg->reg;
843 value = reg->val;
844
845 /*
846 * Note that there shall be no access to other page
847 * by any other function between the page switch and
848 * the actual register write.
849 */
850 reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
851 reg_w(gspca_dev, index, value);
852
853 reg_w(gspca_dev, 0xdc, 0x01);
854 }
855 return gspca_dev->usb_err;
856 }
857 #endif
858
859 #if IS_ENABLED(CONFIG_INPUT)
sd_int_pkt_scan(struct gspca_dev * gspca_dev,u8 * data,int len)860 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
861 u8 *data, /* interrupt packet data */
862 int len) /* interrupt packet length */
863 {
864 int ret = -EINVAL;
865 u8 data0, data1;
866
867 if (len == 2) {
868 data0 = data[0];
869 data1 = data[1];
870 if ((data0 == 0x00 && data1 == 0x11) ||
871 (data0 == 0x22 && data1 == 0x33) ||
872 (data0 == 0x44 && data1 == 0x55) ||
873 (data0 == 0x66 && data1 == 0x77) ||
874 (data0 == 0x88 && data1 == 0x99) ||
875 (data0 == 0xaa && data1 == 0xbb) ||
876 (data0 == 0xcc && data1 == 0xdd) ||
877 (data0 == 0xee && data1 == 0xff)) {
878 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
879 input_sync(gspca_dev->input_dev);
880 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
881 input_sync(gspca_dev->input_dev);
882 ret = 0;
883 }
884 }
885
886 return ret;
887 }
888 #endif
889
890 /* sub-driver description for pac7302 */
891 static const struct sd_desc sd_desc = {
892 .name = KBUILD_MODNAME,
893 .config = sd_config,
894 .init = sd_init,
895 .init_controls = sd_init_controls,
896 .start = sd_start,
897 .stopN = sd_stopN,
898 .stop0 = sd_stop0,
899 .pkt_scan = sd_pkt_scan,
900 .dq_callback = do_autogain,
901 #ifdef CONFIG_VIDEO_ADV_DEBUG
902 .set_register = sd_dbg_s_register,
903 #endif
904 #if IS_ENABLED(CONFIG_INPUT)
905 .int_pkt_scan = sd_int_pkt_scan,
906 #endif
907 };
908
909 /* -- module initialisation -- */
910 static const struct usb_device_id device_table[] = {
911 {USB_DEVICE(0x06f8, 0x3009)},
912 {USB_DEVICE(0x06f8, 0x301b)},
913 {USB_DEVICE(0x093a, 0x2620)},
914 {USB_DEVICE(0x093a, 0x2621)},
915 {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
916 {USB_DEVICE(0x093a, 0x2623), .driver_info = FL_VFLIP},
917 {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
918 {USB_DEVICE(0x093a, 0x2625)},
919 {USB_DEVICE(0x093a, 0x2626)},
920 {USB_DEVICE(0x093a, 0x2627), .driver_info = FL_VFLIP},
921 {USB_DEVICE(0x093a, 0x2628)},
922 {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
923 {USB_DEVICE(0x093a, 0x262a)},
924 {USB_DEVICE(0x093a, 0x262c)},
925 {USB_DEVICE(0x145f, 0x013c)},
926 {USB_DEVICE(0x1ae7, 0x2001)}, /* SpeedLink Snappy Mic SL-6825-SBK */
927 {}
928 };
929 MODULE_DEVICE_TABLE(usb, device_table);
930
931 /* -- device connect -- */
sd_probe(struct usb_interface * intf,const struct usb_device_id * id)932 static int sd_probe(struct usb_interface *intf,
933 const struct usb_device_id *id)
934 {
935 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
936 THIS_MODULE);
937 }
938
939 static struct usb_driver sd_driver = {
940 .name = KBUILD_MODNAME,
941 .id_table = device_table,
942 .probe = sd_probe,
943 .disconnect = gspca_disconnect,
944 #ifdef CONFIG_PM
945 .suspend = gspca_suspend,
946 .resume = gspca_resume,
947 .reset_resume = gspca_resume,
948 #endif
949 };
950
951 module_usb_driver(sd_driver);
952