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->pixfmt.height,
382 gspca_dev->pixfmt.width,
383 0x21);
384 jpeg_set_qual(dev->jpeg_hdr, dev->quality);
385 PDEBUG(D_STREAM, "Start streaming at %dx%d",
386 gspca_dev->pixfmt.height, gspca_dev->pixfmt.width);
387 jlj_start(gspca_dev);
388 return gspca_dev->usb_err;
389}
390
391
392static const struct usb_device_id device_table[] = {
393 {USB_DEVICE(0x0979, 0x0280), .driver_info = SAKAR_57379},
394 {USB_DEVICE(0x0979, 0x0270), .driver_info = SPORTSCAM_DV15},
395 {}
396};
397
398MODULE_DEVICE_TABLE(usb, device_table);
399
400static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
401{
402 struct gspca_dev *gspca_dev =
403 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
404 struct sd *sd = (struct sd *)gspca_dev;
405
406 gspca_dev->usb_err = 0;
407
408 if (!gspca_dev->streaming)
409 return 0;
410
411 switch (ctrl->id) {
412 case V4L2_CID_POWER_LINE_FREQUENCY:
413 setfreq(gspca_dev, ctrl->val);
414 break;
415 case V4L2_CID_RED_BALANCE:
416 setred(gspca_dev, ctrl->val);
417 break;
418 case V4L2_CID_GAIN:
419 setgreen(gspca_dev, ctrl->val);
420 break;
421 case V4L2_CID_BLUE_BALANCE:
422 setblue(gspca_dev, ctrl->val);
423 break;
424 case V4L2_CID_AUTOGAIN:
425 setautogain(gspca_dev, ctrl->val);
426 break;
427 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
428 jpeg_set_qual(sd->jpeg_hdr, ctrl->val);
429 setcamquality(gspca_dev, ctrl->val);
430 break;
431 }
432 return gspca_dev->usb_err;
433}
434
435static const struct v4l2_ctrl_ops sd_ctrl_ops = {
436 .s_ctrl = sd_s_ctrl,
437};
438
439static int sd_init_controls(struct gspca_dev *gspca_dev)
440{
441 struct sd *sd = (struct sd *)gspca_dev;
442 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
443 static const struct v4l2_ctrl_config custom_autogain = {
444 .ops = &sd_ctrl_ops,
445 .id = V4L2_CID_AUTOGAIN,
446 .type = V4L2_CTRL_TYPE_INTEGER,
447 .name = "Automatic Gain (and Exposure)",
448 .max = 3,
449 .step = 1,
450 .def = 0,
451 };
452
453 gspca_dev->vdev.ctrl_handler = hdl;
454 v4l2_ctrl_handler_init(hdl, 6);
455 sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
456 V4L2_CID_POWER_LINE_FREQUENCY,
457 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 1,
458 V4L2_CID_POWER_LINE_FREQUENCY_60HZ);
459 v4l2_ctrl_new_custom(hdl, &custom_autogain, NULL);
460 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
461 V4L2_CID_RED_BALANCE, 0, 3, 1, 2);
462 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
463 V4L2_CID_GAIN, 0, 3, 1, 2);
464 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
465 V4L2_CID_BLUE_BALANCE, 0, 3, 1, 2);
466 sd->jpegqual = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
467 V4L2_CID_JPEG_COMPRESSION_QUALITY,
468 QUALITY_MIN, QUALITY_MAX, 1, QUALITY_DEF);
469
470 if (hdl->error) {
471 pr_err("Could not initialize controls\n");
472 return hdl->error;
473 }
474 return 0;
475}
476
477static int sd_set_jcomp(struct gspca_dev *gspca_dev,
478 const struct v4l2_jpegcompression *jcomp)
479{
480 struct sd *sd = (struct sd *) gspca_dev;
481
482 v4l2_ctrl_s_ctrl(sd->jpegqual, jcomp->quality);
483 return 0;
484}
485
486static int sd_get_jcomp(struct gspca_dev *gspca_dev,
487 struct v4l2_jpegcompression *jcomp)
488{
489 struct sd *sd = (struct sd *) gspca_dev;
490
491 memset(jcomp, 0, sizeof *jcomp);
492 jcomp->quality = v4l2_ctrl_g_ctrl(sd->jpegqual);
493 jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
494 | V4L2_JPEG_MARKER_DQT;
495 return 0;
496}
497
498
499
500static const struct sd_desc sd_desc_sakar_57379 = {
501 .name = MODULE_NAME,
502 .config = sd_config,
503 .init = sd_init,
504 .start = sd_start,
505 .stopN = sd_stopN,
506 .pkt_scan = sd_pkt_scan,
507};
508
509
510static const struct sd_desc sd_desc_sportscam_dv15 = {
511 .name = MODULE_NAME,
512 .config = sd_config,
513 .init = sd_init,
514 .init_controls = sd_init_controls,
515 .start = sd_start,
516 .stopN = sd_stopN,
517 .pkt_scan = sd_pkt_scan,
518 .get_jcomp = sd_get_jcomp,
519 .set_jcomp = sd_set_jcomp,
520};
521
522static const struct sd_desc *sd_desc[2] = {
523 &sd_desc_sakar_57379,
524 &sd_desc_sportscam_dv15
525};
526
527
528static int sd_probe(struct usb_interface *intf,
529 const struct usb_device_id *id)
530{
531 return gspca_dev_probe(intf, id,
532 sd_desc[id->driver_info],
533 sizeof(struct sd),
534 THIS_MODULE);
535}
536
537static struct usb_driver sd_driver = {
538 .name = MODULE_NAME,
539 .id_table = device_table,
540 .probe = sd_probe,
541 .disconnect = gspca_disconnect,
542#ifdef CONFIG_PM
543 .suspend = gspca_suspend,
544 .resume = gspca_resume,
545 .reset_resume = gspca_resume,
546#endif
547};
548
549module_usb_driver(sd_driver);
550