1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Support for GalaxyCore GC0310 VGA camera sensor. 4 * 5 * Copyright (c) 2013 Intel Corporation. All Rights Reserved. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 */ 17 18 #include <linux/module.h> 19 #include <linux/types.h> 20 #include <linux/kernel.h> 21 #include <linux/mm.h> 22 #include <linux/string.h> 23 #include <linux/errno.h> 24 #include <linux/init.h> 25 #include <linux/kmod.h> 26 #include <linux/device.h> 27 #include <linux/delay.h> 28 #include <linux/slab.h> 29 #include <linux/i2c.h> 30 #include <linux/moduleparam.h> 31 #include <linux/pm_runtime.h> 32 #include <media/v4l2-device.h> 33 #include <linux/io.h> 34 #include "../include/linux/atomisp_gmin_platform.h" 35 36 #include "gc0310.h" 37 38 /* 39 * gc0310_write_reg_array - Initializes a list of GC0310 registers 40 * @client: i2c driver client structure 41 * @reglist: list of registers to be written 42 * @count: number of register, value pairs in the list 43 */ 44 static int gc0310_write_reg_array(struct i2c_client *client, 45 const struct gc0310_reg *reglist, int count) 46 { 47 int i, err; 48 49 for (i = 0; i < count; i++) { 50 err = i2c_smbus_write_byte_data(client, reglist[i].reg, reglist[i].val); 51 if (err) { 52 dev_err(&client->dev, "write error: wrote 0x%x to offset 0x%x error %d", 53 reglist[i].val, reglist[i].reg, err); 54 return err; 55 } 56 } 57 58 return 0; 59 } 60 61 static int gc0310_exposure_set(struct gc0310_device *dev, u32 exp) 62 { 63 struct i2c_client *client = v4l2_get_subdevdata(&dev->sd); 64 65 return i2c_smbus_write_word_swapped(client, GC0310_AEC_PK_EXPO_H, exp); 66 } 67 68 static int gc0310_gain_set(struct gc0310_device *dev, u32 gain) 69 { 70 struct i2c_client *client = v4l2_get_subdevdata(&dev->sd); 71 u8 again, dgain; 72 int ret; 73 74 /* Taken from original driver, this never sets dgain lower then 32? */ 75 76 /* Change 0 - 95 to 32 - 127 */ 77 gain += 32; 78 79 if (gain < 64) { 80 again = 0x0; /* sqrt(2) */ 81 dgain = gain; 82 } else { 83 again = 0x2; /* 2 * sqrt(2) */ 84 dgain = gain / 2; 85 } 86 87 ret = i2c_smbus_write_byte_data(client, GC0310_AGC_ADJ, again); 88 if (ret) 89 return ret; 90 91 return i2c_smbus_write_byte_data(client, GC0310_DGC_ADJ, dgain); 92 } 93 94 static int gc0310_s_ctrl(struct v4l2_ctrl *ctrl) 95 { 96 struct gc0310_device *dev = 97 container_of(ctrl->handler, struct gc0310_device, ctrls.handler); 98 int ret; 99 100 /* Only apply changes to the controls if the device is powered up */ 101 if (!pm_runtime_get_if_in_use(dev->sd.dev)) 102 return 0; 103 104 switch (ctrl->id) { 105 case V4L2_CID_EXPOSURE: 106 ret = gc0310_exposure_set(dev, ctrl->val); 107 break; 108 case V4L2_CID_GAIN: 109 ret = gc0310_gain_set(dev, ctrl->val); 110 break; 111 default: 112 ret = -EINVAL; 113 break; 114 } 115 116 pm_runtime_put(dev->sd.dev); 117 return ret; 118 } 119 120 static const struct v4l2_ctrl_ops ctrl_ops = { 121 .s_ctrl = gc0310_s_ctrl, 122 }; 123 124 static int power_ctrl(struct v4l2_subdev *sd, bool flag) 125 { 126 int ret = 0; 127 struct gc0310_device *dev = to_gc0310_sensor(sd); 128 129 if (!dev || !dev->platform_data) 130 return -ENODEV; 131 132 if (flag) { 133 /* The upstream module driver (written to Crystal 134 * Cove) had this logic to pulse the rails low first. 135 * This appears to break things on the MRD7 with the 136 * X-Powers PMIC... 137 * 138 * ret = dev->platform_data->v1p8_ctrl(sd, 0); 139 * ret |= dev->platform_data->v2p8_ctrl(sd, 0); 140 * mdelay(50); 141 */ 142 ret |= dev->platform_data->v1p8_ctrl(sd, 1); 143 ret |= dev->platform_data->v2p8_ctrl(sd, 1); 144 usleep_range(10000, 15000); 145 } 146 147 if (!flag || ret) { 148 ret |= dev->platform_data->v1p8_ctrl(sd, 0); 149 ret |= dev->platform_data->v2p8_ctrl(sd, 0); 150 } 151 return ret; 152 } 153 154 static int gpio_ctrl(struct v4l2_subdev *sd, bool flag) 155 { 156 int ret; 157 struct gc0310_device *dev = to_gc0310_sensor(sd); 158 159 if (!dev || !dev->platform_data) 160 return -ENODEV; 161 162 /* GPIO0 == "reset" (active low), GPIO1 == "power down" */ 163 if (flag) { 164 /* Pulse reset, then release power down */ 165 ret = dev->platform_data->gpio0_ctrl(sd, 0); 166 usleep_range(5000, 10000); 167 ret |= dev->platform_data->gpio0_ctrl(sd, 1); 168 usleep_range(10000, 15000); 169 ret |= dev->platform_data->gpio1_ctrl(sd, 0); 170 usleep_range(10000, 15000); 171 } else { 172 ret = dev->platform_data->gpio1_ctrl(sd, 1); 173 ret |= dev->platform_data->gpio0_ctrl(sd, 0); 174 } 175 return ret; 176 } 177 178 static int power_up(struct v4l2_subdev *sd) 179 { 180 struct gc0310_device *dev = to_gc0310_sensor(sd); 181 struct i2c_client *client = v4l2_get_subdevdata(sd); 182 int ret; 183 184 if (!dev->platform_data) { 185 dev_err(&client->dev, 186 "no camera_sensor_platform_data"); 187 return -ENODEV; 188 } 189 190 /* power control */ 191 ret = power_ctrl(sd, 1); 192 if (ret) 193 goto fail_power; 194 195 /* flis clock control */ 196 ret = dev->platform_data->flisclk_ctrl(sd, 1); 197 if (ret) 198 goto fail_clk; 199 200 /* gpio ctrl */ 201 ret = gpio_ctrl(sd, 1); 202 if (ret) { 203 ret = gpio_ctrl(sd, 1); 204 if (ret) 205 goto fail_gpio; 206 } 207 208 msleep(100); 209 210 return 0; 211 212 fail_gpio: 213 dev->platform_data->flisclk_ctrl(sd, 0); 214 fail_clk: 215 power_ctrl(sd, 0); 216 fail_power: 217 dev_err(&client->dev, "sensor power-up failed\n"); 218 219 return ret; 220 } 221 222 static int power_down(struct v4l2_subdev *sd) 223 { 224 struct gc0310_device *dev = to_gc0310_sensor(sd); 225 struct i2c_client *client = v4l2_get_subdevdata(sd); 226 int ret = 0; 227 228 if (!dev->platform_data) { 229 dev_err(&client->dev, 230 "no camera_sensor_platform_data"); 231 return -ENODEV; 232 } 233 234 /* gpio ctrl */ 235 ret = gpio_ctrl(sd, 0); 236 if (ret) { 237 ret = gpio_ctrl(sd, 0); 238 if (ret) 239 dev_err(&client->dev, "gpio failed 2\n"); 240 } 241 242 ret = dev->platform_data->flisclk_ctrl(sd, 0); 243 if (ret) 244 dev_err(&client->dev, "flisclk failed\n"); 245 246 /* power control */ 247 ret = power_ctrl(sd, 0); 248 if (ret) 249 dev_err(&client->dev, "vprog failed.\n"); 250 251 return ret; 252 } 253 254 static struct v4l2_mbus_framefmt * 255 gc0310_get_pad_format(struct gc0310_device *dev, 256 struct v4l2_subdev_state *state, 257 unsigned int pad, enum v4l2_subdev_format_whence which) 258 { 259 if (which == V4L2_SUBDEV_FORMAT_TRY) 260 return v4l2_subdev_get_try_format(&dev->sd, state, pad); 261 262 return &dev->mode.fmt; 263 } 264 265 /* The GC0310 currently only supports 1 fixed fmt */ 266 static void gc0310_fill_format(struct v4l2_mbus_framefmt *fmt) 267 { 268 memset(fmt, 0, sizeof(*fmt)); 269 fmt->width = GC0310_NATIVE_WIDTH; 270 fmt->height = GC0310_NATIVE_HEIGHT; 271 fmt->field = V4L2_FIELD_NONE; 272 fmt->code = MEDIA_BUS_FMT_SGRBG8_1X8; 273 } 274 275 static int gc0310_set_fmt(struct v4l2_subdev *sd, 276 struct v4l2_subdev_state *sd_state, 277 struct v4l2_subdev_format *format) 278 { 279 struct gc0310_device *dev = to_gc0310_sensor(sd); 280 struct v4l2_mbus_framefmt *fmt; 281 282 fmt = gc0310_get_pad_format(dev, sd_state, format->pad, format->which); 283 gc0310_fill_format(fmt); 284 285 format->format = *fmt; 286 return 0; 287 } 288 289 static int gc0310_get_fmt(struct v4l2_subdev *sd, 290 struct v4l2_subdev_state *sd_state, 291 struct v4l2_subdev_format *format) 292 { 293 struct gc0310_device *dev = to_gc0310_sensor(sd); 294 struct v4l2_mbus_framefmt *fmt; 295 296 fmt = gc0310_get_pad_format(dev, sd_state, format->pad, format->which); 297 format->format = *fmt; 298 return 0; 299 } 300 301 static int gc0310_detect(struct i2c_client *client) 302 { 303 struct i2c_adapter *adapter = client->adapter; 304 int ret; 305 306 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) 307 return -ENODEV; 308 309 ret = i2c_smbus_read_word_swapped(client, GC0310_SC_CMMN_CHIP_ID_H); 310 if (ret < 0) { 311 dev_err(&client->dev, "read sensor_id failed: %d\n", ret); 312 return -ENODEV; 313 } 314 315 dev_dbg(&client->dev, "sensor ID = 0x%x\n", ret); 316 317 if (ret != GC0310_ID) { 318 dev_err(&client->dev, "sensor ID error, read id = 0x%x, target id = 0x%x\n", 319 ret, GC0310_ID); 320 return -ENODEV; 321 } 322 323 dev_dbg(&client->dev, "detect gc0310 success\n"); 324 325 return 0; 326 } 327 328 static int gc0310_s_stream(struct v4l2_subdev *sd, int enable) 329 { 330 struct gc0310_device *dev = to_gc0310_sensor(sd); 331 struct i2c_client *client = v4l2_get_subdevdata(sd); 332 int ret = 0; 333 334 dev_dbg(&client->dev, "%s S enable=%d\n", __func__, enable); 335 mutex_lock(&dev->input_lock); 336 337 if (dev->is_streaming == enable) { 338 dev_warn(&client->dev, "stream already %s\n", enable ? "started" : "stopped"); 339 goto error_unlock; 340 } 341 342 if (enable) { 343 ret = pm_runtime_get_sync(&client->dev); 344 if (ret < 0) 345 goto error_power_down; 346 347 ret = gc0310_write_reg_array(client, gc0310_reset_register, 348 ARRAY_SIZE(gc0310_reset_register)); 349 if (ret) 350 goto error_power_down; 351 352 ret = gc0310_write_reg_array(client, gc0310_VGA_30fps, 353 ARRAY_SIZE(gc0310_VGA_30fps)); 354 if (ret) 355 goto error_power_down; 356 357 /* restore value of all ctrls */ 358 ret = __v4l2_ctrl_handler_setup(&dev->ctrls.handler); 359 if (ret) 360 goto error_power_down; 361 362 /* enable per frame MIPI and sensor ctrl reset */ 363 ret = i2c_smbus_write_byte_data(client, 0xFE, 0x30); 364 if (ret) 365 goto error_power_down; 366 } 367 368 ret = i2c_smbus_write_byte_data(client, GC0310_RESET_RELATED, GC0310_REGISTER_PAGE_3); 369 if (ret) 370 goto error_power_down; 371 372 ret = i2c_smbus_write_byte_data(client, GC0310_SW_STREAM, 373 enable ? GC0310_START_STREAMING : GC0310_STOP_STREAMING); 374 if (ret) 375 goto error_power_down; 376 377 ret = i2c_smbus_write_byte_data(client, GC0310_RESET_RELATED, GC0310_REGISTER_PAGE_0); 378 if (ret) 379 goto error_power_down; 380 381 if (!enable) 382 pm_runtime_put(&client->dev); 383 384 dev->is_streaming = enable; 385 mutex_unlock(&dev->input_lock); 386 return 0; 387 388 error_power_down: 389 pm_runtime_put(&client->dev); 390 dev->is_streaming = false; 391 error_unlock: 392 mutex_unlock(&dev->input_lock); 393 return ret; 394 } 395 396 static int gc0310_s_config(struct v4l2_subdev *sd, 397 int irq, void *platform_data) 398 { 399 struct gc0310_device *dev = to_gc0310_sensor(sd); 400 struct i2c_client *client = v4l2_get_subdevdata(sd); 401 int ret = 0; 402 403 if (!platform_data) 404 return -ENODEV; 405 406 dev->platform_data = 407 (struct camera_sensor_platform_data *)platform_data; 408 409 mutex_lock(&dev->input_lock); 410 411 ret = pm_runtime_get_sync(&client->dev); 412 if (ret < 0) { 413 dev_err(&client->dev, "gc0310 power-up err.\n"); 414 goto fail_power_on; 415 } 416 417 ret = dev->platform_data->csi_cfg(sd, 1); 418 if (ret) 419 goto fail_csi_cfg; 420 421 /* config & detect sensor */ 422 ret = gc0310_detect(client); 423 if (ret) { 424 dev_err(&client->dev, "gc0310_detect err s_config.\n"); 425 goto fail_csi_cfg; 426 } 427 428 /* turn off sensor, after probed */ 429 pm_runtime_put(&client->dev); 430 mutex_unlock(&dev->input_lock); 431 432 return 0; 433 434 fail_csi_cfg: 435 dev->platform_data->csi_cfg(sd, 0); 436 fail_power_on: 437 pm_runtime_put(&client->dev); 438 mutex_unlock(&dev->input_lock); 439 return ret; 440 } 441 442 static int gc0310_g_frame_interval(struct v4l2_subdev *sd, 443 struct v4l2_subdev_frame_interval *interval) 444 { 445 interval->interval.numerator = 1; 446 interval->interval.denominator = GC0310_FPS; 447 448 return 0; 449 } 450 451 static int gc0310_enum_mbus_code(struct v4l2_subdev *sd, 452 struct v4l2_subdev_state *sd_state, 453 struct v4l2_subdev_mbus_code_enum *code) 454 { 455 /* We support only a single format */ 456 if (code->index) 457 return -EINVAL; 458 459 code->code = MEDIA_BUS_FMT_SGRBG8_1X8; 460 return 0; 461 } 462 463 static int gc0310_enum_frame_size(struct v4l2_subdev *sd, 464 struct v4l2_subdev_state *sd_state, 465 struct v4l2_subdev_frame_size_enum *fse) 466 { 467 /* We support only a single resolution */ 468 if (fse->index) 469 return -EINVAL; 470 471 fse->min_width = GC0310_NATIVE_WIDTH; 472 fse->max_width = GC0310_NATIVE_WIDTH; 473 fse->min_height = GC0310_NATIVE_HEIGHT; 474 fse->max_height = GC0310_NATIVE_HEIGHT; 475 476 return 0; 477 } 478 479 static int gc0310_g_skip_frames(struct v4l2_subdev *sd, u32 *frames) 480 { 481 *frames = GC0310_SKIP_FRAMES; 482 return 0; 483 } 484 485 static const struct v4l2_subdev_sensor_ops gc0310_sensor_ops = { 486 .g_skip_frames = gc0310_g_skip_frames, 487 }; 488 489 static const struct v4l2_subdev_video_ops gc0310_video_ops = { 490 .s_stream = gc0310_s_stream, 491 .g_frame_interval = gc0310_g_frame_interval, 492 }; 493 494 static const struct v4l2_subdev_pad_ops gc0310_pad_ops = { 495 .enum_mbus_code = gc0310_enum_mbus_code, 496 .enum_frame_size = gc0310_enum_frame_size, 497 .get_fmt = gc0310_get_fmt, 498 .set_fmt = gc0310_set_fmt, 499 }; 500 501 static const struct v4l2_subdev_ops gc0310_ops = { 502 .video = &gc0310_video_ops, 503 .pad = &gc0310_pad_ops, 504 .sensor = &gc0310_sensor_ops, 505 }; 506 507 static int gc0310_init_controls(struct gc0310_device *dev) 508 { 509 struct v4l2_ctrl_handler *hdl = &dev->ctrls.handler; 510 511 v4l2_ctrl_handler_init(hdl, 2); 512 513 /* Use the same lock for controls as for everything else */ 514 hdl->lock = &dev->input_lock; 515 dev->sd.ctrl_handler = hdl; 516 517 dev->ctrls.exposure = 518 v4l2_ctrl_new_std(hdl, &ctrl_ops, V4L2_CID_EXPOSURE, 0, 4095, 1, 1023); 519 520 /* 32 steps at base gain 1 + 64 half steps at base gain 2 */ 521 dev->ctrls.gain = 522 v4l2_ctrl_new_std(hdl, &ctrl_ops, V4L2_CID_GAIN, 0, 95, 1, 31); 523 524 return hdl->error; 525 } 526 527 static void gc0310_remove(struct i2c_client *client) 528 { 529 struct v4l2_subdev *sd = i2c_get_clientdata(client); 530 struct gc0310_device *dev = to_gc0310_sensor(sd); 531 532 dev_dbg(&client->dev, "gc0310_remove...\n"); 533 534 dev->platform_data->csi_cfg(sd, 0); 535 536 v4l2_device_unregister_subdev(sd); 537 media_entity_cleanup(&dev->sd.entity); 538 v4l2_ctrl_handler_free(&dev->ctrls.handler); 539 pm_runtime_disable(&client->dev); 540 kfree(dev); 541 } 542 543 static int gc0310_probe(struct i2c_client *client) 544 { 545 struct gc0310_device *dev; 546 int ret; 547 void *pdata; 548 549 dev = devm_kzalloc(&client->dev, sizeof(*dev), GFP_KERNEL); 550 if (!dev) 551 return -ENOMEM; 552 553 mutex_init(&dev->input_lock); 554 v4l2_i2c_subdev_init(&dev->sd, client, &gc0310_ops); 555 gc0310_fill_format(&dev->mode.fmt); 556 557 pdata = gmin_camera_platform_data(&dev->sd, 558 ATOMISP_INPUT_FORMAT_RAW_8, 559 atomisp_bayer_order_grbg); 560 if (!pdata) 561 return -EINVAL; 562 563 pm_runtime_set_suspended(&client->dev); 564 pm_runtime_enable(&client->dev); 565 pm_runtime_set_autosuspend_delay(&client->dev, 1000); 566 pm_runtime_use_autosuspend(&client->dev); 567 568 ret = gc0310_s_config(&dev->sd, client->irq, pdata); 569 if (ret) { 570 gc0310_remove(client); 571 return ret; 572 } 573 574 ret = atomisp_register_i2c_module(&dev->sd, pdata, RAW_CAMERA); 575 if (ret) { 576 gc0310_remove(client); 577 return ret; 578 } 579 580 dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 581 dev->pad.flags = MEDIA_PAD_FL_SOURCE; 582 dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 583 584 ret = gc0310_init_controls(dev); 585 if (ret) { 586 gc0310_remove(client); 587 return ret; 588 } 589 590 ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad); 591 if (ret) 592 gc0310_remove(client); 593 594 return ret; 595 } 596 597 static int gc0310_suspend(struct device *dev) 598 { 599 struct v4l2_subdev *sd = dev_get_drvdata(dev); 600 601 return power_down(sd); 602 } 603 604 static int gc0310_resume(struct device *dev) 605 { 606 struct v4l2_subdev *sd = dev_get_drvdata(dev); 607 608 return power_up(sd); 609 } 610 611 static DEFINE_RUNTIME_DEV_PM_OPS(gc0310_pm_ops, gc0310_suspend, gc0310_resume, NULL); 612 613 static const struct acpi_device_id gc0310_acpi_match[] = { 614 {"XXGC0310"}, 615 {"INT0310"}, 616 {}, 617 }; 618 MODULE_DEVICE_TABLE(acpi, gc0310_acpi_match); 619 620 static struct i2c_driver gc0310_driver = { 621 .driver = { 622 .name = "gc0310", 623 .pm = pm_sleep_ptr(&gc0310_pm_ops), 624 .acpi_match_table = gc0310_acpi_match, 625 }, 626 .probe_new = gc0310_probe, 627 .remove = gc0310_remove, 628 }; 629 module_i2c_driver(gc0310_driver); 630 631 MODULE_AUTHOR("Lai, Angie <angie.lai@intel.com>"); 632 MODULE_DESCRIPTION("A low-level driver for GalaxyCore GC0310 sensors"); 633 MODULE_LICENSE("GPL"); 634