// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2018 Rockchip Electronics Co., Ltd. */

#include <linux/kernel.h>
#include <linux/mtd/cfi.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/slab.h>
#include <linux/string.h>

#include "rkflash_blk.h"
#include "rkflash_debug.h"
#include "sfc_nand.h"
#include "sfc_nand_mtd.h"

#ifdef CONFIG_RK_SFC_NAND_MTD

static struct mtd_partition nand_parts[MAX_PART_COUNT];

static inline struct snand_mtd_dev *mtd_to_priv(struct mtd_info *ptr_mtd)
{
	return (struct snand_mtd_dev *)((char *)ptr_mtd -
		offsetof(struct snand_mtd_dev, mtd));
}

int sfc_nand_erase_mtd(struct mtd_info *mtd, u32 addr)
{
	int ret;

	ret = sfc_nand_erase_block(0, addr >> mtd->writesize_shift);
	if (ret) {
		rkflash_print_error("%s fail ret= %d\n", __func__, ret);
		ret = -EIO;
	}

	return ret;
}

static int sfc_nand_write_mtd(struct mtd_info *mtd, loff_t to,
			      struct mtd_oob_ops *ops)
{
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);
	u8 *data = (u8 *)ops->datbuf;
	size_t remaining = ops->len;
	u32 ret = 0;

	rkflash_print_dio("%s addr= %llx len= %x\n", __func__, to, (u32)remaining);
	if ((to + remaining) > mtd->size || to & mtd->writesize_mask ||
	    remaining & mtd->writesize_mask || ops->ooblen) {
		rkflash_print_error("%s input error, %llx %x\n", __func__, to, (u32)remaining);

		return -EINVAL;
	}

	ops->retlen = 0;
	while (remaining) {
		memcpy(p_dev->dma_buf, data, mtd->writesize);
		memset(p_dev->dma_buf + mtd->writesize, 0xff, mtd->oobsize);
		ret = sfc_nand_prog_page_raw(0, to >> mtd->writesize_shift,
					     (u32 *)p_dev->dma_buf);
		if (ret != SFC_OK) {
			rkflash_print_error("%s addr %llx ret= %d\n",
					    __func__, to, ret);
			ret = -EIO;
			break;
		}

		data += mtd->writesize;
		ops->retlen += mtd->writesize;
		remaining -= mtd->writesize;
		to += mtd->writesize;
	}

	return ret;
}

static int sfc_nand_read_mtd(struct mtd_info *mtd, loff_t from,
			     struct mtd_oob_ops *ops)
{
	u8 *data = (u8 *)ops->datbuf;
	size_t remaining = ops->len;
	u32 ret = 0;
	bool ecc_failed = false;
	size_t page, off, real_size;
	int max_bitflips = 0;

	rkflash_print_dio("%s addr= %llx len= %x\n", __func__, from, (u32)remaining);
	if ((from + remaining) > mtd->size || ops->ooblen) {
		rkflash_print_error("%s input error, from= %llx len= %x oob= %x\n",
				    __func__, from, (u32)remaining, (u32)ops->ooblen);

		return -EINVAL;
	}

	ops->retlen = 0;
	while (remaining) {
		page = from >> mtd->writesize_shift;
		off = from & mtd->writesize_mask;
		real_size = min_t(u32, remaining, mtd->writesize - off);

		ret = sfc_nand_read(page, (u32 *)data, off, real_size);
		if (ret == SFC_NAND_HW_ERROR) {
			rkflash_print_error("%s addr %llx ret= %d\n",
					    __func__, from, ret);
			ret = -EIO;
			break;
		} else if (ret == SFC_NAND_ECC_ERROR) {
			rkflash_print_error("%s addr %llx ret= %d\n",
					    __func__, from, ret);
			ecc_failed = true;
			mtd->ecc_stats.failed++;
		} else if (ret == SFC_NAND_ECC_REFRESH) {
			rkflash_print_dio("%s addr %llx ret= %d\n",
					  __func__, from, ret);
			mtd->ecc_stats.corrected += 1;
			max_bitflips = 1;
		}

		ret = 0;
		data += real_size;
		ops->retlen += real_size;
		remaining -= real_size;
		from += real_size;
	}

	if (ecc_failed && !ret)
		ret = -EBADMSG;

	return ret ? ret : max_bitflips;
}

