bytenvram.c

Tornado 2.0 BSP for HaeDong HD860-R3 韩国HaeDong公司开发的基于Motorola的MPC860处理器的开发板的BSP

/* byteNvRam.c - byte-oriented SEEPROM(Microchip 24LC32A) driver */
/* copyright (c)Haedong Information & Communications Co. Ltd. */
/* 2000/6/12 ykahn */

#include "copyright_wrs.h"

/*
DESCRIPTION
This driver is for byte-oriented SEEPROM.

This is boilerplate driver code.  It is to be included in source form
into sysLib.c.  Macros are used to provide the actual working elements
while this code provides the generic logic.

The following numeric value macros are required:

  NV_RAM_INTRVL	  - address interval between bytes
  NV_RAM_SIZE	  - total number of bytes in device
  NV_BOOT_OFFSET  - Offset to first byte of boot line information

*/

#include "vxWorks.h"
#include "config.h"

/* default procedures assume static ram with no special r/w routines */
#ifndef NV_RAM_WR_ENBL
#   define NV_RAM_WR_ENBL	/* no write enable procedure */
#endif /*NV_RAM_WR_ENBL*/

#ifndef NV_RAM_WR_DSBL
#   define NV_RAM_WR_DSBL	/* no write disable procedure */
#endif /*NV_RAM_WR_DSBL*/

#ifndef NV_RAM_READ
#   define NV_RAM_READ(x) \
	(*(UCHAR *)((int)NV_RAM_ADRS + ((x) * NV_RAM_INTRVL)))
#endif /*NV_RAM_READ*/

#ifndef NV_RAM_WRITE
#   define NV_RAM_WRITE(x,y) \
	(*(UCHAR *)((int)NV_RAM_ADRS + ((x) * NV_RAM_INTRVL)) = (y))
#endif /*NV_RAM_WRITE*/



void seeprom_nop(void);
void seeprom_write(void);
void seeprom_poll(void);
void seeprom_read(void);
void seeprom_start(void);
void seeprom_stop(void);
void seeprom_clock(void);
void seeprom_ack(void);
void seeprom_sendb(void);
void seeprom_readb(void);
void seeprom_writeToEEPROM(unsigned long add, unsigned char d);
unsigned char seeprom_readFromEEPROM(unsigned long add);
void seeprom_initI2C(void);
unsigned int seeprom_ACK(void);

/**************************************************************************/
/*	SEEPROM(24C64) Byte Read & Write Functions Definition                 */
/**************************************************************************/

unsigned char addhi, addlo, addlo2, rwdata, seeprom_a, seeprom_c, rddata;

void seeprom_nop(void)
{
	unsigned int i;
	for(i =0;i<SEEPROM_NOP_DELAY;i++);

} 
 
void seeprom_write(void)
{

	seeprom_start();
 	seeprom_a = addhi;
 	seeprom_a = seeprom_a << 1;
 	seeprom_a = seeprom_a | 0xA0;
 	seeprom_a = seeprom_a & 0xAF;
 	seeprom_sendb();
 	seeprom_ack();
 	
 	seeprom_a = addlo;
  	seeprom_sendb();
 	seeprom_ack();
 	
 	seeprom_a = addlo2;
  	seeprom_sendb();
 	seeprom_ack();
 	
 	seeprom_a = rwdata;
 	seeprom_sendb();
 	seeprom_ack();
 	seeprom_stop();
}
 
void seeprom_poll(void)
{
	do{
 		seeprom_start();
 		seeprom_a = 0xa0;
 		seeprom_sendb();
 		seeprom_ack();
 	}while(seeprom_c);
 	seeprom_stop();
}
 
