/*************************************************************************/
/*                                                                       */
/* FILE NAME                                      VERSION                */
/*                                                                       */
/* Amd16.c                                  	  1.0                    */
/*                                                                       */
/*                                                                       */
/*                                                                       */
/* FUNCTIONS : AMD Flash program code                            		 */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*                                Copyrigth (C) 2010 JNDTECH CO.,LTD  */
/*************************************************************************/

#include <stdio.h>
#include <string.h>
#include "common.h"
#include "main.h"

#define TOGGLE

#define STM32F10x_16  


#define PROGRAM_TIMEOUT         100
#define ERASE_SECTOR_TIMEOUT    500

#ifdef STM32F10x_16
#define DEVICE_SIZE   0x4000  // Device Size in Bytes (16kB)
#define SECTOR_SIZE   1024
#endif

#ifdef STM32F10x_128
#define DEVICE_SIZE   0x20000  // Device Size in Bytes (128kB)
#define SECTOR_SIZE   1024
#endif

#ifdef STM32F10x_512
#define DEVICE_SIZE   0x80000  // Device Size in Bytes (512kB)
#define SECTOR_SIZE   1024
#endif


#ifdef STM32F10x_1024
#define DEVICE_SIZE   0x00100000  // Device Size in Bytes (1024kB)
#define SECTOR_SIZE   1024
#endif

#ifdef STM32F10x_CL
#define DEVICE_SIZE   0x40000  // Device Size in Bytes (256kB)
#define SECTOR_SIZE   1024
#endif

#ifdef FLASH_OPT
#define DEVICE_SIZE   0x00010  // Device Size in Bytes (16)
#define SECTOR_SIZE   16 
#endif

 
// Host program data & command structure
extern FLASH_INFO Flash_Info;


 
void Main(void)
{
    Flash_Init();
	switch(Flash_Info.Command)
	{
		case FPROGRAM: 
            Program();
            break;
		case FERASEALL: 
            EraseAll();
            break;
		case FERASESEC: 
            EraseSector();
            break;
		case FREADID: 
            ReadChipID();
            break;
		default :
            memset(&Flash_Info,0,sizeof(Flash_Info));
			Flash_Info.Result = 0;
	} 
    dummy();
    __NOP();
    __NOP();
}
	
/*
// Flash program function
void  Program(void)
{
	ulong i;
	
	volatile ushort *targetP;
	volatile ushort *srcP;

	targetP = (ushort *)Flash_Info.TargetAddr;
	srcP = (ushort *)Flash_Info.Buf;

    for(i=0; i<Flash_Info.Length; i+=2, targetP++, srcP++)
    { 
		*targetP = *srcP;
	
		if(!Wait((ulong)targetP))
			return;
    }
	 

    Flash_Info.Result = Verification(Flash_Info.TargetAddr, Flash_Info.Length, (ulong)Flash_Info.Buf);
}

// Chip erase function
void EraseAll(void)
{
	Flash_Info.Result = 0;

	// First Flash erase 
	 
	Flash_Info.Result = BlankCheck(BASE_ADDRESS, 0x400000); // 16Mbyte
}

// Sector erase function
void EraseSector(void)
{
	int i;
	
	Flash_Info.Result = 0;
	
	for(i=0; i<SECTOR_COUNT-1; i++) // Start sector 
		if(SectorTable[i+1]>Flash_Info.TargetAddr)
			break;
	
	for(;i<SECTOR_COUNT-1; i++) {
		if(SectorTable[i] >= (Flash_Info.TargetAddr+Flash_Info.Length))
			break;
			
		if(!OneSectorErase(SectorTable[i]))
			return;
	}

	Flash_Info.Result = BlankCheck(Flash_Info.TargetAddr, Flash_Info.Length);
}

// Sector Erase
int OneSectorErase(ulong targetAddr)
{
	volatile ushort *targetP;
	
	targetP = (ushort *)targetAddr;
 
	if(!Wait((ulong)targetP))
		return 0;

	*targetP = RESET_CMD;

	return 1;
}

// Read Manufacturer & Device ID
void ReadChipID(void)
{
    ushort manId,devId;
 
    manId=*((volatile ushort *)0);
	manId &= 0xff;
 

    devId=*((volatile ushort *)2);

	devId &= 0xff;
	Flash_Info.Result = (devId << 8) + manId;
	 
}

int BlankCheck(ulong targetAddr,ulong targetSize) 
{
	ulong i;
	volatile ulong *targetP = (volatile ulong *)targetAddr;
	
	for (i=0; i<targetSize; i+=4) {
		if (*targetP++ != 0xffffffff) 
			return 0;
	}
		
	return 1;
}

int Verification(ulong targetAddr, ulong limit, ulong srcAddr)
{
    int i=0;
    volatile ulong * targetP;
    volatile ulong * sourceP;

	targetP = (volatile ulong *)targetAddr;
	sourceP = (volatile ulong *)srcAddr;

    for(i=0; i<limit; i+=4)
    {
		if(*targetP++ != *sourceP++)
		{
	    	return 0;
		}
#ifdef AUTOKICK
		if (((ulong)targetP & 0x1fff) == 0) {
			*AutoKick_reg = 1;
			*AutoKick_reg = 0;
		}
#endif
    }
    return 1;
}

int Wait(ulong tAddr)
{
	volatile ushort old, status;
	volatile ushort * targetP;
	
	targetP = (ushort *)tAddr;
	
#ifdef TOGGLE	
	old = *targetP;
#endif

    while(1)
   	{
		status=*targetP;

#ifdef TOGGLE	
		//Toggle algorithm			
		if((status & TOGGLE_MASK1) == (old & TOGGLE_MASK1)) 
			break;
				
		if(status & TOGGLE_MASK2) {
			old = *targetP;
			status=*targetP;

			if((status & TOGGLE_MASK1) == (old & TOGGLE_MASK1)) 
				break;
			else {
				Flash_Info.Result = 0; 
				return 0;
			}
			
		}
			
		old = status;
#else		
		if((status & POLL_MASK1) > 0)
			break;
		else if((status & POLL_MASK2) > 0) {
			status = *targetP;
			if((status & POLL_MASK1) > 0)
				break;
			else {
				*targetP = RESET_CMD;
				return 0;
			}
		}
#endif		
	}		

	return 1;
}
*/