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

   1 /*
   2  * Driver for the mt9m111 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_mt9m111.h"
  20
  21 static int mt9m111_set_vflip(struct gspca_dev *gspca_dev, __s32 val);
  22 static int mt9m111_get_vflip(struct gspca_dev *gspca_dev, __s32 *val);
  23 static int mt9m111_get_hflip(struct gspca_dev *gspca_dev, __s32 *val);
  24 static int mt9m111_set_hflip(struct gspca_dev *gspca_dev, __s32 val);
  25 static int mt9m111_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
  26 static int mt9m111_set_gain(struct gspca_dev *gspca_dev, __s32 val);
  27 static int mt9m111_set_auto_white_balance(struct gspca_dev *gspca_dev,
  28                                          __s32 val);
  29 static int mt9m111_get_auto_white_balance(struct gspca_dev *gspca_dev,
  30                                           __s32 *val);
  31 static int mt9m111_get_green_balance(struct gspca_dev *gspca_dev, __s32 *val);
  32 static int mt9m111_set_green_balance(struct gspca_dev *gspca_dev, __s32 val);
  33 static int mt9m111_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val);
  34 static int mt9m111_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val);
  35 static int mt9m111_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val);
  36 static int mt9m111_set_red_balance(struct gspca_dev *gspca_dev, __s32 val);
  37
  38 static struct v4l2_pix_format mt9m111_modes[] = {
  39         {
  40                 640,
  41                 480,
  42                 V4L2_PIX_FMT_SBGGR8,
  43                 V4L2_FIELD_NONE,
  44                 .sizeimage = 640 * 480,
  45                 .bytesperline = 640,
  46                 .colorspace = V4L2_COLORSPACE_SRGB,
  47                 .priv = 0
  48         }
  49 };
  50
  51 const static struct ctrl mt9m111_ctrls[] = {
  52 #define VFLIP_IDX 0
  53         {
  54                 {
  55                         .id             = V4L2_CID_VFLIP,
  56                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
  57                         .name           = "vertical flip",
  58                         .minimum        = 0,
  59                         .maximum        = 1,
  60                         .step           = 1,
  61                         .default_value  = 0
  62                 },
  63                 .set = mt9m111_set_vflip,
  64                 .get = mt9m111_get_vflip
  65         },
  66 #define HFLIP_IDX 1
  67         {
  68                 {
  69                         .id             = V4L2_CID_HFLIP,
  70                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
  71                         .name           = "horizontal flip",
  72                         .minimum        = 0,
  73                         .maximum        = 1,
  74                         .step           = 1,
  75                         .default_value  = 0
  76                 },
  77                 .set = mt9m111_set_hflip,
  78                 .get = mt9m111_get_hflip
  79         },
  80 #define GAIN_IDX 2
  81         {
  82                 {
  83                         .id             = V4L2_CID_GAIN,
  84                         .type           = V4L2_CTRL_TYPE_INTEGER,
  85                         .name           = "gain",
  86                         .minimum        = 0,
  87                         .maximum        = (INITIAL_MAX_GAIN - 1) * 2 * 2 * 2,
  88                         .step           = 1,
  89                         .default_value  = DEFAULT_GAIN,
  90                         .flags          = V4L2_CTRL_FLAG_SLIDER
  91                 },
  92                 .set = mt9m111_set_gain,
  93                 .get = mt9m111_get_gain
  94         },
  95 #define AUTO_WHITE_BALANCE_IDX 3
  96         {
  97                 {
  98                         .id             = V4L2_CID_AUTO_WHITE_BALANCE,
  99                         .type           = V4L2_CTRL_TYPE_BOOLEAN,
 100                         .name           = "auto white balance",
 101                         .minimum        = 0,
 102                         .maximum        = 1,
 103                         .step           = 1,
 104                         .default_value  = 0,
 105                 },
 106                 .set = mt9m111_set_auto_white_balance,
 107                 .get = mt9m111_get_auto_white_balance
 108         },
 109 #define GREEN_BALANCE_IDX 4
 110         {
 111                 {
 112                         .id             = M5602_V4L2_CID_GREEN_BALANCE,
 113                         .type           = V4L2_CTRL_TYPE_INTEGER,
 114                         .name           = "green balance",
 115                         .minimum        = 0x00,
 116                         .maximum        = 0x7ff,
 117                         .step           = 0x1,
 118                         .default_value  = MT9M111_GREEN_GAIN_DEFAULT,
 119                         .flags          = V4L2_CTRL_FLAG_SLIDER
 120                 },
 121                 .set = mt9m111_set_green_balance,
 122                 .get = mt9m111_get_green_balance
 123         },
 124 #define BLUE_BALANCE_IDX 5
 125         {
 126                 {
 127                         .id             = V4L2_CID_BLUE_BALANCE,
 128                         .type           = V4L2_CTRL_TYPE_INTEGER,
 129                         .name           = "blue balance",
 130                         .minimum        = 0x00,
 131                         .maximum        = 0x7ff,
 132                         .step           = 0x1,
 133                         .default_value  = MT9M111_BLUE_GAIN_DEFAULT,
 134                         .flags          = V4L2_CTRL_FLAG_SLIDER
 135                 },
 136                 .set = mt9m111_set_blue_balance,
 137                 .get = mt9m111_get_blue_balance
 138         },
 139 #define RED_BALANCE_IDX 5
 140         {
 141                 {
 142                         .id             = V4L2_CID_RED_BALANCE,
 143                         .type           = V4L2_CTRL_TYPE_INTEGER,
 144                         .name           = "red balance",
 145                         .minimum        = 0x00,
 146                         .maximum        = 0x7ff,
 147                         .step           = 0x1,
 148                         .default_value  = MT9M111_RED_GAIN_DEFAULT,
 149                         .flags          = V4L2_CTRL_FLAG_SLIDER
 150                 },
 151                 .set = mt9m111_set_red_balance,
 152                 .get = mt9m111_get_red_balance
 153         },
 154 };
 155
 156 static void mt9m111_dump_registers(struct sd *sd);
 157
 158 int mt9m111_probe(struct sd *sd)
 159 {
 160         u8 data[2] = {0x00, 0x00};
 161         int i;
 162         s32 *sensor_settings;
 163
 164         if (force_sensor) {
 165                 if (force_sensor == MT9M111_SENSOR) {
 166                         info("Forcing a %s sensor", mt9m111.name);
 167                         goto sensor_found;
 168                 }
 169                 /* If we want to force another sensor, don't try to probe this
 170                  * one */
 171                 return -ENODEV;
 172         }
 173
 174         info("Probing for a mt9m111 sensor");
 175
 176         /* Do the preinit */
 177         for (i = 0; i < ARRAY_SIZE(preinit_mt9m111); i++) {
 178                 if (preinit_mt9m111[i][0] == BRIDGE) {
 179                         m5602_write_bridge(sd,
 180                                 preinit_mt9m111[i][1],
 181                                 preinit_mt9m111[i][2]);
 182                 } else {
 183                         data[0] = preinit_mt9m111[i][2];
 184                         data[1] = preinit_mt9m111[i][3];
 185                         m5602_write_sensor(sd,
 186                                 preinit_mt9m111[i][1], data, 2);
 187                 }
 188         }
 189
 190         if (m5602_read_sensor(sd, MT9M111_SC_CHIPVER, data, 2))
 191                 return -ENODEV;
 192
 193         if ((data[0] == 0x14) && (data[1] == 0x3a)) {
 194                 info("Detected a mt9m111 sensor");
 195                 goto sensor_found;
 196         }
 197
 198         return -ENODEV;
 199
 200 sensor_found:
 201         sensor_settings = kmalloc(ARRAY_SIZE(mt9m111_ctrls) * sizeof(s32),
 202                                   GFP_KERNEL);
 203         if (!sensor_settings)
 204                 return -ENOMEM;
 205
 206         sd->gspca_dev.cam.cam_mode = mt9m111_modes;
 207         sd->gspca_dev.cam.nmodes = ARRAY_SIZE(mt9m111_modes);
 208         sd->desc->ctrls = mt9m111_ctrls;
 209         sd->desc->nctrls = ARRAY_SIZE(mt9m111_ctrls);
 210
 211         for (i = 0; i < ARRAY_SIZE(mt9m111_ctrls); i++)
 212                 sensor_settings[i] = mt9m111_ctrls[i].qctrl.default_value;
 213         sd->sensor_priv = sensor_settings;
 214
 215         return 0;
 216 }
 217
 218 int mt9m111_init(struct sd *sd)
 219 {
 220         int i, err = 0;
 221         s32 *sensor_settings = sd->sensor_priv;
 222
 223         /* Init the sensor */
 224         for (i = 0; i < ARRAY_SIZE(init_mt9m111) && !err; i++) {
 225                 u8 data[2];
 226
 227                 if (init_mt9m111[i][0] == BRIDGE) {
 228                         err = m5602_write_bridge(sd,
 229                                 init_mt9m111[i][1],
 230                                 init_mt9m111[i][2]);
 231                 } else {
 232                         data[0] = init_mt9m111[i][2];
 233                         data[1] = init_mt9m111[i][3];
 234                         err = m5602_write_sensor(sd,
 235                                 init_mt9m111[i][1], data, 2);
 236                 }
 237         }
 238
 239         if (dump_sensor)
 240                 mt9m111_dump_registers(sd);
 241
 242         err = mt9m111_set_vflip(&sd->gspca_dev, sensor_settings[VFLIP_IDX]);
 243         if (err < 0)
 244                 return err;
 245
 246         err = mt9m111_set_hflip(&sd->gspca_dev, sensor_settings[HFLIP_IDX]);
 247         if (err < 0)
 248                 return err;
 249
 250         err = mt9m111_set_green_balance(&sd->gspca_dev,
 251                                          sensor_settings[GREEN_BALANCE_IDX]);
 252         if (err < 0)
 253                 return err;
 254
 255         err = mt9m111_set_blue_balance(&sd->gspca_dev,
 256                                          sensor_settings[BLUE_BALANCE_IDX]);
 257         if (err < 0)
 258                 return err;
 259
 260         err = mt9m111_set_red_balance(&sd->gspca_dev,
 261                                         sensor_settings[RED_BALANCE_IDX]);
 262         if (err < 0)
 263                 return err;
 264
 265         return mt9m111_set_gain(&sd->gspca_dev, sensor_settings[GAIN_IDX]);
 266 }
 267
 268 int mt9m111_start(struct sd *sd)
 269 {
 270         int i, err = 0;
 271         u8 data[2];
 272         struct cam *cam = &sd->gspca_dev.cam;
 273         s32 *sensor_settings = sd->sensor_priv;
 274
 275         int width = cam->cam_mode[sd->gspca_dev.curr_mode].width - 1;
 276         int height = cam->cam_mode[sd->gspca_dev.curr_mode].height;
 277
 278         for (i = 0; i < ARRAY_SIZE(start_mt9m111) && !err; i++) {
 279                 if (start_mt9m111[i][0] == BRIDGE) {
 280                         err = m5602_write_bridge(sd,
 281                                 start_mt9m111[i][1],
 282                                 start_mt9m111[i][2]);
 283                 } else {
 284                         data[0] = start_mt9m111[i][2];
 285                         data[1] = start_mt9m111[i][3];
 286                         err = m5602_write_sensor(sd,
 287                                 start_mt9m111[i][1], data, 2);
 288                 }
 289         }
 290         if (err < 0)
 291                 return err;
 292
 293         err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, (height >> 8) & 0xff);
 294         if (err < 0)
 295                 return err;
 296
 297         err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, (height & 0xff));
 298         if (err < 0)
 299                 return err;
 300
 301         for (i = 0; i < 2 && !err; i++)
 302                 err = m5602_write_bridge(sd, M5602_XB_VSYNC_PARA, 0);
 303         if (err < 0)
 304                 return err;
 305
 306         err = m5602_write_bridge(sd, M5602_XB_SIG_INI, 0);
 307         if (err < 0)
 308                 return err;
 309
 310         err = m5602_write_bridge(sd, M5602_XB_SIG_INI, 2);
 311         if (err < 0)
 312                 return err;
 313
 314         for (i = 0; i < 2 && !err; i++)
 315                 err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA, 0);
 316         if (err < 0)
 317                 return err;
 318
 319         err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA,
 320                                  (width >> 8) & 0xff);
 321         if (err < 0)
 322                 return err;
 323
 324         err = m5602_write_bridge(sd, M5602_XB_HSYNC_PARA, width & 0xff);
 325         if (err < 0)
 326                 return err;
 327
 328         err = m5602_write_bridge(sd, M5602_XB_SIG_INI, 0);
 329         if (err < 0)
 330                 return err;
 331
 332         switch (width) {
 333         case 640:
 334                 PDEBUG(D_V4L2, "Configuring camera for VGA mode");
 335                 data[0] = MT9M111_RMB_OVER_SIZED;
 336                 data[1] = MT9M111_RMB_ROW_SKIP_2X |
 337                           MT9M111_RMB_COLUMN_SKIP_2X |
 338                           (sensor_settings[VFLIP_IDX] << 0) |
 339                           (sensor_settings[HFLIP_IDX] << 1);
 340
 341                 err = m5602_write_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B, data, 2);
 342                 break;
 343
 344         case 320:
 345                 PDEBUG(D_V4L2, "Configuring camera for QVGA mode");
 346                 data[0] = MT9M111_RMB_OVER_SIZED;
 347                 data[1] = MT9M111_RMB_ROW_SKIP_4X |
 348                                 MT9M111_RMB_COLUMN_SKIP_4X |
 349                                 (sensor_settings[VFLIP_IDX] << 0) |
 350                                 (sensor_settings[HFLIP_IDX] << 1);
 351                 err = m5602_write_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B, data, 2);
 352                 break;
 353         }
 354         return err;
 355 }
 356
 357 void mt9m111_disconnect(struct sd *sd)
 358 {
 359         sd->sensor = NULL;
 360         kfree(sd->sensor_priv);
 361 }
 362
 363 static int mt9m111_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
 364 {
 365         struct sd *sd = (struct sd *) gspca_dev;
 366         s32 *sensor_settings = sd->sensor_priv;
 367
 368         *val = sensor_settings[VFLIP_IDX];
 369         PDEBUG(D_V4L2, "Read vertical flip %d", *val);
 370
 371         return 0;
 372 }
 373
 374 static int mt9m111_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
 375 {
 376         int err;
 377         u8 data[2] = {0x00, 0x00};
 378         struct sd *sd = (struct sd *) gspca_dev;
 379         s32 *sensor_settings = sd->sensor_priv;
 380
 381         PDEBUG(D_V4L2, "Set vertical flip to %d", val);
 382
 383         sensor_settings[VFLIP_IDX] = val;
 384
 385         /* The mt9m111 is flipped by default */
 386         val = !val;
 387
 388         /* Set the correct page map */
 389         err = m5602_write_sensor(sd, MT9M111_PAGE_MAP, data, 2);
 390         if (err < 0)
 391                 return err;
 392
 393         err = m5602_read_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B, data, 2);
 394         if (err < 0)
 395                 return err;
 396
 397         data[1] = (data[1] & 0xfe) | val;
 398         err = m5602_write_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B,
 399                                    data, 2);
 400         return err;
 401 }
 402
 403 static int mt9m111_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
 404 {
 405         struct sd *sd = (struct sd *) gspca_dev;
 406         s32 *sensor_settings = sd->sensor_priv;
 407
 408         *val = sensor_settings[HFLIP_IDX];
 409         PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
 410
 411         return 0;
 412 }
 413
 414 static int mt9m111_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
 415 {
 416         int err;
 417         u8 data[2] = {0x00, 0x00};
 418         struct sd *sd = (struct sd *) gspca_dev;
 419         s32 *sensor_settings = sd->sensor_priv;
 420
 421         PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
 422
 423         sensor_settings[HFLIP_IDX] = val;
 424
 425         /* The mt9m111 is flipped by default */
 426         val = !val;
 427
 428         /* Set the correct page map */
 429         err = m5602_write_sensor(sd, MT9M111_PAGE_MAP, data, 2);
 430         if (err < 0)
 431                 return err;
 432
 433         err = m5602_read_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B, data, 2);
 434         if (err < 0)
 435                 return err;
 436
 437         data[1] = (data[1] & 0xfd) | ((val << 1) & 0x02);
 438         err = m5602_write_sensor(sd, MT9M111_SC_R_MODE_CONTEXT_B,
 439                                         data, 2);
 440         return err;
 441 }
 442
 443 static int mt9m111_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
 444 {
 445         struct sd *sd = (struct sd *) gspca_dev;
 446         s32 *sensor_settings = sd->sensor_priv;
 447
 448         *val = sensor_settings[GAIN_IDX];
 449         PDEBUG(D_V4L2, "Read gain %d", *val);
 450
 451         return 0;
 452 }
 453
 454 static int mt9m111_set_auto_white_balance(struct gspca_dev *gspca_dev,
 455                                           __s32 val)
 456 {
 457         struct sd *sd = (struct sd *) gspca_dev;
 458         s32 *sensor_settings = sd->sensor_priv;
 459         int err;
 460         u8 data[2];
 461
 462         err = m5602_read_sensor(sd, MT9M111_CP_OPERATING_MODE_CTL, data, 2);
 463         if (err < 0)
 464                 return err;
 465
 466         sensor_settings[AUTO_WHITE_BALANCE_IDX] = val & 0x01;
 467         data[1] = ((data[1] & 0xfd) | ((val & 0x01) << 1));
 468
 469         err = m5602_write_sensor(sd, MT9M111_CP_OPERATING_MODE_CTL, data, 2);
 470
 471         PDEBUG(D_V4L2, "Set auto white balance %d", val);
 472         return err;
 473 }
 474
 475 static int mt9m111_get_auto_white_balance(struct gspca_dev *gspca_dev,
 476                                           __s32 *val) {
 477         struct sd *sd = (struct sd *) gspca_dev;
 478         s32 *sensor_settings = sd->sensor_priv;
 479
 480         *val = sensor_settings[AUTO_WHITE_BALANCE_IDX];
 481         PDEBUG(D_V4L2, "Read auto white balance %d", *val);
 482         return 0;
 483 }
 484
 485 static int mt9m111_set_gain(struct gspca_dev *gspca_dev, __s32 val)
 486 {
 487         int err, tmp;
 488         u8 data[2] = {0x00, 0x00};
 489         struct sd *sd = (struct sd *) gspca_dev;
 490         s32 *sensor_settings = sd->sensor_priv;
 491
 492         sensor_settings[GAIN_IDX] = val;
 493
 494         /* Set the correct page map */
 495         err = m5602_write_sensor(sd, MT9M111_PAGE_MAP, data, 2);
 496         if (err < 0)
 497                 return err;
 498
 499         if (val >= INITIAL_MAX_GAIN * 2 * 2 * 2)
 500                 return -EINVAL;
 501
 502         if ((val >= INITIAL_MAX_GAIN * 2 * 2) &&
 503             (val < (INITIAL_MAX_GAIN - 1) * 2 * 2 * 2))
 504                 tmp = (1 << 10) | (val << 9) |
 505                                 (val << 8) | (val / 8);
 506         else if ((val >= INITIAL_MAX_GAIN * 2) &&
 507                  (val <  INITIAL_MAX_GAIN * 2 * 2))
 508                 tmp = (1 << 9) | (1 << 8) | (val / 4);
 509         else if ((val >= INITIAL_MAX_GAIN) &&
 510                  (val < INITIAL_MAX_GAIN * 2))
 511                 tmp = (1 << 8) | (val / 2);
 512         else
 513                 tmp = val;
 514
 515         data[1] = (tmp & 0xff);
 516         data[0] = (tmp & 0xff00) >> 8;
 517         PDEBUG(D_V4L2, "tmp=%d, data[1]=%d, data[0]=%d", tmp,
 518                data[1], data[0]);
 519
 520         err = m5602_write_sensor(sd, MT9M111_SC_GLOBAL_GAIN,
 521                                    data, 2);
 522
 523         return err;
 524 }
 525
 526 static int mt9m111_set_green_balance(struct gspca_dev *gspca_dev, __s32 val)
 527 {
 528         int err;
 529         u8 data[2];
 530         struct sd *sd = (struct sd *) gspca_dev;
 531         s32 *sensor_settings = sd->sensor_priv;
 532
 533         sensor_settings[GREEN_BALANCE_IDX] = val;
 534         data[1] = (val & 0xff);
 535         data[0] = (val & 0xff00) >> 8;
 536
 537         PDEBUG(D_V4L2, "Set green balance %d", val);
 538         err = m5602_write_sensor(sd, MT9M111_SC_GREEN_1_GAIN,
 539                                  data, 2);
 540         if (err < 0)
 541                 return err;
 542
 543         return m5602_write_sensor(sd, MT9M111_SC_GREEN_2_GAIN,
 544                                   data, 2);
 545 }
 546
 547 static int mt9m111_get_green_balance(struct gspca_dev *gspca_dev, __s32 *val)
 548 {
 549         struct sd *sd = (struct sd *) gspca_dev;
 550         s32 *sensor_settings = sd->sensor_priv;
 551
 552         *val = sensor_settings[GREEN_BALANCE_IDX];
 553         PDEBUG(D_V4L2, "Read green balance %d", *val);
 554         return 0;
 555 }
 556
 557 static int mt9m111_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
 558 {
 559         u8 data[2];
 560         struct sd *sd = (struct sd *) gspca_dev;
 561         s32 *sensor_settings = sd->sensor_priv;
 562
 563         sensor_settings[BLUE_BALANCE_IDX] = val;
 564         data[1] = (val & 0xff);
 565         data[0] = (val & 0xff00) >> 8;
 566
 567         PDEBUG(D_V4L2, "Set blue balance %d", val);
 568
 569         return m5602_write_sensor(sd, MT9M111_SC_BLUE_GAIN,
 570                                   data, 2);
 571 }
 572
 573 static int mt9m111_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
 574 {
 575         struct sd *sd = (struct sd *) gspca_dev;
 576         s32 *sensor_settings = sd->sensor_priv;
 577
 578         *val = sensor_settings[BLUE_BALANCE_IDX];
 579         PDEBUG(D_V4L2, "Read blue balance %d", *val);
 580         return 0;
 581 }
 582
 583 static int mt9m111_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
 584 {
 585         u8 data[2];
 586         struct sd *sd = (struct sd *) gspca_dev;
 587         s32 *sensor_settings = sd->sensor_priv;
 588
 589         sensor_settings[RED_BALANCE_IDX] = val;
 590         data[1] = (val & 0xff);
 591         data[0] = (val & 0xff00) >> 8;
 592
 593         PDEBUG(D_V4L2, "Set red balance %d", val);
 594
 595         return m5602_write_sensor(sd, MT9M111_SC_RED_GAIN,
 596                                   data, 2);
 597 }
 598
 599 static int mt9m111_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
 600 {
 601         struct sd *sd = (struct sd *) gspca_dev;
 602         s32 *sensor_settings = sd->sensor_priv;
 603
 604         *val = sensor_settings[RED_BALANCE_IDX];
 605         PDEBUG(D_V4L2, "Read red balance %d", *val);
 606         return 0;
 607 }
 608
 609 static void mt9m111_dump_registers(struct sd *sd)
 610 {
 611         u8 address, value[2] = {0x00, 0x00};
 612
 613         info("Dumping the mt9m111 register state");
 614
 615         info("Dumping the mt9m111 sensor core registers");
 616         value[1] = MT9M111_SENSOR_CORE;
 617         m5602_write_sensor(sd, MT9M111_PAGE_MAP, value, 2);
 618         for (address = 0; address < 0xff; address++) {
 619                 m5602_read_sensor(sd, address, value, 2);
 620                 info("register 0x%x contains 0x%x%x",
 621                      address, value[0], value[1]);
 622         }
 623
 624         info("Dumping the mt9m111 color pipeline registers");
 625         value[1] = MT9M111_COLORPIPE;
 626         m5602_write_sensor(sd, MT9M111_PAGE_MAP, value, 2);
 627         for (address = 0; address < 0xff; address++) {
 628                 m5602_read_sensor(sd, address, value, 2);
 629                 info("register 0x%x contains 0x%x%x",
 630                      address, value[0], value[1]);
 631         }
 632
 633         info("Dumping the mt9m111 camera control registers");
 634         value[1] = MT9M111_CAMERA_CONTROL;
 635         m5602_write_sensor(sd, MT9M111_PAGE_MAP, value, 2);
 636         for (address = 0; address < 0xff; address++) {
 637                 m5602_read_sensor(sd, address, value, 2);
 638                 info("register 0x%x contains 0x%x%x",
 639                      address, value[0], value[1]);
 640         }
 641
 642         info("mt9m111 register state dump complete");
 643 }