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 <linux/kthread.h>
  20 #include "m5602_s5k83a.h"
  21
  22 static struct v4l2_pix_format s5k83a_modes[] = {
  23         {
  24                 640,
  25                 480,
  26                 V4L2_PIX_FMT_SBGGR8,
  27                 V4L2_FIELD_NONE,
  28                 .sizeimage =
  29                         640 * 480,
  30                 .bytesperline = 640,
  31                 .colorspace = V4L2_COLORSPACE_SRGB,
  32                 .priv = 0
  33         }
  34 };
  35
  36 const static struct ctrl s5k83a_ctrls[] = {
  37 #define GAIN_IDX 0
  38         {
  39                 {
  40                         .id = V4L2_CID_GAIN,
  41                         .type = V4L2_CTRL_TYPE_INTEGER,
  42                         .name = "gain",
  43                         .minimum = 0x00,
  44                         .maximum = 0xff,
  45                         .step = 0x01,
  46                         .default_value = S5K83A_DEFAULT_GAIN,
  47                         .flags = V4L2_CTRL_FLAG_SLIDER
  48                 },
  49                         .set = s5k83a_set_gain,
  50                         .get = s5k83a_get_gain
  51
  52         },
  53 #define BRIGHTNESS_IDX 1
  54         {
  55                 {
  56                         .id = V4L2_CID_BRIGHTNESS,
  57                         .type = V4L2_CTRL_TYPE_INTEGER,
  58                         .name = "brightness",
  59                         .minimum = 0x00,
  60                         .maximum = 0xff,
  61                         .step = 0x01,
  62                         .default_value = S5K83A_DEFAULT_BRIGHTNESS,
  63                         .flags = V4L2_CTRL_FLAG_SLIDER
  64                 },
  65                         .set = s5k83a_set_brightness,
  66                         .get = s5k83a_get_brightness,
  67         },
  68 #define EXPOSURE_IDX 2
  69         {
  70                 {
  71                         .id = V4L2_CID_EXPOSURE,
  72                         .type = V4L2_CTRL_TYPE_INTEGER,
  73                         .name = "exposure",
  74                         .minimum = 0x00,
  75                         .maximum = S5K83A_MAXIMUM_EXPOSURE,
  76                         .step = 0x01,
  77                         .default_value = S5K83A_DEFAULT_EXPOSURE,
  78                         .flags = V4L2_CTRL_FLAG_SLIDER
  79                 },
  80                         .set = s5k83a_set_exposure,
  81                         .get = s5k83a_get_exposure
  82         },
  83 #define HFLIP_IDX 3
  84         {
  85                 {
  86                         .id         = V4L2_CID_HFLIP,
  87                         .type       = V4L2_CTRL_TYPE_BOOLEAN,
  88                         .name       = "horizontal flip",
  89                         .minimum    = 0,
  90                         .maximum    = 1,
  91                         .step       = 1,
  92                         .default_value  = 0
  93                 },
  94                         .set = s5k83a_set_hflip,
  95                         .get = s5k83a_get_hflip
  96         },
  97 #define VFLIP_IDX 4
  98         {
  99                 {
 100                  .id         = V4L2_CID_VFLIP,
 101                 .type       = V4L2_CTRL_TYPE_BOOLEAN,
 102                 .name       = "vertical flip",
 103                 .minimum    = 0,
 104                 .maximum    = 1,
 105                 .step       = 1,
 106                 .default_value  = 0
 107                 },
 108                 .set = s5k83a_set_vflip,
 109                 .get = s5k83a_get_vflip
 110         }
 111 };
 112
 113 static void s5k83a_dump_registers(struct sd *sd);
 114 static int s5k83a_get_rotation(struct sd *sd, u8 *reg_data);
 115 static int s5k83a_set_led_indication(struct sd *sd, u8 val);
 116 int s5k83a_set_flip_real(struct gspca_dev *gspca_dev, __s32 vflip, __s32 hflip);
 117
 118 int s5k83a_probe(struct sd *sd)
 119 {
 120         struct s5k83a_priv *sens_priv;
 121         u8 prod_id = 0, ver_id = 0;
 122         int i, err = 0;
 123
 124         if (force_sensor) {
 125                 if (force_sensor == S5K83A_SENSOR) {
 126                         info("Forcing a %s sensor", s5k83a.name);
 127                         goto sensor_found;
 128                 }
 129                 /* If we want to force another sensor, don't try to probe this
 130                  * one */
 131                 return -ENODEV;
 132         }
 133
 134         info("Probing for a s5k83a sensor");
 135
 136         /* Preinit the sensor */
 137         for (i = 0; i < ARRAY_SIZE(preinit_s5k83a) && !err; i++) {
 138                 u8 data[2] = {preinit_s5k83a[i][2], preinit_s5k83a[i][3]};
 139                 if (preinit_s5k83a[i][0] == SENSOR)
 140                         err = m5602_write_sensor(sd, preinit_s5k83a[i][1],
 141                                 data, 2);
 142                 else
 143                         err = m5602_write_bridge(sd, preinit_s5k83a[i][1],
 144                                 data[0]);
 145         }
 146
 147         /* We don't know what register (if any) that contain the product id
 148          * Just pick the first addresses that seem to produce the same results
 149          * on multiple machines */
 150         if (m5602_read_sensor(sd, 0x00, &prod_id, 1))
 151                 return -ENODEV;
 152
 153         if (m5602_read_sensor(sd, 0x01, &ver_id, 1))
 154                 return -ENODEV;
 155
 156         if ((prod_id == 0xff) || (ver_id == 0xff))
 157                 return -ENODEV;
 158         else
 159                 info("Detected a s5k83a sensor");
 160
 161 sensor_found:
 162         sens_priv = kmalloc(
 163                 sizeof(struct s5k83a_priv), GFP_KERNEL);
 164         if (!sens_priv)
 165                 return -ENOMEM;
 166
 167         sens_priv->settings =
 168         kmalloc(sizeof(s32)*ARRAY_SIZE(s5k83a_ctrls), GFP_KERNEL);
 169         if (!sens_priv->settings)
 170                 return -ENOMEM;
 171
 172         sd->gspca_dev.cam.cam_mode = s5k83a_modes;
 173         sd->gspca_dev.cam.nmodes = ARRAY_SIZE(s5k83a_modes);
 174         sd->desc->ctrls = s5k83a_ctrls;
 175         sd->desc->nctrls = ARRAY_SIZE(s5k83a_ctrls);
 176
 177         /* null the pointer! thread is't running now */
 178         sens_priv->rotation_thread = NULL;
 179
 180         for (i = 0; i < ARRAY_SIZE(s5k83a_ctrls); i++)
 181                 sens_priv->settings[i] = s5k83a_ctrls[i].qctrl.default_value;
 182
 183         sd->sensor_priv = sens_priv;
 184         return 0;
 185 }
 186
 187 int s5k83a_init(struct sd *sd)
 188 {
 189         int i, err = 0;
 190
 191         for (i = 0; i < ARRAY_SIZE(init_s5k83a) && !err; i++) {
 192                 u8 data[2] = {0x00, 0x00};
 193
 194                 switch (init_s5k83a[i][0]) {
 195                 case BRIDGE:
 196                         err = m5602_write_bridge(sd,
 197                                         init_s5k83a[i][1],
 198                                         init_s5k83a[i][2]);
 199                         break;
 200
 201                 case SENSOR:
 202                         data[0] = init_s5k83a[i][2];
 203                         err = m5602_write_sensor(sd,
 204                                 init_s5k83a[i][1], data, 1);
 205                         break;
 206
 207                 case SENSOR_LONG:
 208                         data[0] = init_s5k83a[i][2];
 209                         data[1] = init_s5k83a[i][3];
 210                         err = m5602_write_sensor(sd,
 211                                 init_s5k83a[i][1], data, 2);
 212                         break;
 213                 default:
 214                         info("Invalid stream command, exiting init");
 215                         return -EINVAL;
 216                 }
 217         }
 218
 219         if (dump_sensor)
 220                 s5k83a_dump_registers(sd);
 221
 222         return (err < 0) ? err : 0;
 223 }
 224
 225 static int rotation_thread_function(void *data)
 226 {
 227         struct sd *sd = (struct sd *) data;
 228         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 229         u8 reg, previous_rotation = 0;
 230         __s32 vflip, hflip;
 231
 232         set_current_state(TASK_INTERRUPTIBLE);
 233         while (!schedule_timeout(100)) {
 234                 if (mutex_lock_interruptible(&sd->gspca_dev.usb_lock))
 235                         break;
 236
 237                 s5k83a_get_rotation(sd, &reg);
 238                 if (previous_rotation != reg) {
 239                         previous_rotation = reg;
 240                         info("Camera was flipped");
 241
 242                         s5k83a_get_vflip((struct gspca_dev *) sd, &vflip);
 243                         s5k83a_get_hflip((struct gspca_dev *) sd, &hflip);
 244
 245                         if (reg) {
 246                                 vflip = !vflip;
 247                                 hflip = !hflip;
 248                         }
 249                         s5k83a_set_flip_real((struct gspca_dev *) sd, vflip, hflip);
 250                 }
 251
 252                 mutex_unlock(&sd->gspca_dev.usb_lock);
 253                 set_current_state(TASK_INTERRUPTIBLE);
 254         }
 255
 256         /* return to "front" flip */
 257         if (previous_rotation) {
 258                 s5k83a_get_vflip((struct gspca_dev *) sd, &vflip);
 259                 s5k83a_get_hflip((struct gspca_dev *) sd, &hflip);
 260                 s5k83a_set_flip_real((struct gspca_dev *) sd, vflip, hflip);
 261         }
 262
 263         sens_priv->rotation_thread = NULL;
 264         return 0;
 265 }
 266
 267 int s5k83a_start(struct sd *sd)
 268 {
 269         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 270
 271         /* Create another thread, polling the GPIO ports of the camera to check
 272            if it got rotated. This is how the windows driver does it so we have
 273            to assume that there is no better way of accomplishing this */
 274         sens_priv->rotation_thread = kthread_create(rotation_thread_function, sd, "rotation thread");
 275         wake_up_process(sens_priv->rotation_thread);
 276
 277         return s5k83a_set_led_indication(sd, 1);
 278 }
 279
 280 int s5k83a_stop(struct sd *sd)
 281 {
 282         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 283
 284         if (sens_priv->rotation_thread)
 285                 kthread_stop(sens_priv->rotation_thread);
 286
 287         return s5k83a_set_led_indication(sd, 0);
 288 }
 289
 290 void s5k83a_disconnect(struct sd *sd)
 291 {
 292         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 293
 294         s5k83a_stop(sd);
 295
 296         sd->sensor = NULL;
 297         kfree(sens_priv->settings);
 298         kfree(sens_priv);
 299 }
 300
 301 int s5k83a_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 302 {
 303         struct sd *sd = (struct sd *) gspca_dev;
 304         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 305
 306         *val = sens_priv->settings[GAIN_IDX];
 307         return 0;
 308 }
 309
 310 int s5k83a_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 311 {
 312         int err;
 313         u8 data[2];
 314         struct sd *sd = (struct sd *) gspca_dev;
 315         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 316
 317         sens_priv->settings[GAIN_IDX] = val;
 318
 319         data[0] = 0x00;
 320         data[1] = 0x20;
 321         err = m5602_write_sensor(sd, 0x14, data, 2);
 322         if (err < 0)
 323                 return err;
 324
 325         data[0] = 0x01;
 326         data[1] = 0x00;
 327         err = m5602_write_sensor(sd, 0x0d, data, 2);
 328         if (err < 0)
 329                 return err;
 330
 331         /* FIXME: This is not sane, we need to figure out the composition
 332                   of these registers */
 333         data[0] = val >> 3; /* gain, high 5 bits */
 334         data[1] = val >> 1; /* gain, high 7 bits */
 335         err = m5602_write_sensor(sd, S5K83A_GAIN, data, 2);
 336
 337         return err;
 338 }
 339
 340 int s5k83a_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
 341 {
 342         struct sd *sd = (struct sd *) gspca_dev;
 343         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 344
 345         *val = sens_priv->settings[BRIGHTNESS_IDX];
 346         return 0;
 347 }
 348
 349 int s5k83a_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
 350 {
 351         int err;
 352         u8 data[1];
 353         struct sd *sd = (struct sd *) gspca_dev;
 354         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 355
 356         sens_priv->settings[BRIGHTNESS_IDX] = val;
 357         data[0] = val;
 358         err = m5602_write_sensor(sd, S5K83A_BRIGHTNESS, data, 1);
 359         return err;
 360 }
 361
 362 int s5k83a_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
 363 {
 364         struct sd *sd = (struct sd *) gspca_dev;
 365         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 366
 367         *val = sens_priv->settings[EXPOSURE_IDX];
 368         return 0;
 369 }
 370
 371 int s5k83a_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
 372 {
 373         int err;
 374         u8 data[2];
 375         struct sd *sd = (struct sd *) gspca_dev;
 376         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 377
 378         sens_priv->settings[EXPOSURE_IDX] = val;
 379         data[0] = 0;
 380         data[1] = val;
 381         err = m5602_write_sensor(sd, S5K83A_EXPOSURE, data, 2);
 382         return err;
 383 }
 384
 385 int s5k83a_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 386 {
 387         struct sd *sd = (struct sd *) gspca_dev;
 388         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 389
 390         *val = sens_priv->settings[VFLIP_IDX];
 391         return 0;
 392 }
 393
 394 int s5k83a_set_flip_real(struct gspca_dev *gspca_dev, __s32 vflip, __s32 hflip)
 395 {
 396         int err;
 397         u8 data[1];
 398         struct sd *sd = (struct sd *) gspca_dev;
 399
 400         data[0] = 0x05;
 401         err = m5602_write_sensor(sd, S5K83A_PAGE_MAP, data, 1);
 402         if (err < 0)
 403                 return err;
 404
 405         /* six bit is vflip, seven is hflip */
 406         data[0] = S5K83A_FLIP_MASK;
 407         data[0] = (vflip) ? data[0] | 0x40 : data[0];
 408         data[0] = (hflip) ? data[0] | 0x80 : data[0];
 409
 410         err = m5602_write_sensor(sd, S5K83A_FLIP, data, 1);
 411         if (err < 0)
 412                 return err;
 413
 414         data[0] = (vflip) ? 0x0b : 0x0a;
 415         err = m5602_write_sensor(sd, S5K83A_VFLIP_TUNE, data, 1);
 416         if (err < 0)
 417                 return err;
 418
 419         data[0] = (hflip) ? 0x0a : 0x0b;
 420         err = m5602_write_sensor(sd, S5K83A_HFLIP_TUNE, data, 1);
 421         return err;
 422 }
 423
 424 int s5k83a_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 425 {
 426         int err;
 427         u8 reg;
 428         __s32 hflip;
 429         struct sd *sd = (struct sd *) gspca_dev;
 430         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 431
 432         sens_priv->settings[VFLIP_IDX] = val;
 433
 434         s5k83a_get_hflip(gspca_dev, &hflip);
 435
 436         err = s5k83a_get_rotation(sd, &reg);
 437         if (err < 0)
 438                 return err;
 439         if (reg) {
 440                 val = !val;
 441                 hflip = !hflip;
 442         }
 443
 444         err = s5k83a_set_flip_real(gspca_dev, val, hflip);
 445         return err;
 446 }
 447
 448 int s5k83a_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
 449 {
 450         struct sd *sd = (struct sd *) gspca_dev;
 451         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 452
 453         *val = sens_priv->settings[HFLIP_IDX];
 454         return 0;
 455 }
 456
 457 int s5k83a_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 458 {
 459         int err;
 460         u8 reg;
 461         __s32 vflip;
 462         struct sd *sd = (struct sd *) gspca_dev;
 463         struct s5k83a_priv *sens_priv = sd->sensor_priv;
 464
 465         sens_priv->settings[HFLIP_IDX] = val;
 466
 467         s5k83a_get_vflip(gspca_dev, &vflip);
 468
 469         err = s5k83a_get_rotation(sd, &reg);
 470         if (err < 0)
 471                 return err;
 472         if (reg) {
 473                 val = !val;
 474                 vflip = !vflip;
 475         }
 476
 477         err = s5k83a_set_flip_real(gspca_dev, vflip, val);
 478         return err;
 479 }
 480
 481 static int s5k83a_set_led_indication(struct sd *sd, u8 val)
 482 {
 483         int err = 0;
 484         u8 data[1];
 485
 486         err = m5602_read_bridge(sd, M5602_XB_GPIO_DAT, data);
 487         if (err < 0)
 488                 return err;
 489
 490         if (val)
 491                 data[0] = data[0] | S5K83A_GPIO_LED_MASK;
 492         else
 493                 data[0] = data[0] & ~S5K83A_GPIO_LED_MASK;
 494
 495         err = m5602_write_bridge(sd, M5602_XB_GPIO_DAT, data[0]);
 496
 497         return (err < 0) ? err : 0;
 498 }
 499
 500 /* Get camera rotation on Acer notebooks */
 501 static int s5k83a_get_rotation(struct sd *sd, u8 *reg_data)
 502 {
 503         int err = m5602_read_bridge(sd, M5602_XB_GPIO_DAT, reg_data);
 504         *reg_data = (*reg_data & S5K83A_GPIO_ROTATION_MASK) ? 0 : 1;
 505         return err;
 506 }
 507
 508 static void s5k83a_dump_registers(struct sd *sd)
 509 {
 510         int address;
 511         u8 page, old_page;
 512         m5602_read_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
 513
 514         for (page = 0; page < 16; page++) {
 515                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
 516                 info("Dumping the s5k83a register state for page 0x%x", page);
 517                 for (address = 0; address <= 0xff; address++) {
 518                         u8 val = 0;
 519                         m5602_read_sensor(sd, address, &val, 1);
 520                         info("register 0x%x contains 0x%x",
 521                              address, val);
 522                 }
 523         }
 524         info("s5k83a register state dump complete");
 525
 526         for (page = 0; page < 16; page++) {
 527                 m5602_write_sensor(sd, S5K83A_PAGE_MAP, &page, 1);
 528                 info("Probing for which registers that are read/write "
 529                                 "for page 0x%x", page);
 530                 for (address = 0; address <= 0xff; address++) {
 531                         u8 old_val, ctrl_val, test_val = 0xff;
 532
 533                         m5602_read_sensor(sd, address, &old_val, 1);
 534                         m5602_write_sensor(sd, address, &test_val, 1);
 535                         m5602_read_sensor(sd, address, &ctrl_val, 1);
 536
 537                         if (ctrl_val == test_val)
 538                                 info("register 0x%x is writeable", address);
 539                         else
 540                                 info("register 0x%x is read only", address);
 541
 542                         /* Restore original val */
 543                         m5602_write_sensor(sd, address, &old_val, 1);
 544                 }
 545         }
 546         info("Read/write register probing complete");
 547         m5602_write_sensor(sd, S5K83A_PAGE_MAP, &old_page, 1);
 548 }