/*
 * cyttsp5_test_device_access_api.c
 * Parade TrueTouch(TM) Standard Product V5 Device Access API test module.
 * For use with Parade touchscreen controllers.
 * Supported parts include:
 * CYTMA5XX
 * CYTMA448
 * CYTMA445A
 * CYTT21XXX
 * CYTT31XXX
 *
 * Copyright (C) 2015 Parade Technologies
 * Copyright (C) 2012-2015 Cypress Semiconductor
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2, and only version 2, as published by the
 * Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * Contact Parade Technologies at www.paradetech.com <ttdrivers@paradetech.com>
 *
 */

#include <linux/module.h>
#include <linux/cyttsp5_device_access-api.h>
#include <asm/unaligned.h>

#define BUFFER_SIZE		256

#define COMMAND_GET_SYSTEM_INFO		2
#define COMMAND_SUSPEND_SCANNING	3
#define COMMAND_RESUME_SCANNING		4
#define COMMAND_GET_PARAMETER		5
#define COMMAND_SET_PARAMETER		6

#define PARAMETER_ACTIVE_DISTANCE_2	0x0B

struct tt_output_report {
	__le16 reg_address;
	__le16 length;
	u8 report_id;
	u8 reserved;
	u8 command;
	u8 parameters[0];
} __packed;

struct tt_input_report {
	__le16 length;
	u8 report_id;
	u8 reserved;
	u8 command;
	u8 return_data[0];
} __packed;

static int prepare_tt_output_report(struct tt_output_report *out,
		u16 length, u8 command)
{
	put_unaligned_le16(0x04, &out->reg_address);
	put_unaligned_le16(5 + length, &out->length);

	out->report_id = 0x2f;
	out->reserved = 0x00;
	out->command = command;

	return 7 + length;
}

static int check_and_parse_tt_input_report(struct tt_input_report *in,
		u16 *length, u8 *command)
{
	if (in->report_id != 0x1f)
		return -EINVAL;

	*length = get_unaligned_le16(&in->length);
	*command = in->command & 0x7f;

	return 0;
}

static int prepare_get_system_info_report(u8 *buf)
{
	struct tt_output_report *out = (struct tt_output_report *)buf;

	return prepare_tt_output_report(out, 0, COMMAND_GET_SYSTEM_INFO);
}

static int check_get_system_info_response(u8 *buf, u16 read_length)
{
	struct tt_input_report *in = (struct tt_input_report *)buf;
	u16 length = 0;
	u8 command = 0;

	if (read_length != 51)
		return -EINVAL;

	if (check_and_parse_tt_input_report(in, &length, &command)
			|| command != COMMAND_GET_SYSTEM_INFO
			|| length != 51)
		return -EINVAL;

	pr_info("PIP Major Version: %d\n", in->return_data[0]);
	pr_info("PIP Minor Version: %d\n", in->return_data[1]);
	pr_info("Touch Firmware Product Id: %d\n",
			get_unaligned_le16(&in->return_data[2]));
	pr_info("Touch Firmware Major Version: %d\n", in->return_data[4]);
	pr_info("Touch Firmware Minor Version: %d\n", in->return_data[5]);
	pr_info("Touch Firmware Internal Revision Control Number: %d\n",
			get_unaligned_le32(&in->return_data[6]));
	pr_info("Customer Specified Firmware/Configuration Version: %d\n",
			get_unaligned_le16(&in->return_data[10]));
	pr_info("Bootloader Major Version: %d\n", in->return_data[12]);
	pr_info("Bootloader Minor Version: %d\n", in->return_data[13]);
	pr_info("Family ID: 0x%02x\n", in->return_data[14]);
	pr_info("Revision ID: 0x%02x\n", in->return_data[15]);
	pr_info("Silicon ID: 0x%02x\n",
			get_unaligned_le16(&in->return_data[16]));
	pr_info("Parade Manufacturing ID[0]: 0x%02x\n", in->return_data[18]);
	pr_info("Parade Manufacturing ID[1]: 0x%02x\n", in->return_data[19]);
	pr_info("Parade Manufacturing ID[2]: 0x%02x\n", in->return_data[20]);
	pr_info("Parade Manufacturing ID[3]: 0x%02x\n", in->return_data[21]);
	pr_info("Parade Manufacturing ID[4]: 0x%02x\n", in->return_data[22]);
	pr_info("Parade Manufacturing ID[5]: 0x%02x\n", in->return_data[23]);
	pr_info("Parade Manufacturing ID[6]: 0x%02x\n", in->return_data[24]);
	pr_info("Parade Manufacturing ID[7]: 0x%02x\n", in->return_data[25]);
	pr_info("POST Result Code: 0x%02x\n",
			get_unaligned_le16(&in->return_data[26]));

	pr_info("Number of X Electrodes: %d\n", in->return_data[28]);
	pr_info("Number of Y Electrodes: %d\n", in->return_data[29]);
	pr_info("Panel X Axis Length: %d\n",
			get_unaligned_le16(&in->return_data[30]));
	pr_info("Panel Y Axis Length: %d\n",
			get_unaligned_le16(&in->return_data[32]));
	pr_info("Panel X Axis Resolution: %d\n",
			get_unaligned_le16(&in->return_data[34]));
	pr_info("Panel Y Axis Resolution: %d\n",
			get_unaligned_le16(&in->return_data[36]));
	pr_info("Panel Pressure Resolution: %d\n",
			get_unaligned_le16(&in->return_data[38]));
	pr_info("X_ORG: %d\n", in->return_data[40]);
	pr_info("Y_ORG: %d\n", in->return_data[41]);
	pr_info("Panel ID: %d\n", in->return_data[42]);
	pr_info("Buttons: 0x%02x\n", in->return_data[43]);
	pr_info("BAL SELF MC: 0x%02x\n", in->return_data[44]);
	pr_info("Max Number of Touch Records per Refresh Cycle: %d\n",
			in->return_data[45]);

	return 0;
}

