drivers/media/platform/exynos/fimc-is2/sensor/module_framework/eeprom/fimc-is-sensor-eeprom-16885c.c

   1 /*
   2  * Samsung Exynos5 SoC series Sensor driver
   3  *
   4  *
   5  * Copyright (c) 2018 Samsung Electronics Co., Ltd
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/i2c.h>
  13 #include <linux/time.h>
  14 #include <linux/slab.h>
  15 #include <linux/module.h>
  16 #include <linux/videodev2.h>
  17 #include <linux/videodev2_exynos_camera.h>
  18 #include <media/v4l2-ctrls.h>
  19 #include <media/v4l2-device.h>
  20 #include <media/v4l2-subdev.h>
  21
  22 #include <exynos-fimc-is-sensor.h>
  23 #include "fimc-is-sensor-eeprom-16885c.h"
  24 #include "fimc-is-sensor-eeprom.h"
  25 #include "fimc-is-device-sensor.h"
  26 #include "fimc-is-device-sensor-peri.h"
  27 #include "fimc-is-core.h"
  28
  29 #define SENSOR_EEPROM_NAME "16885C"
  30
  31 int fimc_is_eeprom_16885c_check_all_crc(struct v4l2_subdev *subdev)
  32 {
  33         int ret = 0;
  34         struct fimc_is_module_enum *module;
  35         struct fimc_is_eeprom *eeprom = NULL;
  36         struct fimc_is_device_sensor *sensor = NULL;
  37         int ret_sum = 0;
  38         int i;
  39
  40         FIMC_BUG(!subdev);
  41
  42         module = (struct fimc_is_module_enum *)v4l2_get_subdev_hostdata(subdev);
  43
  44         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
  45
  46         FIMC_BUG(!eeprom);
  47         FIMC_BUG(!module);
  48
  49         sensor = (struct fimc_is_device_sensor *)v4l2_get_subdev_hostdata(module->subdev);
  50         if (!sensor) {
  51                 err("device sensor is NULL");
  52                 ret = -ENODEV;
  53                 return ret;
  54         }
  55
  56         /* Check CRC to Address cal data */
  57         ret = CALL_EEPROMOPS(eeprom, eeprom_check_address, subdev);
  58         if (ret) {
  59                 err("%s(): 16885C EEPROM Address section CRC check fail(%d)", __func__, ret);
  60
  61                 /* All calibration data is zero set only Address section is invalid CRC */
  62                 fimc_is_eeprom_cal_data_set(eeprom->data, "all",
  63                                 EEPROM_ADD_CRC_FST, EEPROM_DATA_SIZE, 0xff);
  64
  65                 /*Set all cal_status to ERROR if Address cal data invalid*/
  66                 for (i = 0; i < CAMERA_CRC_INDEX_MAX; i++)
  67                     sensor->cal_status[i] = CRC_ERROR;
  68
  69                 return ret;
  70         } else
  71                 info("16885C EEPROM Address section CRC check success\n");
  72
  73         /* Check CRC to Information cal data */
  74         ret = CALL_EEPROMOPS(eeprom, eeprom_check_info, subdev);
  75         if (ret) {
  76                 ret_sum++;
  77                 err("%s(): 16885C EEPROM Information CRC section check fail(%d)", __func__, ret);
  78
  79                 /* All calibration data is 0xff set but exception Address section */
  80                 fimc_is_eeprom_cal_data_set(eeprom->data, "Information - End",
  81                                 EEPROM_INFO_CRC_FST, EEPROM_ADD_CAL_SIZE, 0xff);
  82
  83                 sensor->cal_status[CAMERA_CRC_INDEX_MNF] = CRC_ERROR;
  84
  85         } else {
  86                 info("16885C EEPROM Informaion section CRC check success\n");
  87
  88                 sensor->cal_status[CAMERA_CRC_INDEX_MNF] = CRC_NO_ERROR;
  89         }
  90
  91         /* Check CRC to AWB cal data */
  92         ret = CALL_EEPROMOPS(eeprom, eeprom_check_awb, subdev);
  93         if (ret) {
  94                 ret_sum++;
  95                 err("%s(): 16885C EEPROM AWB section CRC check fail(%d)", __func__, ret);
  96
  97                 fimc_is_eeprom_cal_data_set(eeprom->data, "AWB",
  98                                 EEPROM_AWB_CRC_FST, EEPROM_AWB_CAL_SIZE, 0xff);
  99
 100                 sensor->cal_status[CAMERA_CRC_INDEX_AWB] = CRC_ERROR;
 101
 102         } else {
 103                 info("16885C EEPROM AWB section CRC check success\n");
 104
 105                 sensor->cal_status[CAMERA_CRC_INDEX_AWB] = CRC_NO_ERROR;
 106
 107                 ret = fimc_is_sensor_eeprom_check_awb_ratio(&eeprom->data[EEPROM_AWB_UNIT_OFFSET],
 108                         &eeprom->data[EEPROM_AWB_GOLDEN_OFFSET],&eeprom->data[EEPROM_AWB_LIMIT_OFFSET]);
 109                 if (ret) {
 110                         err("%s(): 16885C EEPROM AWB ratio out of limit(%d)", __func__, ret);
 111
 112                         sensor->cal_status[CAMERA_CRC_INDEX_AWB] = LIMIT_FAILURE;
 113                 }
 114         }
 115
 116         /* Check CRC to LSC cal data */
 117         ret = CALL_EEPROMOPS(eeprom, eeprom_check_lsc, subdev);
 118         if (ret) {
 119                 ret_sum++;
 120                 err("%s(): 16885C EEPROM LSC section CRC check fail(%d)", __func__, ret);
 121
 122                 fimc_is_eeprom_cal_data_set(eeprom->data, "LSC",
 123                                 EEPROM_LSC_CRC_FST, EEPROM_LSC_CAL_SIZE, 0xff);
 124
 125         } else
 126                 info("16885C EEPROM LSC section CRC check success\n");
 127
 128         /* Check CRC to SFR cal data */
 129         ret = CALL_EEPROMOPS(eeprom, eeprom_check_sfr, subdev);
 130         if (ret) {
 131                 ret_sum++;
 132                 err("%s(): EEPROM SFR section CRC check fail(%d)", __func__, ret);
 133
 134                 fimc_is_eeprom_cal_data_set(eeprom->data, "SFR",
 135                                 EEPROM_SFR_CRC_FST, EEPROM_SFR_CAL_SIZE, 0xff);
 136
 137         } else
 138                 info("16885C EEPROM SFR section CRC check success\n");
 139
 140         return ret_sum;
 141 }
 142
 143 static int fimc_is_eeprom_16885c_check_address(struct v4l2_subdev *subdev)
 144 {
 145         int ret = 0;
 146         u16 crc_value = 0;
 147         u16 crc16 = 0;
 148         struct fimc_is_eeprom *eeprom = NULL;
 149
 150         FIMC_BUG(!subdev);
 151
 152         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
 153
 154         FIMC_BUG(!eeprom);
 155
 156         crc_value = ((eeprom->data[EEPROM_ADD_CRC_SEC] << 8) | (eeprom->data[EEPROM_ADD_CRC_FST]));
 157
 158         crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_ADD_CRC_CHK_START], EEPROM_ADD_CRC_CHK_SIZE);
 159         if (crc_value != crc16) {
 160                 err("Error to ADD CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
 161
 162                 ret = -EINVAL;
 163         } else
 164                 info("ADD CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
 165
 166         return ret;
 167 }
 168
 169 static int fimc_is_eeprom_16885c_check_info(struct v4l2_subdev *subdev)
 170 {
 171         int ret = 0;
 172         u16 crc_value = 0;
 173         u16 crc16 = 0;
 174         struct fimc_is_eeprom *eeprom = NULL;
 175
 176         FIMC_BUG(!subdev);
 177
 178         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
 179
 180         FIMC_BUG(!eeprom);
 181
 182         crc_value = ((eeprom->data[EEPROM_INFO_CRC_SEC] << 8) | (eeprom->data[EEPROM_INFO_CRC_FST]));
 183
 184         crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_INFO_CRC_CHK_START], EEPROM_INFO_CRC_CHK_SIZE);
 185         if (crc_value != crc16) {
 186                 err("Error to INFO CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
 187
 188                 ret = -EINVAL;
 189         } else
 190                 info("INFO CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
 191
 192         return ret;
 193 }
 194
 195 static int fimc_is_eeprom_16885c_check_awb(struct v4l2_subdev *subdev)
 196 {
 197         int ret = 0;
 198         u16 crc_value = 0;
 199         u16 crc16 = 0;
 200         struct fimc_is_eeprom *eeprom = NULL;
 201
 202         FIMC_BUG(!subdev);
 203
 204         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
 205
 206         FIMC_BUG(!eeprom);
 207
 208         crc_value = ((eeprom->data[EEPROM_AWB_CRC_SEC] << 8) | (eeprom->data[EEPROM_AWB_CRC_FST]));
 209
 210         crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_AWB_CRC_CHK_START], EEPROM_AWB_CRC_CHK_SIZE);
 211         if (crc_value != crc16) {
 212                 err("Error to AWB CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
 213
 214                 ret = -EINVAL;
 215         } else
 216                 info("AWB CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
 217
 218         return ret;
 219 }
 220
 221 static int fimc_is_eeprom_16885c_check_lsc(struct v4l2_subdev *subdev)
 222 {
 223         int ret = 0;
 224         u16 crc_value = 0;
 225         u16 crc16 = 0;
 226         struct fimc_is_eeprom *eeprom = NULL;
 227
 228         FIMC_BUG(!subdev);
 229
 230         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
 231
 232         FIMC_BUG(!eeprom);
 233
 234         crc_value = ((eeprom->data[EEPROM_LSC_CRC_SEC] << 8) | (eeprom->data[EEPROM_LSC_CRC_FST]));
 235
 236         crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_LSC_CRC_CHK_START], EEPROM_LSC_CRC_CHK_SIZE);
 237         if (crc_value != crc16) {
 238                 err("Error to LSC CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
 239
 240                 ret = -EINVAL;
 241         } else
 242                 info("LSC CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
 243
 244         return ret;
 245 }
 246
 247 static int fimc_is_eeprom_16885c_check_sfr(struct v4l2_subdev *subdev)
 248 {
 249         int ret = 0;
 250         u16 crc_value = 0;
 251         u16 crc16 = 0;
 252         struct fimc_is_eeprom *eeprom = NULL;
 253
 254         FIMC_BUG(!subdev);
 255
 256         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
 257
 258         FIMC_BUG(!eeprom);
 259
 260         crc_value = ((eeprom->data[EEPROM_SFR_CRC_SEC] << 8) | (eeprom->data[EEPROM_SFR_CRC_FST]));
 261
 262         crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_SFR_CRC_CHK_START], EEPROM_SFR_CRC_CHK_SIZE);
 263         if (crc_value != crc16) {
 264                 err("Error to SFR CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
 265
 266                 ret = -EINVAL;
 267         } else
 268                 info("SFR CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
 269
 270         return ret;
 271 }
 272
 273 int fimc_is_eeprom_16885c_get_cal_data(struct v4l2_subdev *subdev)
 274 {
 275         int ret = 0;
 276         struct fimc_is_eeprom *eeprom;
 277         struct i2c_client *client;
 278
 279         FIMC_BUG(!subdev);
 280
 281         eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
 282
 283         FIMC_BUG(!eeprom);
 284
 285         client = eeprom->client;
 286         if (unlikely(!client)) {
 287                 err("client is NULL");
 288                 ret = -EINVAL;
 289                 return ret;
 290         }
 291
 292         /*
 293          * EEPROM data file(.bin) will be deleted at every reboot
 294          * so, when eeprom->file_write is zero, there is no eeprom data file
 295          */
 296         if (!eeprom->file_write) {
 297                 I2C_MUTEX_LOCK(eeprom->i2c_lock);
 298                 /* I2C read to Sensor EEPROM cal data */
 299                 ret = fimc_is_eeprom_module_read(client, EEPROM_ADD_CRC_FST, eeprom->data, EEPROM_DATA_SIZE);
 300                 if (ret < 0) {
 301                         err("%s(): eeprom i2c read failed(%d)\n", __func__, ret);
 302                         I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
 303                         return ret;
 304                 }
 305                 I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
 306
 307                 /* CRC check to each section cal data */
 308                 ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
 309                 if (ret)
 310                         err("%s(): eeprom data invalid(%d)\n", __func__, ret);
 311
 312                 /* Write file to Cal data */
 313                 ret = fimc_is_eeprom_file_write(EEPROM_DATA_PATH, (void *)eeprom->data, EEPROM_DATA_SIZE);
 314                 if (ret < 0) {
 315                         err("%s(), eeprom file write fail(%d)\n", __func__, ret);
 316                         return ret;
 317                 }
 318                 eeprom->file_write = 1;
 319         } else {
 320                 ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
 321                 if (ret) {
 322                         err("%s(): eeprom data invalid(%d)\n", __func__, ret);
 323                         err("retry to read data from eeprom module and update file\n");
 324
 325                         I2C_MUTEX_LOCK(eeprom->i2c_lock);
 326                         /* I2C read to Sensor EEPROM cal data */
 327                         ret = fimc_is_eeprom_module_read(client, EEPROM_ADD_CRC_FST, eeprom->data, EEPROM_DATA_SIZE);
 328                         if (ret < 0) {
 329                                 err("%s(): eeprom i2c read failed(%d)\n", __func__, ret);
 330                                 I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
 331                                 return ret;
 332                         }
 333                         I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
 334
 335                         /* CRC check to each section cal data */
 336                         ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
 337                         if (ret)
 338                                 err("%s(): eeprom data invalid(%d)\n", __func__, ret);
 339                 }
 340         }
 341
 342         return ret;
 343 }
 344
 345 static struct fimc_is_eeprom_ops sensor_eeprom_ops = {
 346         .eeprom_read = fimc_is_eeprom_16885c_get_cal_data,
 347         .eeprom_check_all_crc = fimc_is_eeprom_16885c_check_all_crc,
 348         .eeprom_check_address = fimc_is_eeprom_16885c_check_address,
 349         .eeprom_check_info = fimc_is_eeprom_16885c_check_info,
 350         .eeprom_check_awb = fimc_is_eeprom_16885c_check_awb,
 351         .eeprom_check_lsc = fimc_is_eeprom_16885c_check_lsc,
 352         .eeprom_check_sfr = fimc_is_eeprom_16885c_check_sfr,
 353 };
 354
 355 static int sensor_eeprom_16885c_probe(struct i2c_client *client,
 356                 const struct i2c_device_id *id)
 357 {
 358         int ret = 0, i;
 359         struct fimc_is_core *core;
 360         struct v4l2_subdev *subdev_eeprom = NULL;
 361         struct fimc_is_eeprom *eeprom = NULL;
 362         struct fimc_is_device_sensor *device;
 363         struct device *dev;
 364         struct device_node *dnode;
 365         u32 sensor_id = 0;
 366
 367         FIMC_BUG(!client);
 368         FIMC_BUG(!fimc_is_dev);
 369
 370         core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
 371         if (!core) {
 372                 probe_info("core device is not yet probed");
 373                 return -EPROBE_DEFER;
 374         }
 375
 376         dev = &client->dev;
 377         dnode = dev->of_node;
 378
 379         ret = of_property_read_u32(dnode, "id", &sensor_id);
 380         if (ret) {
 381                 probe_info("core device is not yet probed");
 382                 return -EPROBE_DEFER;
 383         }
 384
 385         device = &core->sensor[sensor_id];
 386         if (!device) {
 387                 err("sensor device is NULL");
 388                 ret = -ENOMEM;
 389                 goto p_err;
 390         }
 391
 392         eeprom = kzalloc(sizeof(struct fimc_is_eeprom), GFP_KERNEL);
 393         if (!eeprom) {
 394                 err("eeprom is NULL");
 395                 ret = -ENOMEM;
 396                 goto p_err;
 397         }
 398
 399         subdev_eeprom = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
 400         if (!subdev_eeprom) {
 401                 probe_err("subdev_cis NULL");
 402                 ret = -ENOMEM;
 403                 goto p_err;
 404         }
 405
 406         eeprom->data = kzalloc(EEPROM_DATA_SIZE, GFP_KERNEL);
 407         if (!eeprom->data) {
 408                 err("data is NULL");
 409                 ret = -ENOMEM;
 410                 goto p_err;
 411         }
 412
 413         eeprom->id = EEPROM_NAME_16885C;
 414         eeprom->subdev = subdev_eeprom;
 415         eeprom->device = sensor_id;
 416         eeprom->client = client;
 417         eeprom->i2c_lock = NULL;
 418         eeprom->total_size = EEPROM_DATA_SIZE;
 419         eeprom->eeprom_ops = &sensor_eeprom_ops;
 420
 421         for (i = 0; i < CAMERA_CRC_INDEX_MAX; i++)
 422                 device->cal_status[i] = CRC_NO_ERROR;
 423
 424         device->subdev_eeprom = subdev_eeprom;
 425         device->eeprom = eeprom;
 426
 427         v4l2_set_subdevdata(subdev_eeprom, eeprom);
 428         v4l2_set_subdev_hostdata(subdev_eeprom, device);
 429
 430         snprintf(subdev_eeprom->name, V4L2_SUBDEV_NAME_SIZE, "eeprom-subdev.%d", eeprom->id);
 431
 432         probe_info("%s done\n", __func__);
 433
 434 p_err:
 435         return ret;
 436 }
 437
 438 static const struct of_device_id sensor_eeprom_16885c_match[] = {
 439         {
 440                 .compatible = "samsung,exynos5-fimc-is-sensor-eeprom-16885c",
 441         },
 442         {},
 443 };
 444 MODULE_DEVICE_TABLE(of, sensor_eeprom_16885c_match);
 445
 446 static const struct i2c_device_id sensor_eeprom_16885c_idt[] = {
 447         { SENSOR_EEPROM_NAME, 0 },
 448         {},
 449 };
 450
 451 static struct i2c_driver sensor_eeprom_16885c_driver = {
 452         .probe  = sensor_eeprom_16885c_probe,
 453         .driver = {
 454                 .name   = SENSOR_EEPROM_NAME,
 455                 .owner  = THIS_MODULE,
 456                 .of_match_table = sensor_eeprom_16885c_match,
 457                 .suppress_bind_attrs = true,
 458         },
 459         .id_table = sensor_eeprom_16885c_idt
 460 };
 461
 462 static int __init sensor_eeprom_16885c_init(void)
 463 {
 464         int ret;
 465
 466         ret = i2c_add_driver(&sensor_eeprom_16885c_driver);
 467         if (ret)
 468                 err("failed to add %s driver: %d\n",
 469                         sensor_eeprom_16885c_driver.driver.name, ret);
 470
 471         return ret;
 472 }
 473 late_initcall_sync(sensor_eeprom_16885c_init);