[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / drivers / media / platform / exynos / fimc-is2 / sensor / module_framework / eeprom / fimc-is-sensor-eeprom-5e9.c

/*
 * Samsung Exynos5 SoC series Sensor driver
 *
 *
 * Copyright (c) 2018 Samsung Electronics Co., Ltd
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/i2c.h>
#include <linux/time.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/videodev2.h>
#include <linux/videodev2_exynos_camera.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>
#include <media/v4l2-subdev.h>

#include <exynos-fimc-is-sensor.h>
#include "fimc-is-sensor-eeprom-5e9.h"
#include "fimc-is-sensor-eeprom.h"
#include "fimc-is-device-sensor.h"
#include "fimc-is-device-sensor-peri.h"
#include "fimc-is-core.h"

#define SENSOR_EEPROM_NAME "5E9"

int fimc_is_eeprom_5e9_check_all_crc(struct v4l2_subdev *subdev)
{
	int ret = 0;
	struct fimc_is_module_enum *module;
	struct fimc_is_eeprom *eeprom = NULL;
	struct fimc_is_device_sensor *sensor = NULL;
	int i;

	FIMC_BUG(!subdev);

	module = (struct fimc_is_module_enum *)v4l2_get_subdev_hostdata(subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);
	FIMC_BUG(!module);

	sensor = (struct fimc_is_device_sensor *)v4l2_get_subdev_hostdata(module->subdev);
	if (!sensor) {
		err("device sensor is NULL");
		ret = -ENODEV;
		return ret;
	}

	/* Check CRC to Address cal data */
	ret = CALL_EEPROMOPS(eeprom, eeprom_check_address, subdev);
	if (ret) {
		err("%s(): 5E9 EEPROM Address section CRC check fail(%d)", __func__, ret);

		/* All calibration data is zero set only Address section is invalid CRC */
		fimc_is_eeprom_cal_data_set(eeprom->data, "all",
				EEPROM_ADD_CRC_FST, EEPROM_DATA_SIZE, 0xff);

		/*Set all cal_status to ERROR if Address cal data invalid*/
		for (i = 0; i < CAMERA_CRC_INDEX_MAX; i++)
		    sensor->cal_status[i] = CRC_ERROR;

		return ret;
	} else
		info("5E9 EEPROM Address section CRC check success\n");

	/* Check CRC to Information cal data */
	ret = CALL_EEPROMOPS(eeprom, eeprom_check_info, subdev);
	if (ret) {
		err("%s(): 5E9 EEPROM Information CRC section check fail(%d)", __func__, ret);

		/* All calibration data is 0xff set but exception Address section */
		fimc_is_eeprom_cal_data_set(eeprom->data, "Information - End",
				EEPROM_INFO_CRC_FST, EEPROM_ADD_CAL_SIZE, 0xff);

		sensor->cal_status[CAMERA_CRC_INDEX_MNF] = CRC_ERROR;

	} else {
		info("5E9 EEPROM Informaion section CRC check success\n");

		sensor->cal_status[CAMERA_CRC_INDEX_MNF] = CRC_NO_ERROR;
	}

	/* Check CRC to AWB cal data */
	ret = CALL_EEPROMOPS(eeprom, eeprom_check_awb, subdev);
	if (ret) {
		err("%s(): 5E9 EEPROM AWB section CRC check fail(%d)", __func__, ret);

		fimc_is_eeprom_cal_data_set(eeprom->data, "AWB",
				EEPROM_AWB_CRC_FST, EEPROM_AWB_CAL_SIZE, 0xff);

		sensor->cal_status[CAMERA_CRC_INDEX_AWB] = CRC_ERROR;

	} else {
		info("5E9 EEPROM AWB section CRC check success\n");

		sensor->cal_status[CAMERA_CRC_INDEX_AWB] = CRC_NO_ERROR;

		ret = fimc_is_sensor_eeprom_check_awb_ratio(&eeprom->data[EEPROM_AWB_UNIT_OFFSET],
			&eeprom->data[EEPROM_AWB_GOLDEN_OFFSET],&eeprom->data[EEPROM_AWB_LIMIT_OFFSET]);
		if (ret) {
			err("%s(): 5E9 EEPROM AWB ratio out of limit(%d)", __func__, ret);

			sensor->cal_status[CAMERA_CRC_INDEX_AWB] = LIMIT_FAILURE;
		}
	}

	/* Check CRC to LSC cal data */
	ret = CALL_EEPROMOPS(eeprom, eeprom_check_lsc, subdev);
	if (ret) {
		err("%s(): 5E9 EEPROM LSC section CRC check fail(%d)", __func__, ret);

		fimc_is_eeprom_cal_data_set(eeprom->data, "LSC",
				EEPROM_LSC_CRC_FST, EEPROM_LSC_CAL_SIZE, 0xff);

	} else
		info("5E9 EEPROM LSC section CRC check success\n");

	/* Check CRC to AE Sync cal data */
	ret = CALL_EEPROMOPS(eeprom, eeprom_check_ae, subdev);
	if (ret) {
		err("%s(): 5E9 EEPROM AE section CRC check fail(%d)", __func__, ret);

		fimc_is_eeprom_cal_data_set(eeprom->data, "AE",
				EEPROM_AE_CRC_FST, EEPROM_AE_CAL_SIZE, 0xff);

	} else
		info("5E9 EEPROM AE section CRC check success\n");

	/* Check CRC to SFR cal data */
	ret = CALL_EEPROMOPS(eeprom, eeprom_check_sfr, subdev);
	if (ret) {
		err("%s(): EEPROM SFR section CRC check fail(%d)", __func__, ret);

		fimc_is_eeprom_cal_data_set(eeprom->data, "SFR",
				EEPROM_SFR_CRC_FST, EEPROM_SFR_CAL_SIZE, 0xff);

	} else
		info("5E9 EEPROM SFR section CRC check success\n");

	return ret;
}

