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

   1 /*
   2  * Driver for the mt9m111 sensor
   3  *
   4  * Copyright (C) 2008 Erik Andren
   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_mt9m111.h"
  20
  21 int mt9m111_probe(struct sd *sd)
  22 {
  23         u8 data[2] = {0x00, 0x00};
  24         int i;
  25
  26         if (force_sensor) {
  27                 if (force_sensor == MT9M111_SENSOR) {
  28                         info("Forcing a %s sensor", mt9m111.name);
  29                         goto sensor_found;
  30                 }
  31                 /* If we want to force another sensor, don't try to probe this
  32                  * one */
  33                 return -ENODEV;
  34         }
  35
  36         info("Probing for a mt9m111 sensor");
  37
  38         /* Do the preinit */
  39         for (i = 0; i < ARRAY_SIZE(preinit_mt9m111); i++) {
  40                 if (preinit_mt9m111[i][0] == BRIDGE) {
  41                         m5602_write_bridge(sd,
  42                                 preinit_mt9m111[i][1],
  43                                 preinit_mt9m111[i][2]);
  44                 } else {
  45                         data[0] = preinit_mt9m111[i][2];
  46                         data[1] = preinit_mt9m111[i][3];
  47                         mt9m111_write_sensor(sd,
  48                                 preinit_mt9m111[i][1], data, 2);
  49                 }
  50         }
  51
  52         if (mt9m111_read_sensor(sd, MT9M111_SC_CHIPVER, data, 2))
  53                 return -ENODEV;
  54
  55         if ((data[0] == 0x14) && (data[1] == 0x3a)) {
  56                 info("Detected a mt9m111 sensor");
  57                 goto sensor_found;
  58         }
  59
  60         return -ENODEV;
  61
  62 sensor_found:
  63         sd->gspca_dev.cam.cam_mode = mt9m111.modes;
  64         sd->gspca_dev.cam.nmodes = mt9m111.nmodes;
  65         return 0;
  66 }
  67
  68 int mt9m111_init(struct sd *sd)
  69 {
  70         int i, err;
  71
  72         /* Init the sensor */
  73         for (i = 0; i < ARRAY_SIZE(init_mt9m111); i++) {
  74                 u8 data[2];
  75
  76                 if (init_mt9m111[i][0] == BRIDGE) {
  77                         err = m5602_write_bridge(sd,
  78                                 init_mt9m111[i][1],
  79                                 init_mt9m111[i][2]);
  80                 } else {
  81                         data[0] = init_mt9m111[i][2];
  82                         data[1] = init_mt9m111[i][3];
  83                         err = mt9m111_write_sensor(sd,
  84                                 init_mt9m111[i][1], data, 2);
  85                 }
  86         }
  87
  88         if (dump_sensor)
  89                 mt9m111_dump_registers(sd);
  90
  91         return (err < 0) ? err : 0;
  92 }
  93
  94 int mt9m111_power_down(struct sd *sd)
  95 {
  96         return 0;
  97 }
  98
  99 int mt9m111_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 100 {
 101         int err;
 102         u8 data[2] = {0x00, 0x00};
 103         struct sd *sd = (struct sd *) gspca_dev;
 104
 105         err = mt9m111_read_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B,
 106                                   data, 2);
 107         *val = data[0] & MT9M111_RMB_MIRROR_ROWS;
 108         PDEBUG(DBG_V4L2_CID, "Read vertical flip %d", *val);
 109
 110         return (err < 0) ? err : 0;
 111 }
 112
 113 int mt9m111_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 114 {
 115         int err;
 116         u8 data[2] = {0x00, 0x00};
 117         struct sd *sd = (struct sd *) gspca_dev;
 118
 119         PDEBUG(DBG_V4L2_CID, "Set vertical flip to %d", val);
 120
 121         /* Set the correct page map */
 122         err = mt9m111_write_sensor(sd, MT9M111_PAGE_MAP, data, 2);
 123         if (err < 0)
 124                 goto out;
 125
 126         err = mt9m111_read_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B, data, 2);
 127         if (err < 0)
 128                 goto out;
 129
 130         data[0] = (data[0] & 0xfe) | val;
 131         err = mt9m111_write_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B,
 132                                    data, 2);
 133 out:
 134         return (err < 0) ? err : 0;
 135 }
 136
 137 int mt9m111_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
 138 {
 139         int err;
 140         u8 data[2] = {0x00, 0x00};
 141         struct sd *sd = (struct sd *) gspca_dev;
 142
 143         err = mt9m111_read_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B,
 144                                   data, 2);
 145         *val = data[0] & MT9M111_RMB_MIRROR_COLS;
 146         PDEBUG(DBG_V4L2_CID, "Read horizontal flip %d", *val);
 147
 148         return (err < 0) ? err : 0;
 149 }
 150
 151 int mt9m111_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 152 {
 153         int err;
 154         u8 data[2] = {0x00, 0x00};
 155         struct sd *sd = (struct sd *) gspca_dev;
 156
 157         PDEBUG(DBG_V4L2_CID, "Set horizontal flip to %d", val);
 158
 159         /* Set the correct page map */
 160         err = mt9m111_write_sensor(sd, MT9M111_PAGE_MAP, data, 2);
 161         if (err < 0)
 162                 goto out;
 163
 164         err = mt9m111_read_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B, data, 2);
 165         if (err < 0)
 166                 goto out;
 167
 168         data[0] = (data[0] & 0xfd) | ((val << 1) & 0x02);
 169         err = mt9m111_write_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B,
 170                                         data, 2);
 171 out:
 172         return (err < 0) ? err : 0;
 173 }
 174
 175 int mt9m111_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 176 {
 177         int err, tmp;
 178         u8 data[2] = {0x00, 0x00};
 179         struct sd *sd = (struct sd *) gspca_dev;
 180
 181         err = mt9m111_read_sensor(sd, MT9M111_SC_GLOBAL_GAIN, data, 2);
 182         tmp = ((data[1] << 8) | data[0]);
 183
 184         *val = ((tmp & (1 << 10)) * 2) |
 185               ((tmp & (1 <<  9)) * 2) |
 186               ((tmp & (1 <<  8)) * 2) |
 187                (tmp & 0x7f);
 188
 189         PDEBUG(DBG_V4L2_CID, "Read gain %d", *val);
 190
 191         return (err < 0) ? err : 0;
 192 }
 193
 194 int mt9m111_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 195 {
 196         int err, tmp;
 197         u8 data[2] = {0x00, 0x00};
 198         struct sd *sd = (struct sd *) gspca_dev;
 199
 200         /* Set the correct page map */
 201         err = mt9m111_write_sensor(sd, MT9M111_PAGE_MAP, data, 2);
 202         if (err < 0)
 203                 goto out;
 204
 205         if (val >= INITIAL_MAX_GAIN * 2 * 2 * 2)
 206                 return -EINVAL;
 207
 208         if ((val >= INITIAL_MAX_GAIN * 2 * 2) &&
 209             (val < (INITIAL_MAX_GAIN - 1) * 2 * 2 * 2))
 210                 tmp = (1 << 10) | (val << 9) |
 211                                 (val << 8) | (val / 8);
 212         else if ((val >= INITIAL_MAX_GAIN * 2) &&
 213                  (val <  INITIAL_MAX_GAIN * 2 * 2))
 214                 tmp = (1 << 9) | (1 << 8) | (val / 4);
 215         else if ((val >= INITIAL_MAX_GAIN) &&
 216                  (val < INITIAL_MAX_GAIN * 2))
 217                 tmp = (1 << 8) | (val / 2);
 218         else
 219                 tmp = val;
 220
 221         data[1] = (tmp & 0xff00) >> 8;
 222         data[0] = (tmp & 0xff);
 223         PDEBUG(DBG_V4L2_CID, "tmp=%d, data[1]=%d, data[0]=%d", tmp,
 224                data[1], data[0]);
 225
 226         err = mt9m111_write_sensor(sd, MT9M111_SC_GLOBAL_GAIN,
 227                                    data, 2);
 228 out:
 229         return (err < 0) ? err : 0;
 230 }
 231
 232 int mt9m111_read_sensor(struct sd *sd, const u8 address,
 233                         u8 *i2c_data, const u8 len) {
 234         int err, i;
 235
 236         do {
 237                 err = m5602_read_bridge(sd, M5602_XB_I2C_STATUS, i2c_data);
 238         } while ((*i2c_data & I2C_BUSY) && !err);
 239         if (err < 0)
 240                 goto out;
 241
 242         err = m5602_write_bridge(sd, M5602_XB_I2C_DEV_ADDR,
 243                                  sd->sensor->i2c_slave_id);
 244         if (err < 0)
 245                 goto out;
 246
 247         err = m5602_write_bridge(sd, M5602_XB_I2C_REG_ADDR, address);
 248         if (err < 0)
 249                 goto out;
 250
 251         err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x1a);
 252         if (err < 0)
 253                 goto out;
 254
 255         for (i = 0; i < len && !err; i++) {
 256                 err = m5602_read_bridge(sd, M5602_XB_I2C_DATA, &(i2c_data[i]));
 257
 258                 PDEBUG(DBG_TRACE, "Reading sensor register "
 259                        "0x%x contains 0x%x ", address, *i2c_data);
 260         }
 261 out:
 262         return (err < 0) ? err : 0;
 263 }
 264
 265 int mt9m111_write_sensor(struct sd *sd, const u8 address,
 266                                 u8 *i2c_data, const u8 len)
 267 {
 268         int err, i;
 269         u8 *p;
 270         struct usb_device *udev = sd->gspca_dev.dev;
 271         __u8 *buf = sd->gspca_dev.usb_buf;
 272
 273         /* No sensor with a data width larger
 274            than 16 bits has yet been seen, nor with 0 :p*/
 275         if (len > 2 || !len)
 276                 return -EINVAL;
 277
 278         memcpy(buf, sensor_urb_skeleton,
 279                sizeof(sensor_urb_skeleton));
 280
 281         buf[11] = sd->sensor->i2c_slave_id;
 282         buf[15] = address;
 283
 284         p = buf + 16;
 285
 286         /* Copy a four byte write sequence for each byte to be written to */
 287         for (i = 0; i < len; i++) {
 288                 memcpy(p, sensor_urb_skeleton + 16, 4);
 289                 p[3] = i2c_data[i];
 290                 p += 4;
 291                 PDEBUG(DBG_TRACE, "Writing sensor register 0x%x with 0x%x",
 292                        address, i2c_data[i]);
 293         }
 294
 295         /* Copy the tailer */
 296         memcpy(p, sensor_urb_skeleton + 20, 4);
 297
 298         /* Set the total length */
 299         p[3] = 0x10 + len;
 300
 301         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 302                               0x04, 0x40, 0x19,
 303                               0x0000, buf,
 304                               20 + len * 4, M5602_URB_MSG_TIMEOUT);
 305
 306         return (err < 0) ? err : 0;
 307 }
 308
 309 void mt9m111_dump_registers(struct sd *sd)
 310 {
 311         u8 address, value[2] = {0x00, 0x00};
 312
 313         info("Dumping the mt9m111 register state");
 314
 315         info("Dumping the mt9m111 sensor core registers");
 316         value[1] = MT9M111_SENSOR_CORE;
 317         mt9m111_write_sensor(sd, MT9M111_PAGE_MAP, value, 2);
 318         for (address = 0; address < 0xff; address++) {
 319                 mt9m111_read_sensor(sd, address, value, 2);
 320                 info("register 0x%x contains 0x%x%x",
 321                      address, value[0], value[1]);
 322         }
 323
 324         info("Dumping the mt9m111 color pipeline registers");
 325         value[1] = MT9M111_COLORPIPE;
 326         mt9m111_write_sensor(sd, MT9M111_PAGE_MAP, value, 2);
 327         for (address = 0; address < 0xff; address++) {
 328                 mt9m111_read_sensor(sd, address, value, 2);
 329                 info("register 0x%x contains 0x%x%x",
 330                      address, value[0], value[1]);
 331         }
 332
 333         info("Dumping the mt9m111 camera control registers");
 334         value[1] = MT9M111_CAMERA_CONTROL;
 335         mt9m111_write_sensor(sd, MT9M111_PAGE_MAP, value, 2);
 336         for (address = 0; address < 0xff; address++) {
 337                 mt9m111_read_sensor(sd, address, value, 2);
 338                 info("register 0x%x contains 0x%x%x",
 339                      address, value[0], value[1]);
 340         }
 341
 342         info("mt9m111 register state dump complete");
 343 }