drivers/media/video/gspca/m5602/m5602_s5k4aa.c

   1 /*
   2  * Driver for the s5k4aa 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_s5k4aa.h"
  20
  21 static int s5k4aa_get_exposure(struct gspca_dev *gspca_dev, __s32 *val);
  22 static int s5k4aa_set_exposure(struct gspca_dev *gspca_dev, __s32 val);
  23 static int s5k4aa_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
  24 static int s5k4aa_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
  25 static int s5k4aa_get_hflip(struct gspca_dev *gspca_dev, __s32 *val);
  26 static int s5k4aa_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
  27 static int s5k4aa_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
  28 static int s5k4aa_set_gain(struct gspca_dev *gspca_dev, __s32 val);
  29 static int s5k4aa_get_noise(struct gspca_dev *gspca_dev, __s32 *val);
  30 static int s5k4aa_set_noise(struct gspca_dev *gspca_dev, __s32 val);
  31
  32 static
  33     const
  34         struct dmi_system_id s5k4aa_vflip_dmi_table[] = {
  35         {
  36                 .ident = "Fujitsu-Siemens Amilo Xa 2528",
  37                 .matches = {
  38                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
  39                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xa 2528")
  40                 }
  41         }, {
  42                 .ident = "Fujitsu-Siemens Amilo Xi 2550",
  43                 .matches = {
  44                         DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
  45                         DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Xi 2550")
  46                 }
  47         }, {
  48                 .ident = "MSI GX700",
  49                 .matches = {
  50                         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
  51                         DMI_MATCH(DMI_PRODUCT_NAME, "GX700"),
  52                         DMI_MATCH(DMI_BIOS_DATE, "07/26/2007")
  53                 }
  54         }, {
  55                 .ident = "MSI GX700/GX705/EX700",
  56                 .matches = {
  57                         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
  58                         DMI_MATCH(DMI_PRODUCT_NAME, "GX700/GX705/EX700")
  59                 }
  60         },
  61         { }
  62 };
  63
  64 static struct v4l2_pix_format s5k4aa_modes[] = {
  65         {
  66                 640,
  67                 480,
  68                 V4L2_PIX_FMT_SBGGR8,
  69                 V4L2_FIELD_NONE,
  70                 .sizeimage =
  71                         640 * 480,
  72                 .bytesperline = 640,
  73                 .colorspace = V4L2_COLORSPACE_SRGB,
  74                 .priv = 0
  75         }
  76 };
  77
  78 const static struct ctrl s5k4aa_ctrls[] = {
  79 #define VFLIP_IDX 0
  80         {
  81                 {
  82                         .id             = V4L2_CID_VFLIP,
  83                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
  84                         .name           = "vertical flip",
  85                         .minimum        = 0,
  86                         .maximum        = 1,
  87                         .step           = 1,
  88                         .default_value  = 0
  89                 },
  90                 .set = s5k4aa_set_vflip,
  91                 .get = s5k4aa_get_vflip
  92         },
  93 #define HFLIP_IDX 1
  94         {
  95                 {
  96                         .id             = V4L2_CID_HFLIP,
  97                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
  98                         .name           = "horizontal flip",
  99                         .minimum        = 0,
 100                         .maximum        = 1,
 101                         .step           = 1,
 102                         .default_value  = 0
 103                 },
 104                 .set = s5k4aa_set_hflip,
 105                 .get = s5k4aa_get_hflip
 106         },
 107 #define GAIN_IDX 2
 108         {
 109                 {
 110                         .id             = V4L2_CID_GAIN,
 111                         .type           = V4L2_CTRL_TYPE_INTEGER,
 112                         .name           = "Gain",
 113                         .minimum        = 0,
 114                         .maximum        = 127,
 115                         .step           = 1,
 116                         .default_value  = DEFAULT_GAIN_2,
 117                         .flags          = V4L2_CTRL_FLAG_SLIDER
 118                 },
 119                 .set = s5k4aa_set_gain,
 120                 .get = s5k4aa_get_gain
 121         },
 122 #define EXPOSURE_IDX 3
 123         {
 124                 {
 125                         .id             = V4L2_CID_EXPOSURE,
 126                         .type           = V4L2_CTRL_TYPE_INTEGER,
 127                         .name           = "Exposure",
 128                         .minimum        = 13,
 129                         .maximum        = 0xfff,
 130                         .step           = 1,
 131                         .default_value  = 0x100,
 132                         .flags          = V4L2_CTRL_FLAG_SLIDER
 133                 },
 134                 .set = s5k4aa_set_exposure,
 135                 .get = s5k4aa_get_exposure
 136         },
 137 #define NOISE_SUPP_IDX 4
 138         {
 139                 {
 140                         .id             = V4L2_CID_PRIVATE_BASE,
 141                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
 142                         .name           = "Noise suppression (smoothing)",
 143                         .minimum        = 0,
 144                         .maximum        = 1,
 145                         .step           = 1,
 146                         .default_value  = 1,
 147                 },
 148                         .set = s5k4aa_set_noise,
 149                         .get = s5k4aa_get_noise
 150         },
 151 };
 152
 153 static void s5k4aa_dump_registers(struct sd *sd);
 154
 155 int s5k4aa_probe(struct sd *sd)
 156 {
 157         u8 prod_id[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 158         const u8 expected_prod_id[6] = {0x00, 0x10, 0x00, 0x4b, 0x33, 0x75};
 159         int i, err = 0;
 160         s32 *sensor_settings;
 161
 162         if (force_sensor) {
 163                 if (force_sensor == S5K4AA_SENSOR) {
 164                         info("Forcing a %s sensor", s5k4aa.name);
 165                         goto sensor_found;
 166                 }
 167                 /* If we want to force another sensor, don't try to probe this
 168                  * one */
 169                 return -ENODEV;
 170         }
 171
 172         info("Probing for a s5k4aa sensor");
 173
 174         /* Preinit the sensor */
 175         for (i = 0; i < ARRAY_SIZE(preinit_s5k4aa) && !err; i++) {
 176                 u8 data[2] = {0x00, 0x00};
 177
 178                 switch (preinit_s5k4aa[i][0]) {
 179                 case BRIDGE:
 180                         err = m5602_write_bridge(sd,
 181                                                  preinit_s5k4aa[i][1],
 182                                                  preinit_s5k4aa[i][2]);
 183                         break;
 184
 185                 case SENSOR:
 186                         data[0] = preinit_s5k4aa[i][2];
 187                         err = m5602_write_sensor(sd,
 188                                                   preinit_s5k4aa[i][1],
 189                                                   data, 1);
 190                         break;
 191
 192                 case SENSOR_LONG:
 193                         data[0] = preinit_s5k4aa[i][2];
 194                         data[1] = preinit_s5k4aa[i][3];
 195                         err = m5602_write_sensor(sd,
 196                                                   preinit_s5k4aa[i][1],
 197                                                   data, 2);
 198                         break;
 199                 default:
 200                         info("Invalid stream command, exiting init");
 201                         return -EINVAL;
 202                 }
 203         }
 204
 205         /* Test some registers, but we don't know their exact meaning yet */
 206         if (m5602_read_sensor(sd, 0x00, prod_id, 2))
 207                 return -ENODEV;
 208         if (m5602_read_sensor(sd, 0x02, prod_id+2, 2))
 209                 return -ENODEV;
 210         if (m5602_read_sensor(sd, 0x04, prod_id+4, 2))
 211                 return -ENODEV;
 212
 213         if (memcmp(prod_id, expected_prod_id, sizeof(prod_id)))
 214                 return -ENODEV;
 215         else
 216                 info("Detected a s5k4aa sensor");
 217
 218 sensor_found:
 219         sensor_settings = kmalloc(
 220                 ARRAY_SIZE(s5k4aa_ctrls) * sizeof(s32), GFP_KERNEL);
 221         if (!sensor_settings)
 222                 return -ENOMEM;
 223
 224         sd->gspca_dev.cam.cam_mode = s5k4aa_modes;
 225         sd->gspca_dev.cam.nmodes = ARRAY_SIZE(s5k4aa_modes);
 226         sd->desc->ctrls = s5k4aa_ctrls;
 227         sd->desc->nctrls = ARRAY_SIZE(s5k4aa_ctrls);
 228
 229         for (i = 0; i < ARRAY_SIZE(s5k4aa_ctrls); i++)
 230                 sensor_settings[i] = s5k4aa_ctrls[i].qctrl.default_value;
 231         sd->sensor_priv = sensor_settings;
 232
 233         return 0;
 234 }
 235
 236 int s5k4aa_start(struct sd *sd)
 237 {
 238         int i, err = 0;
 239         u8 data[2];
 240         struct cam *cam = &sd->gspca_dev.cam;
 241
 242         switch (cam->cam_mode[sd->gspca_dev.curr_mode].width) {
 243         case 640:
 244                 PDEBUG(D_V4L2, "Configuring camera for VGA mode");
 245
 246                 for (i = 0; i < ARRAY_SIZE(VGA_s5k4aa); i++) {
 247                         switch (VGA_s5k4aa[i][0]) {
 248                         case BRIDGE:
 249                                 err = m5602_write_bridge(sd,
 250                                                  VGA_s5k4aa[i][1],
 251                                                  VGA_s5k4aa[i][2]);
 252                         break;
 253
 254                         case SENSOR:
 255                                 data[0] = VGA_s5k4aa[i][2];
 256                                 err = m5602_write_sensor(sd,
 257                                                  VGA_s5k4aa[i][1],
 258                                                  data, 1);
 259                         break;
 260
 261                         case SENSOR_LONG:
 262                                 data[0] = VGA_s5k4aa[i][2];
 263                                 data[1] = VGA_s5k4aa[i][3];
 264                                 err = m5602_write_sensor(sd,
 265                                                   VGA_s5k4aa[i][1],
 266                                                   data, 2);
 267                         break;
 268
 269                         default:
 270                                 err("Invalid stream command, exiting init");
 271                                 return -EINVAL;
 272                         }
 273                 }
 274         }
 275         return err;
 276 }
 277
 278 int s5k4aa_init(struct sd *sd)
 279 {
 280         int i, err = 0;
 281         s32 *sensor_settings = sd->sensor_priv;
 282
 283         for (i = 0; i < ARRAY_SIZE(init_s5k4aa) && !err; i++) {
 284                 u8 data[2] = {0x00, 0x00};
 285
 286                 switch (init_s5k4aa[i][0]) {
 287                 case BRIDGE:
 288                         err = m5602_write_bridge(sd,
 289                                 init_s5k4aa[i][1],
 290                                 init_s5k4aa[i][2]);
 291                         break;
 292
 293                 case SENSOR:
 294                         data[0] = init_s5k4aa[i][2];
 295                         err = m5602_write_sensor(sd,
 296                                 init_s5k4aa[i][1], data, 1);
 297                         break;
 298
 299                 case SENSOR_LONG:
 300                         data[0] = init_s5k4aa[i][2];
 301                         data[1] = init_s5k4aa[i][3];
 302                         err = m5602_write_sensor(sd,
 303                                 init_s5k4aa[i][1], data, 2);
 304                         break;
 305                 default:
 306                         info("Invalid stream command, exiting init");
 307                         return -EINVAL;
 308                 }
 309         }
 310
 311         if (dump_sensor)
 312                 s5k4aa_dump_registers(sd);
 313
 314         err = s5k4aa_set_exposure(&sd->gspca_dev,
 315                                    sensor_settings[EXPOSURE_IDX]);
 316         if (err < 0)
 317                 return err;
 318
 319         err = s5k4aa_set_gain(&sd->gspca_dev, sensor_settings[GAIN_IDX]);
 320         if (err < 0)
 321                 return err;
 322
 323         err = s5k4aa_set_noise(&sd->gspca_dev, sensor_settings[NOISE_SUPP_IDX]);
 324         if (err < 0)
 325                 return err;
 326
 327         err = s5k4aa_set_vflip(&sd->gspca_dev, sensor_settings[VFLIP_IDX]);
 328         if (err < 0)
 329                 return err;
 330
 331         return s5k4aa_set_hflip(&sd->gspca_dev, sensor_settings[HFLIP_IDX]);
 332 }
 333
 334 static int s5k4aa_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
 335 {
 336         struct sd *sd = (struct sd *) gspca_dev;
 337         s32 *sensor_settings = sd->sensor_priv;
 338
 339         *val = sensor_settings[EXPOSURE_IDX];
 340         PDEBUG(D_V4L2, "Read exposure %d", *val);
 341
 342         return 0;
 343 }
 344
 345 static int s5k4aa_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
 346 {
 347         struct sd *sd = (struct sd *) gspca_dev;
 348         s32 *sensor_settings = sd->sensor_priv;
 349         u8 data = S5K4AA_PAGE_MAP_2;
 350         int err;
 351
 352         sensor_settings[EXPOSURE_IDX] = val;
 353         PDEBUG(D_V4L2, "Set exposure to %d", val);
 354         err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
 355         if (err < 0)
 356                 return err;
 357         data = (val >> 8) & 0xff;
 358         err = m5602_write_sensor(sd, S5K4AA_EXPOSURE_HI, &data, 1);
 359         if (err < 0)
 360                 return err;
 361         data = val & 0xff;
 362         err = m5602_write_sensor(sd, S5K4AA_EXPOSURE_LO, &data, 1);
 363
 364         return err;
 365 }
 366
 367 static int s5k4aa_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 368 {
 369         struct sd *sd = (struct sd *) gspca_dev;
 370         s32 *sensor_settings = sd->sensor_priv;
 371
 372         *val = sensor_settings[VFLIP_IDX];
 373         PDEBUG(D_V4L2, "Read vertical flip %d", *val);
 374
 375         return 0;
 376 }
 377
 378 static int s5k4aa_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 379 {
 380         struct sd *sd = (struct sd *) gspca_dev;
 381         s32 *sensor_settings = sd->sensor_priv;
 382         u8 data = S5K4AA_PAGE_MAP_2;
 383         int err;
 384
 385         sensor_settings[VFLIP_IDX] = val;
 386
 387         PDEBUG(D_V4L2, "Set vertical flip to %d", val);
 388         err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
 389         if (err < 0)
 390                 return err;
 391         err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
 392         if (err < 0)
 393                 return err;
 394
 395         err = m5602_read_sensor(sd, S5K4AA_READ_MODE, &data, 1);
 396         if (err < 0)
 397                 return err;
 398
 399         if (dmi_check_system(s5k4aa_vflip_dmi_table))
 400                 val = !val;
 401
 402         data = ((data & ~S5K4AA_RM_V_FLIP)
 403                         | ((val & 0x01) << 7));
 404         err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
 405         if (err < 0)
 406                 return err;
 407
 408         if (dmi_check_system(s5k4aa_vflip_dmi_table))
 409                 val = !val;
 410
 411         if (val) {
 412                 err = m5602_read_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
 413                 if (err < 0)
 414                         return err;
 415
 416                 data++;
 417                 err = m5602_write_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
 418         } else {
 419                 err = m5602_read_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
 420                 if (err < 0)
 421                         return err;
 422
 423                 data--;
 424                 err = m5602_write_sensor(sd, S5K4AA_ROWSTART_LO, &data, 1);
 425         }
 426
 427         return err;
 428 }
 429
 430 static int s5k4aa_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
 431 {
 432         struct sd *sd = (struct sd *) gspca_dev;
 433         s32 *sensor_settings = sd->sensor_priv;
 434
 435         *val = sensor_settings[HFLIP_IDX];
 436         PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
 437
 438         return 0;
 439 }
 440
 441 static int s5k4aa_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 442 {
 443         struct sd *sd = (struct sd *) gspca_dev;
 444         s32 *sensor_settings = sd->sensor_priv;
 445         u8 data = S5K4AA_PAGE_MAP_2;
 446         int err;
 447
 448         sensor_settings[HFLIP_IDX] = val;
 449
 450         PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
 451         err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
 452         if (err < 0)
 453                 return err;
 454         err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
 455         if (err < 0)
 456                 return err;
 457
 458         err = m5602_read_sensor(sd, S5K4AA_READ_MODE, &data, 1);
 459         if (err < 0)
 460                 return err;
 461
 462         data = ((data & ~S5K4AA_RM_H_FLIP) | ((val & 0x01) << 6));
 463         err = m5602_write_sensor(sd, S5K4AA_READ_MODE, &data, 1);
 464         if (err < 0)
 465                 return err;
 466
 467         if (val) {
 468                 err = m5602_read_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
 469                 if (err < 0)
 470                         return err;
 471                 data++;
 472                 err = m5602_write_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
 473                 if (err < 0)
 474                         return err;
 475         } else {
 476                 err = m5602_read_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
 477                 if (err < 0)
 478                         return err;
 479                 data--;
 480                 err = m5602_write_sensor(sd, S5K4AA_COLSTART_LO, &data, 1);
 481         }
 482
 483         return err;
 484 }
 485
 486 static int s5k4aa_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 487 {
 488         struct sd *sd = (struct sd *) gspca_dev;
 489         s32 *sensor_settings = sd->sensor_priv;
 490
 491         *val = sensor_settings[GAIN_IDX];
 492         PDEBUG(D_V4L2, "Read gain %d", *val);
 493         return 0;
 494 }
 495
 496 static int s5k4aa_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 497 {
 498         struct sd *sd = (struct sd *) gspca_dev;
 499         s32 *sensor_settings = sd->sensor_priv;
 500         u8 data = S5K4AA_PAGE_MAP_2;
 501         int err;
 502
 503         sensor_settings[GAIN_IDX] = val;
 504
 505         PDEBUG(D_V4L2, "Set gain to %d", val);
 506         err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
 507         if (err < 0)
 508                 return err;
 509
 510         data = val & 0xff;
 511         err = m5602_write_sensor(sd, S5K4AA_GAIN_2, &data, 1);
 512
 513         return err;
 514 }
 515
 516 static int s5k4aa_get_noise(struct gspca_dev *gspca_dev, __s32 *val)
 517 {
 518         struct sd *sd = (struct sd *) gspca_dev;
 519         s32 *sensor_settings = sd->sensor_priv;
 520
 521         *val = sensor_settings[NOISE_SUPP_IDX];
 522         PDEBUG(D_V4L2, "Read noise %d", *val);
 523         return 0;
 524 }
 525
 526 static int s5k4aa_set_noise(struct gspca_dev *gspca_dev, __s32 val)
 527 {
 528         struct sd *sd = (struct sd *) gspca_dev;
 529         s32 *sensor_settings = sd->sensor_priv;
 530         u8 data = S5K4AA_PAGE_MAP_2;
 531         int err;
 532
 533         sensor_settings[NOISE_SUPP_IDX] = val;
 534
 535         PDEBUG(D_V4L2, "Set noise to %d", val);
 536         err = m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &data, 1);
 537         if (err < 0)
 538                 return err;
 539
 540         data = val & 0x01;
 541         return m5602_write_sensor(sd, S5K4AA_NOISE_SUPP, &data, 1);
 542 }
 543
 544 void s5k4aa_disconnect(struct sd *sd)
 545 {
 546         sd->sensor = NULL;
 547         kfree(sd->sensor_priv);
 548 }
 549
 550 static void s5k4aa_dump_registers(struct sd *sd)
 551 {
 552         int address;
 553         u8 page, old_page;
 554         m5602_read_sensor(sd, S5K4AA_PAGE_MAP, &old_page, 1);
 555         for (page = 0; page < 16; page++) {
 556                 m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &page, 1);
 557                 info("Dumping the s5k4aa register state for page 0x%x", page);
 558                 for (address = 0; address <= 0xff; address++) {
 559                         u8 value = 0;
 560                         m5602_read_sensor(sd, address, &value, 1);
 561                         info("register 0x%x contains 0x%x",
 562                              address, value);
 563                 }
 564         }
 565         info("s5k4aa register state dump complete");
 566
 567         for (page = 0; page < 16; page++) {
 568                 m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &page, 1);
 569                 info("Probing for which registers that are "
 570                      "read/write for page 0x%x", page);
 571                 for (address = 0; address <= 0xff; address++) {
 572                         u8 old_value, ctrl_value, test_value = 0xff;
 573
 574                         m5602_read_sensor(sd, address, &old_value, 1);
 575                         m5602_write_sensor(sd, address, &test_value, 1);
 576                         m5602_read_sensor(sd, address, &ctrl_value, 1);
 577
 578                         if (ctrl_value == test_value)
 579                                 info("register 0x%x is writeable", address);
 580                         else
 581                                 info("register 0x%x is read only", address);
 582
 583                         /* Restore original value */
 584                         m5602_write_sensor(sd, address, &old_value, 1);
 585                 }
 586         }
 587         info("Read/write register probing complete");
 588         m5602_write_sensor(sd, S5K4AA_PAGE_MAP, &old_page, 1);
 589 }