LXR linux/drivers/media/usb/gspca/spca1528.c

   1/*
   2 * spca1528 subdriver
   3 *
   4 * Copyright (C) 2010-2011 Jean-Francois Moine (http://moinejf.free.fr)
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2 of the License, or
   9 * any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 * GNU General Public License for more details.
  15 */
  16
  17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19#define MODULE_NAME "spca1528"
  20
  21#include "gspca.h"
  22#include "jpeg.h"
  23
  24MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
  25MODULE_DESCRIPTION("SPCA1528 USB Camera Driver");
  26MODULE_LICENSE("GPL");
  27
  28/* specific webcam descriptor */
  29struct sd {
  30        struct gspca_dev gspca_dev;     /* !! must be the first item */
  31
  32        u8 pkt_seq;
  33
  34        u8 jpeg_hdr[JPEG_HDR_SZ];
  35};
  36
  37static const struct v4l2_pix_format vga_mode[] = {
  38/*              (does not work correctly)
  39        {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  40                .bytesperline = 176,
  41                .sizeimage = 176 * 144 * 5 / 8 + 590,
  42                .colorspace = V4L2_COLORSPACE_JPEG,
  43                .priv = 3},
  44*/
  45        {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  46                .bytesperline = 320,
  47                .sizeimage = 320 * 240 * 4 / 8 + 590,
  48                .colorspace = V4L2_COLORSPACE_JPEG,
  49                .priv = 2},
  50        {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  51                .bytesperline = 640,
  52                .sizeimage = 640 * 480 * 3 / 8 + 590,
  53                .colorspace = V4L2_COLORSPACE_JPEG,
  54                .priv = 1},
  55};
  56
  57/* read <len> bytes to gspca usb_buf */
  58static void reg_r(struct gspca_dev *gspca_dev,
  59                        u8 req,
  60                        u16 index,
  61                        int len)
  62{
  63#if USB_BUF_SZ < 64
  64#error "USB buffer too small"
  65#endif
  66        struct usb_device *dev = gspca_dev->dev;
  67        int ret;
  68
  69        if (gspca_dev->usb_err < 0)
  70                return;
  71        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  72                        req,
  73                        USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  74                        0x0000,                 /* value */
  75                        index,
  76                        gspca_dev->usb_buf, len,
  77                        500);
  78        gspca_dbg(gspca_dev, D_USBI, "GET %02x 0000 %04x %02x\n", req, index,
  79                  gspca_dev->usb_buf[0]);
  80        if (ret < 0) {
  81                pr_err("reg_r err %d\n", ret);
  82                gspca_dev->usb_err = ret;
  83        }
  84}
  85
  86static void reg_w(struct gspca_dev *gspca_dev,
  87                        u8 req,
  88                        u16 value,
  89                        u16 index)
  90{
  91        struct usb_device *dev = gspca_dev->dev;
  92        int ret;
  93
  94        if (gspca_dev->usb_err < 0)
  95                return;
  96        gspca_dbg(gspca_dev, D_USBO, "SET %02x %04x %04x\n", req, value, index);
  97        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  98                        req,
  99                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 100                        value, index,
 101                        NULL, 0, 500);
 102        if (ret < 0) {
 103                pr_err("reg_w err %d\n", ret);
 104                gspca_dev->usb_err = ret;
 105        }
 106}
 107
 108static void reg_wb(struct gspca_dev *gspca_dev,
 109                        u8 req,
 110                        u16 value,
 111                        u16 index,
 112                        u8 byte)
 113{
 114        struct usb_device *dev = gspca_dev->dev;
 115        int ret;
 116
 117        if (gspca_dev->usb_err < 0)
 118                return;
 119        gspca_dbg(gspca_dev, D_USBO, "SET %02x %04x %04x %02x\n",
 120                  req, value, index, byte);
 121        gspca_dev->usb_buf[0] = byte;
 122        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 123                        req,
 124                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 125                        value, index,
 126                        gspca_dev->usb_buf, 1, 500);
 127        if (ret < 0) {
 128                pr_err("reg_w err %d\n", ret);
 129                gspca_dev->usb_err = ret;
 130        }
 131}
 132
 133static void wait_status_0(struct gspca_dev *gspca_dev)
 134{
 135        int i, w;
 136
 137        i = 16;
 138        w = 0;
 139        do {
 140                reg_r(gspca_dev, 0x21, 0x0000, 1);
 141                if (gspca_dev->usb_buf[0] == 0)
 142                        return;
 143                w += 15;
 144                msleep(w);
 145        } while (--i > 0);
 146        gspca_err(gspca_dev, "wait_status_0 timeout\n");
 147        gspca_dev->usb_err = -ETIME;
 148}
 149
 150static void wait_status_1(struct gspca_dev *gspca_dev)
 151{
 152        int i;
 153
 154        i = 10;
 155        do {
 156                reg_r(gspca_dev, 0x21, 0x0001, 1);
 157                msleep(10);
 158                if (gspca_dev->usb_buf[0] == 1) {
 159                        reg_wb(gspca_dev, 0x21, 0x0000, 0x0001, 0x00);
 160                        reg_r(gspca_dev, 0x21, 0x0001, 1);
 161                        return;
 162                }
 163        } while (--i > 0);
 164        gspca_err(gspca_dev, "wait_status_1 timeout\n");
 165        gspca_dev->usb_err = -ETIME;
 166}
 167
 168static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
 169{
 170        reg_wb(gspca_dev, 0xc0, 0x0000, 0x00c0, val);
 171}
 172
 173static void setcontrast(struct gspca_dev *gspca_dev, s32 val)
 174{
 175        reg_wb(gspca_dev, 0xc1, 0x0000, 0x00c1, val);
 176}
 177
 178static void sethue(struct gspca_dev *gspca_dev, s32 val)
 179{
 180        reg_wb(gspca_dev, 0xc2, 0x0000, 0x0000, val);
 181}
 182
 183static void setcolor(struct gspca_dev *gspca_dev, s32 val)
 184{
 185        reg_wb(gspca_dev, 0xc3, 0x0000, 0x00c3, val);
 186}
 187
 188static void setsharpness(struct gspca_dev *gspca_dev, s32 val)
 189{
 190        reg_wb(gspca_dev, 0xc4, 0x0000, 0x00c4, val);
 191}
 192
 193/* this function is called at probe time */
 194static int sd_config(struct gspca_dev *gspca_dev,
 195                        const struct usb_device_id *id)
 196{
 197        gspca_dev->cam.cam_mode = vga_mode;
 198        gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
 199        gspca_dev->cam.npkt = 128; /* number of packets per ISOC message */
 200                        /*fixme: 256 in ms-win traces*/
 201
 202        return 0;
 203}
 204
 205/* this function is called at probe and resume time */
 206static int sd_init(struct gspca_dev *gspca_dev)
 207{
 208        reg_w(gspca_dev, 0x00, 0x0001, 0x2067);
 209        reg_w(gspca_dev, 0x00, 0x00d0, 0x206b);
 210        reg_w(gspca_dev, 0x00, 0x0000, 0x206c);
 211        reg_w(gspca_dev, 0x00, 0x0001, 0x2069);
 212        msleep(8);
 213        reg_w(gspca_dev, 0x00, 0x00c0, 0x206b);
 214        reg_w(gspca_dev, 0x00, 0x0000, 0x206c);
 215        reg_w(gspca_dev, 0x00, 0x0001, 0x2069);
 216
 217        reg_r(gspca_dev, 0x20, 0x0000, 1);
 218        reg_r(gspca_dev, 0x20, 0x0000, 5);
 219        reg_r(gspca_dev, 0x23, 0x0000, 64);
 220        gspca_dbg(gspca_dev, D_PROBE, "%s%s\n", &gspca_dev->usb_buf[0x1c],
 221                  &gspca_dev->usb_buf[0x30]);
 222        reg_r(gspca_dev, 0x23, 0x0001, 64);
 223        return gspca_dev->usb_err;
 224}
 225
 226/* function called at start time before URB creation */
 227static int sd_isoc_init(struct gspca_dev *gspca_dev)
 228{
 229        u8 mode;
 230
 231        reg_r(gspca_dev, 0x00, 0x2520, 1);
 232        wait_status_0(gspca_dev);
 233        reg_w(gspca_dev, 0xc5, 0x0003, 0x0000);
 234        wait_status_1(gspca_dev);
 235
 236        wait_status_0(gspca_dev);
 237        mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
 238        reg_wb(gspca_dev, 0x25, 0x0000, 0x0004, mode);
 239        reg_r(gspca_dev, 0x25, 0x0004, 1);
 240        reg_wb(gspca_dev, 0x27, 0x0000, 0x0000, 0x06);  /* 420 */
 241        reg_r(gspca_dev, 0x27, 0x0000, 1);
 242
 243/* not useful..
 244        gspca_dev->alt = 4;             * use alternate setting 3 */
 245
 246        return gspca_dev->usb_err;
 247}
 248
 249/* -- start the camera -- */
 250static int sd_start(struct gspca_dev *gspca_dev)
 251{
 252        struct sd *sd = (struct sd *) gspca_dev;
 253
 254        /* initialize the JPEG header */
 255        jpeg_define(sd->jpeg_hdr, gspca_dev->pixfmt.height,
 256                        gspca_dev->pixfmt.width,
 257                        0x22);          /* JPEG 411 */
 258
 259        /* the JPEG quality shall be 85% */
 260        jpeg_set_qual(sd->jpeg_hdr, 85);
 261
 262        reg_r(gspca_dev, 0x00, 0x2520, 1);
 263        msleep(8);
 264
 265        /* start the capture */
 266        wait_status_0(gspca_dev);
 267        reg_w(gspca_dev, 0x31, 0x0000, 0x0004); /* start request */
 268        wait_status_1(gspca_dev);
 269        wait_status_0(gspca_dev);
 270        msleep(200);
 271
 272        sd->pkt_seq = 0;
 273        return gspca_dev->usb_err;
 274}
 275
 276static void sd_stopN(struct gspca_dev *gspca_dev)
 277{
 278        /* stop the capture */
 279        wait_status_0(gspca_dev);
 280        reg_w(gspca_dev, 0x31, 0x0000, 0x0000); /* stop request */
 281        wait_status_1(gspca_dev);
 282        wait_status_0(gspca_dev);
 283}
 284
 285/* move a packet adding 0x00 after 0xff */
 286static void add_packet(struct gspca_dev *gspca_dev,
 287                        u8 *data,
 288                        int len)
 289{
 290        int i;
 291
 292        i = 0;
 293        do {
 294                if (data[i] == 0xff) {
 295                        gspca_frame_add(gspca_dev, INTER_PACKET,
 296                                        data, i + 1);
 297                        len -= i;
 298                        data += i;
 299                        *data = 0x00;
 300                        i = 0;
 301                }
 302        } while (++i < len);
 303        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 304}
 305
 306static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 307                        u8 *data,                       /* isoc packet */
 308                        int len)                        /* iso packet length */
 309{
 310        struct sd *sd = (struct sd *) gspca_dev;
 311        static const u8 ffd9[] = {0xff, 0xd9};
 312
 313        /* image packets start with:
 314         *      02 8n
 315         * with <n> bit:
 316         *      0x01: even (0) / odd (1) image
 317         *      0x02: end of image when set
 318         */
 319        if (len < 3)
 320                return;                         /* empty packet */
 321        if (*data == 0x02) {
 322                if (data[1] & 0x02) {
 323                        sd->pkt_seq = !(data[1] & 1);
 324                        add_packet(gspca_dev, data + 2, len - 2);
 325                        gspca_frame_add(gspca_dev, LAST_PACKET,
 326                                        ffd9, 2);
 327                        return;
 328                }
 329                if ((data[1] & 1) != sd->pkt_seq)
 330                        goto err;
 331                if (gspca_dev->last_packet_type == LAST_PACKET)
 332                        gspca_frame_add(gspca_dev, FIRST_PACKET,
 333                                        sd->jpeg_hdr, JPEG_HDR_SZ);
 334                add_packet(gspca_dev, data + 2, len - 2);
 335                return;
 336        }
 337err:
 338        gspca_dev->last_packet_type = DISCARD_PACKET;
 339}
 340
 341static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 342{
 343        struct gspca_dev *gspca_dev =
 344                container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
 345
 346        gspca_dev->usb_err = 0;
 347
 348        if (!gspca_dev->streaming)
 349                return 0;
 350
 351        switch (ctrl->id) {
 352        case V4L2_CID_BRIGHTNESS:
 353                setbrightness(gspca_dev, ctrl->val);
 354                break;
 355        case V4L2_CID_CONTRAST:
 356                setcontrast(gspca_dev, ctrl->val);
 357                break;
 358        case V4L2_CID_HUE:
 359                sethue(gspca_dev, ctrl->val);
 360                break;
 361        case V4L2_CID_SATURATION:
 362                setcolor(gspca_dev, ctrl->val);
 363                break;
 364        case V4L2_CID_SHARPNESS:
 365                setsharpness(gspca_dev, ctrl->val);
 366                break;
 367        }
 368        return gspca_dev->usb_err;
 369}
 370
 371static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 372        .s_ctrl = sd_s_ctrl,
 373};
 374
 375static int sd_init_controls(struct gspca_dev *gspca_dev)
 376{
 377        struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 378
 379        gspca_dev->vdev.ctrl_handler = hdl;
 380        v4l2_ctrl_handler_init(hdl, 5);
 381        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 382                        V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
 383        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 384                        V4L2_CID_CONTRAST, 0, 8, 1, 1);
 385        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 386                        V4L2_CID_HUE, 0, 255, 1, 0);
 387        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 388                        V4L2_CID_SATURATION, 0, 8, 1, 1);
 389        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 390                        V4L2_CID_SHARPNESS, 0, 255, 1, 0);
 391
 392        if (hdl->error) {
 393                pr_err("Could not initialize controls\n");
 394                return hdl->error;
 395        }
 396        return 0;
 397}
 398
 399/* sub-driver description */
 400static const struct sd_desc sd_desc = {
 401        .name = MODULE_NAME,
 402        .config = sd_config,
 403        .init = sd_init,
 404        .init_controls = sd_init_controls,
 405        .isoc_init = sd_isoc_init,
 406        .start = sd_start,
 407        .stopN = sd_stopN,
 408        .pkt_scan = sd_pkt_scan,
 409};
 410
 411/* -- module initialisation -- */
 412static const struct usb_device_id device_table[] = {
 413        {USB_DEVICE(0x04fc, 0x1528)},
 414        {}
 415};
 416MODULE_DEVICE_TABLE(usb, device_table);
 417
 418/* -- device connect -- */
 419static int sd_probe(struct usb_interface *intf,
 420                        const struct usb_device_id *id)
 421{
 422        /* the video interface for isochronous transfer is 1 */
 423        if (intf->cur_altsetting->desc.bInterfaceNumber != 1)
 424                return -ENODEV;
 425
 426        return gspca_dev_probe2(intf, id, &sd_desc, sizeof(struct sd),
 427                                THIS_MODULE);
 428}
 429
 430static struct usb_driver sd_driver = {
 431        .name = MODULE_NAME,
 432        .id_table = device_table,
 433        .probe = sd_probe,
 434        .disconnect = gspca_disconnect,
 435#ifdef CONFIG_PM
 436        .suspend = gspca_suspend,
 437        .resume = gspca_resume,
 438        .reset_resume = gspca_resume,
 439#endif
 440};
 441
 442module_usb_driver(sd_driver);
 443