static int fimc_is_eeprom_5e9_check_address(struct v4l2_subdev *subdev)
{
	int ret = 0;
	u16 crc_value = 0;
	u16 crc16 = 0;
	struct fimc_is_eeprom *eeprom = NULL;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	crc_value = ((eeprom->data[EEPROM_ADD_CRC_FST] << 8) | (eeprom->data[EEPROM_ADD_CRC_SEC]));

	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_ADD_CRC_CHK_START], EEPROM_ADD_CRC_CHK_SIZE);
	if (crc_value != crc16) {
		err("Error to ADD CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);

		ret = -EINVAL;
	} else
		info("ADD CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);

	return ret;
}

static int fimc_is_eeprom_5e9_check_info(struct v4l2_subdev *subdev)
{
	int ret = 0;
	u16 crc_value = 0;
	u16 crc16 = 0;
	struct fimc_is_eeprom *eeprom = NULL;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	crc_value = ((eeprom->data[EEPROM_INFO_CRC_FST] << 8) | (eeprom->data[EEPROM_INFO_CRC_SEC]));

	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_INFO_CRC_CHK_START], EEPROM_INFO_CRC_CHK_SIZE);
	if (crc_value != crc16) {
		err("Error to INFO CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);

		ret = -EINVAL;
	} else
		info("INFO CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);

	return ret;
}

static int fimc_is_eeprom_5e9_check_awb(struct v4l2_subdev *subdev)
{
	int ret = 0;
	u16 crc_value = 0;
	u16 crc16 = 0;
	struct fimc_is_eeprom *eeprom = NULL;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	crc_value = ((eeprom->data[EEPROM_AWB_CRC_FST] << 8) | (eeprom->data[EEPROM_AWB_CRC_SEC]));

	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_AWB_CRC_CHK_START], EEPROM_AWB_CRC_CHK_SIZE);
	if (crc_value != crc16) {
		err("Error to AWB CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);

		ret = -EINVAL;
	} else
		info("AWB CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);

	return ret;
}

static int fimc_is_eeprom_5e9_check_ae(struct v4l2_subdev *subdev)
{
	int ret = 0;
	u16 crc_value = 0;
	u16 crc16 = 0;
	struct fimc_is_eeprom *eeprom = NULL;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	crc_value = ((eeprom->data[EEPROM_AE_CRC_FST] << 8) | (eeprom->data[EEPROM_AE_CRC_SEC]));

	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_AE_CRC_CHK_START], EEPROM_AE_CRC_CHK_SIZE);
	if (crc_value != crc16) {
		err("Error to AE CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);

		ret = -EINVAL;
	} else
		info("AE CRC16: %x, cal_buffer CRC: %x\n", crc16, crc_value);

	return ret;
}

