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