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,4,5,7 can be written) */	CE_High();			/* disable the device */}/************************************************************************//* PROCEDURE: WREN							*//*									*//* This procedure enables the Write Enable Latch.  It can also be used 	*//* to Enables Write Status Register.					*//*									*//* 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: EBSY							*//*									*//* This procedure enable SO to output RY/BY# status during AAI 		*//* programming.								*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		Nothing							*//************************************************************************/void EBSY(){	CE_Low();			/* enable device */	Send_Byte(0x70);		/* send EBSY command */	CE_High();			/* disable device */}/************************************************************************//* PROCEDURE: DBSY							*//*									*//* This procedure disable SO as output RY/BY# status signal during AAI	*//* programming.								*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		Nothing							*//************************************************************************/void DBSY(){	CE_Low();			/* enable device */	Send_Byte(0x80);		/* send DBSY 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(Manufacture's ID = BFh or Device ID = 80h)	*//*									*//************************************************************************/unsigned char Read_ID(ID_addr){	unsigned char byte;	CE_Low();			/* enable device */	Send_Byte(0x90);		/* send read ID command (90h or ABh) */    	Send_Byte(0x00);		/* send address */	Send_Byte(0x00);		/* send address */	Send_Byte(ID_addr);		/* send address - either 00H or 01H */	byte = Get_Byte();		/* receive byte */	CE_High();			/* disable device */	return byte;}/************************************************************************//* PROCEDURE: Jedec_ID_Read						*//*									*//* This procedure Reads the manufacturer's ID (BFh), memory type (25h)  *//* and device ID (41h).  It will use 9Fh as the JEDEC ID command.    	*//* Please see the product datasheet for details.  			*//*									*//* Input:								*//*		None							*//*									*//* Returns:								*//*		IDs_Read:ID1(Manufacture's ID = BFh, Memory Type (25h), *//*		 and Device ID (80h)					*//*									*//************************************************************************/unsigned long Jedec_ID_Read() {	unsigned long temp;		temp = 0;	CE_Low();			 /* enable device */	Send_Byte(0x9F);		 /* send JEDEC ID command (9Fh) */    	temp = (temp | Get_Byte()) << 8; /* receive byte */	temp = (temp | Get_Byte()) << 8;		temp = (temp | Get_Byte()); 	 /* temp value = 0xBF2541 */	CE_High();			 /* disable device */	return temp;}/************************************************************************//* PROCEDURE:	Read							*//*									*/		/* This procedure reads one address of the device.  It will return the 	*//* byte read in variable byte.						*//*									*//*									*//*									*//* Input:								*//*		Dst:	Destination Address 000000H - 1FFFFFH		*//*      								*//*									*//* Returns:								*//*		byte							*//*									*//************************************************************************/unsigned char Read(unsigned long Dst) {	unsigned char byte = 0;		CE_Low();			/* enable device */	Send_Byte(0x03); 		/* read command */	Send_Byte(((Dst & 0xFFFFFF) >> 16));	/* send 3 address bytes */	Send_Byte(((Dst & 0xFFFF) >> 8));	Send_Byte(Dst & 0xFF);	byte = Get_Byte();	CE_High();			/* disable device */	return byte;			/* return one byte read */}/************************************************************************//* PROCEDURE:	Read_Cont						*//*									*/		/* This procedure reads multiple addresses of the device and stores	*//* data into 128 byte buffer. Maximum byte that can be read is 128 bytes*//*									*//* Input:								*//*		Dst:		Destination Address 000000H - 1FFFFFH	*//*      	no_bytes	Number of bytes to read	(max = 128)	*//*									*//* Returns:								*//*		Nothing							*//*									*//************************************************************************/void Read_Cont(unsigned long Dst, unsigned long no_bytes){	unsigned long i = 0;	CE_Low();				/* enable device */	Send_Byte(0x03); 			/* read command */	Send_Byte(((Dst & 0xFFFFFF) >> 16)); 	/* send 3 address bytes */	Send_Byte(((Dst & 0xFFFF) >> 8));	Send_Byte(Dst & 0xFF);	for (i = 0; i < no_bytes; i++)		/* read until no_bytes is reached */	{		upper_128[i] = Get_Byte();	/* receive byte and store at address 80H - FFH */	}	CE_High();				/* disable device */}/************************************************************************//* PROCEDURE:	HighSpeed_Read						*//*									*/		/* This procedure reads one address of the device.  It will return the 	*//* byte read in variable byte.						*//*									*//*									*//*									*//* Input:								*//*		Dst:	Destination Address 000000H - 1FFFFFH		*//*      								*//*									*//* Returns:								*//*		byte							*//*									*//************************************************************************/unsigned char HighSpeed_Read(unsigned long Dst) {	unsigned char byte = 0;		CE_Low();			/* enable device */	Send_Byte(0x0B); 		/* read command */	Send_Byte(((Dst & 0xFFFFFF) >> 16));	/* send 3 address bytes */	Send_Byte(((Dst & 0xFFFF) >> 8));	Send_Byte(Dst & 0xFF);	Send_Byte(0xFF);		/*dummy byte*/	byte = Get_Byte();	CE_High();			/* disable device */	return byte;			/* return one byte read */}/************************************************************************//* PROCEDURE:	HighSpeed_Read_Cont					*//*									*/		/* This procedure reads multiple addresses of the device and stores	*//* data into 128 byte buffer. Maximum byte that can be read is 128 bytes*//*									*//* Input:								*//*		Dst:		Destination Address 000000H - 1FFFFFH	*//*      	no_bytes	Number of bytes to read	(max = 128)	*//*									*//* Returns:								*//*		Nothing							*//*									*//************************************************************************/void HighSpeed_Read_Cont(unsigned long Dst, unsigned long no_bytes){	unsigned long i = 0;	CE_Low();				/* enable device */	Send_Byte(0x0B); 			/* read command */	Send_Byte(((Dst & 0xFFFFFF) >> 16)); 	/* send 3 address bytes */	Send_Byte(((Dst & 0xFFFF) >> 8));	Send_Byte(Dst & 0xFF);	Send_Byte(0xFF);			/*dummy byte*/	for (i = 0; i < no_bytes; i++)		/* read until no_bytes is reached */	{		upper_128[i] = Get_Byte();	/* receive byte and store at address 80H - FFH */	}	CE_High();				/* disable device */}/************************************************************************//* PROCEDURE:	Byte_Program						*//*									*//* This procedure programs one address of the device.			*//* Assumption:  Address being programmed is already erased and is NOT	*//*		block protected.					*//*									*//*									*//*									*//* Input:								*//*		Dst:		Destination Address 000000H - 1FFFFFH	*//*		byte:		byte to be programmed			*//*      								*//*									*//* Returns:								*//*		Nothing							*//*									*//************************************************************************/void Byte_Program(unsigned long Dst, unsigned char byte){	CE_Low();				/* enable device */	Send_Byte(0x02); 			/* send Byte Program command */	Send_Byte(((Dst & 0xFFFFFF) >> 16));	/* send 3 address bytes */	Send_Byte(((Dst & 0xFFFF) >> 8));	Send_Byte(Dst & 0xFF);	Send_Byte(byte);			/* send byte to be programmed */	CE_High();				/* disable device */}/************************************************************************//* PROCEDURE:	Auto_Add_IncA						*//*									*//* This procedure programs consecutive addresses of 2 bytes of data into*//* the device:  1st data byte will be programmed into the initial 	*//* address [A23-A1] and with A0 = 0.  The 2nd data byte will be be 	*//* programmed into initial address [A23-A1] and with A0  = 1.  This  	*//* is used to to start the AAI process.  It should be followed by 	*//* Auto_Add_IncB.							*//* Assumption:  Address being programmed is already erased and is NOT	*//*		block protected.					*//*									*//*									*//* Note: Only RDSR command can be executed once in AAI mode with SO  	*//* 	 disable to output RY/BY# status.  Use WRDI to exit AAI mode 	*//*	 unless AAI is programming the last address or last address of  *//* 	 unprotected block, which automatically exits AAI mode.		*//*									*//* Input:								*//*		Dst:		Destination Address 000000H - 1FFFFFH	*//*		byte1:		1st byte to be programmed		*//*      	byte1:		2nd byte to be programmed		*/