void seeprom_read(void)
{
	
	seeprom_start();
 	seeprom_a = addhi;
 	seeprom_a = seeprom_a << 1;
 	seeprom_a = seeprom_a | 0xa0;
 	seeprom_sendb();
 	seeprom_ack();
 	
 	seeprom_a = addlo;
 	seeprom_sendb();
 	seeprom_ack();
 	
 	seeprom_a = addlo2;
 	seeprom_sendb();
 	seeprom_ack();
 	
 	
 	seeprom_start();
 	seeprom_a = addhi;
 	seeprom_a = seeprom_a << 1;
 	seeprom_a = seeprom_a | 0xa1;
 	seeprom_sendb();
 	seeprom_ack();
 	
 	seeprom_readb();
/* 	rddata = a;*/
 	SetSDA();
 	seeprom_clock();
 	seeprom_stop();
}
 
 
void seeprom_start(void)
{
 	SetSDA();
 	SetSCL();
 	seeprom_nop();
 	ResetSDA();
 	seeprom_nop();
 	seeprom_nop();
 	seeprom_nop(); 	
 	ResetSCL();
 	seeprom_nop();
 	
}
 
void seeprom_stop(void)
{
 	SetSCL();
 	seeprom_nop();
 	ResetSDA();
 	seeprom_nop();
 	SetSDA();
 	seeprom_nop();
}
 
void seeprom_clock(void)
{
	seeprom_nop();
 	SetSCL();
 	seeprom_nop();
/* 	c = ACK();
	seeprom_nop(); 	*/
 	ResetSCL();
}
 
void seeprom_ack(void)
{
	unsigned int save, i;
	unsigned int *pbdir = (unsigned int *)REG_PBDIR;
	unsigned int *pbdat = (unsigned int *)REG_PBDAT;	

	seeprom_nop();
	save = *pbdir;
	*pbdir &= ~0x10;

 	SetSCL();
 	seeprom_nop();
	seeprom_c = (*pbdat & B_SDA);
	for(i=0;i<0x100;i++){
		seeprom_c = (*pbdat & B_SDA);
		if(seeprom_c== 0)
			break;
	}
	seeprom_nop();	
	seeprom_nop();	
	seeprom_nop();	
	seeprom_nop();				
	ResetSCL();
	*pbdir |=0x10;
}
 
void seeprom_sendb(void)
{
 	int i;
 	unsigned char tdata;
	
 	tdata = seeprom_a;

 	for(i=0;i<8;i++)
 	{
 		if(tdata & 0x80)
 			SetSDA();
 		else
 			ResetSDA();
 		 		
 		seeprom_clock();
 		
 		tdata = tdata << 1;
 	}

	SetSDA(); /* lisong */ 	
}
 
void seeprom_readb(void)
{
	unsigned int save, i;
	unsigned int *pbdir = (unsigned int *)REG_PBDIR;
	unsigned int *pbdat = (unsigned int *)REG_PBDAT;	

	seeprom_nop();
	save = *pbdir;
	*pbdir &= ~0x10;
 	
 	seeprom_a = 0;
 	for(i=0;i<8;i++)
 	{

		seeprom_nop();
	 	SetSCL();

	 	if(*pbdat & 0x10)
			seeprom_a = (seeprom_a<<1) + 1;
	 	else
	 		seeprom_a = seeprom_a<<1;

	 	seeprom_nop();
	 	ResetSCL();
 		 			
 	}
 	rddata = seeprom_a;
	*pbdir |=0x10; 	
}
void seeprom_delay(unsigned long delay)
{
		unsigned long i;
		for(i=0;i<delay;i++);
}   

/* add : 0.. */
void seeprom_writeToEEPROM(unsigned long add, unsigned char d)
{
	addhi = (unsigned char)(add >> 16);
	addlo = (unsigned char)((add >> 8) & 0x000000ff);
	addlo2 = (unsigned char)(add & 0x000000ff);
	
	rwdata = d;
	seeprom_write();
	seeprom_delay(SEEPROM_WRITE_DELAY);
}

/* add : 0.. */
unsigned char seeprom_readFromEEPROM(unsigned long add)
{
	addhi = (unsigned char)(add >> 16);
	addlo = (unsigned char)((add >> 8) & 0x000000ff);
	addlo2 = (unsigned char)(add & 0x000000ff);
	
	seeprom_read();
	return rddata;
} 
 
