/*
 * MMC-based transactional key-value store
 *
 * Copyright (C) 2010 Google, Inc.
 * Author: Bill he <yuegui.he@amlogic.com>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 */
#include <flash_ts.h>
#include <mmc_ts.h>
#include <common.h>
#include <malloc.h>
#include <mmc.h>
#include <partition_table.h>
#include <emmc_partitions.h>
#include <asm/arch/cpu_sdio.h>
#include <asm/arch/sd_emmc.h>
#include <linux/sizes.h>
#include <amlogic/aml_mmc.h>

#define DRV_DESC        	"MMC-based key-value storage"

/* Internal state */
struct mmc_ts_priv {
	struct mutex lock;
	struct mmc *mmc;
	struct partitions *part_info;

	/* chunk size, >= sizeof(struct mmc_ts) */
	size_t chunk;

	int mmc_read_write_unit;

	/* current record offset within mmc partition device */
	loff_t offset;

	/* fts partition offset on*/
	u64 mmc_ts_offset;

	/* fts partition size */
	u64 mmc_ts_size;

	/* mmc dev*/
	int dev;

	/* in-memory copy of mmc content */
	struct flash_ts cache;

	/* temporary buffers
	 *  - one backup for failure rollback
	 *  - another for read-after-write verification
	 */
	struct flash_ts cache_tmp_backup;
	struct flash_ts cache_tmp_verify;
};

static struct mmc_ts_priv *__ts;
static inline void __mmc_ts_put(struct mmc_ts_priv *ts)
{
	mutex_unlock(&ts->lock);
}

static void set_to_default_empty_state(struct mmc_ts_priv *ts)
{
	ts->offset = ts->part_info->size - ts->chunk;
	ts->cache.version = 0;
	ts->cache.len = 1;
	ts->cache.magic = FLASH_TS_MAGIC;
	ts->cache.data[0] = '\0';
}

static struct mmc_ts_priv *__mmc_ts_get(void)
{
	struct mmc_ts_priv *ts = __ts;

	if (likely(ts)) {
		mutex_lock(&ts->lock);
	} else {
		printk(KERN_ERR DRV_NAME ": not initialized yet\n");
	}

	return ts;
}

static char *mmc_ts_find(struct mmc_ts_priv *ts, const char *key, size_t key_len)
{
	char *s = ts->cache.data;
	while (*s) {
		if (!strncmp(s, key, key_len)) {
			if (s[key_len] == '=')
				return s;
		}

		s += strlen(s) + 1;
	}
	return NULL;
}

static inline u32 mmc_ts_check_header(const struct flash_ts *cache)
{
	if (cache->magic == FLASH_TS_MAGIC &&
	    cache->version &&
	    cache->len && cache->len <= sizeof(cache->data) &&
	    /* check correct null-termination */
	    !cache->data[cache->len - 1] &&
	    (cache->len == 1 || !cache->data[cache->len - 2])) {
		/* all is good */
		return cache->version;
	}

	return 0;
}

static int mmc_ts_read(int dev, struct mmc_ts_priv *ts, loff_t off, void *buf, size_t size, u64 part_start_offset)
{
	ulong start_blk;
	struct mmc *mmc = ts->mmc;
	void *addr_byte, *addr = buf, *addr_tmp;
	u64 cnt = 0, sz_byte = 0, n = 0, blk = 0;

	mmc = find_mmc_device(dev);
	if(!mmc) {
		return 1;
	}
	mmc_init(mmc);

	/* blk shift : normal is 9 */
	int blk_shift = 0;
	blk_shift =  ffs(mmc->read_bl_len) - 1;

	/* start blk offset */
	blk = (part_start_offset + off) >> blk_shift;

	/* seziof(ts->cache_tmp_verify) = cnt * ts->chunk + sz_byte */
	cnt = size >> blk_shift;
	sz_byte = size - (cnt << blk_shift);

	/* read cnt* ts->chunk bytes */
	n = mmc->block_dev.block_read(dev, blk, cnt, addr);

	/* read sz_byte bytes */
    if ((n == cnt) && (sz_byte != 0)) {
		//printf("sz_byte=%#llx bytes\n",sz_byte);
		addr_tmp = malloc(mmc->read_bl_len);
		addr_byte = (void *)(addr+cnt*(mmc->read_bl_len));
        start_blk = blk+cnt;

       	if (addr_tmp == NULL) {
			printf("mmc read: malloc fail\n");
			free(addr);
			return 1;
		}

		if (mmc->block_dev.block_read(dev, start_blk, 1, addr_tmp) != 1) { // read 1 block
			free(addr_tmp);
			printf("mmc read 1 block fail\n");
			return 1;
		}

		memcpy(addr_byte, addr_tmp, sz_byte);
	  	free(addr_tmp);
	}

	return 0;
}

static int mmc_is_blank(const void *buf, size_t size)
{
	size_t i;
	const unsigned int *data = (const unsigned int *)buf;
	size /= sizeof(data[0]);

	for (i = 0; i < size; i++)
		if (data[i] != 0xffffffff)
			return 0;
	return 1;
}