static int fimc_is_eeprom_5e9_check_lsc(struct v4l2_subdev *subdev)
{
	int ret = 0;
	u16 crc_value = 0;
	u16 crc16 = 0;
	struct fimc_is_eeprom *eeprom = NULL;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	crc_value = ((eeprom->data[EEPROM_LSC_CRC_FST] << 8) | (eeprom->data[EEPROM_LSC_CRC_SEC]));

	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_LSC_CRC_CHK_START], EEPROM_LSC_CRC_CHK_SIZE);
	if (crc_value != crc16) {
		err("Error to LSC CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);

		ret = -EINVAL;
	} else
		info("LSC CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);

	return ret;
}

static int fimc_is_eeprom_5e9_check_sfr(struct v4l2_subdev *subdev)
{
	int ret = 0;
	u16 crc_value = 0;
	u16 crc16 = 0;
	struct fimc_is_eeprom *eeprom = NULL;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	crc_value = ((eeprom->data[EEPROM_SFR_CRC_FST] << 8) | (eeprom->data[EEPROM_SFR_CRC_SEC]));

	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_SFR_CRC_CHK_START], EEPROM_SFR_CRC_CHK_SIZE);
	if (crc_value != crc16) {
		err("Error to SFR CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);

		ret = -EINVAL;
	} else
		info("SFR CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);

	return ret;
}

int fimc_is_eeprom_5e9_get_cal_data(struct v4l2_subdev *subdev)
{
	int ret = 0;
	struct fimc_is_eeprom *eeprom;
	struct i2c_client *client;

	FIMC_BUG(!subdev);

	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);

	FIMC_BUG(!eeprom);

	client = eeprom->client;
	if (unlikely(!client)) {
		err("client is NULL");
		ret = -EINVAL;
		return ret;
	}

	/*
	 * If already read at EEPROM data in module
	 * don't again read at EEPROM but there isn't file or
	 * data is NULL read EEPROM data
	 */
	ret = fimc_is_eeprom_file_read(EEPROM_DATA_PATH, (void *)eeprom->data, EEPROM_DATA_SIZE);
	if (ret) {
		I2C_MUTEX_LOCK(eeprom->i2c_lock);
		/* I2C read to Sensor EEPROM cal data */
		ret = fimc_is_eeprom_module_read(client, EEPROM_ADD_CRC_FST, eeprom->data, EEPROM_DATA_SIZE);
		if (ret < 0) {
			err("%s(): eeprom i2c read failed(%d)\n", __func__, ret);
			I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
			return ret;
		}
		I2C_MUTEX_UNLOCK(eeprom->i2c_lock);

		/* CRC check to each section cal data */
		ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
		if (ret < 0)
			err("%s(): eeprom data invalid(%d)\n", __func__, ret);

		/* Write file to Cal data */
		ret = fimc_is_eeprom_file_write(EEPROM_DATA_PATH, (void *)eeprom->data, EEPROM_DATA_SIZE);
		if (ret < 0) {
			err("%s(), eeprom file write fail(%d)\n", __func__, ret);
			return ret;
		}
	} else {
		/* CRC check to each section cal data */
		ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
		if (ret < 0)
			err("%s(): eeprom data invalid(%d)\n", __func__, ret);
	}

	return ret;
}

static struct fimc_is_eeprom_ops sensor_eeprom_ops = {
	.eeprom_read = fimc_is_eeprom_5e9_get_cal_data,
	.eeprom_check_all_crc = fimc_is_eeprom_5e9_check_all_crc,
	.eeprom_check_address = fimc_is_eeprom_5e9_check_address,
	.eeprom_check_info = fimc_is_eeprom_5e9_check_info,
	.eeprom_check_awb = fimc_is_eeprom_5e9_check_awb,
	.eeprom_check_ae = fimc_is_eeprom_5e9_check_ae,
	.eeprom_check_lsc = fimc_is_eeprom_5e9_check_lsc,
	.eeprom_check_sfr = fimc_is_eeprom_5e9_check_sfr,
};

