// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2021 Rockchip Electronics Co. Ltd.
 *
 * Author: Shunqing Chen <csq@rock-chips.com>
 */

#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/rockchip/rockchip_sip.h>
#include <linux/sched.h>
#include <linux/soc/rockchip/rk_vendor_storage.h>
#include <linux/slab.h>

#include "rk_hdmirx.h"
#include "rk_hdmirx_hdcp.h"

enum rk_hdmirx_hdcp_state {
	HDMIRX_HDCP_DISABLED,
	HDMIRX_HDCP_AUTH_START,
	HDMIRX_HDCP_AUTH_SUCCESS,
	HDMIRX_HDCP_AUTH_FAIL,
};

static struct rk_hdmirx_hdcp *g_hdmirx_hdcp;

static void hdmirx_hdcp_write(struct rk_hdmirx_hdcp *hdcp, int reg, u32 val)
{
	hdcp->write(hdcp->hdmirx, reg, val);
}

static u32 hdmirx_hdcp_read(struct rk_hdmirx_hdcp *hdcp, int reg)
{
	return hdcp->read(hdcp->hdmirx, reg);
}

static void hdmirx_hdcp_update_bits(struct rk_hdmirx_hdcp *hdcp, int reg,
				    u32 mask, u32 data)
{
	u32 val = hdmirx_hdcp_read(hdcp, reg) & ~mask;

	val |= (data & mask);
	hdmirx_hdcp_write(hdcp, reg, val);
}

static int hdcp_load_keys_cb(struct rk_hdmirx_hdcp *hdcp)
{
	int size;
	u8 hdcp_vendor_data[VENDOR_DATA_SIZE + 1];
	struct hdcp_key_data_t *key_data;
	void __iomem *base;

	size = rk_vendor_read(HDMIRX_HDCP1X_ID, hdcp_vendor_data,
			      VENDOR_DATA_SIZE);
	if (size < (HDCP_KEY_SIZE + HDCP_KEY_SEED_SIZE)) {
		dev_dbg(hdcp->dev, "HDCP: read size %d\n", size);
		return -EINVAL;
	}

	key_data = (struct hdcp_key_data_t *)hdcp_vendor_data;
	if ((key_data->signature != HDCP_SIG_MAGIC)
	    || !(key_data->flags & HDCP_FLG_AES))
		hdcp->aes_encrypt = false;
	else
		hdcp->aes_encrypt = true;

	base = sip_hdcp_request_share_memory(HDMI_RX);
	if (!base)
		return -ENOMEM;

	memcpy_toio(base, hdcp_vendor_data, size);
	hdcp->keys_is_load = true;

	return 0;
}

static int rk_hdmirx_hdcp_load_key(struct rk_hdmirx_hdcp *hdcp)
{
	int ret = 0;

	hdcp->status = HDMIRX_HDCP_DISABLED;
	if (!hdcp->keys_is_load)
		ret = hdcp_load_keys_cb(hdcp);

	if (ret && !hdcp->test_key_load)
		return -EINVAL;

	hdcp->status = HDMIRX_HDCP_AUTH_START;
	if (hdcp->aes_encrypt)
		sip_hdcp_config(HDCP_FUNC_KEY_LOAD, HDMI_RX, 0);
	else
		sip_hdcp_config(HDCP_FUNC_KEY_LOAD, HDMI_RX, 1);

	hdmirx_hdcp_update_bits(hdcp, HDCP2_CONFIG,
				HDCP2_CONNECTED |
				HDCP2_SWITCH_OVR_VALUE,
				HDCP2_CONNECTED);

	return 0;
}

static int rk_hdmirx_hdcp1x_start(struct rk_hdmirx_hdcp *hdcp)
{
	rk_hdmirx_hdcp_load_key(hdcp);

	dev_dbg(hdcp->dev, "%s success\n", __func__);
	return 0;
}

static int rk_hdmirx_hdcp1x_stop(struct rk_hdmirx_hdcp *hdcp)
{
	if (hdcp->status == HDMIRX_HDCP_DISABLED)
		return 0;

	hdmirx_hdcp_update_bits(hdcp, GLOBAL_SWENABLE, HDCP_ENABLE, 0);
	hdcp->status = HDMIRX_HDCP_DISABLED;

	return 0;
}

