// SPDX-License-Identifier: GPL-2.0
/*
 * vehicle sensor adv7181
 *
 * Copyright (C) 2022 Rockchip Electronics Co.Ltd
 * Authors:
 *      Zhiqin Wei <wzq@rock-chips.com>
 *
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/sysctl.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/proc_fs.h>
#include <linux/suspend.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/videodev2.h>
#include "vehicle_cfg.h"
#include "vehicle_main.h"
#include "vehicle_ad.h"
#include "vehicle_ad_7181.h"

enum {
	FORCE_PAL_WIDTH = 720,
	FORCE_PAL_HEIGHT = 576,
	FORCE_NTSC_WIDTH = 720,
	FORCE_NTSC_HEIGHT = 480,
	FORCE_CIF_OUTPUT_FORMAT = CIF_OUTPUT_FORMAT_420,
};

static struct vehicle_ad_dev *ad7181_g_addev;
static v4l2_std_id std_old = V4L2_STD_NTSC;

#define SENSOR_REGISTER_LEN	1	/* sensor register address bytes*/
#define SENSOR_VALUE_LEN	1	/* sensor register value bytes*/

struct rk_sensor_reg {
	unsigned int reg;
	unsigned int val;
};

#define ADV7181_STATUS1_REG		0x10
#define ADV7181_STATUS1_IN_LOCK		0x01
#define ADV7181_STATUS1_AUTOD_MASK	0x70
#define ADV7181_STATUS1_AUTOD_NTSM_M_J	0x00
#define ADV7181_STATUS1_AUTOD_NTSC_4_43 0x10
#define ADV7181_STATUS1_AUTOD_PAL_M	0x20
#define ADV7181_STATUS1_AUTOD_PAL_60	0x30
#define ADV7181_STATUS1_AUTOD_PAL_B_G	0x40
#define ADV7181_STATUS1_AUTOD_SECAM	0x50
#define ADV7181_STATUS1_AUTOD_PAL_COMB	0x60
#define ADV7181_STATUS1_AUTOD_SECAM_525	0x70

#define ADV7181_INPUT_CONTROL		0x00
#define ADV7181_INPUT_DEFAULT		0x00
#define ADV7181_INPUT_CVBS_AIN2		0x00
#define ADV7181_INPUT_CVBS_AIN3		0x01
#define ADV7181_INPUT_CVBS_AIN5		0x02
#define ADV7181_INPUT_CVBS_AIN6		0x03
#define ADV7181_INPUT_CVBS_AIN8		0x04
#define ADV7181_INPUT_CVBS_AIN10	0x05
#define ADV7181_INPUT_CVBS_AIN1		0x0B
#define ADV7181_INPUT_CVBS_AIN4		0x0D
#define ADV7181_INPUT_CVBS_AIN7		0x0F
#define ADV7181_INPUT_YPRPB_AIN6_8_10	0x00

#define SEQCMD_END  0xFF000000
#define SensorEnd   {SEQCMD_END, 0x00}

#define SENSOR_DG VEHICLE_DG

/* Preview resolution setting*/
static struct rk_sensor_reg sensor_preview_data[] = {
	/* autodetect cvbs in ntsc/pal/secam 8-bit 422 encode */
	{0x00, 0x0B}, /*cvbs in AIN1*/
	{0x04, 0x77},
	{0x17, 0x41},
	{0x1D, 0x47},
	{0x31, 0x02},
	{0x3A, 0x17},
	{0x3B, 0x81},
	{0x3D, 0xA2},
	{0x3E, 0x6A},
	{0x3F, 0xA0},
	{0x86, 0x0B},
	{0xF3, 0x01},
	{0xF9, 0x03},
	{0x0E, 0x80},
	{0x52, 0x46},
	{0x54, 0x80},
	{0x7F, 0xFF},
	{0x81, 0x30},
	{0x90, 0xC9},
	{0x91, 0x40},
	{0x92, 0x3C},
	{0x93, 0xCA},
	{0x94, 0xD5},
	{0xB1, 0xFF},
	{0xB6, 0x08},
	{0xC0, 0x9A},
	{0xCF, 0x50},
	{0xD0, 0x4E},
	{0xD1, 0xB9},
	{0xD6, 0xDD},
	{0xD7, 0xE2},
	{0xE5, 0x51},
	{0xF6, 0x3B},
	{0x0E, 0x00},
	{0x03, 0x4C}, //stream off
	{0xDF, 0X46},
	{0xC9, 0x04},
	{0xC5, 0x81},
	{0xC4, 0x34},
	{0xBf, 0x02},
	{0xB5, 0x83},
	{0xB6, 0x00},
	{0xaf, 0x03},
	{0xae, 0x00},
	{0xac, 0x00},
	{0xAB, 0x00},
	{0xa1, 0xFF},
	{0xA2, 0x00},
	{0xA3, 0x00},
	{0xA4, 0x00},
	{0xa5, 0x01},
	{0xA6, 0x00},
	{0xA6, 0x00},
	{0xA7, 0x00},
	{0xA8, 0x00},
	{0xa0, 0x03},
	{0x98, 0X00},
	{0x97, 0X00},
	{0X90, 0X00},
	{0X85, 0X02},
	{0x7B, 0x1E},
	{0x74, 0x04},
	{0x75, 0x01},
	{0x76, 0x00},
	{0x6B, 0xC0},
	{0x67, 0x03},
	{0x3C, 0x58},
	{0x30, 0x4C},
	{0x2E, 0X9F},
	{0x12, 0XC0},
	{0x10, 0X0D},
	{0x05, 0X00},
	{0x06, 0X02},
	{0x60, 0x01},
	SensorEnd
};