static int sensor_eeprom_5e9_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	int ret = 0, i;
	struct fimc_is_core *core;
	struct v4l2_subdev *subdev_eeprom = NULL;
	struct fimc_is_eeprom *eeprom = NULL;
	struct fimc_is_device_sensor *device;
	struct device *dev;
	struct device_node *dnode;
	u32 sensor_id = 0;

	FIMC_BUG(!client);
	FIMC_BUG(!fimc_is_dev);

	core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
	if (!core) {
		probe_info("core device is not yet probed");
		return -EPROBE_DEFER;
	}

	dev = &client->dev;
	dnode = dev->of_node;

	ret = of_property_read_u32(dnode, "id", &sensor_id);
	if (ret) {
		probe_info("core device is not yet probed");
		return -EPROBE_DEFER;
	}

	device = &core->sensor[sensor_id];
	if (!device) {
		err("sensor device is NULL");
		ret = -ENOMEM;
		goto p_err;
	}

	eeprom = kzalloc(sizeof(struct fimc_is_eeprom), GFP_KERNEL);
	if (!eeprom) {
		err("eeprom is NULL");
		ret = -ENOMEM;
		goto p_err;
	}

	subdev_eeprom = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
	if (!subdev_eeprom) {
		probe_err("subdev_cis NULL");
		ret = -ENOMEM;
		goto p_err;
	}

	eeprom->data = kzalloc(EEPROM_DATA_SIZE, GFP_KERNEL);
	if (!eeprom->data) {
		err("data is NULL");
		ret = -ENOMEM;
		goto p_err;
	}

	eeprom->id = EEPROM_NAME_5E9;
	eeprom->subdev = subdev_eeprom;
	eeprom->device = sensor_id;
	eeprom->client = client;
	eeprom->i2c_lock = NULL;
	eeprom->total_size = EEPROM_DATA_SIZE;
	eeprom->eeprom_ops = &sensor_eeprom_ops;

	for (i = 0; i < CAMERA_CRC_INDEX_MAX; i++)
		device->cal_status[i] = CRC_NO_ERROR;

	device->subdev_eeprom = subdev_eeprom;
	device->eeprom = eeprom;

	v4l2_set_subdevdata(subdev_eeprom, eeprom);
	v4l2_set_subdev_hostdata(subdev_eeprom, device);

	snprintf(subdev_eeprom->name, V4L2_SUBDEV_NAME_SIZE, "eeprom-subdev.%d", eeprom->id);

	probe_info("%s done\n", __func__);

p_err:
	return ret;
}

static const struct of_device_id sensor_eeprom_5e9_match[] = {
	{
		.compatible = "samsung,exynos5-fimc-is-sensor-eeprom-5e9",
	},
	{},
};
MODULE_DEVICE_TABLE(of, sensor_eeprom_5e9_match);

static const struct i2c_device_id sensor_eeprom_5e9_idt[] = {
	{ SENSOR_EEPROM_NAME, 0 },
	{},
};

static struct i2c_driver sensor_eeprom_5e9_driver = {
	.probe  = sensor_eeprom_5e9_probe,
	.driver = {
		.name	= SENSOR_EEPROM_NAME,
		.owner	= THIS_MODULE,
		.of_match_table = sensor_eeprom_5e9_match,
		.suppress_bind_attrs = true,
	},
	.id_table = sensor_eeprom_5e9_idt
};

static int __init sensor_eeprom_5e9_init(void)
{
	int ret;

	ret = i2c_add_driver(&sensor_eeprom_5e9_driver);
	if (ret)
		err("failed to add %s driver: %d\n",
			sensor_eeprom_5e9_driver.driver.name, ret);

	return ret;
}
late_initcall_sync(sensor_eeprom_5e9_init);
Commit	Line	Data
f3af0f51 WK	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-5e9.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 "5E9"
	30
	31	int fimc_is_eeprom_5e9_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;
