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