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

   1 /*
   2  * Driver for the po1030 sensor
   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_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(D_CONF, "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(D_CONF, "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(D_V4L2, "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(D_V4L2, "Set exposure to %d", val & 0xffff);
 200
 201         i2c_data = ((val & 0xff00) >> 8);
 202         PDEBUG(D_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(D_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(D_V4L2, "Read global gain %d", *val);
 230
 231         return (err < 0) ? err : 0;
 232 }
 233
 234 int po1030_get_hflip(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         err = po1030_read_sensor(sd, PO1030_REG_CONTROL2,
 241                                  &i2c_data, 1);
 242
 243         *val = (i2c_data >> 7) & 0x01 ;
 244
 245         PDEBUG(D_V4L2, "Read hflip %d", *val);
 246
 247         return (err < 0) ? err : 0;
 248 }
 249
 250 int po1030_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 251 {
 252         struct sd *sd = (struct sd *) gspca_dev;
 253         u8 i2c_data;
 254         int err;
 255
 256         PDEBUG(D_V4L2, "Set hflip %d", val);
 257
 258         i2c_data = (val & 0x01) << 7;
 259
 260         err = po1030_write_sensor(sd, PO1030_REG_CONTROL2,
 261                                   &i2c_data, 1);
 262
 263         return (err < 0) ? err : 0;
 264 }
 265
 266 int po1030_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 267 {
 268         struct sd *sd = (struct sd *) gspca_dev;
 269         u8 i2c_data;
 270         int err;
 271
 272         err = po1030_read_sensor(sd, PO1030_REG_GLOBALGAIN,
 273                                  &i2c_data, 1);
 274
 275         *val = (i2c_data >> 6) & 0x01;
 276
 277         PDEBUG(D_V4L2, "Read vflip %d", *val);
 278
 279         return (err < 0) ? err : 0;
 280 }
 281
 282 int po1030_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 283 {
 284         struct sd *sd = (struct sd *) gspca_dev;
 285         u8 i2c_data;
 286         int err;
 287
 288         PDEBUG(D_V4L2, "Set vflip %d", val);
 289
 290         i2c_data = (val & 0x01) << 6;
 291
 292         err = po1030_write_sensor(sd, PO1030_REG_CONTROL2,
 293                                   &i2c_data, 1);
 294
 295         return (err < 0) ? err : 0;
 296 }
 297
 298 int po1030_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 299 {
 300         struct sd *sd = (struct sd *) gspca_dev;
 301         u8 i2c_data;
 302         int err;
 303
 304         i2c_data = val & 0xff;
 305         PDEBUG(D_V4L2, "Set global gain to %d", i2c_data);
 306         err = po1030_write_sensor(sd, PO1030_REG_GLOBALGAIN,
 307                                   &i2c_data, 1);
 308         return (err < 0) ? err : 0;
 309 }
 310
 311 int po1030_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
 312 {
 313         struct sd *sd = (struct sd *) gspca_dev;
 314         u8 i2c_data;
 315         int err;
 316
 317         err = po1030_read_sensor(sd, PO1030_REG_RED_GAIN,
 318                                  &i2c_data, 1);
 319         *val = i2c_data;
 320         PDEBUG(D_V4L2, "Read red gain %d", *val);
 321         return (err < 0) ? err : 0;
 322 }
 323
 324 int po1030_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
 325 {
 326         struct sd *sd = (struct sd *) gspca_dev;
 327         u8 i2c_data;
 328         int err;
 329
 330         i2c_data = val & 0xff;
 331         PDEBUG(D_V4L2, "Set red gain to %d", i2c_data);
 332         err = po1030_write_sensor(sd, PO1030_REG_RED_GAIN,
 333                                   &i2c_data, 1);
 334         return (err < 0) ? err : 0;
 335 }
 336
 337 int po1030_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
 338 {
 339         struct sd *sd = (struct sd *) gspca_dev;
 340         u8 i2c_data;
 341         int err;
 342
 343         err = po1030_read_sensor(sd, PO1030_REG_BLUE_GAIN,
 344                                  &i2c_data, 1);
 345         *val = i2c_data;
 346         PDEBUG(D_V4L2, "Read blue gain %d", *val);
 347
 348         return (err < 0) ? err : 0;
 349 }
 350
 351 int po1030_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
 352 {
 353         struct sd *sd = (struct sd *) gspca_dev;
 354         u8 i2c_data;
 355         int err;
 356         i2c_data = val & 0xff;
 357         PDEBUG(D_V4L2, "Set blue gain to %d", i2c_data);
 358         err = po1030_write_sensor(sd, PO1030_REG_BLUE_GAIN,
 359                                   &i2c_data, 1);
 360
 361         return (err < 0) ? err : 0;
 362 }
 363
 364 int po1030_power_down(struct sd *sd)
 365 {
 366         return 0;
 367 }
 368
 369 void po1030_dump_registers(struct sd *sd)
 370 {
 371         int address;
 372         u8 value = 0;
 373
 374         info("Dumping the po1030 sensor core registers");
 375         for (address = 0; address < 0x7f; address++) {
 376                 po1030_read_sensor(sd, address, &value, 1);
 377                 info("register 0x%x contains 0x%x",
 378                      address, value);
 379         }
 380
 381         info("po1030 register state dump complete");
 382
 383         info("Probing for which registers that are read/write");
 384         for (address = 0; address < 0xff; address++) {
 385                 u8 old_value, ctrl_value;
 386                 u8 test_value[2] = {0xff, 0xff};
 387
 388                 po1030_read_sensor(sd, address, &old_value, 1);
 389                 po1030_write_sensor(sd, address, test_value, 1);
 390                 po1030_read_sensor(sd, address, &ctrl_value, 1);
 391
 392                 if (ctrl_value == test_value[0])
 393                         info("register 0x%x is writeable", address);
 394                 else
 395                         info("register 0x%x is read only", address);
 396
 397                 /* Restore original value */
 398                 po1030_write_sensor(sd, address, &old_value, 1);
 399         }
 400 }