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