Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/media/usb/gspca/jeilinj.c

  1 /*
  2  * Jeilinj subdriver
  3  *
  4  * Supports some Jeilin dual-mode cameras which use bulk transport and
  5  * download raw JPEG data.
  6  *
  7  * Copyright (C) 2009 Theodore Kilgore
  8  *
  9  * Sportscam DV15 support and control settings are
 10  * Copyright (C) 2011 Patrice Chotard
 11  *
 12  * This program is free software; you can redistribute it and/or modify
 13  * it under the terms of the GNU General Public License as published by
 14  * the Free Software Foundation; either version 2 of the License, or
 15  * any later version.
 16  *
 17  * This program is distributed in the hope that it will be useful,
 18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 20  * GNU General Public License for more details.
 21  *
 22  * You should have received a copy of the GNU General Public License
 23  * along with this program; if not, write to the Free Software
 24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 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 
 35 MODULE_AUTHOR("Theodore Kilgore <kilgota@auburn.edu>");
 36 MODULE_DESCRIPTION("GSPCA/JEILINJ USB Camera Driver");
 37 MODULE_LICENSE("GPL");
 38 
 39 /* Default timeouts, in ms */
 40 #define JEILINJ_CMD_TIMEOUT 500
 41 #define JEILINJ_CMD_DELAY 160
 42 #define JEILINJ_DATA_TIMEOUT 1000
 43 
 44 /* Maximum transfer size to use. */
 45 #define JEILINJ_MAX_TRANSFER 0x200
 46 #define FRAME_HEADER_LEN 0x10
 47 #define FRAME_START 0xFFFFFFFF
 48 
 49 enum {
 50         SAKAR_57379,
 51         SPORTSCAM_DV15,
 52 };
 53 
 54 #define CAMQUALITY_MIN 0        /* highest cam quality */
 55 #define CAMQUALITY_MAX 97       /* lowest cam quality  */
 56 
 57 /* Structure to hold all of our device specific stuff */
 58 struct sd {
 59         struct gspca_dev gspca_dev;     /* !! must be the first item */
 60         int blocks_left;
 61         const struct v4l2_pix_format *cap_mode;
 62         struct v4l2_ctrl *freq;
 63         struct v4l2_ctrl *jpegqual;
 64         /* Driver stuff */
 65         u8 type;
 66         u8 quality;                              /* image 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 
 73 struct jlj_command {
 74         unsigned char instruction[2];
 75         unsigned char ack_wanted;
 76         unsigned char delay;
 77 };
 78 
 79 /* AFAICT these cameras will only do 320x240. */
 80 static 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  * cam uses endpoint 0x03 to send commands, 0x84 for read commands,
 95  * and 0x82 for bulk transfer.
 96  */
 97 
 98 /* All commands are two bytes only */
 99 static 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 /* Responses are one byte only */
117 static 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 
134 static 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 
147 static 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         /* adapt camera quality from jpeg quality */
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 
164 static 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 
177 static 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 
190 static 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 
203 static 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 
216 static 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},   /* start streaming ??*/
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         /* Under Windows, USB spy shows that only the 9 first start
251          * commands are used for SPORTSCAM_DV15 webcam
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 
273 static 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         /* check if it's start of frame */
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                 /* Start a new frame, and add the JPEG header, first thing */
292                 gspca_frame_add(gspca_dev, FIRST_PACKET,
293                                 sd->jpeg_hdr, JPEG_HDR_SZ);
294                 /* Toss line 0 of data block 0, keep the rest. */
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;
311 discard:
312         /* Discard data until a new frame starts. */
313         gspca_dev->last_packet_type = DISCARD_PACKET;
314 }
315 
316 /* This function is called at probe time just before sd_init */
317 static 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 
334 static 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                 /* get the image remaining blocks */
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                 /* search for 0xff 0xd9  (EOF for JPEG) */
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                         /* last remaining block found */
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 /* this function is called at probe and resume time */
370 static int sd_init(struct gspca_dev *gspca_dev)
371 {
372         return gspca_dev->usb_err;
373 }
374 
375 /* Set up for getting frames. */
376 static int sd_start(struct gspca_dev *gspca_dev)
377 {
378         struct sd *dev = (struct sd *) gspca_dev;
379 
380         /* create the JPEG header */
381         jpeg_define(dev->jpeg_hdr, gspca_dev->pixfmt.height,
382                         gspca_dev->pixfmt.width,
383                         0x21);          /* JPEG 422 */
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 /* Table of supported USB devices */
392 static 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 
398 MODULE_DEVICE_TABLE(usb, device_table);
399 
400 static 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 
435 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
436         .s_ctrl = sd_s_ctrl,
437 };
438 
439 static 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 
477 static 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 
486 static 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 /* sub-driver description */
500 static 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 /* sub-driver description */
510 static 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 
522 static const struct sd_desc *sd_desc[2] = {
523         &sd_desc_sakar_57379,
524         &sd_desc_sportscam_dv15
525 };
526 
527 /* -- device connect -- */
528 static 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 
537 static 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 
549 module_usb_driver(sd_driver);
550 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us