int sfc_nand_isbad_mtd(struct mtd_info *mtd, loff_t ofs)
{
	int ret;
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);

	rkflash_print_dio("%s %llx\n", __func__, ofs);
	if (ofs & mtd->writesize_mask) {
		rkflash_print_error("%s %llx input error\n", __func__, ofs);

		return -EINVAL;
	}

	if (snanddev_bbt_is_initialized(p_dev)) {
		unsigned int entry;
		int status;

		entry = snanddev_bbt_pos_to_entry(p_dev, ofs);
		status = snanddev_bbt_get_block_status(p_dev, entry);
		/* Lazy block status retrieval */
		if (status == NAND_BBT_BLOCK_STATUS_UNKNOWN) {
			if ((int)sfc_nand_check_bad_block(0, ofs >> mtd->writesize_shift))
				status = NAND_BBT_BLOCK_FACTORY_BAD;
			else
				status = NAND_BBT_BLOCK_GOOD;

			snanddev_bbt_set_block_status(p_dev, entry, status);
		}

		if (status == NAND_BBT_BLOCK_WORN ||
		    status == NAND_BBT_BLOCK_FACTORY_BAD)
			return true;

		return false;
	}

	ret = (int)sfc_nand_check_bad_block(0, ofs >> mtd->writesize_shift);
	if (ret)
		pr_err("%s %llx is bad block\n", __func__, ofs);

	return ret;
}

static int sfc_nand_markbad_mtd(struct mtd_info *mtd, loff_t ofs)
{
	u32 ret;
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);
	unsigned int entry;

	rkflash_print_error("%s %llx\n", __func__, ofs);
	if (ofs & mtd->erasesize_mask) {
		rkflash_print_error("%s %llx input error\n", __func__, ofs);

		return -EINVAL;
	}

	if (sfc_nand_isbad_mtd(mtd, ofs))
		return 0;

	/* Erase block before marking it bad. */
	ret = sfc_nand_erase_block(0, ofs >> mtd->writesize_shift);
	if (ret)
		rkflash_print_error("%s erase fail ofs 0x%llx ret=%d\n",
				    __func__, ofs, ret);

	/* Mark bad. */
	ret = sfc_nand_mark_bad_block(0, ofs >> mtd->writesize_shift);
	if (ret)
		rkflash_print_error("%s mark fail ofs 0x%llx ret=%d\n",
				    __func__, ofs, ret);

	if (!snanddev_bbt_is_initialized(p_dev))
		goto out;

	entry = snanddev_bbt_pos_to_entry(p_dev, ofs);
	ret = snanddev_bbt_set_block_status(p_dev, entry, NAND_BBT_BLOCK_WORN);
	if (ret)
		goto out;

	ret = snanddev_bbt_update(p_dev);
out:
	/* Mark bad recheck */
	if (sfc_nand_check_bad_block(0, ofs >> mtd->writesize_shift)) {
		mtd->ecc_stats.badblocks++;
		ret = 0;
	} else {
		rkflash_print_error("%s recheck fail ofs 0x%llx ret=%d\n",
				    __func__, ofs, ret);
		ret = -EIO;
	}

	return ret;
}

static int sfc_erase_mtd(struct mtd_info *mtd, struct erase_info *instr)
{
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);
	struct snand_mtd_dev *nand = mtd_to_snanddev(mtd);
	u64 addr, remaining;
	int ret = 0;

	mutex_lock(p_dev->lock);
	addr = instr->addr;
	remaining = instr->len;
	rkflash_print_dio("%s addr= %llx len= %llx\n", __func__, addr, remaining);
	if ((addr + remaining) > mtd->size || addr & mtd->erasesize_mask) {
		ret = -EINVAL;
		goto out;
	}

	while (remaining) {
		ret = snanddev_bbt_get_block_status(nand, addr >> mtd->erasesize_shift);
		if (ret == NAND_BBT_BLOCK_WORN ||
		    ret == NAND_BBT_BLOCK_FACTORY_BAD) {
			rkflash_print_error("attempt to erase a bad/reserved block @%llx\n",
					    addr >> mtd->erasesize_shift);
			addr += mtd->erasesize;
			remaining -= mtd->erasesize;
			continue;
		}

		ret = sfc_nand_erase_mtd(mtd, addr);
		if (ret) {
			rkflash_print_error("%s fail addr 0x%llx ret=%d\n",
					    __func__, addr, ret);
			instr->fail_addr = addr;

			ret = -EIO;
			goto out;
		}

		addr += mtd->erasesize;
		remaining -= mtd->erasesize;
	}

out:
	mutex_unlock(p_dev->lock);

	return ret;
}

static int sfc_write_mtd(struct mtd_info *mtd, loff_t to, size_t len,
			 size_t *retlen, const u_char *buf)
{
	int ret;
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);
	struct mtd_oob_ops ops;

	mutex_lock(p_dev->lock);
	memset(&ops, 0, sizeof(struct mtd_oob_ops));
	ops.datbuf = (u8 *)buf;
	ops.len = len;
	ret = sfc_nand_write_mtd(mtd, to, &ops);
	*retlen = ops.retlen;
	mutex_unlock(p_dev->lock);

	return ret;
}