void seeprom_initI2C()
{
	volatile unsigned short *cpcr  = (unsigned short *)REG_CPCR;
	volatile unsigned int   *pbdir = (unsigned int *  )REG_PBDIR;
	volatile unsigned int   *pbdat = (unsigned int *  )REG_PBDAT;
	volatile unsigned int   *pbpar = (unsigned int *  )REG_PBPAR;
	volatile unsigned int   *pbodr = (unsigned int *)REG_PBODR;

	*pbpar &= ~0x30;
	*pbdir |=  0x30;	
	*pbodr |=  0x30;
	*pbdat |=  0x30;

	*cpcr = (CP_FLG	| CP_I2C);
	while(*cpcr & CP_FLG);

}
	
/******************************************************************************
*
* sysNvRamGet - get the contents of non-volatile RAM
*
* This routine copies the contents of non-volatile memory into a specified
* string.  The string is terminated with an EOS.
*
* RETURNS: OK, or ERROR if access is outside the non-volatile RAM range.
*
* SEE ALSO: sysNvRamSet()
*/

STATUS sysNvRamGet
    (
    char *string,    /* where to copy non-volatile RAM    */
    int strLen,      /* maximum number of bytes to copy   */
    int offset       /* byte offset into non-volatile RAM */
    )

    {
    	
/*    
    printf("start of sysNvRamGet()\n");
    printf("strlen: %d, offset:%d\n",strLen,offset);
*/    
    offset += NV_BOOT_OFFSET;   /* boot line begins at <offset> = 0 */

    if ((offset < 0)
     || (strLen < 0)
     || ((offset + strLen) > NV_RAM_SIZE))
        return (ERROR);

    while (strLen--)
	{
/*	
	printf("strlen: %d, offset:%d\n",strLen,offset);
*/	
	/* *string = NV_RAM_READ (offset); */
	*string = seeprom_readFromEEPROM ((unsigned long)offset);
	
	/* printf(".%c", *string); */
/*	
	printf("strlen: %d\n",strLen);
*/	
	
	string++, offset++;
	}
    *string = EOS;
/*    
    printf("\n\nstring: %s\n", string);
    
    printf("end of sysNvRamGet()\n");
*/
    return (OK);
    }

/*******************************************************************************
*
* sysNvRamSet - write to non-volatile RAM
*
* This routine copies a specified string into non-volatile RAM.
*
* RETURNS: OK, or ERROR if access is outside the non-volatile RAM range.
*
* SEE ALSO: sysNvRamGet()
*/

STATUS sysNvRamSet
    (
    char *string,     /* string to be copied into non-volatile RAM */
    int strLen,       /* maximum number of bytes to copy           */
    int offset        /* byte offset into non-volatile RAM         */
    )

    {
    STATUS result = OK;
/*    
    printf("start of sysNvRamSet()\n");
*/    

    offset += NV_BOOT_OFFSET;   /* boot line begins at <offset> = 0 */

    if ((offset < 0)
     || (strLen < 0)
     || ((offset + strLen) > NV_RAM_SIZE))
        return ERROR;

    /* NV_RAM_WR_ENBL; */

    while (strLen--)
	{
	char data;

	data = *string; /* avoid any macro side effects */

/*
	printf("seeprom_writeToEEPROM((unsigned long)offset, (unsigned char)data);\n");
	printf("offset : %d, data : %c \n", offset, data );
*/	
	/* NV_RAM_WRITE (offset, data); */	
	seeprom_writeToEEPROM((unsigned long)offset, (unsigned char)data);

/*
	data = seeprom_readFromEEPROM ((unsigned long)offset);
	printf("seeprom_readFromEEPROM ((unsigned long)offset)\n");
	printf("offset : %d, data : %c \n", offset, data );
*/
	
	
	/* verify data */
	/* if (NV_RAM_READ (offset) != (UCHAR)data) */
	if (seeprom_readFromEEPROM ((unsigned long)offset) != (UCHAR)data)	
	    {
	    result = ERROR;
/*	    
	    printf(" result = ERROR; \n");
*/	    
	    goto exit;
	    }

	string++, offset++;
	}
	
exit:
/*
	printf("end of sysNvRamSet()\n");
*/	
    /* NV_RAM_WR_DSBL; */

    return result;
    }