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_start(struct sd *sd)
 112 {
 113         return s5k83a_set_led_indication(sd, 1);
 114 }
 115
 116 int s5k83a_stop(struct sd *sd)
 117 {
 118         return s5k83a_set_led_indication(sd, 0);
 119 }
 120
 121 int s5k83a_power_down(struct sd *sd)
 122 {
 123         return 0;
 124 }
 125
 126 static void s5k83a_dump_registers(struct sd *sd)
 127 {
 128         int address;
 129         u8 page, old_page;
 130         m5602_read_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
 131
 132         for (page = 0; page < 16; page++) {
 133                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
 134                 info("Dumping the s5k83a register state for page 0x%x", page);
 135                 for (address = 0; address <= 0xff; address++) {
 136                         u8 val = 0;
 137                         m5602_read_sensor(sd, address, &val, 1);
 138                         info("register 0x%x contains 0x%x",
 139                              address, val);
 140                 }
 141         }
 142         info("s5k83a register state dump complete");
 143
 144         for (page = 0; page < 16; page++) {
 145                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
 146                 info("Probing for which registers that are read/write "
 147                       "for page 0x%x", page);
 148                 for (address = 0; address <= 0xff; address++) {
 149                         u8 old_val, ctrl_val, test_val = 0xff;
 150
 151                         m5602_read_sensor(sd, address, &old_val, 1);
 152                         m5602_write_sensor(sd, address, &test_val, 1);
 153                         m5602_read_sensor(sd, address, &ctrl_val, 1);
 154
 155                         if (ctrl_val == test_val)
 156                                 info("register 0x%x is writeable", address);
 157                         else
 158                                 info("register 0x%x is read only", address);
 159
 160                         /* Restore original val */
 161                         m5602_write_sensor(sd, address, &old_val, 1);
 162                 }
 163         }
 164         info("Read/write register probing complete");
 165         m5602_write_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
 166 }
 167
 168 int s5k83a_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
 169 {
 170         int err;
 171         u8 data[2];
 172         struct sd *sd = (struct sd *) gspca_dev;
 173
 174         err = m5602_read_sensor(sd, S5K83A_BRIGHTNESS, data, 2);
 175         if (err < 0)
 176                 return err;
 177
 178         data[1] = data[1] << 1;
 179         *val = data[1];
 180
 181         return err;
 182 }
 183
 184 int s5k83a_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
 185 {
 186         int err;
 187         u8 data[2];
 188         struct sd *sd = (struct sd *) gspca_dev;
 189
 190         data[0] = 0x00;
 191         data[1] = 0x20;
 192         err = m5602_write_sensor(sd, 0x14, data, 2);
 193         if (err < 0)
 194                 return err;
 195
 196         data[0] = 0x01;
 197         data[1] = 0x00;
 198         err = m5602_write_sensor(sd, 0x0d, data, 2);
 199         if (err < 0)
 200                 return err;
 201
 202         /* FIXME: This is not sane, we need to figure out the composition
 203                   of these registers */
 204         data[0] = val >> 3; /* brightness, high 5 bits */
 205         data[1] = val >> 1; /* brightness, high 7 bits */
 206         err = m5602_write_sensor(sd, S5K83A_BRIGHTNESS, data, 2);
 207
 208         return err;
 209 }
 210
 211 int s5k83a_get_whiteness(struct gspca_dev *gspca_dev, __s32 *val)
 212 {
 213         int err;
 214         u8 data;
 215         struct sd *sd = (struct sd *) gspca_dev;
 216
 217         err = m5602_read_sensor(sd, S5K83A_WHITENESS, &data, 1);
 218         if (err < 0)
 219                 return err;
 220
 221         *val = data;
 222
 223         return err;
 224 }
 225
 226 int s5k83a_set_whiteness(struct gspca_dev *gspca_dev, __s32 val)
 227 {
 228         int err;
 229         u8 data[1];
 230         struct sd *sd = (struct sd *) gspca_dev;
 231
 232         data[0] = val;
 233         err = m5602_write_sensor(sd, S5K83A_WHITENESS, data, 1);
 234
 235         return err;
 236 }
 237
 238 int s5k83a_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 239 {
 240         int err;
 241         u8 data[2];
 242         struct sd *sd = (struct sd *) gspca_dev;
 243
 244         err = m5602_read_sensor(sd, S5K83A_GAIN, data, 2);
 245         if (err < 0)
 246                 return err;
 247
 248         data[1] = data[1] & 0x3f;
 249         if (data[1] > S5K83A_MAXIMUM_GAIN)
 250                 data[1] = S5K83A_MAXIMUM_GAIN;
 251
 252         *val = data[1];
 253
 254         return err;
 255 }
 256
 257 int s5k83a_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 258 {
 259         int err;
 260         u8 data[2];
 261         struct sd *sd = (struct sd *) gspca_dev;
 262
 263         data[0] = 0;
 264         data[1] = val;
 265         err = m5602_write_sensor(sd, S5K83A_GAIN, data, 2);
 266         return err;
 267 }
 268
 269 int s5k83a_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 270 {
 271         int err;
 272         u8 data[1];
 273         struct sd *sd = (struct sd *) gspca_dev;
 274
 275         data[0] = 0x05;
 276         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 277         if (err < 0)
 278                 return err;
 279
 280         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 281         *val = (data[0] | 0x40) ? 1 : 0;
 282
 283         return err;
 284 }
 285
 286 int s5k83a_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 287 {
 288         int err;
 289         u8 data[1];
 290         struct sd *sd = (struct sd *) gspca_dev;
 291
 292         data[0] = 0x05;
 293         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 294         if (err < 0)
 295                 return err;
 296
 297         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 298         if (err < 0)
 299                 return err;
 300
 301         /* set or zero six bit, seven is hflip */
 302         data[0] = (val) ? (data[0] & 0x80) | 0x40 | S5K83A_FLIP_MASK
 303                         : (data[0] & 0x80) | S5K83A_FLIP_MASK;
 304         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
 305         if (err < 0)
 306                 return err;
 307
 308         data[0] = (val) ? 0x0b : 0x0a;
 309         err = m5602_write_sensor(sd, S5K83A_VFLIP_TUNE, data, 1);
 310
 311         return err;
 312 }
 313
 314 int s5k83a_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
 315 {
 316         int err;
 317         u8 data[1];
 318         struct sd *sd = (struct sd *) gspca_dev;
 319
 320         data[0] = 0x05;
 321         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 322         if (err < 0)
 323                 return err;
 324
 325         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 326         *val = (data[0] | 0x80) ? 1 : 0;
 327
 328         return err;
 329 }
 330
 331 int s5k83a_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 332 {
 333         int err;
 334         u8 data[1];
 335         struct sd *sd = (struct sd *) gspca_dev;
 336
 337         data[0] = 0x05;
 338         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 339         if (err < 0)
 340                 return err;
 341
 342         err = m5602_read_sensor(sd, S5K83A_FLIP, data, 1);
 343         if (err < 0)
 344                 return err;
 345
 346         /* set or zero seven bit, six is vflip */
 347         data[0] = (val) ? (data[0] & 0x40) | 0x80 | S5K83A_FLIP_MASK
 348                         : (data[0] & 0x40) | S5K83A_FLIP_MASK;
 349         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
 350         if (err < 0)
 351                 return err;
 352
 353         data[0] = (val) ? 0x0a : 0x0b;
 354         err = m5602_write_sensor(sd, S5K83A_HFLIP_TUNE, data, 1);
 355
 356         return err;
 357 }
 358
 359 int s5k83a_set_led_indication(struct sd *sd, u8 val)
 360 {
 361         int err = 0;
 362         u8 data[1];
 363
 364         err = m5602_read_bridge(sd, M5602_XB_GPIO_DAT, data);
 365         if (err < 0)
 366                 return err;
 367
 368         if (val)
 369                 data[0] = data[0] | S5K83A_GPIO_LED_MASK;
 370         else
 371                 data[0] = data[0] & ~S5K83A_GPIO_LED_MASK;
 372
 373         err = m5602_write_bridge(sd, M5602_XB_GPIO_DAT, data[0]);
 374
 375         return (err < 0) ? err : 0;
 376 }