/*Software DriverSST25LF020A 2 Mbit (256K x 8) Serial Flash MemoryFebruary 25th, 2004, Rev. 1.1ABOUT THE SOFTWAREThis application note provides software driver examples for 25LF020A,Serial Flash. Extensive comments are included in each routine to describe the function of each routine.  The interface coding uses polling method rather than the SPI protocol to interface with these serial devices.  Thefunctions are differentiated below in terms of the communication protocols(uses Mode 0) and specific device operation instructions. This code has been designed to compile using the Keil compiler.ABOUT THE 25LF020ACompanion product datasheets for the 25LF020A should be reviewed in conjunction with this application note for a complete understanding of the device.Device Communication Protocol(pinout related) functions:Functions                    		Function------------------------------------------------------------------init					Initializes clock to set up mode 0.Send_Byte				Sends one byte using SI pin to send and 					shift out 1-bit per clock rising edgeGet_Byte				Receives one byte using SO pin to receive and shift 					in 1-bit per clock falling edgeCE_High					Sets Chip Enable pin of the serial flash to highCE_Low					Clears Chip Enable of the serial flash to lowHold_Low				Clears Hold pin to make serial flash holdUnhold					Unholds the serial flashWP_Low					Clears WP pin to make serial flash write protectedUnWP					Disables write protection pinNote:  The pin names of the 25LF020A are used in this application note. The associated test codewill not compile unless these pinouts (SCK, SI, SO, SO, CE, WP, Hold) are pre-defined on yoursoftware which should reflect your hardware interfaced. 	 Device Operation Instruction functions:Functions                    		Function------------------------------------------------------------------Read_Status_Register			Reads the status register of the serial flashEWSR					Enables the Write Status RegisterWRSR					Performs a write to the status registerWREN					Write enables the serial flashWRDI					Write disables the serial flashRead_ID					Reads the manufacturer ID and device IDRead					Reads one byte from the serial flash and returns byte(max of 20 MHz CLK frequency)Read_Cont				Reads multiple bytes(max of 20 MHz CLK frequency)HighSpeed_Read				Reads one byte from the serial flash and returns byte(max of 33 MHz CLK frequency)HighSpeed_Read_Cont				Reads multiple bytes(max of 33 MHz CLK frequency)Byte_Program				Program one byte to the serial flashAuto_Add_IncA				Initial Auto Address Increment processAuto_Add_IncB				Successive Auto_Address_Increment process after AAI initiationChip_Erase				Erases entire serial flashSector_Erase				Erases one sector (4 KB) of the serial flashBlock_Erase				Erases one block (32 KB) of the serial flashWait_Busy				Polls status register until busy bit is lowWait_Busy_AAI				Polls status register until busy bit is low for AAI programmingWREN_Check				Checks to see if WEL is setWREN_AAI_Check				Checks to see if WEL and AAI mode is set*/                                                                     "C" LANGUAGE DRIVERS *//********************************************************************//* Copyright Silicon Storage Technology, Inc. (SST), 1994-2003	    *//* Example "C" language Driver of 25LF020A Serial Flash		    *//* Conrado Canio, Silicon Storage Technology, Inc.                  *//*                                                                  */ /* Revision 1.0, June 30th, 2003			  	    */   /* Revision 1.1, February 25th, 2004:                               *//* 	- Fixed the bug on HighSpeed_Read_Cont function that had the*//*		dummy byte cycle shifted before the LSB address.    *//*	- Replaced the comments about the memory range of the       *//*		25LF040A device with the memory	range of the        *//*		25LF020A device. 		                    *//********************************************************************/#include <stdio.h>#include <stdlib.h>/* Function Prototypes */void init();void Send_Byte(unsigned char out);unsigned char Get_Byte();void CE_High();void CE_Low();void Hold_Low();void Unhold();void WP_Low();void UnWP();unsigned char Read_Status_Register();void EWSR();void WRSR(byte);void WREN();void WRDI();unsigned char Read_ID(ID_addr);unsigned char Read(unsigned long Dst);void Read_Cont(unsigned long Dst, unsigned long no_bytes);unsigned char HighSpeed_Read(unsigned long Dst); void HighSpeed_Read_Cont(unsigned long Dst, unsigned long no_bytes);void Byte_Program(unsigned long Dst, unsigned char byte);void Auto_Add_IncA(unsigned long Dst, unsigned char byte);void Auto_Add_IncB(unsigned char byte);void Chip_Erase();void Sector_Erase(unsigned long Dst);void Block_Erase(unsigned long Dst);void Wait_Busy();void Wait_Busy_AAI();void WREN_Check();void WREN_AAI_Check();void Verify(unsigned char byte, unsigned char cor_byte);unsigned char idata upper_128[128];	/* global array to store read data */					/* to upper RAM area from 80H - FFH *//************************************************************************//* PROCEDURE: init							*//*									*//* This procedure initializes the SCK to low. Must be called prior to 	*//* setting up mode 0.							*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		SCK							*//************************************************************************/void init(){	SCK = 0;	/* set clock to low initial state */}/************************************************************************//* PROCEDURE: Send_Byte							*//*									*//* This procedure outputs a byte shifting out 1-bit per clock rising	*//* edge on the the SI pin(LSB 1st).					*//*									*//* Input:								*//*		out							*//*									*//* Output:								*//*		SI							*//************************************************************************/void Send_Byte(unsigned char out){		unsigned char i = 0;	for (i = 0; i < 8; i++)	{				if ((out & 0x80) == 0x80)	/* check if MSB is high */			SI = 1;		else			SI = 0;			/* if not, set to low */		SCK = 1;			/* toggle clock high */		out = (out << 1);		/* shift 1 place for next bit */		SCK = 0;			/* toggle clock low */	}}/************************************************************************//* PROCEDURE: Get_Byte							*//*									*//* This procedure inputs a byte shifting in 1-bit per clock falling	*//* edge on the SO pin(LSB 1st).						*//*									*//* Input:								*//*		SO							*//*									*//* Output:								*//*		None							*//************************************************************************/unsigned char Get_Byte(){	unsigned char i = 0, in = 0, temp = 0;	for (i = 0; i < 8; i++)	{		in = (in << 1);		/* shift 1 place to the left or shift in 0 */		temp = SO;		/* save input */		SCK = 1;		/* toggle clock high */	if (temp == 1)			/* check to see if bit is high */		in = in | 0x01;		/* if high, make bit high */		SCK = 0;		/* toggle clock low */	}	return in;}/************************************************************************//* PROCEDURE: CE_High							*//*									*//* This procedure set CE = High.					*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		CE							*//*									*//************************************************************************/void CE_High() {	CE = 1;				/* set CE high */}/************************************************************************//* PROCEDURE: CE_Low							*//*									*//* This procedure drives the CE of the device to low.  			*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		CE							*//*									*//************************************************************************/void CE_Low() {		CE = 0;				/* clear CE low */}/************************************************************************//* PROCEDURE: Hold()							*//*									*//* This procedure clears the Hold pin to low.				*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		Hold							*//************************************************************************/void Hold_Low(){	Hold = 0;			/* clear Hold pin */}/************************************************************************//* PROCEDURE: Unhold()							*//*									*//* This procedure sets the Hold pin to high.				*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		Hold							*//************************************************************************/void Unhold(){	Hold = 1;			/* set Hold pin */}/************************************************************************//* PROCEDURE: WP()							*//*									*//* This procedure clears the WP pin to low.				*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		WP							*//************************************************************************/void WP_Low(){	WP = 0;				/* clear WP pin */}/************************************************************************//* PROCEDURE: UnWP()							*//*									*//* This procedure sets the WP pin to high.				*//*									*//* Input:								*//*		None							*//*									*//* Output:								*//*		WP							*//************************************************************************/void UnWP(){	WP = 1;				/* set WP pin */}/************************************************************************//* PROCEDURE: Read_Status_Register					*//*									*//* This procedure read the status register and returns the byte.	*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		byte							*//************************************************************************/unsigned char Read_Status_Register(){	unsigned char byte = 0;	CE_Low();			/* enable device */	Send_Byte(0x05);		/* send RDSR command */	byte = Get_Byte();		/* receive byte */	CE_High();			/* disable device */	return byte;}/************************************************************************//* PROCEDURE: EWSR							*//*									*//* This procedure Enables Write Status Register.  			*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		Nothing							*//************************************************************************/void EWSR(){	CE_Low();			/* enable device */	Send_Byte(0x50);		/* enable writing to the status register */	CE_High();			/* disable device */}/************************************************************************//* PROCEDURE: WRSR							*//*									*//* This procedure writes a byte to the Status Register.			*//*									*//* Input:								*//*		byte							*//*									*//* Returns:								*//*		Nothing							*//************************************************************************/void WRSR(byte){	CE_Low();			/* enable device */	Send_Byte(0x01);		/* select write to status register */	Send_Byte(byte);		/* data that will change the status of BPx 						or BPL (only bits 2,3,7 can be written) */	CE_High();			/* disable the device */}/************************************************************************//* PROCEDURE: WREN							*//*									*//* This procedure enables the Write Enable Latch.			*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		Nothing							*//************************************************************************/void WREN(){	CE_Low();			/* enable device */	Send_Byte(0x06);		/* send WREN command */	CE_High();			/* disable device */}/************************************************************************//* PROCEDURE: WRDI							*//*									*//* This procedure disables the Write Enable Latch.			*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		Nothing							*//************************************************************************/void WRDI(){	CE_Low();			/* enable device */	Send_Byte(0x04);		/* send WRDI command */	CE_High();			/* disable device */}/************************************************************************//* PROCEDURE: Read_ID							*//*									*//* This procedure Reads the manufacturer's ID and device ID.  It will 	*//* use 90h or ABh as the command to read the ID (90h in this sample).   *//* It is up to the user to give the last byte ID_addr to determine      *//* whether the device outputs manufacturer's ID first, or device ID 	*//* first.  Please see the product datasheet for details.  Returns ID in *//* variable byte.							*//*									*//* Input:								*//*		ID_addr							*//*									*//* Returns:								*//*		byte:	ID1						*//*									*//************************************************************************/unsigned char Read_ID(ID_addr){