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