static int __init mmc_ts_scan(struct mmc_ts_priv *ts, int dev)
{
	struct mmc *mmc = ts->mmc;
	int res;
	loff_t off = 0;
	struct flash_ts tmp_scan_backup;
	u64 mmc_ts_size = ts->mmc_ts_size;
	u64 part_start_offset = ts->mmc_ts_offset;
	void *scan_addr = (void *) &tmp_scan_backup;

	memset(&tmp_scan_backup, 0, sizeof(tmp_scan_backup));

	mmc_init(mmc);

	do {
		/* read FLASH_TS_MAX_DATA_SIZE  data to ts->cache_tmp_verify */
		res = mmc_ts_read(dev, ts, off, scan_addr, sizeof(tmp_scan_backup), part_start_offset);
		if (!res) {
			/* check data struct */
			u32 version = mmc_ts_check_header(scan_addr);
			if (version > 0) {
				if (version > ts->cache.version) {
					memcpy(&ts->cache, scan_addr, sizeof(tmp_scan_backup));
					ts->offset = off;
				}
				break;
			} else if (0 == version && mmc_is_blank(&tmp_scan_backup, sizeof(tmp_scan_backup))) {
				off = (off + ts->mmc->erase_grp_size) & ~(ts->mmc->erase_grp_size - 1);
			} else {
				off += ts->chunk;
			}

		} else {
			off += ts->chunk;
		}

	} while(off < mmc_ts_size) ;/* while done*/

	return res;
}


static int mmc_write(int dev, struct mmc_ts_priv *ts, loff_t off, void *buf, size_t size, u64 part_start_offset)
{
	ulong start_blk;
	struct mmc *mmc = ts->mmc;
	void *addr_byte, *addr_tmp, *addr, *addr_read;
	u64 cnt = 0, sz_byte = 0, n = 0, blk = 0, res;
	struct flash_ts tmp_write_backup, tmp_read_backup;

	/*********init local data struct**************/
	memset(&tmp_write_backup, 0, sizeof(tmp_write_backup));
	memset(&tmp_read_backup, 0, sizeof(tmp_read_backup));
	memcpy(&tmp_write_backup, buf, size);
	addr = (void *) &tmp_write_backup;
	addr_read = (void *) &tmp_read_backup;
	/********************************************/

	mmc = find_mmc_device(dev);
	if(!mmc) {
		return 1;
	}
	mmc_init(mmc);

	/* blk shift : normal is 9 */
	int blk_shift = 0;
	blk_shift =  ffs(mmc->read_bl_len) - 1;

	/* start blk offset */
	blk = (part_start_offset + off) >> blk_shift;

	/* seziof(ts->cache_tmp_verify) = cnt * ts->chunk + sz_byte */
	cnt = size >> blk_shift;
	sz_byte = size - (cnt << blk_shift);

    n = mmc->block_dev.block_write(dev, blk, cnt, addr);
	//write sz_byte bytes
    if ((n == cnt) && (sz_byte != 0)) {
        // printf("sz_byte=%#llx bytes\n",sz_byte);
        addr_tmp = malloc(mmc->write_bl_len);
        addr_byte = (void*)(addr+cnt*(mmc->write_bl_len));
        start_blk = blk+cnt;

        if (addr_tmp == NULL) {
            printf("mmc write: malloc fail\n");
            return 1;
        }

        if (mmc->block_dev.block_read(dev, start_blk, 1, addr_tmp) != 1) { // read 1 block
            free(addr_tmp);
            printf("mmc read 1 block fail\n");
            return 1;
        }

        memcpy(addr_tmp, addr_byte, sz_byte);
        if (mmc->block_dev.block_write(dev, start_blk, 1, addr_tmp) != 1) { // write 1 block
            free(addr_tmp);
            printf("mmc write 1 block fail\n");
            return 1;
        }
        free(addr_tmp);
    }

	res = mmc_ts_read(dev, ts, off, addr_read, sizeof(tmp_read_backup), part_start_offset);

	if (!res) {
		if (! memcmp(&tmp_write_backup, &tmp_read_backup, size)) {
			memcpy(&ts->cache, &tmp_write_backup, size);
			printk("key write successfull!\n");
			return 0;
		} else {
			printk("%s:%d error!\n", __func__, __LINE__);
			return -1;
		}

	} else {
		printk("check key failure!\n");
		printk("%s:%d error!\n", __func__, __LINE__);
		return -2;
	}

	return 0;
}

static int mmc_ts_commit(struct mmc_ts_priv *ts)
{
	int res;
	int dev = ts->dev;
	u64 part_start_offset = ts->mmc_ts_offset;

	res = mmc_write(dev,ts, 0, &ts->cache, sizeof(ts->cache), part_start_offset);

	return res;
}