static int prepare_get_parameter_report(u8 *buf, u8 parameter_id)
{
	struct tt_output_report *out = (struct tt_output_report *)buf;

	out->parameters[0] = parameter_id;

	return prepare_tt_output_report(out, 1, COMMAND_GET_PARAMETER);
}

static int check_get_parameter_response(u8 *buf, u16 read_length,
		u32 *parameter_value)
{
	struct tt_input_report *in = (struct tt_input_report *)buf;
	u16 length = 0;
	u8 command = 0;
	u32 param_value = 0;
	u8 param_id;
	u8 param_size = 0;

	if (read_length != 8 && read_length != 9 && read_length != 11)
		return -EINVAL;

	if (check_and_parse_tt_input_report(in, &length, &command)
			|| command != COMMAND_GET_PARAMETER
			|| (length != 8 && length != 9 && length != 11))
		return -EINVAL;

	param_id = in->return_data[0];

	param_size = in->return_data[1];

	if (param_size == 1)
		param_value = in->return_data[2];
	else if (param_size == 2)
		param_value = get_unaligned_le16(&in->return_data[2]);
	else if (param_size == 4)
		param_value = get_unaligned_le32(&in->return_data[2]);
	else
		return -EINVAL;

	pr_info("%s: Parameter ID: 0x%02x Value: 0x%02x\n",
		__func__, param_id, param_value);

	if (parameter_value)
		*parameter_value = param_value;

	return 0;
}

static int prepare_set_parameter_report(u8 *buf, u8 parameter_id,
		u8 parameter_size, u32 parameter_value)
{
	struct tt_output_report *out = (struct tt_output_report *)buf;

	out->parameters[0] = parameter_id;
	out->parameters[1] = parameter_size;

	if (parameter_size == 1)
		out->parameters[2] = (u8)parameter_value;
	else if (parameter_size == 2)
		put_unaligned_le16(parameter_value, &out->parameters[2]);
	else if (parameter_size == 4)
		put_unaligned_le32(parameter_value, &out->parameters[2]);
	else
		return -EINVAL;

	return prepare_tt_output_report(out, 2 + parameter_size,
			COMMAND_SET_PARAMETER);
}

static int check_set_parameter_response(u8 *buf, u16 read_length)
{
	struct tt_input_report *in = (struct tt_input_report *)buf;
	u16 length = 0;
	u8 command = 0;
	u8 param_id;
	u8 param_size = 0;

	if (read_length != 7)
		return -EINVAL;

	if (check_and_parse_tt_input_report(in, &length, &command)
			|| command != COMMAND_SET_PARAMETER
			|| length != 7)
		return -EINVAL;

	param_id = in->return_data[0];
	param_size = in->return_data[1];

	pr_info("%s: Parameter ID: 0x%02x Size: 0x%02x\n",
		__func__, param_id, param_size);

	return 0;
}

static int prepare_suspend_scanning_report(u8 *buf)
{
	struct tt_output_report *out = (struct tt_output_report *)buf;

	return prepare_tt_output_report(out, 0, COMMAND_SUSPEND_SCANNING);
}

static int check_suspend_scanning_response(u8 *buf, u16 read_length)
{
	struct tt_input_report *in = (struct tt_input_report *)buf;
	u16 length = 0;
	u8 command = 0;

	if (read_length != 5)
		return -EINVAL;

	if (check_and_parse_tt_input_report(in, &length, &command)
			|| command != COMMAND_SUSPEND_SCANNING
			|| length != 5)
		return -EINVAL;

	return 0;
}

static int prepare_resume_scanning_report(u8 *buf)
{
	struct tt_output_report *out = (struct tt_output_report *)buf;

	return prepare_tt_output_report(out, 0, COMMAND_RESUME_SCANNING);
}

