drivers/media/video/gspca/m5602/m5602_core.c

   1  /*
   2  * USB Driver for ALi m5602 based webcams
   3  *
   4  * Copyright (C) 2008 Erik Andrén
   5  * Copyright (C) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
   6  * Copyright (C) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
   7  *
   8  * Portions of code to USB interface and ALi driver software,
   9  * Copyright (c) 2006 Willem Duinker
  10  * v4l2 interface modeled after the V4L2 driver
  11  * for SN9C10x PC Camera Controllers
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation, version 2.
  16  *
  17  */
  18
  19 #include "m5602_ov9650.h"
  20 #include "m5602_mt9m111.h"
  21 #include "m5602_po1030.h"
  22 #include "m5602_s5k83a.h"
  23 #include "m5602_s5k4aa.h"
  24
  25 /* Kernel module parameters */
  26 int force_sensor;
  27 static int dump_bridge;
  28 int dump_sensor;
  29
  30 static const __devinitdata struct usb_device_id m5602_table[] = {
  31         {USB_DEVICE(0x0402, 0x5602)},
  32         {}
  33 };
  34
  35 MODULE_DEVICE_TABLE(usb, m5602_table);
  36
  37 /* Reads a byte from the m5602 */
  38 int m5602_read_bridge(struct sd *sd, u8 address, u8 *i2c_data)
  39 {
  40         int err;
  41         struct usb_device *udev = sd->gspca_dev.dev;
  42         __u8 *buf = sd->gspca_dev.usb_buf;
  43
  44         err = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
  45                               0x04, 0xc0, 0x14,
  46                               0x8100 + address, buf,
  47                               1, M5602_URB_MSG_TIMEOUT);
  48         *i2c_data = buf[0];
  49
  50         PDEBUG(D_CONF, "Reading bridge register 0x%x containing 0x%x",
  51                address, *i2c_data);
  52
  53         /* usb_control_msg(...) returns the number of bytes sent upon success,
  54         mask that and return zero upon success instead*/
  55         return (err < 0) ? err : 0;
  56 }
  57
  58 /* Writes a byte to to the m5602 */
  59 int m5602_write_bridge(struct sd *sd, u8 address, u8 i2c_data)
  60 {
  61         int err;
  62         struct usb_device *udev = sd->gspca_dev.dev;
  63         __u8 *buf = sd->gspca_dev.usb_buf;
  64
  65         PDEBUG(D_CONF, "Writing bridge register 0x%x with 0x%x",
  66                address, i2c_data);
  67
  68         memcpy(buf, bridge_urb_skeleton,
  69                sizeof(bridge_urb_skeleton));
  70         buf[1] = address;
  71         buf[3] = i2c_data;
  72
  73         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
  74                                 0x04, 0x40, 0x19,
  75                                 0x0000, buf,
  76                                 4, M5602_URB_MSG_TIMEOUT);
  77
  78         /* usb_control_msg(...) returns the number of bytes sent upon success,
  79            mask that and return zero upon success instead */
  80         return (err < 0) ? err : 0;
  81 }
  82
  83 int m5602_read_sensor(struct sd *sd, const u8 address,
  84                        u8 *i2c_data, const u8 len)
  85 {
  86         int err, i;
  87
  88         if (!len || len > sd->sensor->i2c_regW)
  89                 return -EINVAL;
  90
  91         do {
  92                 err = m5602_read_bridge(sd, M5602_XB_I2C_STATUS, i2c_data);
  93         } while ((*i2c_data & I2C_BUSY) && !err);
  94         if (err < 0)
  95                 goto out;
  96
  97         err = m5602_write_bridge(sd, M5602_XB_I2C_DEV_ADDR,
  98                                  sd->sensor->i2c_slave_id);
  99         if (err < 0)
 100                 goto out;
 101
 102         err = m5602_write_bridge(sd, M5602_XB_I2C_REG_ADDR, address);
 103         if (err < 0)
 104                 goto out;
 105
 106         if (sd->sensor->i2c_regW == 1) {
 107                 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, len);
 108                 if (err < 0)
 109                         goto out;
 110
 111                 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x08);
 112                 if (err < 0)
 113                         goto out;
 114         } else {
 115                 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x18 + len);
 116                 if (err < 0)
 117                         goto out;
 118         }
 119
 120         for (i = 0; (i < len) && !err; i++) {
 121                 err = m5602_read_bridge(sd, M5602_XB_I2C_DATA, &(i2c_data[i]));
 122
 123                 PDEBUG(D_CONF, "Reading sensor register "
 124                                "0x%x containing 0x%x ", address, *i2c_data);
 125         }
 126 out:
 127         return err;
 128 }
 129
 130 int m5602_write_sensor(struct sd *sd, const u8 address,
 131                         u8 *i2c_data, const u8 len)
 132 {
 133         int err, i;
 134         u8 *p;
 135         struct usb_device *udev = sd->gspca_dev.dev;
 136         __u8 *buf = sd->gspca_dev.usb_buf;
 137
 138         /* No sensor with a data width larger than 16 bits has yet been seen */
 139         if (len > sd->sensor->i2c_regW || !len)
 140                 return -EINVAL;
 141
 142         memcpy(buf, sensor_urb_skeleton,
 143                sizeof(sensor_urb_skeleton));
 144
 145         buf[11] = sd->sensor->i2c_slave_id;
 146         buf[15] = address;
 147
 148         /* Special case larger sensor writes */
 149         p = buf + 16;
 150
 151         /* Copy a four byte write sequence for each byte to be written to */
 152         for (i = 0; i < len; i++) {
 153                 memcpy(p, sensor_urb_skeleton + 16, 4);
 154                 p[3] = i2c_data[i];
 155                 p += 4;
 156                 PDEBUG(D_CONF, "Writing sensor register 0x%x with 0x%x",
 157                        address, i2c_data[i]);
 158         }
 159
 160         /* Copy the tailer */
 161         memcpy(p, sensor_urb_skeleton + 20, 4);
 162
 163         /* Set the total length */
 164         p[3] = 0x10 + len;
 165
 166         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 167                               0x04, 0x40, 0x19,
 168                               0x0000, buf,
 169                               20 + len * 4, M5602_URB_MSG_TIMEOUT);
 170
 171         return (err < 0) ? err : 0;
 172 }
 173
 174 /* Dump all the registers of the m5602 bridge,
 175    unfortunately this breaks the camera until it's power cycled */
 176 static void m5602_dump_bridge(struct sd *sd)
 177 {
 178         int i;
 179         for (i = 0; i < 0x80; i++) {
 180                 unsigned char val = 0;
 181                 m5602_read_bridge(sd, i, &val);
 182                 info("ALi m5602 address 0x%x contains 0x%x", i, val);
 183         }
 184         info("Warning: The ALi m5602 webcam probably won't work "
 185                 "until it's power cycled");
 186 }
 187
 188 static int m5602_probe_sensor(struct sd *sd)
 189 {
 190         /* Try the po1030 */
 191         sd->sensor = &po1030;
 192         if (!sd->sensor->probe(sd))
 193                 return 0;
 194
 195         /* Try the mt9m111 sensor */
 196         sd->sensor = &mt9m111;
 197         if (!sd->sensor->probe(sd))
 198                 return 0;
 199
 200         /* Try the s5k4aa */
 201         sd->sensor = &s5k4aa;
 202         if (!sd->sensor->probe(sd))
 203                 return 0;
 204
 205         /* Try the ov9650 */
 206         sd->sensor = &ov9650;
 207         if (!sd->sensor->probe(sd))
 208                 return 0;
 209
 210         /* Try the s5k83a */
 211         sd->sensor = &s5k83a;
 212         if (!sd->sensor->probe(sd))
 213                 return 0;
 214
 215         /* More sensor probe function goes here */
 216         info("Failed to find a sensor");
 217         sd->sensor = NULL;
 218         return -ENODEV;
 219 }
 220
 221 static int m5602_configure(struct gspca_dev *gspca_dev,
 222                            const struct usb_device_id *id);
 223
 224 static int m5602_init(struct gspca_dev *gspca_dev)
 225 {
 226         struct sd *sd = (struct sd *) gspca_dev;
 227         int err;
 228
 229         PDEBUG(D_CONF, "Initializing ALi m5602 webcam");
 230         /* Run the init sequence */
 231         err = sd->sensor->init(sd);
 232
 233         return err;
 234 }
 235
 236 static int m5602_start_transfer(struct gspca_dev *gspca_dev)
 237 {
 238         struct sd *sd = (struct sd *) gspca_dev;
 239         __u8 *buf = sd->gspca_dev.usb_buf;
 240         int err;
 241
 242         /* Send start command to the camera */
 243         const u8 buffer[4] = {0x13, 0xf9, 0x0f, 0x01};
 244
 245         if (sd->sensor->start)
 246                 sd->sensor->start(sd);
 247
 248         memcpy(buf, buffer, sizeof(buffer));
 249         err = usb_control_msg(gspca_dev->dev,
 250                               usb_sndctrlpipe(gspca_dev->dev, 0),
 251                               0x04, 0x40, 0x19, 0x0000, buf,
 252                               sizeof(buffer), M5602_URB_MSG_TIMEOUT);
 253
 254         PDEBUG(D_STREAM, "Transfer started");
 255         return (err < 0) ? err : 0;
 256 }
 257
 258 static void m5602_urb_complete(struct gspca_dev *gspca_dev,
 259                         struct gspca_frame *frame,
 260                         __u8 *data, int len)
 261 {
 262         struct sd *sd = (struct sd *) gspca_dev;
 263
 264         if (len < 6) {
 265                 PDEBUG(D_PACK, "Packet is less than 6 bytes");
 266                 return;
 267         }
 268
 269         /* Frame delimiter: ff xx xx xx ff ff */
 270         if (data[0] == 0xff && data[4] == 0xff && data[5] == 0xff &&
 271             data[2] != sd->frame_id) {
 272                 PDEBUG(D_FRAM, "Frame delimiter detected");
 273                 sd->frame_id = data[2];
 274
 275                 /* Remove the extra fluff appended on each header */
 276                 data += 6;
 277                 len -= 6;
 278
 279                 /* Complete the last frame (if any) */
 280                 frame = gspca_frame_add(gspca_dev, LAST_PACKET,
 281                                         frame, data, 0);
 282                 sd->frame_count++;
 283
 284                 /* Create a new frame */
 285                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
 286
 287                 PDEBUG(D_FRAM, "Starting new frame %d",
 288                        sd->frame_count);
 289
 290         } else {
 291                 int cur_frame_len = frame->data_end - frame->data;
 292
 293                 /* Remove urb header */
 294                 data += 4;
 295                 len -= 4;
 296
 297                 if (cur_frame_len + len <= frame->v4l2_buf.length) {
 298                         PDEBUG(D_FRAM, "Continuing frame %d copying %d bytes",
 299                                sd->frame_count, len);
 300
 301                         gspca_frame_add(gspca_dev, INTER_PACKET, frame,
 302                                         data, len);
 303                 } else if (frame->v4l2_buf.length - cur_frame_len > 0) {
 304                         /* Add the remaining data up to frame size */
 305                         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data,
 306                                         frame->v4l2_buf.length - cur_frame_len);
 307                 }
 308         }
 309 }
 310
 311 static void m5602_stop_transfer(struct gspca_dev *gspca_dev)
 312 {
 313         /* Is there are a command to stop a data transfer? */
 314 }
 315
 316 /* sub-driver description, the ctrl and nctrl is filled at probe time */
 317 static struct sd_desc sd_desc = {
 318         .name           = MODULE_NAME,
 319         .config         = m5602_configure,
 320         .init           = m5602_init,
 321         .start          = m5602_start_transfer,
 322         .stopN          = m5602_stop_transfer,
 323         .pkt_scan       = m5602_urb_complete
 324 };
 325
 326 /* this function is called at probe time */
 327 static int m5602_configure(struct gspca_dev *gspca_dev,
 328                            const struct usb_device_id *id)
 329 {
 330         struct sd *sd = (struct sd *) gspca_dev;
 331         struct cam *cam;
 332         int err;
 333
 334         cam = &gspca_dev->cam;
 335         sd->desc = &sd_desc;
 336
 337         if (dump_bridge)
 338                 m5602_dump_bridge(sd);
 339
 340         /* Probe sensor */
 341         err = m5602_probe_sensor(sd);
 342         if (err)
 343                 goto fail;
 344
 345         return 0;
 346
 347 fail:
 348         PDEBUG(D_ERR, "ALi m5602 webcam failed");
 349         cam->cam_mode = NULL;
 350         cam->nmodes = 0;
 351
 352         return err;
 353 }
 354
 355 static int m5602_probe(struct usb_interface *intf,
 356                        const struct usb_device_id *id)
 357 {
 358         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
 359                                THIS_MODULE);
 360 }
 361
 362 static struct usb_driver sd_driver = {
 363         .name = MODULE_NAME,
 364         .id_table = m5602_table,
 365         .probe = m5602_probe,
 366 #ifdef CONFIG_PM
 367         .suspend = gspca_suspend,
 368         .resume = gspca_resume,
 369 #endif
 370         .disconnect = gspca_disconnect
 371 };
 372
 373 /* -- module insert / remove -- */
 374 static int __init mod_m5602_init(void)
 375 {
 376         int ret;
 377         ret = usb_register(&sd_driver);
 378         if (ret < 0)
 379                 return ret;
 380         PDEBUG(D_PROBE, "registered");
 381         return 0;
 382 }
 383
 384 static void __exit mod_m5602_exit(void)
 385 {
 386         usb_deregister(&sd_driver);
 387         PDEBUG(D_PROBE, "deregistered");
 388 }
 389
 390 module_init(mod_m5602_init);
 391 module_exit(mod_m5602_exit);
 392
 393 MODULE_AUTHOR(DRIVER_AUTHOR);
 394 MODULE_DESCRIPTION(DRIVER_DESC);
 395 MODULE_LICENSE("GPL");
 396 module_param(force_sensor, int, S_IRUGO | S_IWUSR);
 397 MODULE_PARM_DESC(force_sensor,
 398                 "force detection of sensor, "
 399                 "1 = OV9650, 2 = S5K83A, 3 = S5K4AA, 4 = MT9M111, 5 = PO1030");
 400
 401 module_param(dump_bridge, bool, S_IRUGO | S_IWUSR);
 402 MODULE_PARM_DESC(dump_bridge, "Dumps all usb bridge registers at startup");
 403
 404 module_param(dump_sensor, bool, S_IRUGO | S_IWUSR);
 405 MODULE_PARM_DESC(dump_sensor, "Dumps all usb sensor registers "
 406                 "at startup providing a sensor is found");