kernel/2.6.29.6-aldebaran-rt/drivers/media/video/gspca/m5602/m5602_s5k83a.c

   1 /*
   2  * Driver for the s5k83a 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_s5k83a.h"
  20
  21 static void s5k83a_dump_registers(struct sd *sd);
  22
  23 int s5k83a_probe(struct sd *sd)
  24 {
  25         u8 prod_id = 0, ver_id = 0;
  26         int i, err = 0;
  27
  28         if (force_sensor) {
  29                 if (force_sensor == S5K83A_SENSOR) {
  30                         info("Forcing a %s sensor", s5k83a.name);
  31                         goto sensor_found;
  32                 }
  33                 /* If we want to force another sensor, don't try to probe this
  34                  * one */
  35                 return -ENODEV;
  36         }
  37
  38         info("Probing for a s5k83a sensor");
  39
  40         /* Preinit the sensor */
  41         for (i = 0; i < ARRAY_SIZE(preinit_s5k83a) && !err; i++) {
  42                 u8 data[2] = {preinit_s5k83a[i][2], preinit_s5k83a[i][3]};
  43                 if (preinit_s5k83a[i][0] == SENSOR)
  44                         err = m5602_write_sensor(sd, preinit_s5k83a[i][1],
  45                                 data, 2);
  46                 else
  47                         err = m5602_write_bridge(sd, preinit_s5k83a[i][1],
  48                                 data[0]);
  49         }
  50
  51         /* We don't know what register (if any) that contain the product id
  52          * Just pick the first addresses that seem to produce the same results
  53          * on multiple machines */
  54         if (m5602_read_sensor(sd, 0x00, &prod_id, 1))
  55                 return -ENODEV;
  56
  57         if (m5602_read_sensor(sd, 0x01, &ver_id, 1))
  58                 return -ENODEV;
  59
  60         if ((prod_id == 0xff) || (ver_id == 0xff))
  61                 return -ENODEV;
  62         else
  63                 info("Detected a s5k83a sensor");
  64
  65 sensor_found:
  66         sd->gspca_dev.cam.cam_mode = s5k83a.modes;
  67         sd->gspca_dev.cam.nmodes = s5k83a.nmodes;
  68         sd->desc->ctrls = s5k83a.ctrls;
  69         sd->desc->nctrls = s5k83a.nctrls;
  70         return 0;
  71 }
  72
  73 int s5k83a_init(struct sd *sd)
  74 {
  75         int i, err = 0;
  76
  77         for (i = 0; i < ARRAY_SIZE(init_s5k83a) && !err; i++) {
  78                 u8 data[2] = {0x00, 0x00};
  79
  80                 switch (init_s5k83a[i][0]) {
  81                 case BRIDGE:
  82                         err = m5602_write_bridge(sd,
  83                                         init_s5k83a[i][1],
  84                                         init_s5k83a[i][2]);
  85                         break;
  86
  87                 case SENSOR:
  88                         data[0] = init_s5k83a[i][2];
  89                         err = m5602_write_sensor(sd,
  90                                 init_s5k83a[i][1], data, 1);
  91                         break;
  92
  93                 case SENSOR_LONG:
  94                         data[0] = init_s5k83a[i][2];
  95                         data[1] = init_s5k83a[i][3];
  96                         err = m5602_write_sensor(sd,
  97                                 init_s5k83a[i][1], data, 2);
  98                         break;
  99                 default:
 100                         info("Invalid stream command, exiting init");
 101                         return -EINVAL;
 102                 }
 103         }
 104
 105         if (dump_sensor)
 106                 s5k83a_dump_registers(sd);
 107
 108         return (err < 0) ? err : 0;
 109 }
 110
 111 int s5k83a_power_down(struct sd *sd)
 112 {
 113         return 0;
 114 }
 115
 116 static void s5k83a_dump_registers(struct sd *sd)
 117 {
 118         int address;
 119         u8 page, old_page;
 120         m5602_read_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
 121
 122         for (page = 0; page < 16; page++) {
 123                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
 124                 info("Dumping the s5k83a register state for page 0x%x", page);
 125                 for (address = 0; address <= 0xff; address++) {
 126                         u8 val = 0;
 127                         m5602_read_sensor(sd, address, &val, 1);
 128                         info("register 0x%x contains 0x%x",
 129                              address, val);
 130                 }
 131         }
 132         info("s5k83a register state dump complete");
 133
 134         for (page = 0; page < 16; page++) {
 135                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
 136                 info("Probing for which registers that are read/write "
 137                       "for page 0x%x", page);
 138                 for (address = 0; address <= 0xff; address++) {
 139                         u8 old_val, ctrl_val, test_val = 0xff;
 140
 141                         m5602_read_sensor(sd, address, &old_val, 1);
 142                         m5602_write_sensor(sd, address, &test_val, 1);
 143                         m5602_read_sensor(sd, address, &ctrl_val, 1);
 144
 145                         if (ctrl_val == test_val)
 146                                 info("register 0x%x is writeable", address);
 147                         else
 148                                 info("register 0x%x is read only", address);
 149
 150                         /* Restore original val */
 151                         m5602_write_sensor(sd, address, &old_val, 1);
 152                 }
 153         }
 154         info("Read/write register probing complete");
 155         m5602_write_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
 156 }
 157
 158 int s5k83a_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
 159 {
 160         int err;
 161         u8 data[2];
 162         struct sd *sd = (struct sd *) gspca_dev;
 163
 164         err = m5602_read_sensor(sd, S5K83A_BRIGHTNESS, data, 2);
 165         if (err < 0)
 166                 goto out;
 167
 168         data[1] = data[1] << 1;
 169         *val = data[1];
 170
 171 out:
 172         return err;
 173 }
 174
 175 int s5k83a_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
 176 {
 177         int err;
 178         u8 data[2];
 179         struct sd *sd = (struct sd *) gspca_dev;
 180
 181         data[0] = 0x00;
 182         data[1] = 0x20;
 183         err = m5602_write_sensor(sd, 0x14, data, 2);
 184         if (err < 0)
 185                 goto out;
 186
 187         data[0] = 0x01;
 188         data[1] = 0x00;
 189         err = m5602_write_sensor(sd, 0x0d, data, 2);
 190         if (err < 0)
 191                 goto out;
 192
 193         /* FIXME: This is not sane, we need to figure out the composition
 194                   of these registers */
 195         data[0] = val >> 3; /* brightness, high 5 bits */
 196         data[1] = val >> 1; /* brightness, high 7 bits */
 197         err = m5602_write_sensor(sd, S5K83A_BRIGHTNESS, data, 2);
 198
 199 out:
 200         return err;
 201 }
 202
 203 int s5k83a_get_whiteness(struct gspca_dev *gspca_dev, __s32 *val)
 204 {
 205         int err;
 206         u8 data;
 207         struct sd *sd = (struct sd *) gspca_dev;
 208
 209         err = m5602_read_sensor(sd, S5K83A_WHITENESS, &data, 1);
 210         if (err < 0)
 211                 goto out;
 212
 213         *val = data;
 214
 215 out:
 216         return err;
 217 }
 218
 219 int s5k83a_set_whiteness(struct gspca_dev *gspca_dev, __s32 val)
 220 {
 221         int err;
 222         u8 data[1];
 223         struct sd *sd = (struct sd *) gspca_dev;
 224
 225         data[0] = val;
 226         err = m5602_write_sensor(sd, S5K83A_WHITENESS, data, 1);
 227
 228         return err;
 229 }
 230
 231 int s5k83a_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 232 {
 233         int err;
 234         u8 data[2];
 235         struct sd *sd = (struct sd *) gspca_dev;
 236
 237         err = m5602_read_sensor(sd, S5K83A_GAIN, data, 2);
 238         if (err < 0)
 239                 goto out;
 240
 241         data[1] = data[1] & 0x3f;
 242         if (data[1] > S5K83A_MAXIMUM_GAIN)
 243                 data[1] = S5K83A_MAXIMUM_GAIN;
 244
 245         *val = data[1];
 246
 247 out:
 248         return err;
 249 }
 250
 251 int s5k83a_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 252 {
 253         int err;
 254         u8 data[2];
 255         struct sd *sd = (struct sd *) gspca_dev;
 256
 257         data[0] = 0;
 258         data[1] = val;
 259         err = m5602_write_sensor(sd, S5K83A_GAIN, data, 2);
 260         return err;
 261 }
 262
 263 int s5k83a_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 264 {
 265         int err;
 266         u8 data[1];
 267         struct sd *sd = (struct sd *) gspca_dev;
 268
 269         data[0] = 0x05;
 270         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 271         if (err < 0)
 272                 goto out;
 273
 274         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 275         *val = (data[0] | 0x40) ? 1 : 0;
 276
 277 out:
 278         return err;
 279 }
 280
 281 int s5k83a_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 282 {
 283         int err;
 284         u8 data[1];
 285         struct sd *sd = (struct sd *) gspca_dev;
 286
 287         data[0] = 0x05;
 288         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 289         if (err < 0)
 290                 goto out;
 291
 292         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 293         if (err < 0)
 294                 goto out;
 295
 296         /* set or zero six bit, seven is hflip */
 297         data[0] = (val) ? (data[0] & 0x80) | 0x40 | S5K83A_FLIP_MASK
 298                         : (data[0] & 0x80) | S5K83A_FLIP_MASK;
 299         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
 300         if (err < 0)
 301                 goto out;
 302
 303         data[0] = (val) ? 0x0b : 0x0a;
 304         err = m5602_write_sensor(sd, S5K83A_VFLIP_TUNE, data, 1);
 305
 306 out:
 307         return err;
 308 }
 309
 310 int s5k83a_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
 311 {
 312         int err;
 313         u8 data[1];
 314         struct sd *sd = (struct sd *) gspca_dev;
 315
 316         data[0] = 0x05;
 317         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 318         if (err < 0)
 319                 goto out;
 320
 321         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 322         *val = (data[0] | 0x80) ? 1 : 0;
 323
 324 out:
 325         return err;
 326 }
 327
 328 int s5k83a_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 329 {
 330         int err;
 331         u8 data[1];
 332         struct sd *sd = (struct sd *) gspca_dev;
 333
 334         data[0] = 0x05;
 335         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 336         if (err < 0)
 337                 goto out;
 338
 339         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 340         if (err < 0)
 341                 goto out;
 342
 343         /* set or zero seven bit, six is vflip */
 344         data[0] = (val) ? (data[0] & 0x40) | 0x80 | S5K83A_FLIP_MASK
 345                         : (data[0] & 0x40) | S5K83A_FLIP_MASK;
 346         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
 347         if (err < 0)
 348                 goto out;
 349
 350         data[0] = (val) ? 0x0a : 0x0b;
 351         err = m5602_write_sensor(sd, S5K83A_HFLIP_TUNE, data, 1);
 352 out:
 353         return err;
 354 }