/*
 * Copyright (c) 2006-2013, Cypress Semiconductor Corporation
 * All rights reserved.
 *
 * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/ihex.h>
#include <linux/gpio.h>

#include "issp_priv.h"

#define DRIVER_NAME "issp"

static int issp_check_fw(struct issp_host *host)
{
	const struct ihex_binrec *rec;
	int checks = 0;
	int size;

	size = host->pdata->block_size * host->pdata->blocks;
	rec = (const struct ihex_binrec *)host->fw->data;
	while (rec) {
		int addr, len;

		addr = be32_to_cpu(rec->addr);
		len = be16_to_cpu(rec->len);

		if (addr + len == size)
			checks++;

		if (addr == ISSP_FW_SECURITY_ADDR) {
			host->security_rec = rec;
			checks++;
		}

		if (addr == ISSP_FW_CHECKSUM_ADDR) {
			host->checksum_fw = rec->data[0] << 8 | rec->data[1];
			checks++;
		}

		if (host->pdata->version_addr > addr &&
			host->pdata->version_addr < addr + len) {
			host->version_fw =
				rec->data[host->pdata->version_addr - addr];
			checks++;
		}

		if (checks == 4)
			break;
		rec = ihex_next_binrec(rec);
	}

	if (checks < 4)
		return -EINVAL;
	else
		return 0;
}

void issp_fw_rewind(struct issp_host *host)
{
	host->cur_rec = (const struct ihex_binrec *)host->fw->data;
	host->cur_idx = 0;
}

void issp_fw_seek_security(struct issp_host *host)
{
	host->cur_rec = host->security_rec;
	host->cur_idx = 0;
}

uint8_t issp_fw_get_byte(struct issp_host *host)
{
	uint8_t byte;
	byte = host->cur_rec->data[host->cur_idx];
	host->cur_idx++;
	if (host->cur_idx >= be16_to_cpu(host->cur_rec->len)) {
		host->cur_rec = ihex_next_binrec(host->cur_rec);
		host->cur_idx = 0;
	}

	return byte;
}

static int issp_need_update(struct issp_host *host, bool *update)
{
	uint8_t idx, addr, ver_uc;
	int ret;

	idx = host->pdata->version_addr / host->pdata->block_size;
	addr = host->pdata->version_addr - idx * host->pdata->block_size;
	ret = issp_read_block(host, idx, addr, &ver_uc, 1);
	if (ret == -EACCES) {
		dev_err(&host->pdev->dev,
			"Version Block is protected, force upgrade!\n");
		*update = true;
	} else if (ret == 1) {
		*update = (ver_uc < host->version_fw) ||
				((ver_uc != host->version_fw) &&
				host->pdata->force_update);

		if (*update)
			dev_info(&host->pdev->dev, "firmware needs upgrade, "\
				"version 0x%02x -> 0x%02x\n",
				ver_uc, host->version_fw);
		else
			dev_info(&host->pdev->dev,
				"firmware version %02x is latest!\n", ver_uc);
	} else
		return ret;

	return 0;
}

static int __init issp_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct issp_platform_data *pdata = dev->platform_data;
	struct issp_host *host;
	bool update;
	int ret;

	if (!pdata || !gpio_is_valid(pdata->reset_gpio)
		|| !gpio_is_valid(pdata->data_gpio)
		|| !gpio_is_valid(pdata->clk_gpio)) {
		dev_err(dev, "Invalid platform data!");
		return -EINVAL;
	}

	ret = devm_gpio_request(dev, pdata->reset_gpio, "issp reset");
	if (!ret)
		ret = devm_gpio_request(dev, pdata->data_gpio, "issp data");
	if (!ret)
		ret = devm_gpio_request(dev, pdata->clk_gpio, "issp clock");
	if (ret)
		return ret;

	/* set gpio directions */
	gpio_direction_output(pdata->reset_gpio, 0);
	gpio_direction_input(pdata->data_gpio);
	gpio_direction_output(pdata->clk_gpio, 0);

	host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);
	if (!host)
		return -ENOMEM;

	host->pdev = pdev;
	host->pdata = pdata;
	ret = request_ihex_firmware(&host->fw, pdata->fw_name, dev);
	if (ret) {
		dev_err(dev, "Request firmware %s failed!\n", pdata->fw_name);
		return ret;
	}

	ret = issp_check_fw(host);
	if (ret) {
		dev_err(dev, "Firmware %s invalid!\n", pdata->fw_name);
		goto err;
	}

	issp_uc_program(host);

	if (host->si_id[0] != pdata->si_id[0] ||
		host->si_id[1] != pdata->si_id[1] ||
		host->si_id[2] != pdata->si_id[2] ||
		host->si_id[3] != pdata->si_id[3]) {
		dev_err(dev, "Sillicon ID check failed!\n");
		goto err_id;
	}

	ret = issp_need_update(host, &update);
	if (ret)
		goto err_id;
	if (update) {
		ret = issp_program(host);
		if (!ret)
			dev_info(dev, "Firmware update successfully!\n");
		else
			dev_err(dev, "Firmware update failed!\n");
	}

err_id:
	issp_uc_run(host);

err:
	gpio_direction_input(pdata->data_gpio);
	gpio_direction_input(pdata->clk_gpio);
	release_firmware(host->fw);
	devm_kfree(dev, host);

	return 0;
}

static int __exit issp_remove(struct platform_device *pdev)
{
	return 0;
}

static struct platform_driver issp_driver = {
	.remove		= __exit_p(issp_remove),
	.driver	= {
		.name	= DRIVER_NAME,
		.owner	= THIS_MODULE,
	}
};

static int __init issp_init(void)
{
	return platform_driver_probe(&issp_driver, issp_probe);
}
subsys_initcall(issp_init);

static void __exit issp_exit(void)
{
	platform_driver_unregister(&issp_driver);
}
module_exit(issp_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Richard Zhao, nVidia <rizhao@nvidia.com>");
MODULE_DESCRIPTION("ISSP driver");