static void rk_hdmirx_hdcp2_hpd_config(struct rk_hdmirx_hdcp *hdcp, bool en)
{
	if (hdcp->tx_5v_power(hdcp->hdmirx))
		hdcp->hpd_config(hdcp->hdmirx, en);
}

static int rk_hdmirx_hdcp2x_start(struct rk_hdmirx_hdcp *hdcp)
{
	hdmirx_hdcp_update_bits(hdcp, HDCP2_CONFIG,
				HDCP2_SWITCH_OVR_VALUE |
				HDCP2_SWITCH_LCK |
				HDCP2_SWITCH_OVR_EN,
				HDCP2_SWITCH_LCK);
	if (hdcp->tx_5v_power(hdcp->hdmirx))
		hdmirx_hdcp_write(hdcp, HDCP2_ESM_P0_GPIO_IN, 0x2);

	dev_dbg(hdcp->dev, "%s success\n", __func__);
	return 0;
}

static int rk_hdmirx_hdcp2x_stop(struct rk_hdmirx_hdcp *hdcp)
{
	hdmirx_hdcp_write(hdcp, HDCP2_ESM_P0_GPIO_IN, 0x0);
	hdmirx_hdcp_update_bits(hdcp, HDCP2_CONFIG,
				HDCP2_SWITCH_OVR_VALUE |
				HDCP2_SWITCH_LCK |
				HDCP2_SWITCH_OVR_EN,
				HDCP2_SWITCH_OVR_EN);

	return 0;
}

static void rk_hdmirx_hdcp2_connect_ctrl(struct rk_hdmirx_hdcp *hdcp, bool en)
{
	if (hdcp->enable != HDCP_2X_ENABLE)
		return;
	if (en) {
		hdmirx_hdcp_write(hdcp, HDCP2_ESM_P0_GPIO_IN, 0x2);
		hdmirx_hdcp_update_bits(hdcp, HDCP2_CONFIG, HDCP2_CONNECTED,
					HDCP2_CONNECTED);
	} else {
		hdmirx_hdcp_write(hdcp, HDCP2_ESM_P0_GPIO_IN, 0x0);
		hdmirx_hdcp_update_bits(hdcp, HDCP2_CONFIG,
					HDCP2_CONNECTED, 0);
	}
}

static int rk_hdmirx_hdcp_start(struct rk_hdmirx_hdcp *hdcp)
{
	if (hdcp->enable == HDCP_2X_ENABLE) {
		rk_hdmirx_hdcp1x_start(hdcp);
		rk_hdmirx_hdcp2x_start(hdcp);
		return 0;
	}
	hdmirx_hdcp_update_bits(hdcp, HDCP2_CONFIG,
				HDCP2_SWITCH_OVR_EN,
				HDCP2_SWITCH_OVR_EN);
	if (hdcp->enable == HDCP_1X_ENABLE)
		rk_hdmirx_hdcp1x_start(hdcp);

	return 0;
}

static int rk_hdmirx_hdcp_stop(struct rk_hdmirx_hdcp *hdcp)
{
	if (!hdcp->enable)
		return 0;

	if (hdcp->enable == HDCP_2X_ENABLE)
		rk_hdmirx_hdcp2x_stop(hdcp);
	rk_hdmirx_hdcp1x_stop(hdcp);
	dev_dbg(hdcp->dev, "hdcp stop\n");

	return 0;
}

static ssize_t enable_show(struct device *device,
				struct device_attribute *attr, char *buf)
{
	u8 enable = 0;
	struct rk_hdmirx_hdcp *hdcp = g_hdmirx_hdcp;

	if (hdcp)
		enable = hdcp->enable;

	return snprintf(buf, PAGE_SIZE, "%d\n", enable);
}

