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