static int sfc_read_mtd(struct mtd_info *mtd, loff_t from, size_t len,
			size_t *retlen, u_char *buf)
{
	int ret;
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);
	struct mtd_oob_ops ops;

	mutex_lock(p_dev->lock);
	memset(&ops, 0, sizeof(struct mtd_oob_ops));
	ops.datbuf = buf;
	ops.len = len;
	ret = sfc_nand_read_mtd(mtd, from, &ops);
	*retlen = ops.retlen;
	mutex_unlock(p_dev->lock);

	return ret;
}

static int sfc_isbad_mtd(struct mtd_info *mtd, loff_t ofs)
{
	int ret;
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);

	mutex_lock(p_dev->lock);
	ret = sfc_nand_isbad_mtd(mtd, ofs);
	mutex_unlock(p_dev->lock);

	return ret;
}

static int sfc_markbad_mtd(struct mtd_info *mtd, loff_t ofs)
{
	u32 ret;
	struct snand_mtd_dev *p_dev = mtd_to_priv(mtd);

	mutex_lock(p_dev->lock);
	ret = sfc_nand_markbad_mtd(mtd, ofs);
	mutex_unlock(p_dev->lock);

	return ret;
}

/*
 * if not support rk_partition and partition is confirmed, you can define
 * strust def_nand_part by adding new partition like following example:
 *	{"u-boot", 0x1000 * 512, 0x2000 * 512},
 * Note.
 * 1. New partition format {name. size, offset}
 * 2. Unit:Byte
 * 3. Last partition 'size' can be set 0xFFFFFFFFF to fully user left space.
 */
static struct mtd_partition def_nand_part[] = {};

int sfc_nand_mtd_init(struct SFNAND_DEV *p_dev, struct mutex *lock)
{
	int ret, i, part_num = 0;
	int capacity;
	struct snand_mtd_dev *nand = kzalloc(sizeof(*nand), GFP_KERNEL);

	if (!nand) {
		rkflash_print_error("%s %d alloc failed\n", __func__, __LINE__);
		return -ENOMEM;
	}

	nand->snand = p_dev;
	capacity = (1 << p_dev->capacity) << 9;
	nand->mtd.name = "spi-nand0";
	nand->mtd.type = MTD_NANDFLASH;
	nand->mtd.writesize = p_dev->page_size * SFC_NAND_SECTOR_SIZE;
	nand->mtd.flags = MTD_CAP_NANDFLASH;
	nand->mtd.size = capacity;
	nand->mtd._erase = sfc_erase_mtd;
	nand->mtd._read = sfc_read_mtd;
	nand->mtd._write = sfc_write_mtd;
	nand->mtd._block_isbad = sfc_isbad_mtd;
	nand->mtd._block_markbad = sfc_markbad_mtd;
	nand->mtd.oobsize = 16 * p_dev->page_size;
	nand->mtd.bitflip_threshold = 2;
	nand->mtd.erasesize = p_dev->block_size * SFC_NAND_SECTOR_SIZE;
	nand->mtd.writebufsize = p_dev->page_size * SFC_NAND_SECTOR_SIZE;
	nand->mtd.erasesize_shift = ffs(nand->mtd.erasesize) - 1;
	nand->mtd.erasesize_mask = (1 << nand->mtd.erasesize_shift) - 1;
	nand->mtd.writesize_shift = ffs(nand->mtd.writesize) - 1;
	nand->mtd.writesize_mask = (1 << nand->mtd.writesize_shift) - 1;
	nand->mtd.bitflip_threshold = 1;
	nand->mtd.priv = nand;
	nand->lock = lock;
	nand->dma_buf = kmalloc(SFC_NAND_PAGE_MAX_SIZE, GFP_KERNEL | GFP_DMA);
	if (!nand->dma_buf) {
		rkflash_print_error("%s dma_buf alloc failed\n", __func__);
		ret = -ENOMEM;
		goto error_out;
	}

	nand->bbt.option |= NANDDEV_BBT_USE_FLASH;
	ret = snanddev_bbt_init(nand);
	if (ret) {
		rkflash_print_error("snanddev_bbt_init failed, ret= %d\n", ret);
		return ret;
	}

	part_num = ARRAY_SIZE(def_nand_part);
	for (i = 0; i < part_num; i++) {
		nand_parts[i].name =
			kstrdup(def_nand_part[i].name,
				GFP_KERNEL);
		if (def_nand_part[i].size == 0xFFFFFFFF)
			def_nand_part[i].size = capacity -
				def_nand_part[i].offset;
		nand_parts[i].offset =
			def_nand_part[i].offset;
		nand_parts[i].size =
			def_nand_part[i].size;
		nand_parts[i].mask_flags = 0;
	}

	ret = mtd_device_register(&nand->mtd, nand_parts, part_num);
	if (ret) {
		pr_err("%s register mtd fail %d\n", __func__, ret);
	} else {
		pr_info("%s register mtd succuss\n", __func__);

		return 0;
	}

	kfree(nand->dma_buf);
error_out:
	kfree(nand);

	return ret;
}

#endif