static ssize_t enable_store(struct device *device,
			    struct device_attribute *attr,
			    const char *buf, size_t count)
{
	int enable;
	struct rk_hdmirx_hdcp *hdcp = g_hdmirx_hdcp;

	if (!hdcp)
		return -EINVAL;

	if (kstrtoint(buf, 10, &enable))
		return -EINVAL;

	if (enable > hdcp->hdcp_support)
		return count;

	if (hdcp->enable != enable) {
		rk_hdmirx_hdcp2_hpd_config(hdcp, false);
		if (enable == HDCP_2X_ENABLE) {
			rk_hdmirx_hdcp1x_start(hdcp);
			rk_hdmirx_hdcp2x_start(hdcp);
		} else if (enable == HDCP_1X_ENABLE) {
			if (hdcp->enable == HDCP_2X_ENABLE)
				rk_hdmirx_hdcp2x_stop(hdcp);
			rk_hdmirx_hdcp1x_start(hdcp);
		} else {
			rk_hdmirx_hdcp_stop(hdcp);
		}
		msleep(300);
		rk_hdmirx_hdcp2_hpd_config(hdcp, true);
		hdcp->enable = enable;
	}

	return count;
}

static DEVICE_ATTR_RW(enable);

static ssize_t status_show(struct device *device,
			   struct device_attribute *attr, char *buf)
{
	int status = HDMIRX_HDCP_DISABLED;
	struct rk_hdmirx_hdcp *hdcp = g_hdmirx_hdcp;
	u32 val;
	int dectypt, n = 0;

	if (!hdcp)
		return 0;

	if (!hdcp->enable)
		return snprintf(buf, PAGE_SIZE, "HDCP Disable\n");

	if (hdcp->enable == HDCP_2X_ENABLE) {
		dectypt = hdmirx_hdcp_read(hdcp, HDCP2_STATUS) & BIT(0);
		if (dectypt) {
			val = hdmirx_hdcp_read(hdcp, HDCP2_ESM_P0_GPIO_OUT);
			if (val & BIT(2))
				n += snprintf(buf + n, PAGE_SIZE - n,
					      "HDCP2.3: Authenticated success\n");
			else
				n += snprintf(buf + n, PAGE_SIZE - n,
					      "HDCP2.3: Authenticated failed\n");
			return n;
		}
		n += snprintf(buf, PAGE_SIZE, "HDCP2.3: No dectypted\n");
	}

	status = hdcp->status;
	if (status == HDMIRX_HDCP_AUTH_START) {
		val = hdmirx_hdcp_read(hdcp, HDCP14_STATUS);
		if ((val & 0x3) == 0)
			status = HDMIRX_HDCP_DISABLED;
		else if ((val & 0x3) == 0x1)
			status = HDMIRX_HDCP_AUTH_START;
		else if (val & BIT(8))
			status = HDMIRX_HDCP_AUTH_SUCCESS;
		else
			status = HDMIRX_HDCP_AUTH_FAIL;
	}

	if (status == HDMIRX_HDCP_AUTH_START)
		n += snprintf(buf + n, PAGE_SIZE, "HDCP1.4: Authenticated start\n");
	else if (status == HDMIRX_HDCP_AUTH_SUCCESS)
		n += snprintf(buf + n, PAGE_SIZE, "HDCP1.4: Authenticated success\n");
	else if (status == HDMIRX_HDCP_AUTH_FAIL)
		n += snprintf(buf + n, PAGE_SIZE, "HDCP1.4: Authenticated failed\n");
	else
		n += snprintf(buf + n, PAGE_SIZE, "HDCP1.4: Unknown status\n");

	return n;
}

static DEVICE_ATTR_RO(status);

static ssize_t support_show(struct device *device,
			    struct device_attribute *attr, char *buf)
{
	struct rk_hdmirx_hdcp *hdcp = g_hdmirx_hdcp;

	return snprintf(buf, PAGE_SIZE, "%d\n", hdcp->hdcp_support);
}

static DEVICE_ATTR_RO(support);