static struct rk_sensor_reg sensor_preview_data_yprpb_p[] = {
	{0x05, 0x01},
	{0x06, 0x06},
	{0xc3, 0x56},
	{0xc4, 0xb4},
	{0x1d, 0x47},
	{0x3a, 0x11},
	{0x3b, 0x81},
	{0x3c, 0x3b},
	{0x6b, 0x83},
	{0xc9, 0x00},
	{0x73, 0x10},
	{0x74, 0xa3},
	{0x75, 0xe8},
	{0x76, 0xfa},
	{0x7b, 0x1c},
	{0x85, 0x19},
	{0x86, 0x0b},
	{0xbf, 0x06},
	{0xc0, 0x40},
	{0xc1, 0xf0},
	{0xc2, 0x80},
	{0xc5, 0x01},
	{0xc9, 0x08},
	{0x0e, 0x80},
	{0x52, 0x46},
	{0x54, 0x80},
	{0x57, 0x01},
	{0xf6, 0x3b},
	{0x0e, 0x00},
	{0x67, 0x2f},
	{0x03, 0x4C}, //disable out put
	SensorEnd
};

static v4l2_std_id adv7181_std_to_v4l2(u8 status1)
{
	/* in case V4L2_IN_ST_NO_SIGNAL */
	if (!(status1 & ADV7181_STATUS1_IN_LOCK))
		return V4L2_STD_UNKNOWN;

	switch (status1 & ADV7181_STATUS1_AUTOD_MASK) {
	case ADV7181_STATUS1_AUTOD_PAL_M:
	case ADV7181_STATUS1_AUTOD_NTSM_M_J:
		return V4L2_STD_NTSC;
	case ADV7181_STATUS1_AUTOD_NTSC_4_43:
		return V4L2_STD_NTSC_443;
	case ADV7181_STATUS1_AUTOD_PAL_60:
		return V4L2_STD_PAL_60;
	case ADV7181_STATUS1_AUTOD_PAL_B_G:
		return V4L2_STD_PAL;
	case ADV7181_STATUS1_AUTOD_SECAM:
		return V4L2_STD_SECAM;
	case ADV7181_STATUS1_AUTOD_PAL_COMB:
		return V4L2_STD_PAL_Nc | V4L2_STD_PAL_N;
	case ADV7181_STATUS1_AUTOD_SECAM_525:
		return V4L2_STD_SECAM;
	default:
		return V4L2_STD_UNKNOWN;
	}
}

static u32 adv7181_status_to_v4l2(u8 status1)
{
	if (!(status1 & ADV7181_STATUS1_IN_LOCK))
		return V4L2_IN_ST_NO_SIGNAL;

	return 0;
}

static int adv7181_vehicle_status(struct vehicle_ad_dev *ad,
				  u32 *status,
				  v4l2_std_id *std)
{
	unsigned char status1 = 0;

	status1 = vehicle_generic_sensor_read(ad, ADV7181_STATUS1_REG);
	if (status1)
		return status1;

	if (status)
		*status = adv7181_status_to_v4l2(status1);

	if (std)
		*std = adv7181_std_to_v4l2(status1);

	return 0;
}

