/*
 * c2k_flash.c
 *
 */

#include <malloc.h>
#include <diags.h>
#include <spi/spi.h>
#include <mach/comcerto_spi.h>
#include <common.h>
#include <linux/list.h>
#include <linux/types.h>
#include <command.h>
#include <config.h>
#include <libbb.h>

#define DEVICE_FAST_SPI	"S25FL064A0"

#define BUF_SIZE	4

extern int spi_write(struct spi_device *spi, const void *buf, size_t len);
extern int spi_read(struct spi_device *spi, void *buf, size_t len);
extern int spi_write_then_read(struct spi_device *spi,\
                const void *txbuf, unsigned n_tx,\
                void *rxbuf, unsigned n_rx);
extern int spi_eeprom_read(struct spi_device *spi,\
                const void *txbuf, unsigned n_tx,\
                void *rxbuf, unsigned n_rx);

static struct spi_device *ls_spi;
unsigned int erase_glob = 0;

#ifdef	DEBUG
void print_buffer(char *buf, int s)
{
	int i = 0;

	printk ("Buffer: ");
	while(i < s){
		printk ("0x%x:", *buf++);
		i++;
	}
	printk ("\n");
}
#endif

u8 read_rdsr(struct spi_device *spi)
{
        int ret = 0;
        uint8_t s25fl128_rdsr_cmd[4] = {
                0x05, 0xa, 0xb, 0xc
        };

        ret = spi_write_then_read(spi, s25fl128_rdsr_cmd, 2, s25fl128_rdsr_cmd+2, 2);
        if(ret)
        {
                printk ("%s:%d: RDSR failed.\n", __func__, __LINE__);
                return -1;
        }

        return s25fl128_rdsr_cmd[3];
}

#ifndef CONFIG_COMCERTO_ULOADER
/* Erase sector_num sector */
int nor_s25fl128_sector_erase(struct spi_device *spi, int sector_num)
{
	/* S25FL128: wren_cmd: |1B_cmd| */
	uint8_t s25fl128_wren_cmd[BUF_SIZE] = {
		0x06, 0x00, 0x00, 0x00,
	};
 	/* S25FL128: erase_cmd: |1B_cmd|3B_addr| */
	uint8_t s25fl128_erase_cmd[BUF_SIZE] = {
	 	0xd8, 0x00, 0x00, 0x00,
	};

        int sector_addr = sector_num * SPI_FLASH_SECTOR_SIZE;
        u8 rdsr = 0x1;
        int ret = 0;

        s25fl128_erase_cmd[1] = ((sector_addr & 0xff0000)>>16);
        s25fl128_erase_cmd[2] = ((sector_addr & 0xff00)>>8);
        s25fl128_erase_cmd[3] = (sector_addr & 0xff);

        do {
                rdsr = read_rdsr(spi);
        }while (rdsr & 0x1);

        ret = spi_write(spi, s25fl128_wren_cmd, 1);
        if(ret)
        {
                printk ("%s:WREN failed.\n", __func__);
                return ret;
        }

        do {
                rdsr = read_rdsr(spi);
        }while (!(rdsr & 0x2));

	if (!erase_glob) {
		ret = spi_write(spi, s25fl128_erase_cmd, 4);
		if(ret)
		{
			printk ("%s:ERASE failed.\n", __func__);
			return ret;
		}

		do {
			rdsr = read_rdsr(spi);
		}while (rdsr & 0x1);

		printk ("Erasing Done.\n");

		return ret;
	}else
		return 0;

}

int spi_sector_erase(int sec, int num_sec)
{
	struct device_d *d_fast_spi = get_device_by_name(DEVICE_FAST_SPI);
	int ret = 0;

	num_sec += sec;

	ls_spi = d_fast_spi->type_data;

	while(sec < num_sec){
		printf ("%s: erase sector %d\n", __func__, sec);
		ret = nor_s25fl128_sector_erase(ls_spi, sec++);
		if(ret)
		{
			printk ("%s: failed.\n", __func__);
			return ret;
		}
	}

	return 0;
}
EXPORT_SYMBOL(spi_sector_erase);

#define	WRITE_BYTES	8
int write_bytes_page_addr(struct spi_device *spi, u8 *b, int num_buytes, u8 p, unsigned int a)
{
	/* S25FL128: pp_cmd: |1B_cmd|3B_addr|at_least_1B_data|erite_buf| */
	uint8_t s25fl128_pp_cmd[4+WRITE_BYTES] = {
		0x02, 0x00, 0x00, 0x00,
	};
	/* S25FL128: wren_cmd: |1B_cmd| */
	uint8_t s25fl128_wren_cmd[BUF_SIZE] = {
		0x06, 0x00, 0x00, 0x00,
	};

        int ret = 0;
        u8 rdsr = 0x1;

        int addr = (SPI_FLASH_SECTOR_SIZE * p)+a;
        s25fl128_pp_cmd[1] = ((addr & 0xff0000)>>16);
        s25fl128_pp_cmd[2] = ((addr & 0xff00)>>8);
        s25fl128_pp_cmd[3] = (addr & 0xff);

	memcpy(s25fl128_pp_cmd+4, b, num_buytes);

        do {
                rdsr = read_rdsr(spi);
        }while (rdsr & 0x1);

        ret = spi_write(spi, s25fl128_wren_cmd, 1);
        if(ret)
        {
                printk ("%s:WREN failed.\n", __func__);
                return ret;
        }

        do {
                rdsr = read_rdsr(spi);
        }while (!(rdsr & 0x2));

        ret = spi_write(spi, s25fl128_pp_cmd, 4+num_buytes);
        if(ret)
        {
                printk ("%s:PP failed.\n", __func__);
                return ret;
        }

        do {
                rdsr = read_rdsr(spi);
        }while (rdsr & 0x1);

        return ret;
}
#endif