a1e4143e	37	int i;
f3af0f51 WK	38
	39	FIMC_BUG(!subdev);
	40
	41	module = (struct fimc_is_module_enum *)v4l2_get_subdev_hostdata(subdev);
	42
	43	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	44
	45	FIMC_BUG(!eeprom);
	46	FIMC_BUG(!module);
	47
	48	sensor = (struct fimc_is_device_sensor *)v4l2_get_subdev_hostdata(module->subdev);
	49	if (!sensor) {
	50	err("device sensor is NULL");
	51	ret = -ENODEV;
	52	return ret;
	53	}
	54
	55	/* Check CRC to Address cal data */
	56	ret = CALL_EEPROMOPS(eeprom, eeprom_check_address, subdev);
	57	if (ret) {
	58	err("%s(): 5E9 EEPROM Address section CRC check fail(%d)", __func__, ret);
	59
	60	/* All calibration data is zero set only Address section is invalid CRC */
	61	fimc_is_eeprom_cal_data_set(eeprom->data, "all",
0581d52f	62	EEPROM_ADD_CRC_FST, EEPROM_DATA_SIZE, 0xff);
f3af0f51 WK	63
f3af0f51 WK	64	/Set all cal_status to ERROR if Address cal data invalid/
a1e4143e	65	for (i = 0; i < CAMERA_CRC_INDEX_MAX; i++)
f3af0f51 WK	66	sensor->cal_status[i] = CRC_ERROR;
	67
	68	return ret;
	69	} else
	70	info("5E9 EEPROM Address section CRC check success\n");
	71
	72	/* Check CRC to Information cal data */
	73	ret = CALL_EEPROMOPS(eeprom, eeprom_check_info, subdev);
	74	if (ret) {
	75	err("%s(): 5E9 EEPROM Information CRC section check fail(%d)", __func__, ret);
	76
	77	/* All calibration data is 0xff set but exception Address section */
	78	fimc_is_eeprom_cal_data_set(eeprom->data, "Information - End",
0581d52f	79	EEPROM_INFO_CRC_FST, EEPROM_ADD_CAL_SIZE, 0xff);
f3af0f51 WK	80
	81	sensor->cal_status[CAMERA_CRC_INDEX_MNF] = CRC_ERROR;
	82
	83	} else {
	84	info("5E9 EEPROM Informaion section CRC check success\n");
	85
	86	sensor->cal_status[CAMERA_CRC_INDEX_MNF] = CRC_NO_ERROR;
	87	}
	88
	89	/* Check CRC to AWB cal data */
	90	ret = CALL_EEPROMOPS(eeprom, eeprom_check_awb, subdev);
	91	if (ret) {
	92	err("%s(): 5E9 EEPROM AWB section CRC check fail(%d)", __func__, ret);
	93
	94	fimc_is_eeprom_cal_data_set(eeprom->data, "AWB",
0581d52f	95	EEPROM_AWB_CRC_FST, EEPROM_AWB_CAL_SIZE, 0xff);
f3af0f51 WK	96
	97	sensor->cal_status[CAMERA_CRC_INDEX_AWB] = CRC_ERROR;
	98
	99	} else {
	100	info("5E9 EEPROM AWB section CRC check success\n");
	101
	102	sensor->cal_status[CAMERA_CRC_INDEX_AWB] = CRC_NO_ERROR;
	103
	104	ret = fimc_is_sensor_eeprom_check_awb_ratio(&eeprom->data[EEPROM_AWB_UNIT_OFFSET],
	105	&eeprom->data[EEPROM_AWB_GOLDEN_OFFSET],&eeprom->data[EEPROM_AWB_LIMIT_OFFSET]);
	106	if (ret) {
	107	err("%s(): 5E9 EEPROM AWB ratio out of limit(%d)", __func__, ret);
	108
	109	sensor->cal_status[CAMERA_CRC_INDEX_AWB] = LIMIT_FAILURE;
	110	}
	111	}
	112
	113	/* Check CRC to LSC cal data */
	114	ret = CALL_EEPROMOPS(eeprom, eeprom_check_lsc, subdev);
	115	if (ret) {
	116	err("%s(): 5E9 EEPROM LSC section CRC check fail(%d)", __func__, ret);
	117
	118	fimc_is_eeprom_cal_data_set(eeprom->data, "LSC",
0581d52f	119	EEPROM_LSC_CRC_FST, EEPROM_LSC_CAL_SIZE, 0xff);
f3af0f51 WK	120
	121	} else
	122	info("5E9 EEPROM LSC section CRC check success\n");
	123
	124	/* Check CRC to AE Sync cal data */
	125	ret = CALL_EEPROMOPS(eeprom, eeprom_check_ae, subdev);
	126	if (ret) {
	127	err("%s(): 5E9 EEPROM AE section CRC check fail(%d)", __func__, ret);
	128
	129	fimc_is_eeprom_cal_data_set(eeprom->data, "AE",
0581d52f	130	EEPROM_AE_CRC_FST, EEPROM_AE_CAL_SIZE, 0xff);
f3af0f51 WK	131
	132	} else
	133	info("5E9 EEPROM AE section CRC check success\n");
	134
	135	/* Check CRC to SFR cal data */
	136	ret = CALL_EEPROMOPS(eeprom, eeprom_check_sfr, subdev);
	137	if (ret) {
	138	err("%s(): EEPROM SFR section CRC check fail(%d)", __func__, ret);
	139
	140	fimc_is_eeprom_cal_data_set(eeprom->data, "SFR",
0581d52f	141	EEPROM_SFR_CRC_FST, EEPROM_SFR_CAL_SIZE, 0xff);
f3af0f51 WK	142
	143	} else
	144	info("5E9 EEPROM SFR section CRC check success\n");
	145