static void adv7181_reinit_parameter(struct vehicle_ad_dev *ad, v4l2_std_id std)
{
	int i;

	if (ad7181_g_addev->ad_chl == 0) {
		ad->cfg.width = 1024;
		ad->cfg.height = 500;
		ad->cfg.start_x = 56;
		ad->cfg.start_y = 0;
		ad->cfg.input_format = CIF_INPUT_FORMAT_YUV;
		ad->cfg.output_format = FORCE_CIF_OUTPUT_FORMAT;
		ad->cfg.field_order = 0;
		ad->cfg.yuv_order = 1;
		ad->cfg.href = 0;
		ad->cfg.vsync = 0;
		ad->cfg.frame_rate = 60;
		ad->cfg.type = V4L2_MBUS_PARALLEL;
		ad->cfg.mbus_flags = V4L2_MBUS_HSYNC_ACTIVE_LOW |
					V4L2_MBUS_VSYNC_ACTIVE_LOW |
					V4L2_MBUS_PCLK_SAMPLE_RISING;
	} else if (std == V4L2_STD_PAL) {
		ad->cfg.width = FORCE_PAL_WIDTH;
		ad->cfg.height = FORCE_PAL_HEIGHT;
		ad->cfg.start_x = 0;
		ad->cfg.start_y = 0;
		ad->cfg.input_format = CIF_INPUT_FORMAT_PAL;
		ad->cfg.output_format = FORCE_CIF_OUTPUT_FORMAT;
		ad->cfg.field_order = 0;
		ad->cfg.yuv_order = 0;
		ad->cfg.href = 0;
		ad->cfg.vsync = 0;
		ad->cfg.frame_rate = 25;
		ad->cfg.type = V4L2_MBUS_PARALLEL;
		ad->cfg.mbus_flags = V4L2_MBUS_HSYNC_ACTIVE_LOW |
					V4L2_MBUS_VSYNC_ACTIVE_LOW |
					V4L2_MBUS_PCLK_SAMPLE_RISING;
	} else {
		ad->cfg.width = FORCE_NTSC_WIDTH;
		ad->cfg.height = FORCE_NTSC_HEIGHT;
		ad->cfg.start_x = 0;
		ad->cfg.start_y = 0;
		ad->cfg.input_format = CIF_INPUT_FORMAT_NTSC;
		ad->cfg.output_format = FORCE_CIF_OUTPUT_FORMAT;
		ad->cfg.field_order = 0;
		ad->cfg.yuv_order = 2;
		ad->cfg.href = 0;
		ad->cfg.vsync = 0;
		ad->cfg.frame_rate = 30;
		ad->cfg.type = V4L2_MBUS_PARALLEL;
		ad->cfg.mbus_flags = V4L2_MBUS_HSYNC_ACTIVE_LOW |
					V4L2_MBUS_VSYNC_ACTIVE_LOW |
					V4L2_MBUS_PCLK_SAMPLE_RISING;
	}

	/* fix crop info from dts config */
	for (i = 0; i < 4; i++) {
		if ((ad->defrects[i].width == ad->cfg.width) &&
		    (ad->defrects[i].height == ad->cfg.height)) {
			ad->cfg.start_x = ad->defrects[i].crop_x;
			ad->cfg.start_y = ad->defrects[i].crop_y;
			ad->cfg.width = ad->defrects[i].crop_width;
			ad->cfg.height = ad->defrects[i].crop_height;
		}
	}

	SENSOR_DG("size %dx%d, crop(%d,%d)\n",
	    ad->cfg.width, ad->cfg.height,
	    ad->cfg.start_x, ad->cfg.start_y);
}

