1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29#define MODULE_NAME "jeilinj"
30
31#include <linux/slab.h>
32#include "gspca.h"
33#include "jpeg.h"
34
35MODULE_AUTHOR("Theodore Kilgore <kilgota@auburn.edu>");
36MODULE_DESCRIPTION("GSPCA/JEILINJ USB Camera Driver");
37MODULE_LICENSE("GPL");
38
39
40#define JEILINJ_CMD_TIMEOUT 500
41#define JEILINJ_CMD_DELAY 160
42#define JEILINJ_DATA_TIMEOUT 1000
43
44
45#define JEILINJ_MAX_TRANSFER 0x200
46#define FRAME_HEADER_LEN 0x10
47#define FRAME_START 0xFFFFFFFF
48
49enum {
50 SAKAR_57379,
51 SPORTSCAM_DV15,
52};
53
54#define CAMQUALITY_MIN 0
55#define CAMQUALITY_MAX 97
56
57
58struct sd {
59 struct gspca_dev gspca_dev;
60 int blocks_left;
61 const struct v4l2_pix_format *cap_mode;
62 struct v4l2_ctrl *freq;
63 struct v4l2_ctrl *jpegqual;
64
65 u8 type;
66 u8 quality;
67#define QUALITY_MIN 35
68#define QUALITY_MAX 85
69#define QUALITY_DEF 85
70 u8 jpeg_hdr[JPEG_HDR_SZ];
71};
72
73struct jlj_command {
74 unsigned char instruction[2];
75 unsigned char ack_wanted;
76 unsigned char delay;
77};
78
79
80static struct v4l2_pix_format jlj_mode[] = {
81 { 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
82 .bytesperline = 320,
83 .sizeimage = 320 * 240,
84 .colorspace = V4L2_COLORSPACE_JPEG,
85 .priv = 0},
86 { 640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
87 .bytesperline = 640,
88 .sizeimage = 640 * 480,
89 .colorspace = V4L2_COLORSPACE_JPEG,
90 .priv = 0}
91};
92
93
94
95
96
97
98
99static void jlj_write2(struct gspca_dev *gspca_dev, unsigned char *command)
100{
101 int retval;
102
103 if (gspca_dev->usb_err < 0)
104 return;
105 memcpy(gspca_dev->usb_buf, command, 2);
106 retval = usb_bulk_msg(gspca_dev->dev,
107 usb_sndbulkpipe(gspca_dev->dev, 3),
108 gspca_dev->usb_buf, 2, NULL, 500);
109 if (retval < 0) {
110 pr_err("command write [%02x] error %d\n",
111 gspca_dev->usb_buf[0], retval);
112 gspca_dev->usb_err = retval;
113 }
114}
115
116
117static void jlj_read1(struct gspca_dev *gspca_dev, unsigned char *response)
118{
119 int retval;
120
121 if (gspca_dev->usb_err < 0)
122 return;
123 retval = usb_bulk_msg(gspca_dev->dev,
124 usb_rcvbulkpipe(gspca_dev->dev, 0x84),
125 gspca_dev->usb_buf, 1, NULL, 500);
126 *response = gspca_dev->usb_buf[0];
127 if (retval < 0) {
128 pr_err("read command [%02x] error %d\n",
129 gspca_dev->usb_buf[0], retval);
130 gspca_dev->usb_err = retval;
131 }
132}
133
134static void setfreq(struct gspca_dev *gspca_dev, s32 val)
135{
136 u8 freq_commands[][2] = {
137 {0x71, 0x80},
138 {0x70, 0x07}
139 };
140
141 freq_commands[0][1] |= val >> 1;
142
143 jlj_write2(gspca_dev, freq_commands[0]);
144 jlj_write2(gspca_dev, freq_commands[1]);
145}
146
147static void setcamquality(struct gspca_dev *gspca_dev, s32 val)
148{
149 u8 quality_commands[][2] = {
150 {0x71, 0x1E},
151 {0x70, 0x06}
152 };
153 u8 camquality;
154
155
156 camquality = ((QUALITY_MAX - val) * CAMQUALITY_MAX)
157 / (QUALITY_MAX - QUALITY_MIN);
158 quality_commands[0][1] += camquality;
159
160 jlj_write2(gspca_dev, quality_commands[0]);
161 jlj_write2(gspca_dev, quality_commands[1]);
162}
163
164static void setautogain(struct gspca_dev *gspca_dev, s32 val)
165{
166 u8 autogain_commands[][2] = {
167 {0x94, 0x02},
168 {0xcf, 0x00}
169 };
170
171 autogain_commands[1][1] = val << 4;
172
173 jlj_write2(gspca_dev, autogain_commands[0]);
174 jlj_write2(gspca_dev, autogain_commands[1]);
175}
176
177static void setred(struct gspca_dev *gspca_dev, s32 val)
178{
179 u8 setred_commands[][2] = {
180 {0x94, 0x02},
181 {0xe6, 0x00}
182 };
183
184 setred_commands[1][1] = val;
185
186 jlj_write2(gspca_dev, setred_commands[0]);
187 jlj_write2(gspca_dev, setred_commands[1]);
188}
189
190static void setgreen(struct gspca_dev *gspca_dev, s32 val)
191{
192 u8 setgreen_commands[][2] = {
193 {0x94, 0x02},
194 {0xe7, 0x00}
195 };
196
197 setgreen_commands[1][1] = val;
198
199 jlj_write2(gspca_dev, setgreen_commands[0]);
200 jlj_write2(gspca_dev, setgreen_commands[1]);
201}
202
203static void setblue(struct gspca_dev *gspca_dev, s32 val)
204{
205 u8 setblue_commands[][2] = {
206 {0x94, 0x02},
207 {0xe9, 0x00}
208 };
209
210 setblue_commands[1][1] = val;
211
212 jlj_write2(gspca_dev, setblue_commands[0]);
213 jlj_write2(gspca_dev, setblue_commands[1]);
214}
215
216static int jlj_start(struct gspca_dev *gspca_dev)
217{
218 int i;
219 int start_commands_size;
220 u8 response = 0xff;
221 struct sd *sd = (struct sd *) gspca_dev;
222 struct jlj_command start_commands[] = {
223 {{0x71, 0x81}, 0, 0},
224 {{0x70, 0x05}, 0, JEILINJ_CMD_DELAY},
225 {{0x95, 0x70}, 1, 0},
226 {{0x71, 0x81 - gspca_dev->curr_mode}, 0, 0},
227 {{0x70, 0x04}, 0, JEILINJ_CMD_DELAY},
228 {{0x95, 0x70}, 1, 0},
229 {{0x71, 0x00}, 0, 0},
230 {{0x70, 0x08}, 0, JEILINJ_CMD_DELAY},
231 {{0x95, 0x70}, 1, 0},
232#define SPORTSCAM_DV15_CMD_SIZE 9
233 {{0x94, 0x02}, 0, 0},
234 {{0xde, 0x24}, 0, 0},
235 {{0x94, 0x02}, 0, 0},
236 {{0xdd, 0xf0}, 0, 0},
237 {{0x94, 0x02}, 0, 0},
238 {{0xe3, 0x2c}, 0, 0},
239 {{0x94, 0x02}, 0, 0},
240 {{0xe4, 0x00}, 0, 0},
241 {{0x94, 0x02}, 0, 0},
242 {{0xe5, 0x00}, 0, 0},
243 {{0x94, 0x02}, 0, 0},
244 {{0xe6, 0x2c}, 0, 0},
245 {{0x94, 0x03}, 0, 0},
246 {{0xaa, 0x00}, 0, 0}
247 };
248
249 sd->blocks_left = 0;
250
251
252
253 if (sd->type == SPORTSCAM_DV15)
254 start_commands_size = SPORTSCAM_DV15_CMD_SIZE;
255 else
256 start_commands_size = ARRAY_SIZE(start_commands);
257
258 for (i = 0; i < start_commands_size; i++) {
259 jlj_write2(gspca_dev, start_commands[i].instruction);
260 if (start_commands[i].delay)
261 msleep(start_commands[i].delay);
262 if (start_commands[i].ack_wanted)
263 jlj_read1(gspca_dev, &response);
264 }
265 setcamquality(gspca_dev, v4l2_ctrl_g_ctrl(sd->jpegqual));
266 msleep(2);
267 setfreq(gspca_dev, v4l2_ctrl_g_ctrl(sd->freq));
268 if (gspca_dev->usb_err < 0)
269 PERR("Start streaming command failed");
270 return gspca_dev->usb_err;
271}
272
273static void sd_pkt_scan(struct gspca_dev *gspca_dev,
274 u8 *data, int len)
275{
276 struct sd *sd = (struct sd *) gspca_dev;
277 int packet_type;
278 u32 header_marker;
279
280 PDEBUG(D_STREAM, "Got %d bytes out of %d for Block 0",
281 len, JEILINJ_MAX_TRANSFER);
282 if (len != JEILINJ_MAX_TRANSFER) {
283 PDEBUG(D_PACK, "bad length");
284 goto discard;
285 }
286
287 header_marker = ((u32 *)data)[0];
288 if (header_marker == FRAME_START) {
289 sd->blocks_left = data[0x0a] - 1;
290 PDEBUG(D_STREAM, "blocks_left = 0x%x", sd->blocks_left);
291
292 gspca_frame_add(gspca_dev, FIRST_PACKET,
293 sd->jpeg_hdr, JPEG_HDR_SZ);
294
295 gspca_frame_add(gspca_dev, INTER_PACKET,
296 data + FRAME_HEADER_LEN,
297 JEILINJ_MAX_TRANSFER - FRAME_HEADER_LEN);
298 } else if (sd->blocks_left > 0) {
299 PDEBUG(D_STREAM, "%d blocks remaining for frame",
300 sd->blocks_left);
301 sd->blocks_left -= 1;
302 if (sd->blocks_left == 0)
303 packet_type = LAST_PACKET;
304 else
305 packet_type = INTER_PACKET;
306 gspca_frame_add(gspca_dev, packet_type,
307 data, JEILINJ_MAX_TRANSFER);
308 } else
309 goto discard;
310 return;
311discard:
312
313 gspca_dev->last_packet_type = DISCARD_PACKET;
314}
315
316
317static int sd_config(struct gspca_dev *gspca_dev,
318 const struct usb_device_id *id)
319{
320 struct cam *cam = &gspca_dev->cam;
321 struct sd *dev = (struct sd *) gspca_dev;
322
323 dev->type = id->driver_info;
324 dev->quality = QUALITY_DEF;
325
326 cam->cam_mode = jlj_mode;
327 cam->nmodes = ARRAY_SIZE(jlj_mode);
328 cam->bulk = 1;
329 cam->bulk_nurbs = 1;
330 cam->bulk_size = JEILINJ_MAX_TRANSFER;
331 return 0;
332}
333
334static void sd_stopN(struct gspca_dev *gspca_dev)
335{
336 int i;
337 u8 *buf;
338 static u8 stop_commands[][2] = {
339 {0x71, 0x00},
340 {0x70, 0x09},
341 {0x71, 0x80},
342 {0x70, 0x05}
343 };
344
345 for (;;) {
346
347 usb_bulk_msg(gspca_dev->dev,
348 gspca_dev->urb[0]->pipe,
349 gspca_dev->urb[0]->transfer_buffer,
350 JEILINJ_MAX_TRANSFER, NULL,
351 JEILINJ_DATA_TIMEOUT);
352
353
354 i = 0;
355 buf = gspca_dev->urb[0]->transfer_buffer;
356 while ((i < (JEILINJ_MAX_TRANSFER - 1)) &&
357 ((buf[i] != 0xff) || (buf[i+1] != 0xd9)))
358 i++;
359
360 if (i != (JEILINJ_MAX_TRANSFER - 1))
361
362 break;
363 }
364
365 for (i = 0; i < ARRAY_SIZE(stop_commands); i++)
366 jlj_write2(gspca_dev, stop_commands[i]);
367}
368
369
370static int sd_init(struct gspca_dev *gspca_dev)
371{
372 return gspca_dev->usb_err;
373}
374
375
376static int sd_start(struct gspca_dev *gspca_dev)
377{
378 struct sd *dev = (struct sd *) gspca_dev;
379
380
381 jpeg_define(dev->jpeg_hdr, gspca_dev->height, gspca_dev->width,
382 0x21);
383 jpeg_set_qual(dev->jpeg_hdr, dev->quality);
384 PDEBUG(D_STREAM, "Start streaming at %dx%d",
385 gspca_dev->height, gspca_dev->width);
386 jlj_start(gspca_dev);
387 return gspca_dev->usb_err;
388}
389
390
391static const struct usb_device_id device_table[] = {
392 {USB_DEVICE(0x0979, 0x0280), .driver_info = SAKAR_57379},
393 {USB_DEVICE(0x0979, 0x0270), .driver_info = SPORTSCAM_DV15},
394 {}
395};
396
397MODULE_DEVICE_TABLE(usb, device_table);
398
399static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
400{
401 struct gspca_dev *gspca_dev =
402 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
403 struct sd *sd = (struct sd *)gspca_dev;
404
405 gspca_dev->usb_err = 0;
406
407 if (!gspca_dev->streaming)
408 return 0;
409
410 switch (ctrl->id) {
411 case V4L2_CID_POWER_LINE_FREQUENCY:
412 setfreq(gspca_dev, ctrl->val);
413 break;
414 case V4L2_CID_RED_BALANCE:
415 setred(gspca_dev, ctrl->val);
416 break;
417 case V4L2_CID_GAIN:
418 setgreen(gspca_dev, ctrl->val);
419 break;
420 case V4L2_CID_BLUE_BALANCE:
421 setblue(gspca_dev, ctrl->val);
422 break;
423 case V4L2_CID_AUTOGAIN:
424 setautogain(gspca_dev, ctrl->val);
425 break;
426 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
427 jpeg_set_qual(sd->jpeg_hdr, ctrl->val);
428 setcamquality(gspca_dev, ctrl->val);
429 break;
430 }
431 return gspca_dev->usb_err;
432}
433
434static const struct v4l2_ctrl_ops sd_ctrl_ops = {
435 .s_ctrl = sd_s_ctrl,
436};
437
438static int sd_init_controls(struct gspca_dev *gspca_dev)
439{
440 struct sd *sd = (struct sd *)gspca_dev;
441 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
442 static const struct v4l2_ctrl_config custom_autogain = {
443 .ops = &sd_ctrl_ops,
444 .id = V4L2_CID_AUTOGAIN,
445 .type = V4L2_CTRL_TYPE_INTEGER,
446 .name = "Automatic Gain (and Exposure)",
447 .max = 3,
448 .step = 1,
449 .def = 0,
450 };
451
452 gspca_dev->vdev.ctrl_handler = hdl;
453 v4l2_ctrl_handler_init(hdl, 6);
454 sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
455 V4L2_CID_POWER_LINE_FREQUENCY,
456 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 1,
457 V4L2_CID_POWER_LINE_FREQUENCY_60HZ);
458 v4l2_ctrl_new_custom(hdl, &custom_autogain, NULL);
459 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
460 V4L2_CID_RED_BALANCE, 0, 3, 1, 2);
461 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
462 V4L2_CID_GAIN, 0, 3, 1, 2);
463 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
464 V4L2_CID_BLUE_BALANCE, 0, 3, 1, 2);
465 sd->jpegqual = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
466 V4L2_CID_JPEG_COMPRESSION_QUALITY,
467 QUALITY_MIN, QUALITY_MAX, 1, QUALITY_DEF);
468
469 if (hdl->error) {
470 pr_err("Could not initialize controls\n");
471 return hdl->error;
472 }
473 return 0;
474}
475
476static int sd_set_jcomp(struct gspca_dev *gspca_dev,
477 const struct v4l2_jpegcompression *jcomp)
478{
479 struct sd *sd = (struct sd *) gspca_dev;
480
481 v4l2_ctrl_s_ctrl(sd->jpegqual, jcomp->quality);
482 return 0;
483}
484
485static int sd_get_jcomp(struct gspca_dev *gspca_dev,
486 struct v4l2_jpegcompression *jcomp)
487{
488 struct sd *sd = (struct sd *) gspca_dev;
489
490 memset(jcomp, 0, sizeof *jcomp);
491 jcomp->quality = v4l2_ctrl_g_ctrl(sd->jpegqual);
492 jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
493 | V4L2_JPEG_MARKER_DQT;
494 return 0;
495}
496
497
498
499static const struct sd_desc sd_desc_sakar_57379 = {
500 .name = MODULE_NAME,
501 .config = sd_config,
502 .init = sd_init,
503 .start = sd_start,
504 .stopN = sd_stopN,
505 .pkt_scan = sd_pkt_scan,
506};
507
508
509static const struct sd_desc sd_desc_sportscam_dv15 = {
510 .name = MODULE_NAME,
511 .config = sd_config,
512 .init = sd_init,
513 .init_controls = sd_init_controls,
514 .start = sd_start,
515 .stopN = sd_stopN,
516 .pkt_scan = sd_pkt_scan,
517 .get_jcomp = sd_get_jcomp,
518 .set_jcomp = sd_set_jcomp,
519};
520
521static const struct sd_desc *sd_desc[2] = {
522 &sd_desc_sakar_57379,
523 &sd_desc_sportscam_dv15
524};
525
526
527static int sd_probe(struct usb_interface *intf,
528 const struct usb_device_id *id)
529{
530 return gspca_dev_probe(intf, id,
531 sd_desc[id->driver_info],
532 sizeof(struct sd),
533 THIS_MODULE);
534}
535
536static struct usb_driver sd_driver = {
537 .name = MODULE_NAME,
538 .id_table = device_table,
539 .probe = sd_probe,
540 .disconnect = gspca_disconnect,
541#ifdef CONFIG_PM
542 .suspend = gspca_suspend,
543 .resume = gspca_resume,
544 .reset_resume = gspca_resume,
545#endif
546};
547
548module_usb_driver(sd_driver);
549