f3af0f51 WK	146	return ret;
	147	}
	148
	149	static int fimc_is_eeprom_5e9_check_address(struct v4l2_subdev *subdev)
	150	{
	151	int ret = 0;
	152	u16 crc_value = 0;
	153	u16 crc16 = 0;
	154	struct fimc_is_eeprom *eeprom = NULL;
	155
	156	FIMC_BUG(!subdev);
	157
	158	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	159
	160	FIMC_BUG(!eeprom);
	161
	162	crc_value = ((eeprom->data[EEPROM_ADD_CRC_FST] << 8) \| (eeprom->data[EEPROM_ADD_CRC_SEC]));
	163
	164	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_ADD_CRC_CHK_START], EEPROM_ADD_CRC_CHK_SIZE);
	165	if (crc_value != crc16) {
	166	err("Error to ADD CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
	167
	168	ret = -EINVAL;
	169	} else
	170	info("ADD CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
	171
	172	return ret;
	173	}
	174
	175	static int fimc_is_eeprom_5e9_check_info(struct v4l2_subdev *subdev)
	176	{
	177	int ret = 0;
	178	u16 crc_value = 0;
	179	u16 crc16 = 0;
	180	struct fimc_is_eeprom *eeprom = NULL;
	181
	182	FIMC_BUG(!subdev);
	183
	184	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	185
	186	FIMC_BUG(!eeprom);
	187
	188	crc_value = ((eeprom->data[EEPROM_INFO_CRC_FST] << 8) \| (eeprom->data[EEPROM_INFO_CRC_SEC]));
	189
	190	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_INFO_CRC_CHK_START], EEPROM_INFO_CRC_CHK_SIZE);
0581d52f	191	if (crc_value != crc16) {
f3af0f51	192	err("Error to INFO CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
0581d52f	193
	194	ret = -EINVAL;
	195	} else
f3af0f51 WK	196	info("INFO CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
	197
	198	return ret;
	199	}
	200
	201	static int fimc_is_eeprom_5e9_check_awb(struct v4l2_subdev *subdev)
	202	{
	203	int ret = 0;
	204	u16 crc_value = 0;
	205	u16 crc16 = 0;
	206	struct fimc_is_eeprom *eeprom = NULL;
	207
	208	FIMC_BUG(!subdev);
	209
	210	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	211
	212	FIMC_BUG(!eeprom);
	213
	214	crc_value = ((eeprom->data[EEPROM_AWB_CRC_FST] << 8) \| (eeprom->data[EEPROM_AWB_CRC_SEC]));
	215
	216	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_AWB_CRC_CHK_START], EEPROM_AWB_CRC_CHK_SIZE);
0581d52f	217	if (crc_value != crc16) {
f3af0f51	218	err("Error to AWB CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
0581d52f	219
	220	ret = -EINVAL;
	221	} else
f3af0f51 WK	222	info("AWB CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
	223
	224	return ret;
	225	}
	226
	227	static int fimc_is_eeprom_5e9_check_ae(struct v4l2_subdev *subdev)
	228	{
	229	int ret = 0;
	230	u16 crc_value = 0;
	231	u16 crc16 = 0;
	232	struct fimc_is_eeprom *eeprom = NULL;
	233
	234	FIMC_BUG(!subdev);
	235
	236	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	237
	238	FIMC_BUG(!eeprom);
	239
	240	crc_value = ((eeprom->data[EEPROM_AE_CRC_FST] << 8) \| (eeprom->data[EEPROM_AE_CRC_SEC]));
	241
	242	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_AE_CRC_CHK_START], EEPROM_AE_CRC_CHK_SIZE);
0581d52f	243	if (crc_value != crc16) {
f3af0f51	244	err("Error to AE CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
0581d52f	245
	246	ret = -EINVAL;
	247	} else
f3af0f51 WK	248	info("AE CRC16: %x, cal_buffer CRC: %x\n", crc16, crc_value);
	249
	250	return ret;
	251	}
	252
	253	static int fimc_is_eeprom_5e9_check_lsc(struct v4l2_subdev *subdev)
	254	{
	255	int ret = 0;
	256	u16 crc_value = 0;
	257	u16 crc16 = 0;
	258	struct fimc_is_eeprom *eeprom = NULL;
	259
	260	FIMC_BUG(!subdev);
	261
	262	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	263
	264	FIMC_BUG(!eeprom);
	265
	266	crc_value = ((eeprom->data[EEPROM_LSC_CRC_FST] << 8) \| (eeprom->data[EEPROM_LSC_CRC_SEC]));
	267
	268	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_LSC_CRC_CHK_START], EEPROM_LSC_CRC_CHK_SIZE);