#define	READ_BYTES	8
int read_bytes_page_addr(struct spi_device *spi, u8 *b, int num_buytes, u8 p, unsigned int a)
{
        int ret = 0;
        u8 rdsr = 0x1;
	/* S25FL128: rd_cmd: |1B_cmd|3B_addr|dummy_bytes| */
	uint8_t s25fl128_rd_cmd[4+READ_BYTES] = {
		0x03, 0x00, 0x00, 0x00,
	};


        int addr = (SPI_FLASH_SECTOR_SIZE * p)+a;
        s25fl128_rd_cmd[1] = ((addr & 0xff0000)>>16);
        s25fl128_rd_cmd[2] = ((addr & 0xff00)>>8);
        s25fl128_rd_cmd[3] = (addr & 0xff);

        do {
                rdsr = read_rdsr(spi);
        }while (rdsr & 0x1);

        ret = spi_write_then_read(spi, s25fl128_rd_cmd, 4+num_buytes, b, 4+num_buytes);
        if(ret)
        {
                printk ("%s:Read failed.\n", __func__);
                return ret;
        }

        do {
                rdsr = read_rdsr(spi);
        }while (rdsr & 0x1);

        return ret;
}

#ifndef CONFIG_COMCERTO_ULOADER
static int spi_copy_write(char *src, unsigned int len, unsigned int sec, unsigned int off)
{
	unsigned int l=0;
	int ret = 0;
	struct device_d *d_fast_spi = get_device_by_name(DEVICE_FAST_SPI);

	ls_spi = d_fast_spi->type_data;

	ret = nor_s25fl128_sector_erase(ls_spi, sec);
	if(ret)
	{
		printk ("%s: failed.\n", __func__);
		return ret;
	}

	while (l < (len/WRITE_BYTES))
	{
		ret = write_bytes_page_addr(ls_spi, src, WRITE_BYTES, sec, off);
		if(ret)
		{
			printk ("%s: failed.\n", __func__);
			return ret;
		}
		src += WRITE_BYTES;
		off += WRITE_BYTES;
		l++;
	}
	
	if(len%WRITE_BYTES)
	{
		l = len%WRITE_BYTES;

		ret = write_bytes_page_addr(ls_spi, src, l, sec, off);
		if(ret)
		{
			printk ("%s: failed.\n", __func__);
			return ret;
		}
	}

	return 0;
}
#endif

int spi_copy_read(char *dst, unsigned int len, unsigned int sec, unsigned int off)
{
	unsigned int l=0;
	int ret = 0;
	char tmp[4+READ_BYTES];
	struct device_d *d_fast_spi = get_device_by_name(DEVICE_FAST_SPI);

	ls_spi = d_fast_spi->type_data;

	while (l < (len/READ_BYTES))
	{
		ret = read_bytes_page_addr(ls_spi, tmp, READ_BYTES, sec, off);
		if(ret)
		{
			printk ("%s: failed.\n", __func__);
			return ret;
		}

		memcpy(dst, tmp+4, READ_BYTES);

		dst += READ_BYTES;
		off += READ_BYTES;
		l++;
	}
	
	if(len%READ_BYTES)
	{
		l = len%READ_BYTES;

		ret = read_bytes_page_addr(ls_spi, tmp, l, sec, off);
		if(ret)
		{
			printk ("%s: failed.\n", __func__);
			return ret;
		}
		memcpy(dst, tmp+4, l);
		dst += l;
		off += l;
	}

	return 0;
}
EXPORT_SYMBOL(spi_copy_read);

#ifndef CONFIG_COMCERTO_ULOADER
static void spi_flash_write(unsigned char *src, ulong sec, ulong offset, ulong count)
{
	int wl = 0;
	unsigned int off = 0;
	unsigned int itr = SPI_FLASH_SECTOR_SIZE/SPI_FLASH_NOR_PAGE_SIZE;
	int write_bytes = SPI_FLASH_NOR_PAGE_SIZE;
	unsigned int *ptr_w;
	int s;
	ulong size;

	ptr_w = (unsigned int *)src;
	s = sec;
	size = count;
	off = offset;

	while(size)
	{
		itr = SPI_FLASH_SECTOR_SIZE/SPI_FLASH_NOR_PAGE_SIZE;
		erase_glob=0;

		if(size < SPI_FLASH_SECTOR_SIZE) {
			if(size%write_bytes)
				itr = size/write_bytes + 1;
			else
				itr = size/write_bytes;

			size = 0;
		} else {
			size -= SPI_FLASH_SECTOR_SIZE;
		}

		for (wl = 0 ; wl < itr ; wl++)
		{
			spi_copy_write((char*)ptr_w, write_bytes, s, off);

			erase_glob=1;
			ptr_w += 64;
			off += write_bytes;
		}
		printk ("Wrote %d bytes at sec %d in %d iterations.\n", \
				write_bytes*itr, s, itr);
		s++;
		off = 0;
	}
}

int update_spi_flash(unsigned char *src, ulong sec, ulong off, ulong count)
{
	spi_flash_write(src, sec, off, count);

        return 0;
}

EXPORT_SYMBOL(update_spi_flash);
#endif