static void adv7181_reg_init(struct vehicle_ad_dev *ad, unsigned char cvstd)
{
	struct rk_sensor_reg *sensor;
	int i = 0;
	unsigned char val[2];

	switch (ad->ad_chl) {
	case 0:
		ad->ad_chl = ADV7181_INPUT_CVBS_AIN1;
		break;
	case 1:
		ad->ad_chl = ADV7181_INPUT_CVBS_AIN6;
		break;
	case 2:
		ad->ad_chl = ADV7181_INPUT_CVBS_AIN8;
		break;
	case 3:
		ad->ad_chl = ADV7181_INPUT_CVBS_AIN10;
		break;
	case 4:
		ad->ad_chl = ADV7181_INPUT_YPRPB_AIN6_8_10;
		break;
	default:
		ad->ad_chl = ADV7181_INPUT_CVBS_AIN1;
	}
	val[0] = ad->ad_chl;
	vehicle_generic_sensor_write(ad, ADV7181_INPUT_CONTROL, val);

	if (ad->ad_chl == ADV7181_INPUT_YPRPB_AIN6_8_10) {
		SENSOR_DG("%s %d set sensor_preview_data_yprpb_p/p", __func__, __LINE__);
		sensor = sensor_preview_data_yprpb_p;
	} else {
		SENSOR_DG("%s %d set n/p", __func__, __LINE__);
		sensor = sensor_preview_data;
	}
	while ((sensor[i].reg != SEQCMD_END) && (sensor[i].reg != 0xFC000000)) {
		if (sensor[i].reg == ADV7181_INPUT_CONTROL) {
			SENSOR_DG("%s %d lkg test ad channel = %d\n",
					__func__, __LINE__, ad->ad_chl);
		} else {
			val[0] = sensor[i].val;
			vehicle_generic_sensor_write(ad, sensor[i].reg, val);
		}
		i++;
	}

	val[0] = ad->ad_chl;
	vehicle_generic_sensor_write(ad, ADV7181_INPUT_CONTROL, val);
}

int adv7181_ad_get_cfg(struct vehicle_cfg **cfg)
{
	u32 status;

	if (!ad7181_g_addev)
		return -1;

	adv7181_vehicle_status(ad7181_g_addev, &status, NULL);

	ad7181_g_addev->cfg.ad_ready = true;

	*cfg = &ad7181_g_addev->cfg;

	return 0;
}

void adv7181_ad_check_cif_error(struct vehicle_ad_dev *ad, int last_line)
{
	SENSOR_DG("%s, last_line %d\n", __func__, last_line);
	if (last_line < 1)
		return;

	ad->cif_error_last_line = last_line;
	if (std_old == V4L2_STD_PAL) {
		if (last_line == FORCE_NTSC_HEIGHT) {
			if (ad->state_check_work.state_check_wq)
				queue_delayed_work(
					ad->state_check_work.state_check_wq,
					&ad->state_check_work.work,
					msecs_to_jiffies(0));
		}
	} else if (std_old == V4L2_STD_NTSC) {
		if (last_line == FORCE_PAL_HEIGHT) {
			if (ad->state_check_work.state_check_wq)
				queue_delayed_work(
					ad->state_check_work.state_check_wq,
					&ad->state_check_work.work,
					msecs_to_jiffies(0));
		}
	}
}

int adv7181_check_id(struct vehicle_ad_dev *ad)
{
	int ret = 0;
	int val;

	val = vehicle_generic_sensor_read(ad, 0x11);
	SENSOR_DG("%s vehicle read 0x11 --> 0x%02x\n", ad->ad_name, val);
	if (val != 0x20) {
		SENSOR_DG("%s vehicle wrong camera ID, expected 0x20, detected 0x%02x\n",
		    ad->ad_name, val);
		ret = -EINVAL;
	}

	return ret;
}

static int adv7181_check_std(struct vehicle_ad_dev *ad, v4l2_std_id *std)
{
	u32 status = 0;

	adv7181_vehicle_status(ad, &status, std);

	if (status != 0) { /* No signal */
		mdelay(30);
		adv7181_vehicle_status(ad, &status, std);
		SENSOR_DG("status 0x%x\n", status);
	}

	return 0;
}
void adv7181_channel_set(struct vehicle_ad_dev *ad, int channel)
{
	static int channel_change = 11;
	v4l2_std_id std = 0;

	ad->ad_chl = channel;
	adv7181_reg_init(ad, std);
	adv7181_check_std(ad, &std);
	adv7181_reinit_parameter(ad, std);
	if (channel_change != ad->ad_chl) {
		SENSOR_DG("%s %d channel changed now channel = %d old_channel = %d\n",
						__func__, __LINE__, ad->ad_chl, channel);
		channel_change = ad->ad_chl;
		vehicle_ad_stat_change_notify();
	}
}

int adv7181_stream(struct vehicle_ad_dev *ad, int value)
{
	char val;

	if (value)
		val = 0x0c;	//on
	else
		val = 0x4c;

	SENSOR_DG("stream write 0x%x to reg 0x03\n", val);
	vehicle_generic_sensor_write(ad, 0x03, &val);
	if (value)
		val = 0x47;	//on
	else
		val = 0x87;

	SENSOR_DG("stream write 0x%x to reg 0x01d\n", val);
	vehicle_generic_sensor_write(ad, 0x1d, &val);

	return 0;
}