0581d52f	269	if (crc_value != crc16) {
f3af0f51	270	err("Error to LSC CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
0581d52f	271
	272	ret = -EINVAL;
	273	} else
f3af0f51 WK	274	info("LSC CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
	275
	276	return ret;
	277	}
	278
	279	static int fimc_is_eeprom_5e9_check_sfr(struct v4l2_subdev *subdev)
	280	{
	281	int ret = 0;
	282	u16 crc_value = 0;
	283	u16 crc16 = 0;
	284	struct fimc_is_eeprom *eeprom = NULL;
	285
	286	FIMC_BUG(!subdev);
	287
	288	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	289
	290	FIMC_BUG(!eeprom);
	291
	292	crc_value = ((eeprom->data[EEPROM_SFR_CRC_FST] << 8) \| (eeprom->data[EEPROM_SFR_CRC_SEC]));
	293
	294	crc16 = fimc_is_sensor_eeprom_check_crc(&eeprom->data[EEPROM_SFR_CRC_CHK_START], EEPROM_SFR_CRC_CHK_SIZE);
0581d52f	295	if (crc_value != crc16) {
f3af0f51	296	err("Error to SFR CRC16: 0x%x, cal_buffer CRC: 0x%x", crc16, crc_value);
0581d52f	297
	298	ret = -EINVAL;
	299	} else
f3af0f51 WK	300	info("SFR CRC16: 0x%x, cal_buffer CRC: 0x%x\n", crc16, crc_value);
	301
	302	return ret;
	303	}
	304
	305	int fimc_is_eeprom_5e9_get_cal_data(struct v4l2_subdev *subdev)
	306	{
	307	int ret = 0;
	308	struct fimc_is_eeprom *eeprom;
	309	struct i2c_client *client;
	310
	311	FIMC_BUG(!subdev);
	312
	313	eeprom = (struct fimc_is_eeprom *)v4l2_get_subdevdata(subdev);
	314
	315	FIMC_BUG(!eeprom);
	316
	317	client = eeprom->client;
	318	if (unlikely(!client)) {
	319	err("client is NULL");
	320	ret = -EINVAL;
	321	return ret;
	322	}
	323
	324	/*
	325	* If already read at EEPROM data in module
	326	* don't again read at EEPROM but there isn't file or
	327	* data is NULL read EEPROM data
	328	*/
	329	ret = fimc_is_eeprom_file_read(EEPROM_DATA_PATH, (void *)eeprom->data, EEPROM_DATA_SIZE);
	330	if (ret) {
0581d52f	331	I2C_MUTEX_LOCK(eeprom->i2c_lock);
f3af0f51 WK	332	/* I2C read to Sensor EEPROM cal data */
	333	ret = fimc_is_eeprom_module_read(client, EEPROM_ADD_CRC_FST, eeprom->data, EEPROM_DATA_SIZE);
	334	if (ret < 0) {
	335	err("%s(): eeprom i2c read failed(%d)\n", __func__, ret);
0581d52f	336	I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
f3af0f51 WK	337	return ret;
f3af0f51 WK	338	}
0581d52f	339	I2C_MUTEX_UNLOCK(eeprom->i2c_lock);
f3af0f51 WK	340
	341	/* CRC check to each section cal data */
	342	ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
	343	if (ret < 0)
	344	err("%s(): eeprom data invalid(%d)\n", __func__, ret);
	345
	346	/* Write file to Cal data */
	347	ret = fimc_is_eeprom_file_write(EEPROM_DATA_PATH, (void *)eeprom->data, EEPROM_DATA_SIZE);
	348	if (ret < 0) {
	349	err("%s(), eeprom file write fail(%d)\n", __func__, ret);
	350	return ret;
	351	}
	352	} else {
	353	/* CRC check to each section cal data */
	354	ret = CALL_EEPROMOPS(eeprom, eeprom_check_all_crc, subdev);
	355	if (ret < 0)
	356	err("%s(): eeprom data invalid(%d)\n", __func__, ret);
	357	}
	358
	359	return ret;
	360	}
	361
	362	static struct fimc_is_eeprom_ops sensor_eeprom_ops = {
	363	.eeprom_read = fimc_is_eeprom_5e9_get_cal_data,
	364	.eeprom_check_all_crc = fimc_is_eeprom_5e9_check_all_crc,
	365	.eeprom_check_address = fimc_is_eeprom_5e9_check_address,
	366	.eeprom_check_info = fimc_is_eeprom_5e9_check_info,
	367	.eeprom_check_awb = fimc_is_eeprom_5e9_check_awb,
	368	.eeprom_check_ae = fimc_is_eeprom_5e9_check_ae,
	369	.eeprom_check_lsc = fimc_is_eeprom_5e9_check_lsc,
	370	.eeprom_check_sfr = fimc_is_eeprom_5e9_check_sfr,
	371	};
	372
	373	static int sensor_eeprom_5e9_probe(struct i2c_client *client,
	374	const struct i2c_device_id *id)
	375	{
	376	int ret = 0, i;
	377	struct fimc_is_core *core;
	378	struct v4l2_subdev *subdev_eeprom = NULL;
	379	struct fimc_is_eeprom *eeprom = NULL;
	380	struct fimc_is_device_sensor *device;
	381	struct device *dev;
	382	struct device_node *dnode;
	383	u32 sensor_id = 0;
	384
	385	FIMC_BUG(!client);
	386	FIMC_BUG(!fimc_is_dev);
	387
	388	core = (struct fimc_is_core *)dev_get_drvdata(fimc_is_dev);
	389	if (!core) {
	390	probe_info("core device is not yet probed");
	391	return -EPROBE_DEFER;
	392	}
	393
	394	dev = &client->dev;
	395	dnode = dev->of_node;
	396
	397	ret = of_property_read_u32(dnode, "id", &sensor_id);
	398	if (ret) {
	399	probe_info("core device is not yet probed");
	400	return -EPROBE_DEFER;
	401	}
	402
	403	device = &core->sensor[sensor_id];
404	if (!device) {
405	err("sensor device is NULL");
406	ret = -ENOMEM;
407	goto p_err;
408	}
409
410	eeprom = kzalloc(sizeof(struct fimc_is_eeprom), GFP_KERNEL);
411	if (!eeprom) {
412	err("eeprom is NULL");
413	ret = -ENOMEM;
414	goto p_err;
415	}
416
417	subdev_eeprom = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
418	if (!subdev_eeprom) {
419	probe_err("subdev_cis NULL");
420	ret = -ENOMEM;
421	goto p_err;
422	}
423
424	eeprom->data = kzalloc(EEPROM_DATA_SIZE, GFP_KERNEL);
425	if (!eeprom->data) {
426	err("data is NULL");
427	ret = -ENOMEM;
428	goto p_err;
429	}
430
431	eeprom->id = EEPROM_NAME_5E9;
432	eeprom->subdev = subdev_eeprom;
433	eeprom->device = sensor_id;
434	eeprom->client = client;
435	eeprom->i2c_lock = NULL;
436	eeprom->total_size = EEPROM_DATA_SIZE;
437	eeprom->eeprom_ops = &sensor_eeprom_ops;
438
439	for (i = 0; i < CAMERA_CRC_INDEX_MAX; i++)
440	device->cal_status[i] = CRC_NO_ERROR;
441
442	device->subdev_eeprom = subdev_eeprom;
443	device->eeprom = eeprom;
444
445	v4l2_set_subdevdata(subdev_eeprom, eeprom);
446	v4l2_set_subdev_hostdata(subdev_eeprom, device);
447
448	snprintf(subdev_eeprom->name, V4L2_SUBDEV_NAME_SIZE, "eeprom-subdev.%d", eeprom->id);
449
450	probe_info("%s done\n", __func__);
451
452	p_err:
453	return ret;
454	}
455
456	static const struct of_device_id sensor_eeprom_5e9_match[] = {
457	{
458	.compatible = "samsung,exynos5-fimc-is-sensor-eeprom-5e9",
459	},
460	{},
461	};
462	MODULE_DEVICE_TABLE(of, sensor_eeprom_5e9_match);
463
464	static const struct i2c_device_id sensor_eeprom_5e9_idt[] = {
465	{ SENSOR_EEPROM_NAME, 0 },
466	{},
467	};
468
469	static struct i2c_driver sensor_eeprom_5e9_driver = {
470	.probe = sensor_eeprom_5e9_probe,
471	.driver = {
472	.name = SENSOR_EEPROM_NAME,
473	.owner = THIS_MODULE,
474	.of_match_table = sensor_eeprom_5e9_match,
475	.suppress_bind_attrs = true,
476	},
477	.id_table = sensor_eeprom_5e9_idt
478	};
479
480	static int __init sensor_eeprom_5e9_init(void)
481	{
482	int ret;
483
484	ret = i2c_add_driver(&sensor_eeprom_5e9_driver);
485	if (ret)
486	err("failed to add %s driver: %d\n",
487	sensor_eeprom_5e9_driver.driver.name, ret);
488
489	return ret;
490	}
491	late_initcall_sync(sensor_eeprom_5e9_init);