static int check_resume_scanning_response(u8 *buf, u16 read_length)
{
	struct tt_input_report *in = (struct tt_input_report *)buf;
	u16 length = 0;
	u8 command = 0;

	if (read_length != 5)
		return -EINVAL;

	if (check_and_parse_tt_input_report(in, &length, &command)
			|| command != COMMAND_RESUME_SCANNING
			|| length != 5)
		return -EINVAL;

	return 0;
}

void cyttsp5_user_command_async_cont(const char *core_name,
		u16 read_len, u8 *read_buf, u16 write_len, u8 *write_buf,
		u16 actual_read_length, int rc)
{
	if (rc) {
		pr_err("%s: suspend scan fails\n", __func__);
		goto exit;
	}

	rc = check_suspend_scanning_response(read_buf, actual_read_length);
	if (rc) {
		pr_err("%s: check suspend scanning response fails\n", __func__);
		goto exit;
	}

	pr_info("%s: suspend scanning succeeds\n", __func__);
exit:
	return;
}

/* Read and write buffers */
static u8 write_buf[BUFFER_SIZE];
static u8 read_buf[BUFFER_SIZE];

static uint active_distance;
module_param(active_distance, uint, 0);

static int __init cyttsp5_test_device_access_api_init(void)
{
	u32 initial_active_distance;
	u16 actual_read_len;
	int write_len;
	int rc;

	pr_info("%s: Enter\n", __func__);

	/* CASE	1: Run get system information */
	write_len = prepare_get_system_info_report(write_buf);

	rc = cyttsp5_device_access_user_command(NULL, sizeof(read_buf),
			read_buf, write_len, write_buf,
			&actual_read_len);
	if (rc)
		goto exit;

	rc = check_get_system_info_response(read_buf, actual_read_len);
	if (rc)
		goto exit;

	/* CASE 2: Run get parameter (Active distance) */
	write_len = prepare_get_parameter_report(write_buf,
			PARAMETER_ACTIVE_DISTANCE_2);

	rc = cyttsp5_device_access_user_command(NULL, sizeof(read_buf),
			read_buf, write_len, write_buf,
			&actual_read_len);
	if (rc)
		goto exit;

	rc = check_get_parameter_response(read_buf, actual_read_len,
			&initial_active_distance);
	if (rc)
		goto exit;

	pr_info("%s: Initial Active Distance: %d\n",
		__func__, initial_active_distance);

	/* CASE	3: Run set parameter (Active distance) */
	write_len = prepare_set_parameter_report(write_buf,
			PARAMETER_ACTIVE_DISTANCE_2, 1,
			active_distance);

	rc = cyttsp5_device_access_user_command(NULL, sizeof(read_buf),
			read_buf, write_len, write_buf,
			&actual_read_len);
	if (rc)
		goto exit;

	rc = check_set_parameter_response(read_buf, actual_read_len);
	if (rc)
		goto exit;

	pr_info("%s: Active Distance set to %d\n", __func__, active_distance);

	/* CASE	4: Run get parameter (Active distance) */
	write_len = prepare_get_parameter_report(write_buf,
			PARAMETER_ACTIVE_DISTANCE_2);

	rc = cyttsp5_device_access_user_command(NULL, sizeof(read_buf),
			read_buf, write_len, write_buf,
			&actual_read_len);
	if (rc)
		goto exit;

	rc = check_get_parameter_response(read_buf, actual_read_len,
			&active_distance);
	if (rc)
		goto exit;

	pr_info("%s: New Active Distance: %d\n", __func__, active_distance);

	/* CASE 5: Run suspend scanning asynchronously */
	write_len = prepare_suspend_scanning_report(write_buf);

	preempt_disable();
	rc = cyttsp5_device_access_user_command_async(NULL,
			sizeof(read_buf), read_buf, write_len, write_buf,
			cyttsp5_user_command_async_cont);
	preempt_enable();
	if (rc)
		goto exit;
exit:
	return rc;
}
module_init(cyttsp5_test_device_access_api_init);

static void __exit cyttsp5_test_device_access_api_exit(void)
{
	u16 actual_read_len;
	int write_len;
	int rc;

	/* CASE 6: Run resume scanning */
	write_len = prepare_resume_scanning_report(write_buf);

	rc = cyttsp5_device_access_user_command(NULL, sizeof(read_buf),
			read_buf, write_len, write_buf,
			&actual_read_len);
	if (rc)
		goto exit;

	rc = check_resume_scanning_response(read_buf, actual_read_len);
	if (rc)
		goto exit;

	pr_info("%s: resume scanning succeeds\n", __func__);
exit:
	return;
}
module_exit(cyttsp5_test_device_access_api_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Parade TrueTouch(R) Standard Product Device Access Driver API Tester");
MODULE_AUTHOR("Parade Technologies <ttdrivers@paradetech.com>");