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

   1 /*
   2  * Driver for the po1030 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_po1030.h"
  20
  21 int po1030_probe(struct sd *sd)
  22 {
  23         u8 prod_id = 0, ver_id = 0, i;
  24
  25         if (force_sensor) {
  26                 if (force_sensor == PO1030_SENSOR) {
  27                         info("Forcing a %s sensor", po1030.name);
  28                         goto sensor_found;
  29                 }
  30                 /* If we want to force another sensor, don't try to probe this
  31                  * one */
  32                 return -ENODEV;
  33         }
  34
  35         info("Probing for a po1030 sensor");
  36
  37         /* Run the pre-init to actually probe the unit */
  38         for (i = 0; i < ARRAY_SIZE(preinit_po1030); i++) {
  39                 u8 data = preinit_po1030[i][2];
  40                 if (preinit_po1030[i][0] == SENSOR)
  41                         po1030_write_sensor(sd,
  42                                 preinit_po1030[i][1], &data, 1);
  43                 else
  44                         m5602_write_bridge(sd, preinit_po1030[i][1], data);
  45         }
  46
  47         if (po1030_read_sensor(sd, 0x3, &prod_id, 1))
  48                 return -ENODEV;
  49
  50         if (po1030_read_sensor(sd, 0x4, &ver_id, 1))
  51                 return -ENODEV;
  52
  53         if ((prod_id == 0x02) && (ver_id == 0xef)) {
  54                 info("Detected a po1030 sensor");
  55                 goto sensor_found;
  56         }
  57         return -ENODEV;
  58
  59 sensor_found:
  60         sd->gspca_dev.cam.cam_mode = po1030.modes;
  61         sd->gspca_dev.cam.nmodes = po1030.nmodes;
  62         sd->desc->ctrls = po1030.ctrls;
  63         sd->desc->nctrls = po1030.nctrls;
  64         return 0;
  65 }
  66
  67 int po1030_read_sensor(struct sd *sd, const u8 address,
  68                         u8 *i2c_data, const u8 len)
  69 {
  70         int err, i;
  71
  72         do {
  73                 err = m5602_read_bridge(sd, M5602_XB_I2C_STATUS, i2c_data);
  74         } while ((*i2c_data & I2C_BUSY) && !err);
  75
  76         m5602_write_bridge(sd, M5602_XB_I2C_DEV_ADDR,
  77                            sd->sensor->i2c_slave_id);
  78         m5602_write_bridge(sd, M5602_XB_I2C_REG_ADDR, address);
  79         m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x10 + len);
  80         m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x08);
  81
  82         for (i = 0; i < len; i++) {
  83                 err = m5602_read_bridge(sd, M5602_XB_I2C_DATA, &(i2c_data[i]));
  84
  85                 PDEBUG(DBG_TRACE, "Reading sensor register "
  86                                 "0x%x containing 0x%x ", address, *i2c_data);
  87         }
  88         return (err < 0) ? err : 0;
  89 }
  90
  91 int po1030_write_sensor(struct sd *sd, const u8 address,
  92                         u8 *i2c_data, const u8 len)
  93 {
  94         int err, i;
  95         u8 *p;
  96         struct usb_device *udev = sd->gspca_dev.dev;
  97         __u8 *buf = sd->gspca_dev.usb_buf;
  98
  99         /* The po1030 only supports one byte writes */
 100         if (len > 1 || !len)
 101                 return -EINVAL;
 102
 103         memcpy(buf, sensor_urb_skeleton, sizeof(sensor_urb_skeleton));
 104
 105         buf[11] = sd->sensor->i2c_slave_id;
 106         buf[15] = address;
 107
 108         p = buf + 16;
 109
 110         /* Copy a four byte write sequence for each byte to be written to */
 111         for (i = 0; i < len; i++) {
 112                 memcpy(p, sensor_urb_skeleton + 16, 4);
 113                 p[3] = i2c_data[i];
 114                 p += 4;
 115                 PDEBUG(DBG_TRACE, "Writing sensor register 0x%x with 0x%x",
 116                        address, i2c_data[i]);
 117         }
 118
 119         /* Copy the footer */
 120         memcpy(p, sensor_urb_skeleton + 20, 4);
 121
 122         /* Set the total length */
 123         p[3] = 0x10 + len;
 124
 125         err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 126                               0x04, 0x40, 0x19,
 127                               0x0000, buf,
 128                               20 + len * 4, M5602_URB_MSG_TIMEOUT);
 129
 130         return (err < 0) ? err : 0;
 131 }
 132
 133 int po1030_init(struct sd *sd)
 134 {
 135         int i, err = 0;
 136
 137         /* Init the sensor */
 138         for (i = 0; i < ARRAY_SIZE(init_po1030); i++) {
 139                 u8 data[2] = {0x00, 0x00};
 140
 141                 switch (init_po1030[i][0]) {
 142                 case BRIDGE:
 143                         err = m5602_write_bridge(sd,
 144                                 init_po1030[i][1],
 145                                 init_po1030[i][2]);
 146                         break;
 147
 148                 case SENSOR:
 149                         data[0] = init_po1030[i][2];
 150                         err = po1030_write_sensor(sd,
 151                                 init_po1030[i][1], data, 1);
 152                         break;
 153
 154                 case SENSOR_LONG:
 155                         data[0] = init_po1030[i][2];
 156                         data[1] = init_po1030[i][3];
 157                         err = po1030_write_sensor(sd,
 158                                 init_po1030[i][1], data, 2);
 159                         break;
 160                 default:
 161                         info("Invalid stream command, exiting init");
 162                         return -EINVAL;
 163                 }
 164         }
 165
 166         if (dump_sensor)
 167                 po1030_dump_registers(sd);
 168
 169         return (err < 0) ? err : 0;
 170 }
 171
 172 int po1030_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
 173 {
 174         struct sd *sd = (struct sd *) gspca_dev;
 175         u8 i2c_data;
 176         int err;
 177
 178         err = po1030_read_sensor(sd, PO1030_REG_INTEGLINES_H,
 179                                  &i2c_data, 1);
 180         if (err < 0)
 181                 goto out;
 182         *val = (i2c_data << 8);
 183
 184         err = po1030_read_sensor(sd, PO1030_REG_INTEGLINES_M,
 185                                  &i2c_data, 1);
 186         *val |= i2c_data;
 187
 188         PDEBUG(DBG_V4L2_CID, "Exposure read as %d", *val);
 189 out:
 190         return (err < 0) ? err : 0;
 191 }
 192
 193 int po1030_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
 194 {
 195         struct sd *sd = (struct sd *) gspca_dev;
 196         u8 i2c_data;
 197         int err;
 198
 199         PDEBUG(DBG_V4L2, "Set exposure to %d", val & 0xffff);
 200
 201         i2c_data = ((val & 0xff00) >> 8);
 202         PDEBUG(DBG_V4L2, "Set exposure to high byte to 0x%x",
 203                i2c_data);
 204
 205         err = po1030_write_sensor(sd, PO1030_REG_INTEGLINES_H,
 206                                   &i2c_data, 1);
 207         if (err < 0)
 208                 goto out;
 209
 210         i2c_data = (val & 0xff);
 211         PDEBUG(DBG_V4L2, "Set exposure to low byte to 0x%x",
 212                i2c_data);
 213         err = po1030_write_sensor(sd, PO1030_REG_INTEGLINES_M,
 214                                   &i2c_data, 1);
 215
 216 out:
 217         return (err < 0) ? err : 0;
 218 }
 219
 220 int po1030_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 221 {
 222         struct sd *sd = (struct sd *) gspca_dev;
 223         u8 i2c_data;
 224         int err;
 225
 226         err = po1030_read_sensor(sd, PO1030_REG_GLOBALGAIN,
 227                                  &i2c_data, 1);
 228         *val = i2c_data;
 229         PDEBUG(DBG_V4L2_CID, "Read global gain %d", *val);
 230
 231         return (err < 0) ? err : 0;
 232 }
 233
 234 int po1030_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 235 {
 236         struct sd *sd = (struct sd *) gspca_dev;
 237         u8 i2c_data;
 238         int err;
 239
 240         i2c_data = val & 0xff;
 241         PDEBUG(DBG_V4L2, "Set global gain to %d", i2c_data);
 242         err = po1030_write_sensor(sd, PO1030_REG_GLOBALGAIN,
 243                                   &i2c_data, 1);
 244         return (err < 0) ? err : 0;
 245 }
 246
 247 int po1030_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
 248 {
 249         struct sd *sd = (struct sd *) gspca_dev;
 250         u8 i2c_data;
 251         int err;
 252
 253         err = po1030_read_sensor(sd, PO1030_REG_RED_GAIN,
 254                                  &i2c_data, 1);
 255         *val = i2c_data;
 256         PDEBUG(DBG_V4L2_CID, "Read red gain %d", *val);
 257         return (err < 0) ? err : 0;
 258 }
 259
 260 int po1030_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
 261 {
 262         struct sd *sd = (struct sd *) gspca_dev;
 263         u8 i2c_data;
 264         int err;
 265
 266         i2c_data = val & 0xff;
 267         PDEBUG(DBG_V4L2, "Set red gain to %d", i2c_data);
 268         err = po1030_write_sensor(sd, PO1030_REG_RED_GAIN,
 269                                   &i2c_data, 1);
 270         return (err < 0) ? err : 0;
 271 }
 272
 273 int po1030_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
 274 {
 275         struct sd *sd = (struct sd *) gspca_dev;
 276         u8 i2c_data;
 277         int err;
 278
 279         err = po1030_read_sensor(sd, PO1030_REG_BLUE_GAIN,
 280                                  &i2c_data, 1);
 281         *val = i2c_data;
 282         PDEBUG(DBG_V4L2_CID, "Read blue gain %d", *val);
 283
 284         return (err < 0) ? err : 0;
 285 }
 286
 287 int po1030_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
 288 {
 289         struct sd *sd = (struct sd *) gspca_dev;
 290         u8 i2c_data;
 291         int err;
 292         i2c_data = val & 0xff;
 293         PDEBUG(DBG_V4L2, "Set blue gain to %d", i2c_data);
 294         err = po1030_write_sensor(sd, PO1030_REG_BLUE_GAIN,
 295                                   &i2c_data, 1);
 296
 297         return (err < 0) ? err : 0;
 298 }
 299
 300 int po1030_power_down(struct sd *sd)
 301 {
 302         return 0;
 303 }
 304
 305 void po1030_dump_registers(struct sd *sd)
 306 {
 307         int address;
 308         u8 value = 0;
 309
 310         info("Dumping the po1030 sensor core registers");
 311         for (address = 0; address < 0x7f; address++) {
 312                 po1030_read_sensor(sd, address, &value, 1);
 313                 info("register 0x%x contains 0x%x",
 314                      address, value);
 315         }
 316
 317         info("po1030 register state dump complete");
 318
 319         info("Probing for which registers that are read/write");
 320         for (address = 0; address < 0xff; address++) {
 321                 u8 old_value, ctrl_value;
 322                 u8 test_value[2] = {0xff, 0xff};
 323
 324                 po1030_read_sensor(sd, address, &old_value, 1);
 325                 po1030_write_sensor(sd, address, test_value, 1);
 326                 po1030_read_sensor(sd, address, &ctrl_value, 1);
 327
 328                 if (ctrl_value == test_value[0])
 329                         info("register 0x%x is writeable", address);
 330                 else
 331                         info("register 0x%x is read only", address);
 332
 333                 /* Restore original value */
 334                 po1030_write_sensor(sd, address, &old_value, 1);
 335         }
 336 }