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 <media/v4l2-device.h> 32 #include <linux/io.h> 33 #include "../include/linux/atomisp_gmin_platform.h" 34 35 #include "gc0310.h" 36 37 /* 38 * gc0310_write_reg_array - Initializes a list of GC0310 registers 39 * @client: i2c driver client structure 40 * @reglist: list of registers to be written 41 * @count: number of register, value pairs in the list 42 */ 43 static int gc0310_write_reg_array(struct i2c_client *client, 44 const struct gc0310_reg *reglist, int count) 45 { 46 int i, err; 47 48 for (i = 0; i < count; i++) { 49 err = i2c_smbus_write_byte_data(client, reglist[i].reg, reglist[i].val); 50 if (err) { 51 dev_err(&client->dev, "write error: wrote 0x%x to offset 0x%x error %d", 52 reglist[i].val, reglist[i].reg, err); 53 return err; 54 } 55 } 56 57 return 0; 58 } 59 60 static int gc0310_s_ctrl(struct v4l2_ctrl *ctrl) 61 { 62 int ret = 0; 63 64 switch (ctrl->id) { 65 default: 66 ret = -EINVAL; 67 } 68 return ret; 69 } 70 71 static const struct v4l2_ctrl_ops ctrl_ops = { 72 .s_ctrl = gc0310_s_ctrl, 73 }; 74 75 static int gc0310_init(struct v4l2_subdev *sd) 76 { 77 int ret; 78 struct i2c_client *client = v4l2_get_subdevdata(sd); 79 struct gc0310_device *dev = to_gc0310_sensor(sd); 80 81 mutex_lock(&dev->input_lock); 82 83 /* set initial registers */ 84 ret = gc0310_write_reg_array(client, gc0310_reset_register, 85 ARRAY_SIZE(gc0310_reset_register)); 86 87 /* restore settings */ 88 gc0310_res = gc0310_res_preview; 89 N_RES = N_RES_PREVIEW; 90 91 mutex_unlock(&dev->input_lock); 92 93 return ret; 94 } 95 96 static int power_ctrl(struct v4l2_subdev *sd, bool flag) 97 { 98 int ret = 0; 99 struct gc0310_device *dev = to_gc0310_sensor(sd); 100 101 if (!dev || !dev->platform_data) 102 return -ENODEV; 103 104 if (flag) { 105 /* The upstream module driver (written to Crystal 106 * Cove) had this logic to pulse the rails low first. 107 * This appears to break things on the MRD7 with the 108 * X-Powers PMIC... 109 * 110 * ret = dev->platform_data->v1p8_ctrl(sd, 0); 111 * ret |= dev->platform_data->v2p8_ctrl(sd, 0); 112 * mdelay(50); 113 */ 114 ret |= dev->platform_data->v1p8_ctrl(sd, 1); 115 ret |= dev->platform_data->v2p8_ctrl(sd, 1); 116 usleep_range(10000, 15000); 117 } 118 119 if (!flag || ret) { 120 ret |= dev->platform_data->v1p8_ctrl(sd, 0); 121 ret |= dev->platform_data->v2p8_ctrl(sd, 0); 122 } 123 return ret; 124 } 125 126 static int gpio_ctrl(struct v4l2_subdev *sd, bool flag) 127 { 128 int ret; 129 struct gc0310_device *dev = to_gc0310_sensor(sd); 130 131 if (!dev || !dev->platform_data) 132 return -ENODEV; 133 134 /* GPIO0 == "reset" (active low), GPIO1 == "power down" */ 135 if (flag) { 136 /* Pulse reset, then release power down */ 137 ret = dev->platform_data->gpio0_ctrl(sd, 0); 138 usleep_range(5000, 10000); 139 ret |= dev->platform_data->gpio0_ctrl(sd, 1); 140 usleep_range(10000, 15000); 141 ret |= dev->platform_data->gpio1_ctrl(sd, 0); 142 usleep_range(10000, 15000); 143 } else { 144 ret = dev->platform_data->gpio1_ctrl(sd, 1); 145 ret |= dev->platform_data->gpio0_ctrl(sd, 0); 146 } 147 return ret; 148 } 149 150 static int power_up(struct v4l2_subdev *sd) 151 { 152 struct gc0310_device *dev = to_gc0310_sensor(sd); 153 struct i2c_client *client = v4l2_get_subdevdata(sd); 154 int ret; 155 156 if (!dev->platform_data) { 157 dev_err(&client->dev, 158 "no camera_sensor_platform_data"); 159 return -ENODEV; 160 } 161 162 if (dev->power_on) 163 return 0; /* Already on */ 164 165 /* power control */ 166 ret = power_ctrl(sd, 1); 167 if (ret) 168 goto fail_power; 169 170 /* flis clock control */ 171 ret = dev->platform_data->flisclk_ctrl(sd, 1); 172 if (ret) 173 goto fail_clk; 174 175 /* gpio ctrl */ 176 ret = gpio_ctrl(sd, 1); 177 if (ret) { 178 ret = gpio_ctrl(sd, 1); 179 if (ret) 180 goto fail_gpio; 181 } 182 183 msleep(100); 184 185 dev->power_on = true; 186 return 0; 187 188 fail_gpio: 189 dev->platform_data->flisclk_ctrl(sd, 0); 190 fail_clk: 191 power_ctrl(sd, 0); 192 fail_power: 193 dev_err(&client->dev, "sensor power-up failed\n"); 194 195 return ret; 196 } 197 198 static int power_down(struct v4l2_subdev *sd) 199 { 200 struct gc0310_device *dev = to_gc0310_sensor(sd); 201 struct i2c_client *client = v4l2_get_subdevdata(sd); 202 int ret = 0; 203 204 if (!dev->platform_data) { 205 dev_err(&client->dev, 206 "no camera_sensor_platform_data"); 207 return -ENODEV; 208 } 209 210 if (!dev->power_on) 211 return 0; /* Already off */ 212 213 /* gpio ctrl */ 214 ret = gpio_ctrl(sd, 0); 215 if (ret) { 216 ret = gpio_ctrl(sd, 0); 217 if (ret) 218 dev_err(&client->dev, "gpio failed 2\n"); 219 } 220 221 ret = dev->platform_data->flisclk_ctrl(sd, 0); 222 if (ret) 223 dev_err(&client->dev, "flisclk failed\n"); 224 225 /* power control */ 226 ret = power_ctrl(sd, 0); 227 if (ret) 228 dev_err(&client->dev, "vprog failed.\n"); 229 230 dev->power_on = false; 231 return ret; 232 } 233 234 static int gc0310_s_power(struct v4l2_subdev *sd, int on) 235 { 236 int ret; 237 238 if (on == 0) 239 return power_down(sd); 240 241 ret = power_up(sd); 242 if (ret) 243 return ret; 244 245 return gc0310_init(sd); 246 } 247 248 /* TODO: remove it. */ 249 static int startup(struct v4l2_subdev *sd) 250 { 251 struct gc0310_device *dev = to_gc0310_sensor(sd); 252 struct i2c_client *client = v4l2_get_subdevdata(sd); 253 int ret = 0; 254 255 ret = gc0310_write_reg_array(client, dev->res->regs, dev->res->reg_count); 256 if (ret) { 257 dev_err(&client->dev, "gc0310 write register err.\n"); 258 return ret; 259 } 260 261 return ret; 262 } 263 264 static int gc0310_set_fmt(struct v4l2_subdev *sd, 265 struct v4l2_subdev_state *sd_state, 266 struct v4l2_subdev_format *format) 267 { 268 struct v4l2_mbus_framefmt *fmt = &format->format; 269 struct gc0310_device *dev = to_gc0310_sensor(sd); 270 struct i2c_client *client = v4l2_get_subdevdata(sd); 271 struct camera_mipi_info *gc0310_info = NULL; 272 struct gc0310_resolution *res; 273 int ret = 0; 274 275 if (format->pad) 276 return -EINVAL; 277 278 if (!fmt) 279 return -EINVAL; 280 281 gc0310_info = v4l2_get_subdev_hostdata(sd); 282 if (!gc0310_info) 283 return -EINVAL; 284 285 mutex_lock(&dev->input_lock); 286 287 res = v4l2_find_nearest_size(gc0310_res_preview, 288 ARRAY_SIZE(gc0310_res_preview), width, 289 height, fmt->width, fmt->height); 290 if (!res) 291 res = &gc0310_res_preview[N_RES - 1]; 292 293 fmt->width = res->width; 294 fmt->height = res->height; 295 dev->res = res; 296 297 fmt->code = MEDIA_BUS_FMT_SGRBG8_1X8; 298 299 if (format->which == V4L2_SUBDEV_FORMAT_TRY) { 300 sd_state->pads->try_fmt = *fmt; 301 mutex_unlock(&dev->input_lock); 302 return 0; 303 } 304 305 /* s_power has not been called yet for std v4l2 clients (camorama) */ 306 power_up(sd); 307 308 dev_dbg(&client->dev, "%s: before gc0310_write_reg_array %s\n", 309 __func__, dev->res->desc); 310 ret = startup(sd); 311 if (ret) { 312 dev_err(&client->dev, "gc0310 startup err\n"); 313 goto err; 314 } 315 316 err: 317 mutex_unlock(&dev->input_lock); 318 return ret; 319 } 320 321 static int gc0310_get_fmt(struct v4l2_subdev *sd, 322 struct v4l2_subdev_state *sd_state, 323 struct v4l2_subdev_format *format) 324 { 325 struct v4l2_mbus_framefmt *fmt = &format->format; 326 struct gc0310_device *dev = to_gc0310_sensor(sd); 327 328 if (format->pad) 329 return -EINVAL; 330 331 if (!fmt) 332 return -EINVAL; 333 334 fmt->width = dev->res->width; 335 fmt->height = dev->res->height; 336 fmt->code = MEDIA_BUS_FMT_SGRBG8_1X8; 337 338 return 0; 339 } 340 341 static int gc0310_detect(struct i2c_client *client) 342 { 343 struct i2c_adapter *adapter = client->adapter; 344 int ret; 345 346 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) 347 return -ENODEV; 348 349 ret = i2c_smbus_read_word_swapped(client, GC0310_SC_CMMN_CHIP_ID_H); 350 if (ret < 0) { 351 dev_err(&client->dev, "read sensor_id failed: %d\n", ret); 352 return -ENODEV; 353 } 354 355 dev_dbg(&client->dev, "sensor ID = 0x%x\n", ret); 356 357 if (ret != GC0310_ID) { 358 dev_err(&client->dev, "sensor ID error, read id = 0x%x, target id = 0x%x\n", 359 ret, GC0310_ID); 360 return -ENODEV; 361 } 362 363 dev_dbg(&client->dev, "detect gc0310 success\n"); 364 365 return 0; 366 } 367 368 static int gc0310_s_stream(struct v4l2_subdev *sd, int enable) 369 { 370 struct gc0310_device *dev = to_gc0310_sensor(sd); 371 struct i2c_client *client = v4l2_get_subdevdata(sd); 372 int ret; 373 374 dev_dbg(&client->dev, "%s S enable=%d\n", __func__, enable); 375 mutex_lock(&dev->input_lock); 376 377 if (enable) { 378 /* enable per frame MIPI and sensor ctrl reset */ 379 ret = i2c_smbus_write_byte_data(client, 0xFE, 0x30); 380 if (ret) { 381 mutex_unlock(&dev->input_lock); 382 return ret; 383 } 384 } 385 386 ret = i2c_smbus_write_byte_data(client, GC0310_RESET_RELATED, GC0310_REGISTER_PAGE_3); 387 if (ret) { 388 mutex_unlock(&dev->input_lock); 389 return ret; 390 } 391 392 ret = i2c_smbus_write_byte_data(client, GC0310_SW_STREAM, 393 enable ? GC0310_START_STREAMING : GC0310_STOP_STREAMING); 394 if (ret) { 395 mutex_unlock(&dev->input_lock); 396 return ret; 397 } 398 399 ret = i2c_smbus_write_byte_data(client, GC0310_RESET_RELATED, GC0310_REGISTER_PAGE_0); 400 if (ret) { 401 mutex_unlock(&dev->input_lock); 402 return ret; 403 } 404 405 mutex_unlock(&dev->input_lock); 406 return ret; 407 } 408 409 static int gc0310_s_config(struct v4l2_subdev *sd, 410 int irq, void *platform_data) 411 { 412 struct gc0310_device *dev = to_gc0310_sensor(sd); 413 struct i2c_client *client = v4l2_get_subdevdata(sd); 414 int ret = 0; 415 416 if (!platform_data) 417 return -ENODEV; 418 419 dev->platform_data = 420 (struct camera_sensor_platform_data *)platform_data; 421 422 mutex_lock(&dev->input_lock); 423 /* power off the module, then power on it in future 424 * as first power on by board may not fulfill the 425 * power on sequqence needed by the module 426 */ 427 dev->power_on = true; /* force power_down() to run */ 428 ret = power_down(sd); 429 if (ret) { 430 dev_err(&client->dev, "gc0310 power-off err.\n"); 431 goto fail_power_off; 432 } 433 434 ret = power_up(sd); 435 if (ret) { 436 dev_err(&client->dev, "gc0310 power-up err.\n"); 437 goto fail_power_on; 438 } 439 440 ret = dev->platform_data->csi_cfg(sd, 1); 441 if (ret) 442 goto fail_csi_cfg; 443 444 /* config & detect sensor */ 445 ret = gc0310_detect(client); 446 if (ret) { 447 dev_err(&client->dev, "gc0310_detect err s_config.\n"); 448 goto fail_csi_cfg; 449 } 450 451 /* turn off sensor, after probed */ 452 ret = power_down(sd); 453 if (ret) { 454 dev_err(&client->dev, "gc0310 power-off err.\n"); 455 goto fail_csi_cfg; 456 } 457 mutex_unlock(&dev->input_lock); 458 459 return 0; 460 461 fail_csi_cfg: 462 dev->platform_data->csi_cfg(sd, 0); 463 fail_power_on: 464 power_down(sd); 465 dev_err(&client->dev, "sensor power-gating failed\n"); 466 fail_power_off: 467 mutex_unlock(&dev->input_lock); 468 return ret; 469 } 470 471 static int gc0310_g_frame_interval(struct v4l2_subdev *sd, 472 struct v4l2_subdev_frame_interval *interval) 473 { 474 struct gc0310_device *dev = to_gc0310_sensor(sd); 475 476 interval->interval.numerator = 1; 477 interval->interval.denominator = dev->res->fps; 478 479 return 0; 480 } 481 482 static int gc0310_enum_mbus_code(struct v4l2_subdev *sd, 483 struct v4l2_subdev_state *sd_state, 484 struct v4l2_subdev_mbus_code_enum *code) 485 { 486 if (code->index >= MAX_FMTS) 487 return -EINVAL; 488 489 code->code = MEDIA_BUS_FMT_SGRBG8_1X8; 490 return 0; 491 } 492 493 static int gc0310_enum_frame_size(struct v4l2_subdev *sd, 494 struct v4l2_subdev_state *sd_state, 495 struct v4l2_subdev_frame_size_enum *fse) 496 { 497 int index = fse->index; 498 499 if (index >= N_RES) 500 return -EINVAL; 501 502 fse->min_width = gc0310_res[index].width; 503 fse->min_height = gc0310_res[index].height; 504 fse->max_width = gc0310_res[index].width; 505 fse->max_height = gc0310_res[index].height; 506 507 return 0; 508 } 509 510 static int gc0310_g_skip_frames(struct v4l2_subdev *sd, u32 *frames) 511 { 512 struct gc0310_device *dev = to_gc0310_sensor(sd); 513 514 mutex_lock(&dev->input_lock); 515 *frames = dev->res->skip_frames; 516 mutex_unlock(&dev->input_lock); 517 518 return 0; 519 } 520 521 static const struct v4l2_subdev_sensor_ops gc0310_sensor_ops = { 522 .g_skip_frames = gc0310_g_skip_frames, 523 }; 524 525 static const struct v4l2_subdev_video_ops gc0310_video_ops = { 526 .s_stream = gc0310_s_stream, 527 .g_frame_interval = gc0310_g_frame_interval, 528 }; 529 530 static const struct v4l2_subdev_core_ops gc0310_core_ops = { 531 .s_power = gc0310_s_power, 532 }; 533 534 static const struct v4l2_subdev_pad_ops gc0310_pad_ops = { 535 .enum_mbus_code = gc0310_enum_mbus_code, 536 .enum_frame_size = gc0310_enum_frame_size, 537 .get_fmt = gc0310_get_fmt, 538 .set_fmt = gc0310_set_fmt, 539 }; 540 541 static const struct v4l2_subdev_ops gc0310_ops = { 542 .core = &gc0310_core_ops, 543 .video = &gc0310_video_ops, 544 .pad = &gc0310_pad_ops, 545 .sensor = &gc0310_sensor_ops, 546 }; 547 548 static void gc0310_remove(struct i2c_client *client) 549 { 550 struct v4l2_subdev *sd = i2c_get_clientdata(client); 551 struct gc0310_device *dev = to_gc0310_sensor(sd); 552 553 dev_dbg(&client->dev, "gc0310_remove...\n"); 554 555 dev->platform_data->csi_cfg(sd, 0); 556 557 v4l2_device_unregister_subdev(sd); 558 media_entity_cleanup(&dev->sd.entity); 559 v4l2_ctrl_handler_free(&dev->ctrl_handler); 560 kfree(dev); 561 } 562 563 static int gc0310_probe(struct i2c_client *client) 564 { 565 struct gc0310_device *dev; 566 int ret; 567 void *pdata; 568 569 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 570 if (!dev) 571 return -ENOMEM; 572 573 mutex_init(&dev->input_lock); 574 575 dev->res = &gc0310_res_preview[0]; 576 v4l2_i2c_subdev_init(&dev->sd, client, &gc0310_ops); 577 578 pdata = gmin_camera_platform_data(&dev->sd, 579 ATOMISP_INPUT_FORMAT_RAW_8, 580 atomisp_bayer_order_grbg); 581 if (!pdata) { 582 ret = -EINVAL; 583 goto out_free; 584 } 585 586 ret = gc0310_s_config(&dev->sd, client->irq, pdata); 587 if (ret) 588 goto out_free; 589 590 ret = atomisp_register_i2c_module(&dev->sd, pdata, RAW_CAMERA); 591 if (ret) 592 goto out_free; 593 594 dev->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 595 dev->pad.flags = MEDIA_PAD_FL_SOURCE; 596 dev->format.code = MEDIA_BUS_FMT_SGRBG8_1X8; 597 dev->sd.entity.function = MEDIA_ENT_F_CAM_SENSOR; 598 ret = v4l2_ctrl_handler_init(&dev->ctrl_handler, 0); 599 if (ret) { 600 gc0310_remove(client); 601 return ret; 602 } 603 604 if (dev->ctrl_handler.error) { 605 gc0310_remove(client); 606 return dev->ctrl_handler.error; 607 } 608 609 /* Use same lock for controls as for everything else. */ 610 dev->ctrl_handler.lock = &dev->input_lock; 611 dev->sd.ctrl_handler = &dev->ctrl_handler; 612 613 ret = media_entity_pads_init(&dev->sd.entity, 1, &dev->pad); 614 if (ret) 615 gc0310_remove(client); 616 617 return ret; 618 out_free: 619 v4l2_device_unregister_subdev(&dev->sd); 620 kfree(dev); 621 return ret; 622 } 623 624 static const struct acpi_device_id gc0310_acpi_match[] = { 625 {"XXGC0310"}, 626 {"INT0310"}, 627 {}, 628 }; 629 MODULE_DEVICE_TABLE(acpi, gc0310_acpi_match); 630 631 static struct i2c_driver gc0310_driver = { 632 .driver = { 633 .name = "gc0310", 634 .acpi_match_table = gc0310_acpi_match, 635 }, 636 .probe_new = gc0310_probe, 637 .remove = gc0310_remove, 638 }; 639 module_i2c_driver(gc0310_driver); 640 641 MODULE_AUTHOR("Lai, Angie <angie.lai@intel.com>"); 642 MODULE_DESCRIPTION("A low-level driver for GalaxyCore GC0310 sensors"); 643 MODULE_LICENSE("GPL"); 644