gspca/stv06xx/stv06xx.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) 2001 Jean-Fredric Clere, Nikolas Zimmermann, Georg Acher
0004  *            Mark Cave-Ayland, Carlo E Prelz, Dick Streefland
0005  * Copyright (c) 2002, 2003 Tuukka Toivonen
0006  * Copyright (c) 2008 Erik Andrén
0007  *
0008  * P/N 861037:      Sensor HDCS1000        ASIC STV0600
0009  * P/N 861050-0010: Sensor HDCS1000        ASIC STV0600
0010  * P/N 861050-0020: Sensor Photobit PB100  ASIC STV0600-1 - QuickCam Express
0011  * P/N 861055:      Sensor ST VV6410       ASIC STV0610   - LEGO cam
0012  * P/N 861075-0040: Sensor HDCS1000        ASIC
0013  * P/N 961179-0700: Sensor ST VV6410       ASIC STV0602   - Dexxa WebCam USB
0014  * P/N 861040-0000: Sensor ST VV6410       ASIC STV0610   - QuickCam Web
0015  */
0016
0017 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0018
0019 #include <linux/input.h>
0020 #include "stv06xx_sensor.h"
0021
0022 MODULE_AUTHOR("Erik Andrén");
0023 MODULE_DESCRIPTION("STV06XX USB Camera Driver");
0024 MODULE_LICENSE("GPL");
0025
0026 static bool dump_bridge;
0027 static bool dump_sensor;
0028
0029 int stv06xx_write_bridge(struct sd *sd, u16 address, u16 i2c_data)
0030 {
0031     int err;
0032     struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
0033     struct usb_device *udev = sd->gspca_dev.dev;
0034     __u8 *buf = sd->gspca_dev.usb_buf;
0035
0036     u8 len = (i2c_data > 0xff) ? 2 : 1;
0037
0038     buf[0] = i2c_data & 0xff;
0039     buf[1] = (i2c_data >> 8) & 0xff;
0040
0041     err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0042                   0x04, 0x40, address, 0, buf, len,
0043                   STV06XX_URB_MSG_TIMEOUT);
0044
0045     gspca_dbg(gspca_dev, D_CONF, "Written 0x%x to address 0x%x, status: %d\n",
0046           i2c_data, address, err);
0047
0048     return (err < 0) ? err : 0;
0049 }
0050
0051 int stv06xx_read_bridge(struct sd *sd, u16 address, u8 *i2c_data)
0052 {
0053     int err;
0054     struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
0055     struct usb_device *udev = sd->gspca_dev.dev;
0056     __u8 *buf = sd->gspca_dev.usb_buf;
0057
0058     err = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
0059                   0x04, 0xc0, address, 0, buf, 1,
0060                   STV06XX_URB_MSG_TIMEOUT);
0061
0062     *i2c_data = buf[0];
0063
0064     gspca_dbg(gspca_dev, D_CONF, "Reading 0x%x from address 0x%x, status %d\n",
0065           *i2c_data, address, err);
0066
0067     return (err < 0) ? err : 0;
0068 }
0069
0070 /* Wraps the normal write sensor bytes / words functions for writing a
0071    single value */
0072 int stv06xx_write_sensor(struct sd *sd, u8 address, u16 value)
0073 {
0074     if (sd->sensor->i2c_len == 2) {
0075         u16 data[2] = { address, value };
0076         return stv06xx_write_sensor_words(sd, data, 1);
0077     } else {
0078         u8 data[2] = { address, value };
0079         return stv06xx_write_sensor_bytes(sd, data, 1);
0080     }
0081 }
0082
0083 static int stv06xx_write_sensor_finish(struct sd *sd)
0084 {
0085     int err = 0;
0086
0087     if (sd->bridge == BRIDGE_STV610) {
0088         struct usb_device *udev = sd->gspca_dev.dev;
0089         __u8 *buf = sd->gspca_dev.usb_buf;
0090
0091         buf[0] = 0;
0092         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0093                       0x04, 0x40, 0x1704, 0, buf, 1,
0094                       STV06XX_URB_MSG_TIMEOUT);
0095     }
0096
0097     return (err < 0) ? err : 0;
0098 }
0099
0100 int stv06xx_write_sensor_bytes(struct sd *sd, const u8 *data, u8 len)
0101 {
0102     int err, i, j;
0103     struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
0104     struct usb_device *udev = sd->gspca_dev.dev;
0105     __u8 *buf = sd->gspca_dev.usb_buf;
0106
0107     gspca_dbg(gspca_dev, D_CONF, "I2C: Command buffer contains %d entries\n",
0108           len);
0109     for (i = 0; i < len;) {
0110         /* Build the command buffer */
0111         memset(buf, 0, I2C_BUFFER_LENGTH);
0112         for (j = 0; j < I2C_MAX_BYTES && i < len; j++, i++) {
0113             buf[j] = data[2*i];
0114             buf[0x10 + j] = data[2*i+1];
0115             gspca_dbg(gspca_dev, D_CONF, "I2C: Writing 0x%02x to reg 0x%02x\n",
0116                   data[2*i+1], data[2*i]);
0117         }
0118         buf[0x20] = sd->sensor->i2c_addr;
0119         buf[0x21] = j - 1; /* Number of commands to send - 1 */
0120         buf[0x22] = I2C_WRITE_CMD;
0121         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0122                       0x04, 0x40, 0x0400, 0, buf,
0123                       I2C_BUFFER_LENGTH,
0124                       STV06XX_URB_MSG_TIMEOUT);
0125         if (err < 0)
0126             return err;
0127     }
0128     return stv06xx_write_sensor_finish(sd);
0129 }
0130
0131 int stv06xx_write_sensor_words(struct sd *sd, const u16 *data, u8 len)
0132 {
0133     int err, i, j;
0134     struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
0135     struct usb_device *udev = sd->gspca_dev.dev;
0136     __u8 *buf = sd->gspca_dev.usb_buf;
0137
0138     gspca_dbg(gspca_dev, D_CONF, "I2C: Command buffer contains %d entries\n",
0139           len);
0140
0141     for (i = 0; i < len;) {
0142         /* Build the command buffer */
0143         memset(buf, 0, I2C_BUFFER_LENGTH);
0144         for (j = 0; j < I2C_MAX_WORDS && i < len; j++, i++) {
0145             buf[j] = data[2*i];
0146             buf[0x10 + j * 2] = data[2*i+1];
0147             buf[0x10 + j * 2 + 1] = data[2*i+1] >> 8;
0148             gspca_dbg(gspca_dev, D_CONF, "I2C: Writing 0x%04x to reg 0x%02x\n",
0149                   data[2*i+1], data[2*i]);
0150         }
0151         buf[0x20] = sd->sensor->i2c_addr;
0152         buf[0x21] = j - 1; /* Number of commands to send - 1 */
0153         buf[0x22] = I2C_WRITE_CMD;
0154         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0155                 0x04, 0x40, 0x0400, 0, buf,
0156                 I2C_BUFFER_LENGTH,
0157                 STV06XX_URB_MSG_TIMEOUT);
0158         if (err < 0)
0159             return err;
0160     }
0161     return stv06xx_write_sensor_finish(sd);
0162 }
0163
0164 int stv06xx_read_sensor(struct sd *sd, const u8 address, u16 *value)
0165 {
0166     int err;
0167     struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;
0168     struct usb_device *udev = sd->gspca_dev.dev;
0169     __u8 *buf = sd->gspca_dev.usb_buf;
0170
0171     err = stv06xx_write_bridge(sd, STV_I2C_FLUSH, sd->sensor->i2c_flush);
0172     if (err < 0)
0173         return err;
0174
0175     /* Clear mem */
0176     memset(buf, 0, I2C_BUFFER_LENGTH);
0177
0178     buf[0] = address;
0179     buf[0x20] = sd->sensor->i2c_addr;
0180     buf[0x21] = 0;
0181
0182     /* Read I2C register */
0183     buf[0x22] = I2C_READ_CMD;
0184
0185     err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0186                   0x04, 0x40, 0x1400, 0, buf, I2C_BUFFER_LENGTH,
0187                   STV06XX_URB_MSG_TIMEOUT);
0188     if (err < 0) {
0189         pr_err("I2C: Read error writing address: %d\n", err);
0190         return err;
0191     }
0192
0193     err = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
0194                   0x04, 0xc0, 0x1410, 0, buf, sd->sensor->i2c_len,
0195                   STV06XX_URB_MSG_TIMEOUT);
0196     if (sd->sensor->i2c_len == 2)
0197         *value = buf[0] | (buf[1] << 8);
0198     else
0199         *value = buf[0];
0200
0201     gspca_dbg(gspca_dev, D_CONF, "I2C: Read 0x%x from address 0x%x, status: %d\n",
0202           *value, address, err);
0203
0204     return (err < 0) ? err : 0;
0205 }
0206
0207 /* Dumps all bridge registers */
0208 static void stv06xx_dump_bridge(struct sd *sd)
0209 {
0210     int i;
0211     u8 data, buf;
0212
0213     pr_info("Dumping all stv06xx bridge registers\n");
0214     for (i = 0x1400; i < 0x160f; i++) {
0215         stv06xx_read_bridge(sd, i, &data);
0216
0217         pr_info("Read 0x%x from address 0x%x\n", data, i);
0218     }
0219
0220     pr_info("Testing stv06xx bridge registers for writability\n");
0221     for (i = 0x1400; i < 0x160f; i++) {
0222         stv06xx_read_bridge(sd, i, &data);
0223         buf = data;
0224
0225         stv06xx_write_bridge(sd, i, 0xff);
0226         stv06xx_read_bridge(sd, i, &data);
0227         if (data == 0xff)
0228             pr_info("Register 0x%x is read/write\n", i);
0229         else if (data != buf)
0230             pr_info("Register 0x%x is read/write, but only partially\n",
0231                 i);
0232         else
0233             pr_info("Register 0x%x is read-only\n", i);
0234
0235         stv06xx_write_bridge(sd, i, buf);
0236     }
0237 }
0238
0239 /* this function is called at probe and resume time */
0240 static int stv06xx_init(struct gspca_dev *gspca_dev)
0241 {
0242     struct sd *sd = (struct sd *) gspca_dev;
0243     int err;
0244
0245     gspca_dbg(gspca_dev, D_PROBE, "Initializing camera\n");
0246
0247     /* Let the usb init settle for a bit
0248        before performing the initialization */
0249     msleep(250);
0250
0251     err = sd->sensor->init(sd);
0252
0253     if (dump_sensor && sd->sensor->dump)
0254         sd->sensor->dump(sd);
0255
0256     return (err < 0) ? err : 0;
0257 }
0258
0259 /* this function is called at probe time */
0260 static int stv06xx_init_controls(struct gspca_dev *gspca_dev)
0261 {
0262     struct sd *sd = (struct sd *) gspca_dev;
0263
0264     gspca_dbg(gspca_dev, D_PROBE, "Initializing controls\n");
0265
0266     gspca_dev->vdev.ctrl_handler = &gspca_dev->ctrl_handler;
0267     return sd->sensor->init_controls(sd);
0268 }
0269
0270 /* Start the camera */
0271 static int stv06xx_start(struct gspca_dev *gspca_dev)
0272 {
0273     struct sd *sd = (struct sd *) gspca_dev;
0274     struct usb_host_interface *alt;
0275     struct usb_interface *intf;
0276     int err, packet_size;
0277
0278     intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
0279     alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
0280     if (!alt) {
0281         gspca_err(gspca_dev, "Couldn't get altsetting\n");
0282         return -EIO;
0283     }
0284
0285     if (alt->desc.bNumEndpoints < 1)
0286         return -ENODEV;
0287
0288     packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
0289     err = stv06xx_write_bridge(sd, STV_ISO_SIZE_L, packet_size);
0290     if (err < 0)
0291         return err;
0292
0293     /* Prepare the sensor for start */
0294     err = sd->sensor->start(sd);
0295     if (err < 0)
0296         goto out;
0297
0298     /* Start isochronous streaming */
0299     err = stv06xx_write_bridge(sd, STV_ISO_ENABLE, 1);
0300
0301 out:
0302     if (err < 0)
0303         gspca_dbg(gspca_dev, D_STREAM, "Starting stream failed\n");
0304     else
0305         gspca_dbg(gspca_dev, D_STREAM, "Started streaming\n");
0306
0307     return (err < 0) ? err : 0;
0308 }
0309
0310 static int stv06xx_isoc_init(struct gspca_dev *gspca_dev)
0311 {
0312     struct usb_interface_cache *intfc;
0313     struct usb_host_interface *alt;
0314     struct sd *sd = (struct sd *) gspca_dev;
0315
0316     intfc = gspca_dev->dev->actconfig->intf_cache[0];
0317
0318     if (intfc->num_altsetting < 2)
0319         return -ENODEV;
0320
0321     alt = &intfc->altsetting[1];
0322
0323     if (alt->desc.bNumEndpoints < 1)
0324         return -ENODEV;
0325
0326     /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
0327     alt->endpoint[0].desc.wMaxPacketSize =
0328         cpu_to_le16(sd->sensor->max_packet_size[gspca_dev->curr_mode]);
0329
0330     return 0;
0331 }
0332
0333 static int stv06xx_isoc_nego(struct gspca_dev *gspca_dev)
0334 {
0335     int ret, packet_size, min_packet_size;
0336     struct usb_host_interface *alt;
0337     struct sd *sd = (struct sd *) gspca_dev;
0338
0339     /*
0340      * Existence of altsetting and endpoint was verified in
0341      * stv06xx_isoc_init()
0342      */
0343     alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
0344     packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
0345     min_packet_size = sd->sensor->min_packet_size[gspca_dev->curr_mode];
0346     if (packet_size <= min_packet_size)
0347         return -EIO;
0348
0349     packet_size -= 100;
0350     if (packet_size < min_packet_size)
0351         packet_size = min_packet_size;
0352     alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
0353
0354     ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
0355     if (ret < 0)
0356         gspca_err(gspca_dev, "set alt 1 err %d\n", ret);
0357
0358     return ret;
0359 }
0360
0361 static void stv06xx_stopN(struct gspca_dev *gspca_dev)
0362 {
0363     int err;
0364     struct sd *sd = (struct sd *) gspca_dev;
0365
0366     /* stop ISO-streaming */
0367     err = stv06xx_write_bridge(sd, STV_ISO_ENABLE, 0);
0368     if (err < 0)
0369         goto out;
0370
0371     err = sd->sensor->stop(sd);
0372
0373 out:
0374     if (err < 0)
0375         gspca_dbg(gspca_dev, D_STREAM, "Failed to stop stream\n");
0376     else
0377         gspca_dbg(gspca_dev, D_STREAM, "Stopped streaming\n");
0378 }
0379
0380 /*
0381  * Analyse an USB packet of the data stream and store it appropriately.
0382  * Each packet contains an integral number of chunks. Each chunk has
0383  * 2-bytes identification, followed by 2-bytes that describe the chunk
0384  * length. Known/guessed chunk identifications are:
0385  * 8001/8005/C001/C005 - Begin new frame
0386  * 8002/8006/C002/C006 - End frame
0387  * 0200/4200           - Contains actual image data, bayer or compressed
0388  * 0005                - 11 bytes of unknown data
0389  * 0100                - 2 bytes of unknown data
0390  * The 0005 and 0100 chunks seem to appear only in compressed stream.
0391  */
0392 static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
0393             u8 *data,           /* isoc packet */
0394             int len)            /* iso packet length */
0395 {
0396     struct sd *sd = (struct sd *) gspca_dev;
0397
0398     gspca_dbg(gspca_dev, D_PACK, "Packet of length %d arrived\n", len);
0399
0400     /* A packet may contain several frames
0401        loop until the whole packet is reached */
0402     while (len) {
0403         int id, chunk_len;
0404
0405         if (len < 4) {
0406             gspca_dbg(gspca_dev, D_PACK, "Packet is smaller than 4 bytes\n");
0407             return;
0408         }
0409
0410         /* Capture the id */
0411         id = (data[0] << 8) | data[1];
0412
0413         /* Capture the chunk length */
0414         chunk_len = (data[2] << 8) | data[3];
0415         gspca_dbg(gspca_dev, D_PACK, "Chunk id: %x, length: %d\n",
0416               id, chunk_len);
0417
0418         data += 4;
0419         len -= 4;
0420
0421         if (len < chunk_len) {
0422             gspca_err(gspca_dev, "URB packet length is smaller than the specified chunk length\n");
0423             gspca_dev->last_packet_type = DISCARD_PACKET;
0424             return;
0425         }
0426
0427         /* First byte seem to be 02=data 2nd byte is unknown??? */
0428         if (sd->bridge == BRIDGE_ST6422 && (id & 0xff00) == 0x0200)
0429             goto frame_data;
0430
0431         switch (id) {
0432         case 0x0200:
0433         case 0x4200:
0434 frame_data:
0435             gspca_dbg(gspca_dev, D_PACK, "Frame data packet detected\n");
0436
0437             if (sd->to_skip) {
0438                 int skip = (sd->to_skip < chunk_len) ?
0439                         sd->to_skip : chunk_len;
0440                 data += skip;
0441                 len -= skip;
0442                 chunk_len -= skip;
0443                 sd->to_skip -= skip;
0444             }
0445
0446             gspca_frame_add(gspca_dev, INTER_PACKET,
0447                     data, chunk_len);
0448             break;
0449
0450         case 0x8001:
0451         case 0x8005:
0452         case 0xc001:
0453         case 0xc005:
0454             gspca_dbg(gspca_dev, D_PACK, "Starting new frame\n");
0455
0456             /* Create a new frame, chunk length should be zero */
0457             gspca_frame_add(gspca_dev, FIRST_PACKET,
0458                     NULL, 0);
0459
0460             if (sd->bridge == BRIDGE_ST6422)
0461                 sd->to_skip = gspca_dev->pixfmt.width * 4;
0462
0463             if (chunk_len)
0464                 gspca_err(gspca_dev, "Chunk length is non-zero on a SOF\n");
0465             break;
0466
0467         case 0x8002:
0468         case 0x8006:
0469         case 0xc002:
0470             gspca_dbg(gspca_dev, D_PACK, "End of frame detected\n");
0471
0472             /* Complete the last frame (if any) */
0473             gspca_frame_add(gspca_dev, LAST_PACKET,
0474                     NULL, 0);
0475
0476             if (chunk_len)
0477                 gspca_err(gspca_dev, "Chunk length is non-zero on a EOF\n");
0478             break;
0479
0480         case 0x0005:
0481             gspca_dbg(gspca_dev, D_PACK, "Chunk 0x005 detected\n");
0482             /* Unknown chunk with 11 bytes of data,
0483                occurs just before end of each frame
0484                in compressed mode */
0485             break;
0486
0487         case 0x0100:
0488             gspca_dbg(gspca_dev, D_PACK, "Chunk 0x0100 detected\n");
0489             /* Unknown chunk with 2 bytes of data,
0490                occurs 2-3 times per USB interrupt */
0491             break;
0492         case 0x42ff:
0493             gspca_dbg(gspca_dev, D_PACK, "Chunk 0x42ff detected\n");
0494             /* Special chunk seen sometimes on the ST6422 */
0495             break;
0496         default:
0497             gspca_dbg(gspca_dev, D_PACK, "Unknown chunk 0x%04x detected\n",
0498                   id);
0499             /* Unknown chunk */
0500         }
0501         data    += chunk_len;
0502         len     -= chunk_len;
0503     }
0504 }
0505
0506 #if IS_ENABLED(CONFIG_INPUT)
0507 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
0508             u8 *data,       /* interrupt packet data */
0509             int len)        /* interrupt packet length */
0510 {
0511     int ret = -EINVAL;
0512
0513     if (len == 1 && (data[0] == 0x80 || data[0] == 0x10)) {
0514         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
0515         input_sync(gspca_dev->input_dev);
0516         ret = 0;
0517     }
0518
0519     if (len == 1 && (data[0] == 0x88 || data[0] == 0x11)) {
0520         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
0521         input_sync(gspca_dev->input_dev);
0522         ret = 0;
0523     }
0524
0525     return ret;
0526 }
0527 #endif
0528
0529 static int stv06xx_config(struct gspca_dev *gspca_dev,
0530               const struct usb_device_id *id);
0531
0532 static void stv06xx_probe_error(struct gspca_dev *gspca_dev)
0533 {
0534     struct sd *sd = (struct sd *)gspca_dev;
0535
0536     kfree(sd->sensor_priv);
0537     sd->sensor_priv = NULL;
0538 }
0539
0540 /* sub-driver description */
0541 static const struct sd_desc sd_desc = {
0542     .name = MODULE_NAME,
0543     .config = stv06xx_config,
0544     .init = stv06xx_init,
0545     .init_controls = stv06xx_init_controls,
0546     .probe_error = stv06xx_probe_error,
0547     .start = stv06xx_start,
0548     .stopN = stv06xx_stopN,
0549     .pkt_scan = stv06xx_pkt_scan,
0550     .isoc_init = stv06xx_isoc_init,
0551     .isoc_nego = stv06xx_isoc_nego,
0552 #if IS_ENABLED(CONFIG_INPUT)
0553     .int_pkt_scan = sd_int_pkt_scan,
0554 #endif
0555 };
0556
0557 /* This function is called at probe time */
0558 static int stv06xx_config(struct gspca_dev *gspca_dev,
0559               const struct usb_device_id *id)
0560 {
0561     struct sd *sd = (struct sd *) gspca_dev;
0562
0563     gspca_dbg(gspca_dev, D_PROBE, "Configuring camera\n");
0564
0565     sd->bridge = id->driver_info;
0566     gspca_dev->sd_desc = &sd_desc;
0567
0568     if (dump_bridge)
0569         stv06xx_dump_bridge(sd);
0570
0571     sd->sensor = &stv06xx_sensor_st6422;
0572     if (!sd->sensor->probe(sd))
0573         return 0;
0574
0575     sd->sensor = &stv06xx_sensor_vv6410;
0576     if (!sd->sensor->probe(sd))
0577         return 0;
0578
0579     sd->sensor = &stv06xx_sensor_hdcs1x00;
0580     if (!sd->sensor->probe(sd))
0581         return 0;
0582
0583     sd->sensor = &stv06xx_sensor_hdcs1020;
0584     if (!sd->sensor->probe(sd))
0585         return 0;
0586
0587     sd->sensor = &stv06xx_sensor_pb0100;
0588     if (!sd->sensor->probe(sd))
0589         return 0;
0590
0591     sd->sensor = NULL;
0592     return -ENODEV;
0593 }
0594
0595
0596
0597 /* -- module initialisation -- */
0598 static const struct usb_device_id device_table[] = {
0599     {USB_DEVICE(0x046d, 0x0840), .driver_info = BRIDGE_STV600 },    /* QuickCam Express */
0600     {USB_DEVICE(0x046d, 0x0850), .driver_info = BRIDGE_STV610 },    /* LEGO cam / QuickCam Web */
0601     {USB_DEVICE(0x046d, 0x0870), .driver_info = BRIDGE_STV602 },    /* Dexxa WebCam USB */
0602     {USB_DEVICE(0x046D, 0x08F0), .driver_info = BRIDGE_ST6422 },    /* QuickCam Messenger */
0603     {USB_DEVICE(0x046D, 0x08F5), .driver_info = BRIDGE_ST6422 },    /* QuickCam Communicate */
0604     {USB_DEVICE(0x046D, 0x08F6), .driver_info = BRIDGE_ST6422 },    /* QuickCam Messenger (new) */
0605     {}
0606 };
0607 MODULE_DEVICE_TABLE(usb, device_table);
0608
0609 /* -- device connect -- */
0610 static int sd_probe(struct usb_interface *intf,
0611             const struct usb_device_id *id)
0612 {
0613     return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
0614                    THIS_MODULE);
0615 }
0616
0617 static void sd_disconnect(struct usb_interface *intf)
0618 {
0619     struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
0620     struct sd *sd = (struct sd *) gspca_dev;
0621     void *priv = sd->sensor_priv;
0622     gspca_dbg(gspca_dev, D_PROBE, "Disconnecting the stv06xx device\n");
0623
0624     sd->sensor = NULL;
0625     gspca_disconnect(intf);
0626     kfree(priv);
0627 }
0628
0629 static struct usb_driver sd_driver = {
0630     .name = MODULE_NAME,
0631     .id_table = device_table,
0632     .probe = sd_probe,
0633     .disconnect = sd_disconnect,
0634 #ifdef CONFIG_PM
0635     .suspend = gspca_suspend,
0636     .resume = gspca_resume,
0637     .reset_resume = gspca_resume,
0638 #endif
0639 };
0640
0641 module_usb_driver(sd_driver);
0642
0643 module_param(dump_bridge, bool, S_IRUGO | S_IWUSR);
0644 MODULE_PARM_DESC(dump_bridge, "Dumps all usb bridge registers at startup");
0645
0646 module_param(dump_sensor, bool, S_IRUGO | S_IWUSR);
0647 MODULE_PARM_DESC(dump_sensor, "Dumps all sensor registers at startup");