static void power_on(struct vehicle_ad_dev *ad)
{
	/* gpio_direction_output(ad->power, ad->pwr_active); */

	if (gpio_is_valid(ad->powerdown)) {
		gpio_request(ad->powerdown, "ad_powerdown");
		gpio_direction_output(ad->powerdown, !ad->pwdn_active);
		/* gpio_set_value(ad->powerdown, !ad->pwdn_active); */
	}

	if (gpio_is_valid(ad->power)) {
		gpio_request(ad->power, "ad_power");
		gpio_direction_output(ad->power, ad->pwr_active);
		/* gpio_set_value(ad->power, ad->pwr_active); */
	}

	if (gpio_is_valid(ad->reset)) {
		gpio_request(ad->reset, "ad_reset");
		gpio_direction_output(ad->reset, 0);
		usleep_range(10000, 12000);
		gpio_set_value(ad->reset, 1);
		usleep_range(10000, 12000);
	}
}

static void power_off(struct vehicle_ad_dev *ad)
{
	if (gpio_is_valid(ad->powerdown))
		gpio_free(ad->powerdown);

	if (gpio_is_valid(ad->power))
		gpio_free(ad->power);

	if (gpio_is_valid(ad->reset))
		gpio_free(ad->reset);
}

static void adv7181_check_state_work(struct work_struct *work)
{
	struct vehicle_ad_dev *ad;
	v4l2_std_id std;

	ad = ad7181_g_addev;

	if (ad->cif_error_last_line > 0)
		ad->cif_error_last_line = 0;

	adv7181_check_std(ad, &std);
	SENSOR_DG("%s:new std(%llx), std_old(%llx)\n", __func__, std, std_old);
	if (std != std_old) {
		std_old = std;
		adv7181_reinit_parameter(ad, std);
		SENSOR_DG("%s:ad signal change notify\n", __func__);
		vehicle_ad_stat_change_notify();
	}

	queue_delayed_work(ad->state_check_work.state_check_wq,
			   &ad->state_check_work.work, msecs_to_jiffies(3000));
}

int adv7181_ad_deinit(void)
{
	struct vehicle_ad_dev *ad;

	ad = ad7181_g_addev;

	if (!ad)
		return -ENODEV;

	if (ad->state_check_work.state_check_wq) {
		cancel_delayed_work_sync(&ad->state_check_work.work);
		flush_delayed_work(&ad->state_check_work.work);
		flush_workqueue(ad->state_check_work.state_check_wq);
		destroy_workqueue(ad->state_check_work.state_check_wq);
	}
	if (ad->irq)
		free_irq(ad->irq, ad);
	power_off(ad);

	return 0;
}

int adv7181_ad_init(struct vehicle_ad_dev *ad)
{
	v4l2_std_id std = V4L2_STD_NTSC;

	if (!ad)
		return -1;

	ad7181_g_addev = ad;

	/*  1. i2c init */
	while (ad->adapter == NULL) {
		ad->adapter = i2c_get_adapter(ad->i2c_chl);
		usleep_range(10000, 12000);
	}

	if (!i2c_check_functionality(ad->adapter, I2C_FUNC_I2C))
		return -EIO;

	/*  2. ad power on sequence */
	power_on(ad);

	/* fix mode */
	adv7181_check_std(ad, &std);
	std_old = std;
	SENSOR_DG("std: %s\n", (std == V4L2_STD_NTSC) ? "ntsc" : "pal");
	SENSOR_DG("std_old: %s\n", (std_old == V4L2_STD_NTSC) ? "ntsc" : "pal");

	/*  3 .init default format params */
	adv7181_reg_init(ad, std);
	adv7181_reinit_parameter(ad, std);
	vehicle_ad_stat_change_notify();

	/*  5. create workqueue to detect signal change */
	INIT_DELAYED_WORK(&ad->state_check_work.work, adv7181_check_state_work);
	ad->state_check_work.state_check_wq =
		create_singlethread_workqueue("vehicle-ad-adv7181");

	queue_delayed_work(ad->state_check_work.state_check_wq,
			   &ad->state_check_work.work, msecs_to_jiffies(100));

	return 0;
}