int mmc_ts_set(const char *key, const char *value)
{
	int res;
	char *p;
	struct mmc_ts_priv *ts;
	size_t klen = strlen(key);
	size_t vlen = strlen(value);

	ts = __mmc_ts_get();
	if (unlikely(!ts))
		return -EINVAL;

	/* save current cache contents so we can restore it on failure */
	memcpy(&ts->cache_tmp_backup, &ts->cache, sizeof(ts->cache_tmp_backup));

	p = mmc_ts_find(ts, key, klen);
	if (p) {
		/* we are replacing existing entry,
		 * empty value (vlen == 0) removes entry completely.
		 */
		size_t cur_len = strlen(p) + 1;
		size_t new_len = vlen ? klen + 1 + vlen + 1 : 0;

		if (cur_len != new_len) {
			/* we need to move stuff around */

			if ((ts->cache.len - cur_len) + new_len >
			     sizeof(ts->cache.data))
				goto no_space;

			memmove(p + new_len, p + cur_len,
				ts->cache.len - (p - ts->cache.data + cur_len));

			ts->cache.len = (ts->cache.len - cur_len) + new_len;
		} else if (!strcmp(p + klen + 1, value)) {
			/* skip update if new value is the same as the old one */
			res = 0;
			goto out;
		}

		if (vlen) {
			p += klen + 1;
			memcpy(p, value, vlen);
			p[vlen] = '\0';
		}
	} else {
		size_t len = klen + 1 + vlen + 1;

		/* don't do anything if value is empty */
		if (!vlen) {
			res = 0;
			goto out;
		}

		if (ts->cache.len + len > sizeof(ts->cache.data))
			goto no_space;

		/* add new entry at the end */
		p = ts->cache.data + ts->cache.len - 1;
		memcpy(p, key, klen);
		p += klen;
		*p++ = '=';
		memcpy(p, value, vlen);
		p += vlen;
		*p++ = '\0';
		*p = '\0';
		ts->cache.len += len;
	}
	++ts->cache.version;
	res = mmc_ts_commit(ts);
	if (unlikely(res))
		memcpy(&ts->cache, &ts->cache_tmp_backup, sizeof(ts->cache));

	goto out;

    no_space:
	printk(KERN_WARNING DRV_NAME ": no space left for '%s=%s'\n",
	       key, value);
	res = -ENOSPC;
    out:
	__mmc_ts_put(ts);

	return res;

}

void mmc_ts_get(const char *key, char *value, unsigned int size)
{
	const char *p;
	struct mmc_ts_priv *ts;
	size_t klen = strlen(key);

	BUG_ON(!size);

	*value = '\0';

	ts = __mmc_ts_get();
	if (unlikely(!ts))
		return;

	p = mmc_ts_find(ts, key, klen);
	if (p)
		strlcpy(value, p + klen + 1, size);

	__mmc_ts_put(ts);

}

/* Round-up to the next power-of-2,
 * from "Hacker's Delight" by Henry S. Warren.
 */
static inline u32 clp2(u32 x)
{
	--x;
	x |= x >> 1;
	x |= x >> 2;
	x |= x >> 4;
	x |= x >> 8;
	x |= x >> 16;
	return x + 1;
}

int mmc_ts_init(void)
{
	int res,dev;
	struct mmc *mmc;
	struct mmc_ts_priv *ts;
	struct partitions *part_info = NULL;

	// get dev by name
	dev = find_dev_num_by_partition_name(CONFIG_FLASH_TS_PARTITION);
	if (dev < 0) {
		printf("Cannot find dev.\n");
		return 1;
	}
	mmc = find_mmc_device(dev);
	if(!mmc) {
		return 1;
	}

	//init mmc
	mmc_init(mmc);

	//init fts data struct
	ts = kzalloc(sizeof(*ts), GFP_KERNEL);
	if (unlikely(!ts)) {
		res = -ENOMEM;
		printk(KERN_ERR DRV_NAME ": failed to allocate memory\n");
	}

	mutex_init(&ts->lock);
	ts->mmc = mmc;
	ts->mmc_read_write_unit = ts->mmc->read_bl_len;
	ts->chunk = clp2((sizeof(struct flash_ts) + ts->mmc->read_bl_len - 1) & 
			~(ts->mmc->read_bl_len - 1));

	/* dev*/
	ts->dev = dev;

	/* get fts part info*/
    part_info = find_mmc_partition_by_name(CONFIG_FLASH_TS_PARTITION);
	if (part_info == NULL) {
		printf("get partition info failed !!\n");
		kfree(ts);
		return -1;
	}

	/* init partiton info to ts data struct*/
	ts->part_info = part_info;
	ts->mmc_ts_offset = ts->part_info->offset;
	ts->mmc_ts_size = ts->part_info->size;

	/* default empty state */
	set_to_default_empty_state(ts);

	/* scan mmc partition for the most recent record */
	res = mmc_ts_scan(ts, dev);
	if (unlikely(res))
		goto out_free;

	if (ts->cache.version)
		printk(KERN_INFO DRV_NAME ": v%u loaded from 0x%08llx\n",
		       ts->cache.version, ts->offset);

	res = misc_register(&mmc_ts_miscdev);
	if (unlikely(res))
		goto out_free;

	__ts = ts;

    out_free:
	kfree(ts);

	return 0;
}