static ssize_t test_key1x_store(struct device *device,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct rk_hdmirx_hdcp *hdcp = g_hdmirx_hdcp;
	u8 hdcp_vendor_data[VENDOR_DATA_SIZE + 1];
	struct hdcp_key_data_t *key_data;
	void __iomem *base;
	char str[4] = {0};
	int ret, len, i;

	len = count / 2;
	if (len < (HDCP_KEY_SIZE + HDCP_KEY_SEED_SIZE))
		return -EINVAL;

	if (len > VENDOR_DATA_SIZE)
		len = VENDOR_DATA_SIZE;

	for (i = 0; i < len; i++) {
		long c = -1;

		memcpy(str, &buf[i * 2], 2);
		ret = kstrtol(str, 16, &c);
		if (ret || c > 255 || c < 0)
			return -EINVAL;
		hdcp_vendor_data[i] = (u8)(c & 0xff);
	}

	key_data = (struct hdcp_key_data_t *)hdcp_vendor_data;
	if ((key_data->signature != HDCP_SIG_MAGIC)
	    || !(key_data->flags & HDCP_FLG_AES))
		hdcp->aes_encrypt = false;
	else
		hdcp->aes_encrypt = true;

	base = sip_hdcp_request_share_memory(HDMI_RX);
	if (!base)
		return -ENOMEM;
	memcpy_toio(base, hdcp_vendor_data, len);
	hdcp->test_key_load = true;

	if (!hdcp->enable)
		return count;

	rk_hdmirx_hdcp2_hpd_config(hdcp, false);
	rk_hdmirx_hdcp_start(hdcp);
	msleep(300);
	rk_hdmirx_hdcp2_hpd_config(hdcp, true);

	return count;
}

static DEVICE_ATTR_WO(test_key1x);

struct rk_hdmirx_hdcp *rk_hdmirx_hdcp_register(struct rk_hdmirx_hdcp *hdcp_data)
{
	int ret = 0;
	struct rk_hdmirx_hdcp *hdcp;

	if (!hdcp_data)
		return NULL;


	hdcp = devm_kzalloc(hdcp_data->dev, sizeof(*hdcp), GFP_KERNEL);
	if (!hdcp)
		return NULL;

	hdcp->hdmirx = hdcp_data->hdmirx;
	hdcp->write = hdcp_data->write;
	hdcp->read = hdcp_data->read;
	hdcp->tx_5v_power = hdcp_data->tx_5v_power;
	hdcp->hpd_config = hdcp_data->hpd_config;
	hdcp->enable = hdcp_data->enable;
	hdcp->hdcp_support = hdcp_data->enable;
	hdcp->dev = hdcp_data->dev;
	g_hdmirx_hdcp = hdcp;
	hdcp->mdev.minor = MISC_DYNAMIC_MINOR;
	hdcp->mdev.name = "hdmirx_hdcp";
	hdcp->mdev.mode = 0666;

	if (misc_register(&hdcp->mdev)) {
		dev_err(hdcp->dev, "HDCP: Could not add character driver\n");
		return NULL;
	}

	ret = device_create_file(hdcp->mdev.this_device, &dev_attr_enable);
	if (ret) {
		dev_err(hdcp->dev, "HDCP: Could not add sys file enable\n");
		goto error0;
	}

	ret = device_create_file(hdcp->mdev.this_device, &dev_attr_status);
	if (ret) {
		dev_err(hdcp->dev, "HDCP: Could not add sys file status\n");
		goto error1;
	}

	ret = device_create_file(hdcp->mdev.this_device, &dev_attr_support);
	if (ret) {
		dev_err(hdcp->dev, "HDCP: Could not add sys file support\n");
		goto error2;
	}

	ret = device_create_file(hdcp->mdev.this_device, &dev_attr_test_key1x);
	if (ret) {
		dev_err(hdcp->dev, "HDCP: Could not add sys file test_key1x\n");
		goto error2;
	}

	hdcp->hdcp_start = rk_hdmirx_hdcp_start;
	hdcp->hdcp_stop = rk_hdmirx_hdcp_stop;
	hdcp->hdcp2_connect_ctrl = rk_hdmirx_hdcp2_connect_ctrl;
	dev_info(hdcp->dev, "%s success\n", __func__);
	return hdcp;

error2:
	device_remove_file(hdcp->mdev.this_device, &dev_attr_status);
error1:
	device_remove_file(hdcp->mdev.this_device, &dev_attr_enable);
error0:
	misc_deregister(&hdcp->mdev);
	return NULL;
}

void rk_hdmirx_hdcp_unregister(struct rk_hdmirx_hdcp *hdcp)
{
	device_remove_file(hdcp->mdev.this_device, &dev_attr_enable);
	device_remove_file(hdcp->mdev.this_device, &dev_attr_status);
	device_remove_file(hdcp->mdev.this_device, &dev_attr_support);
	device_remove_file(hdcp->mdev.this_device, &dev_attr_test_key1x);
	misc_deregister(&hdcp->mdev);
}