ReadWrite EEPROM in 89S8252

"the assembly version ... worked.
but didn't manage to convert it into C."

Then leave it in assembler!
There is absolutely no point whatsoever in converting it to 'C' - just to break it!!

It is perfectly acceptable & normal to have a project containing both 'C' and assembler modules.

There is no problem calling assembler from 'C' and vice-versa - there is a whole section in the C51 manual that tells you how to do it!

// --> how do u write here?

You have an address in xdata space at which you wish to read and write. A C pointer is an address. I'd use a pointer rather than an int. To turn a pointer into the thing at which it points, you "dereference" the pointer with the "*" operator:

char* p;
*p = myChar;

typedef
    volatile BYTE xdata
    Eeprom;

BYTE ReadEEPROM(Eeprom* addr)
{
	char EEdata;
	WMCON |= 0x08; // Enable EEPROM memory space

	EEdata = *addr; // Note the '*'

	WMCON &= 0xF7; // Disable EEPROM memory space
	return(EEdata);
}

typedef
    volatile BYTE xdata
    Eeprom;

#define EepromEnable     0x08
#define EepromWriteEn    0x10

// Address copied from asm example


BYTE ReadEEPROM(Eeprom* addr)
{
	BYTE eeData;

	WMCON |= EepromEnable; // Enable EEPROM memory space

	EEdata = *addr; // Note the '*'

	WMCON &= ~EepromEnable; // Disable EEPROM memory space

	return eeData;
}

void WriteEEPROM(Eeprom* addr, BYTE eeData)
{
	WMCON |= (EepromEnable |
                  EepromWriteEn);

	*addr = eeData; // Note the '*'
        msdelay(15);

	WMCON &= ~(EepromEnable |
                   EepromWriteEn);
}

#define EepromEnableRead  WMCON |=  EepromEnable
#define EepromEnableWrite WMCON |=  (EepromEnable | EepromWriteEn)
#define EepromDisable     WMCON &= ~(EepromEnable | EepromWriteEn)

BYTE ReadEEPROM(Eeprom* addr)
{
	BYTE eeData;

        EepromEnableRead;

	EEdata = *addr; // Note the '*'

        EepromDisable;

	return eeData;
}

void WriteEEPROM(Eeprom* addr, BYTE eeData)
{
        EepromEnableWrite;

	*addr = eeData; // Note the '*'
        msdelay(15);

	EepromDisable;
}

Ok. I did the adjustments as u suggested..
Seems there is no syntax error..
However I can't seem to build it..
Alot of errors while building it..

Heres the

Eeprom.c

#include <AT898252.H>

#ifndef BYTE
#define BYTE unsigned char
#endif

typedef
    volatile BYTE xdata
    Eeprom;

#define EepromEnable     0x08
#define EepromWriteEn    0x10
#define EepromEnableRead  WMCON |=  EepromEnable
#define EepromEnableWrite WMCON |=  (EepromEnable | EepromWriteEn)
#define EepromDisable     WMCON &= ~(EepromEnable | EepromWriteEn)

BYTE ReadEEPROM(Eeprom* addr);
void WriteEEPROM(Eeprom* addr, BYTE eeData);
void msdelay(unsigned x);

BYTE ReadEEPROM(Eeprom* addr)
{
	BYTE eeData;
    EepromEnableRead;

	eeData = *addr;

 	EepromDisable;
	return eeData;
}

void WriteEEPROM(Eeprom* addr, BYTE eeData)
{
	EepromEnableWrite;

	*addr = eeData;

	msdelay(15);
	EepromDisable;
}

void msdelay(unsigned int x)
{
    BYTE delval;
    while(x--)
    {
        delval = 123; /* Modify thisvalue to tune delay for 1mS */
        while(delval--)
            ;
    }
}

#include <AT898252.H>
#include "eeprom.c"

void main()
{
	Eeprom* addr=0;
	BYTE b=0,eeData=0x3F;

	for(b=0;b<9;b++)
	{
		WriteEEPROM(*(addr+b),eeData);
	}

}

Forget that question..
I've found a working version...
Thanks for your help..
It really helped me alot..

here's a sample if anyone wants it..

#include <AT898252.H>
#include <absacc.h>

/*
 * Return EEPROM Byte at address 'adr'
 */
unsigned char ReadEEPROM (unsigned int adr)
{
  unsigned char v;

  WMCON |= EEMEN_;   //  enable EEPROM
  v = XBYTE[adr];    //  read value
  WMCON &= ~EEMEN_;  //  disable EEPROM
  return (v);
}


/*
 * Write EEPROM Byte 'val' at address 'adr'
 */
void WriteEEPROM (unsigned int adr, unsigned char val)
{
  WMCON |= (EEMEN_ | EEMWE_);     // enable EEPROM and set write bit
  XBYTE[adr] = val;               // write value
  while ((WMCON & EERDY_) == 0);  // wait until value programmed
  WMCON &= ~(EEMWE_ | EEMEN_);    // disable EEPROM and write strobe
}


unsigned char v;

void main (void)
{
  v = ReadEEPROM (0x200);         // read EEPROM address 0x200
  WriteEEPROM (0x200, 6);         // write 6 to EEPROM address 0x200
  while (1);
}

If you peek in absacc.h, you'll see:

#define XBYTE ((unsigned char volatile xdata *) 0)

This macro is handy if you like to think of memory as an array of bytes and don't want to deal with pointers.

Or just look at the _at_ keyword extension.

I thought about that -- but figured I might as well stick with generic techniques that work on any compiler. I'll happily use the extensions needed to take advantage of the architecture (bit, using, etc).

But _at_ doesn't seem to me to add any real convenience over standard C features unless you're pointer-phobic. And it risks losing another thread to the complaint about how you can't use _at_ with initializers :)

"But _at_ doesn't seem to me to add any real convenience over standard C features unless you're pointer-phobic."

It allows you to locate 'constant variables' in code space at known addresses without having to muck about with the linker.....

"And it risks losing another thread to the complaint about how you can't use _at_ with initializers :)"

.....but doesn't let you initialise them.

What's the point of an uninitialised constant?