drivers/media/video/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 MODULE_NAME "jeilinj"
  28
  29 #include <linux/slab.h>
  30 #include "gspca.h"
  31 #include "jpeg.h"
  32
  33 MODULE_AUTHOR("Theodore Kilgore <kilgota@auburn.edu>");
  34 MODULE_DESCRIPTION("GSPCA/JEILINJ USB Camera Driver");
  35 MODULE_LICENSE("GPL");
  36
  37 /* Default timeouts, in ms */
  38 #define JEILINJ_CMD_TIMEOUT 500
  39 #define JEILINJ_CMD_DELAY 160
  40 #define JEILINJ_DATA_TIMEOUT 1000
  41
  42 /* Maximum transfer size to use. */
  43 #define JEILINJ_MAX_TRANSFER 0x200
  44 #define FRAME_HEADER_LEN 0x10
  45 #define FRAME_START 0xFFFFFFFF
  46
  47 enum {
  48         SAKAR_57379,
  49         SPORTSCAM_DV15,
  50 };
  51
  52 #define CAMQUALITY_MIN 0        /* highest cam quality */
  53 #define CAMQUALITY_MAX 97       /* lowest cam quality  */
  54
  55 enum e_ctrl {
  56         LIGHTFREQ,
  57         AUTOGAIN,
  58         RED,
  59         GREEN,
  60         BLUE,
  61         NCTRLS          /* number of controls */
  62 };
  63
  64 /* Structure to hold all of our device specific stuff */
  65 struct sd {
  66         struct gspca_dev gspca_dev;     /* !! must be the first item */
  67         struct gspca_ctrl ctrls[NCTRLS];
  68         int blocks_left;
  69         const struct v4l2_pix_format *cap_mode;
  70         /* Driver stuff */
  71         u8 type;
  72         u8 quality;                              /* image quality */
  73 #define QUALITY_MIN 35
  74 #define QUALITY_MAX 85
  75 #define QUALITY_DEF 85
  76         u8 jpeg_hdr[JPEG_HDR_SZ];
  77 };
  78
  79 struct jlj_command {
  80         unsigned char instruction[2];
  81         unsigned char ack_wanted;
  82         unsigned char delay;
  83 };
  84
  85 /* AFAICT these cameras will only do 320x240. */
  86 static struct v4l2_pix_format jlj_mode[] = {
  87         { 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  88                 .bytesperline = 320,
  89                 .sizeimage = 320 * 240,
  90                 .colorspace = V4L2_COLORSPACE_JPEG,
  91                 .priv = 0},
  92         { 640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  93                 .bytesperline = 640,
  94                 .sizeimage = 640 * 480,
  95                 .colorspace = V4L2_COLORSPACE_JPEG,
  96                 .priv = 0}
  97 };
  98
  99 /*
 100  * cam uses endpoint 0x03 to send commands, 0x84 for read commands,
 101  * and 0x82 for bulk transfer.
 102  */
 103
 104 /* All commands are two bytes only */
 105 static void jlj_write2(struct gspca_dev *gspca_dev, unsigned char *command)
 106 {
 107         int retval;
 108
 109         if (gspca_dev->usb_err < 0)
 110                 return;
 111         memcpy(gspca_dev->usb_buf, command, 2);
 112         retval = usb_bulk_msg(gspca_dev->dev,
 113                         usb_sndbulkpipe(gspca_dev->dev, 3),
 114                         gspca_dev->usb_buf, 2, NULL, 500);
 115         if (retval < 0) {
 116                 err("command write [%02x] error %d",
 117                                 gspca_dev->usb_buf[0], retval);
 118                 gspca_dev->usb_err = retval;
 119         }
 120 }
 121
 122 /* Responses are one byte only */
 123 static void jlj_read1(struct gspca_dev *gspca_dev, unsigned char response)
 124 {
 125         int retval;
 126
 127         if (gspca_dev->usb_err < 0)
 128                 return;
 129         retval = usb_bulk_msg(gspca_dev->dev,
 130         usb_rcvbulkpipe(gspca_dev->dev, 0x84),
 131                                 gspca_dev->usb_buf, 1, NULL, 500);
 132         response = gspca_dev->usb_buf[0];
 133         if (retval < 0) {
 134                 err("read command [%02x] error %d",
 135                                 gspca_dev->usb_buf[0], retval);
 136                 gspca_dev->usb_err = retval;
 137         }
 138 }
 139
 140 static void setfreq(struct gspca_dev *gspca_dev)
 141 {
 142         struct sd *sd = (struct sd *) gspca_dev;
 143         u8 freq_commands[][2] = {
 144                 {0x71, 0x80},
 145                 {0x70, 0x07}
 146         };
 147
 148         freq_commands[0][1] |= (sd->ctrls[LIGHTFREQ].val >> 1);
 149
 150         jlj_write2(gspca_dev, freq_commands[0]);
 151         jlj_write2(gspca_dev, freq_commands[1]);
 152 }
 153
 154 static void setcamquality(struct gspca_dev *gspca_dev)
 155 {
 156         struct sd *sd = (struct sd *) gspca_dev;
 157         u8 quality_commands[][2] = {
 158                 {0x71, 0x1E},
 159                 {0x70, 0x06}
 160         };
 161         u8 camquality;
 162
 163         /* adapt camera quality from jpeg quality */
 164         camquality = ((QUALITY_MAX - sd->quality) * CAMQUALITY_MAX)
 165                 / (QUALITY_MAX - QUALITY_MIN);
 166         quality_commands[0][1] += camquality;
 167
 168         jlj_write2(gspca_dev, quality_commands[0]);
 169         jlj_write2(gspca_dev, quality_commands[1]);
 170 }
 171
 172 static void setautogain(struct gspca_dev *gspca_dev)
 173 {
 174         struct sd *sd = (struct sd *) gspca_dev;
 175         u8 autogain_commands[][2] = {
 176                 {0x94, 0x02},
 177                 {0xcf, 0x00}
 178         };
 179
 180         autogain_commands[1][1] = (sd->ctrls[AUTOGAIN].val << 4);
 181
 182         jlj_write2(gspca_dev, autogain_commands[0]);
 183         jlj_write2(gspca_dev, autogain_commands[1]);
 184 }
 185
 186 static void setred(struct gspca_dev *gspca_dev)
 187 {
 188         struct sd *sd = (struct sd *) gspca_dev;
 189         u8 setred_commands[][2] = {
 190                 {0x94, 0x02},
 191                 {0xe6, 0x00}
 192         };
 193
 194         setred_commands[1][1] = sd->ctrls[RED].val;
 195
 196         jlj_write2(gspca_dev, setred_commands[0]);
 197         jlj_write2(gspca_dev, setred_commands[1]);
 198 }
 199
 200 static void setgreen(struct gspca_dev *gspca_dev)
 201 {
 202         struct sd *sd = (struct sd *) gspca_dev;
 203         u8 setgreen_commands[][2] = {
 204                 {0x94, 0x02},
 205                 {0xe7, 0x00}
 206         };
 207
 208         setgreen_commands[1][1] = sd->ctrls[GREEN].val;
 209
 210         jlj_write2(gspca_dev, setgreen_commands[0]);
 211         jlj_write2(gspca_dev, setgreen_commands[1]);
 212 }
 213
 214 static void setblue(struct gspca_dev *gspca_dev)
 215 {
 216         struct sd *sd = (struct sd *) gspca_dev;
 217         u8 setblue_commands[][2] = {
 218                 {0x94, 0x02},
 219                 {0xe9, 0x00}
 220         };
 221
 222         setblue_commands[1][1] = sd->ctrls[BLUE].val;
 223
 224         jlj_write2(gspca_dev, setblue_commands[0]);
 225         jlj_write2(gspca_dev, setblue_commands[1]);
 226 }
 227
 228 static const struct ctrl sd_ctrls[NCTRLS] = {
 229 [LIGHTFREQ] = {
 230             {
 231                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
 232                 .type    = V4L2_CTRL_TYPE_MENU,
 233                 .name    = "Light frequency filter",
 234                 .minimum = V4L2_CID_POWER_LINE_FREQUENCY_DISABLED, /* 1 */
 235                 .maximum = V4L2_CID_POWER_LINE_FREQUENCY_60HZ, /* 2 */
 236                 .step    = 1,
 237                 .default_value = V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
 238             },
 239             .set_control = setfreq
 240         },
 241 [AUTOGAIN] = {
 242             {
 243                 .id = V4L2_CID_AUTOGAIN,
 244                 .type = V4L2_CTRL_TYPE_INTEGER,
 245                 .name = "Automatic Gain (and Exposure)",
 246                 .minimum = 0,
 247                 .maximum = 3,
 248                 .step = 1,
 249 #define AUTOGAIN_DEF 0
 250                 .default_value = AUTOGAIN_DEF,
 251            },
 252            .set_control = setautogain
 253         },
 254 [RED] = {
 255             {
 256                 .id = V4L2_CID_RED_BALANCE,
 257                 .type = V4L2_CTRL_TYPE_INTEGER,
 258                 .name = "red balance",
 259                 .minimum = 0,
 260                 .maximum = 3,
 261                 .step = 1,
 262 #define RED_BALANCE_DEF 2
 263                 .default_value = RED_BALANCE_DEF,
 264            },
 265            .set_control = setred
 266         },
 267
 268 [GREEN] = {
 269             {
 270                 .id = V4L2_CID_GAIN,
 271                 .type = V4L2_CTRL_TYPE_INTEGER,
 272                 .name = "green balance",
 273                 .minimum = 0,
 274                 .maximum = 3,
 275                 .step = 1,
 276 #define GREEN_BALANCE_DEF 2
 277                 .default_value = GREEN_BALANCE_DEF,
 278            },
 279            .set_control = setgreen
 280         },
 281 [BLUE] = {
 282             {
 283                 .id = V4L2_CID_BLUE_BALANCE,
 284                 .type = V4L2_CTRL_TYPE_INTEGER,
 285                 .name = "blue balance",
 286                 .minimum = 0,
 287                 .maximum = 3,
 288                 .step = 1,
 289 #define BLUE_BALANCE_DEF 2
 290                 .default_value = BLUE_BALANCE_DEF,
 291            },
 292            .set_control = setblue
 293         },
 294 };
 295
 296 static int jlj_start(struct gspca_dev *gspca_dev)
 297 {
 298         int i;
 299         int start_commands_size;
 300         u8 response = 0xff;
 301         struct sd *sd = (struct sd *) gspca_dev;
 302         struct jlj_command start_commands[] = {
 303                 {{0x71, 0x81}, 0, 0},
 304                 {{0x70, 0x05}, 0, JEILINJ_CMD_DELAY},
 305                 {{0x95, 0x70}, 1, 0},
 306                 {{0x71, 0x81 - gspca_dev->curr_mode}, 0, 0},
 307                 {{0x70, 0x04}, 0, JEILINJ_CMD_DELAY},
 308                 {{0x95, 0x70}, 1, 0},
 309                 {{0x71, 0x00}, 0, 0},   /* start streaming ??*/
 310                 {{0x70, 0x08}, 0, JEILINJ_CMD_DELAY},
 311                 {{0x95, 0x70}, 1, 0},
 312 #define SPORTSCAM_DV15_CMD_SIZE 9
 313                 {{0x94, 0x02}, 0, 0},
 314                 {{0xde, 0x24}, 0, 0},
 315                 {{0x94, 0x02}, 0, 0},
 316                 {{0xdd, 0xf0}, 0, 0},
 317                 {{0x94, 0x02}, 0, 0},
 318                 {{0xe3, 0x2c}, 0, 0},
 319                 {{0x94, 0x02}, 0, 0},
 320                 {{0xe4, 0x00}, 0, 0},
 321                 {{0x94, 0x02}, 0, 0},
 322                 {{0xe5, 0x00}, 0, 0},
 323                 {{0x94, 0x02}, 0, 0},
 324                 {{0xe6, 0x2c}, 0, 0},
 325                 {{0x94, 0x03}, 0, 0},
 326                 {{0xaa, 0x00}, 0, 0}
 327         };
 328
 329         sd->blocks_left = 0;
 330         /* Under Windows, USB spy shows that only the 9 first start
 331          * commands are used for SPORTSCAM_DV15 webcam
 332          */
 333         if (sd->type == SPORTSCAM_DV15)
 334                 start_commands_size = SPORTSCAM_DV15_CMD_SIZE;
 335         else
 336                 start_commands_size = ARRAY_SIZE(start_commands);
 337
 338         for (i = 0; i < start_commands_size; i++) {
 339                 jlj_write2(gspca_dev, start_commands[i].instruction);
 340                 if (start_commands[i].delay)
 341                         msleep(start_commands[i].delay);
 342                 if (start_commands[i].ack_wanted)
 343                         jlj_read1(gspca_dev, response);
 344         }
 345         setcamquality(gspca_dev);
 346         msleep(2);
 347         setfreq(gspca_dev);
 348         if (gspca_dev->usb_err < 0)
 349                 PDEBUG(D_ERR, "Start streaming command failed");
 350         return gspca_dev->usb_err;
 351 }
 352
 353 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 354                         u8 *data, int len)
 355 {
 356         struct sd *sd = (struct sd *) gspca_dev;
 357         int packet_type;
 358         u32 header_marker;
 359
 360         PDEBUG(D_STREAM, "Got %d bytes out of %d for Block 0",
 361                         len, JEILINJ_MAX_TRANSFER);
 362         if (len != JEILINJ_MAX_TRANSFER) {
 363                 PDEBUG(D_PACK, "bad length");
 364                 goto discard;
 365         }
 366         /* check if it's start of frame */
 367         header_marker = ((u32 *)data)[0];
 368         if (header_marker == FRAME_START) {
 369                 sd->blocks_left = data[0x0a] - 1;
 370                 PDEBUG(D_STREAM, "blocks_left = 0x%x", sd->blocks_left);
 371                 /* Start a new frame, and add the JPEG header, first thing */
 372                 gspca_frame_add(gspca_dev, FIRST_PACKET,
 373                                 sd->jpeg_hdr, JPEG_HDR_SZ);
 374                 /* Toss line 0 of data block 0, keep the rest. */
 375                 gspca_frame_add(gspca_dev, INTER_PACKET,
 376                                 data + FRAME_HEADER_LEN,
 377                                 JEILINJ_MAX_TRANSFER - FRAME_HEADER_LEN);
 378         } else if (sd->blocks_left > 0) {
 379                 PDEBUG(D_STREAM, "%d blocks remaining for frame",
 380                                 sd->blocks_left);
 381                 sd->blocks_left -= 1;
 382                 if (sd->blocks_left == 0)
 383                         packet_type = LAST_PACKET;
 384                 else
 385                         packet_type = INTER_PACKET;
 386                 gspca_frame_add(gspca_dev, packet_type,
 387                                 data, JEILINJ_MAX_TRANSFER);
 388         } else
 389                 goto discard;
 390         return;
 391 discard:
 392         /* Discard data until a new frame starts. */
 393         gspca_dev->last_packet_type = DISCARD_PACKET;
 394 }
 395
 396 /* This function is called at probe time just before sd_init */
 397 static int sd_config(struct gspca_dev *gspca_dev,
 398                 const struct usb_device_id *id)
 399 {
 400         struct cam *cam = &gspca_dev->cam;
 401         struct sd *dev  = (struct sd *) gspca_dev;
 402
 403         dev->type = id->driver_info;
 404         gspca_dev->cam.ctrls = dev->ctrls;
 405         dev->quality = QUALITY_DEF;
 406         dev->ctrls[LIGHTFREQ].def = V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
 407         dev->ctrls[RED].def = RED_BALANCE_DEF;
 408         dev->ctrls[GREEN].def = GREEN_BALANCE_DEF;
 409         dev->ctrls[BLUE].def = BLUE_BALANCE_DEF;
 410         PDEBUG(D_PROBE,
 411                 "JEILINJ camera detected"
 412                 " (vid/pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);
 413         cam->cam_mode = jlj_mode;
 414         cam->nmodes = ARRAY_SIZE(jlj_mode);
 415         cam->bulk = 1;
 416         cam->bulk_nurbs = 1;
 417         cam->bulk_size = JEILINJ_MAX_TRANSFER;
 418         return 0;
 419 }
 420
 421 static void sd_stopN(struct gspca_dev *gspca_dev)
 422 {
 423         int i;
 424         u8 *buf;
 425         u8 stop_commands[][2] = {
 426                 {0x71, 0x00},
 427                 {0x70, 0x09},
 428                 {0x71, 0x80},
 429                 {0x70, 0x05}
 430         };
 431
 432         for (;;) {
 433                 /* get the image remaining blocks */
 434                 usb_bulk_msg(gspca_dev->dev,
 435                                 gspca_dev->urb[0]->pipe,
 436                                 gspca_dev->urb[0]->transfer_buffer,
 437                                 JEILINJ_MAX_TRANSFER, NULL,
 438                                 JEILINJ_DATA_TIMEOUT);
 439
 440                 /* search for 0xff 0xd9  (EOF for JPEG) */
 441                 i = 0;
 442                 buf = gspca_dev->urb[0]->transfer_buffer;
 443                 while ((i < (JEILINJ_MAX_TRANSFER - 1)) &&
 444                         ((buf[i] != 0xff) || (buf[i+1] != 0xd9)))
 445                         i++;
 446
 447                 if (i != (JEILINJ_MAX_TRANSFER - 1))
 448                         /* last remaining block found */
 449                         break;
 450                 }
 451
 452         for (i = 0; i < ARRAY_SIZE(stop_commands); i++)
 453                 jlj_write2(gspca_dev, stop_commands[i]);
 454 }
 455
 456 /* this function is called at probe and resume time */
 457 static int sd_init(struct gspca_dev *gspca_dev)
 458 {
 459         return gspca_dev->usb_err;
 460 }
 461
 462 /* Set up for getting frames. */
 463 static int sd_start(struct gspca_dev *gspca_dev)
 464 {
 465         struct sd *dev = (struct sd *) gspca_dev;
 466
 467         /* create the JPEG header */
 468         jpeg_define(dev->jpeg_hdr, gspca_dev->height, gspca_dev->width,
 469                         0x21);          /* JPEG 422 */
 470         jpeg_set_qual(dev->jpeg_hdr, dev->quality);
 471         PDEBUG(D_STREAM, "Start streaming at %dx%d",
 472                 gspca_dev->height, gspca_dev->width);
 473         jlj_start(gspca_dev);
 474         return gspca_dev->usb_err;
 475 }
 476
 477 /* Table of supported USB devices */
 478 static const struct usb_device_id device_table[] = {
 479         {USB_DEVICE(0x0979, 0x0280), .driver_info = SAKAR_57379},
 480         {USB_DEVICE(0x0979, 0x0270), .driver_info = SPORTSCAM_DV15},
 481         {}
 482 };
 483
 484 MODULE_DEVICE_TABLE(usb, device_table);
 485
 486 static int sd_querymenu(struct gspca_dev *gspca_dev,
 487                         struct v4l2_querymenu *menu)
 488 {
 489         switch (menu->id) {
 490         case V4L2_CID_POWER_LINE_FREQUENCY:
 491                 switch (menu->index) {
 492                 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
 493                         strcpy((char *) menu->name, "disable");
 494                         return 0;
 495                 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
 496                         strcpy((char *) menu->name, "50 Hz");
 497                         return 0;
 498                 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
 499                         strcpy((char *) menu->name, "60 Hz");
 500                         return 0;
 501                 }
 502                 break;
 503         }
 504         return -EINVAL;
 505 }
 506
 507 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
 508                         struct v4l2_jpegcompression *jcomp)
 509 {
 510         struct sd *sd = (struct sd *) gspca_dev;
 511
 512         if (jcomp->quality < QUALITY_MIN)
 513                 sd->quality = QUALITY_MIN;
 514         else if (jcomp->quality > QUALITY_MAX)
 515                 sd->quality = QUALITY_MAX;
 516         else
 517                 sd->quality = jcomp->quality;
 518         if (gspca_dev->streaming) {
 519                 jpeg_set_qual(sd->jpeg_hdr, sd->quality);
 520                 setcamquality(gspca_dev);
 521         }
 522         return 0;
 523 }
 524
 525 static int sd_get_jcomp(struct gspca_dev *gspca_dev,
 526                         struct v4l2_jpegcompression *jcomp)
 527 {
 528         struct sd *sd = (struct sd *) gspca_dev;
 529
 530         memset(jcomp, 0, sizeof *jcomp);
 531         jcomp->quality = sd->quality;
 532         jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
 533                         | V4L2_JPEG_MARKER_DQT;
 534         return 0;
 535 }
 536
 537
 538 /* sub-driver description */
 539 static const struct sd_desc sd_desc_sakar_57379 = {
 540         .name   = MODULE_NAME,
 541         .config = sd_config,
 542         .init   = sd_init,
 543         .start  = sd_start,
 544         .stopN  = sd_stopN,
 545         .pkt_scan = sd_pkt_scan,
 546 };
 547
 548 /* sub-driver description */
 549 static const struct sd_desc sd_desc_sportscam_dv15 = {
 550         .name   = MODULE_NAME,
 551         .config = sd_config,
 552         .init   = sd_init,
 553         .start  = sd_start,
 554         .stopN  = sd_stopN,
 555         .pkt_scan = sd_pkt_scan,
 556         .ctrls = sd_ctrls,
 557         .nctrls = ARRAY_SIZE(sd_ctrls),
 558         .querymenu = sd_querymenu,
 559         .get_jcomp = sd_get_jcomp,
 560         .set_jcomp = sd_set_jcomp,
 561 };
 562
 563 static const struct sd_desc *sd_desc[2] = {
 564         &sd_desc_sakar_57379,
 565         &sd_desc_sportscam_dv15
 566 };
 567
 568 /* -- device connect -- */
 569 static int sd_probe(struct usb_interface *intf,
 570                 const struct usb_device_id *id)
 571 {
 572         return gspca_dev_probe(intf, id,
 573                         sd_desc[id->driver_info],
 574                         sizeof(struct sd),
 575                         THIS_MODULE);
 576 }
 577
 578 static struct usb_driver sd_driver = {
 579         .name       = MODULE_NAME,
 580         .id_table   = device_table,
 581         .probe      = sd_probe,
 582         .disconnect = gspca_disconnect,
 583 #ifdef CONFIG_PM
 584         .suspend = gspca_suspend,
 585         .resume  = gspca_resume,
 586 #endif
 587 };
 588
 589 /* -- module insert / remove -- */
 590 static int __init sd_mod_init(void)
 591 {
 592         return usb_register(&sd_driver);
 593 }
 594
 595 static void __exit sd_mod_exit(void)
 596 {
 597         usb_deregister(&sd_driver);
 598 }
 599
 600 module_init(sd_mod_init);
 601 module_exit(sd_mod_exit);