eeprom.c 8.84 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
#include "types.h"
#include "i2c.h"
#include "eeprom.h"
#include "board.h"
#include "syscon.h"

/*
 * The SFP section is placed somewhere inside FMC EEPROM and it really does not 
 * matter where (can be a binary data inside the Board Info section but can be 
 * placed also outside the FMC standardized EEPROM structure. The only requirement
 * is that it starts with 0xdeadbeef pattern. The structure of SFP section is:
 *
13
 * --------------
14
 * | count (1B) |
15 16 17 18 19 20 21 22 23
 * --------------------------------------------------------------------------------------------
 * |   SFP(1) part number (16B)       | alpha (4B) | deltaTx (4B) | deltaRx (4B) | chksum(1B) |
 * --------------------------------------------------------------------------------------------
 * |   SFP(2) part number (16B)       | alpha (4B) | deltaTx (4B) | deltaRx (4B) | chksum(1B) |
 * --------------------------------------------------------------------------------------------
 * | (....)                           | (....)     | (....)       | (....)       | (...)      |
 * --------------------------------------------------------------------------------------------
 * |   SFP(count) part number (16B)   | alpha (4B) | deltaTx (4B) | deltaRx (4B) | chksum(1B) |
 * --------------------------------------------------------------------------------------------
24 25 26 27 28
 *
 * Fields description:
 * count              - how many SFPs are described in the list (binary)
 * SFP(n) part number - SFP PN as read from SFP's EEPROM (e.g. AXGE-1254-0531) 
 *                      (16 ascii chars)
29
 * checksum           - low order 8 bits of the sum of all bytes for the SFP(PN,alpha,dTx,dRx)
30 31 32
 *
 */

33 34 35 36 37 38 39 40 41 42 43 44 45
/*
 * The init script area consist of 2-byte size field and a set of shell commands
 * separated with '\n' character.
 *
 * -------------------
 * | bytes used (2B) |
 * ------------------------------------------------
 * | shell commands separated with '\n'.....      |
 * |                                              |
 * |                                              |
 * ------------------------------------------------
 */

46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

int eeprom_read(uint8_t i2cif, uint8_t i2c_addr, uint32_t offset, uint8_t *buf, size_t size)
{
	int i;
	unsigned char c;

  mi2c_start(i2cif);
  if(mi2c_put_byte(i2cif, i2c_addr << 1) < 0)
  {
    mi2c_stop(i2cif);
    return -1;
  }
  mi2c_put_byte(i2cif, (offset>>8) & 0xff);
  mi2c_put_byte(i2cif, offset & 0xff);
  mi2c_repeat_start(i2cif);
  mi2c_put_byte(i2cif, (i2c_addr << 1) | 1);
  for(i=0; i<size-1; ++i)
  {
    mi2c_get_byte(i2cif, &c, 0);
    *buf++ = c;
  }
  mi2c_get_byte(i2cif, &c, 1);
  *buf++ = c;
  mi2c_stop(i2cif);

 	return size;
}

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
int eeprom_write(uint8_t i2cif, uint8_t i2c_addr, uint32_t offset, uint8_t *buf, size_t size)
{
	int i, busy;

	for(i=0;i<size;i++)
	{
	 	mi2c_start(i2cif);

	 	if(mi2c_put_byte(i2cif, i2c_addr << 1) < 0)
	 	{
		 	mi2c_stop(i2cif);
	 	 	return -1;
	  }
		mi2c_put_byte(i2cif, (offset >> 8) & 0xff);
		mi2c_put_byte(i2cif, offset & 0xff);
		mi2c_put_byte(i2cif, *buf++);
		offset++;
		mi2c_stop(i2cif);

		do /* wait until the chip becomes ready */
		{
      mi2c_start(i2cif);
			busy = mi2c_put_byte(i2cif, i2c_addr << 1);
			mi2c_stop(i2cif);
		} while(busy);

	}
 	return size;
}
103

104 105 106
int32_t eeprom_sfpdb_erase(uint8_t i2cif, uint8_t i2c_addr)
{
  uint8_t sfpcount = 0;
107

108 109 110 111 112 113 114 115
  //just a dummy function that writes '0' to sfp count field of the SFP DB
  if( eeprom_write(i2cif, i2c_addr, EE_BASE_SFP, &sfpcount, sizeof(sfpcount)) != sizeof(sfpcount))
    return EE_RET_I2CERR;
  else
    return sfpcount;
}

int32_t eeprom_get_sfp(uint8_t i2cif, uint8_t i2c_addr, struct s_sfpinfo* sfp, uint8_t add, uint8_t pos)
116
{
117 118 119
  static uint8_t sfpcount = 0;
  uint8_t i, chksum=0;
  uint8_t* ptr;
120

121 122 123 124 125 126 127 128 129 130 131 132 133
  if( pos>=SFPS_MAX )
    return EE_RET_POSERR;  //position in database outside the range

  //read how many SFPs are in the database, but only in the first call (pos==0)
  if( !pos && eeprom_read(i2cif, i2c_addr, EE_BASE_SFP, &sfpcount, sizeof(sfpcount)) != sizeof(sfpcount) )
    return EE_RET_I2CERR;

  if( add && sfpcount==SFPS_MAX )  //no more space in the database to add new SFPs
    return EE_RET_DBFULL;
  else if( !pos && !add && sfpcount==0 )  //there are no SFPs in the database to read
    return sfpcount;

  if(!add)
134
  {
135 136 137 138 139 140 141 142
    if( eeprom_read(i2cif, i2c_addr, EE_BASE_SFP + sizeof(sfpcount) + pos*sizeof(struct s_sfpinfo), sfp, 
          sizeof(struct s_sfpinfo)) != sizeof(struct s_sfpinfo) )
      return EE_RET_I2CERR;

    ptr = (uint8_t*)sfp;
    for(i=0; i<sizeof(struct s_sfpinfo)-1; ++i) //'-1' because we do not include chksum in computation
      chksum = (uint8_t) ((uint16_t)chksum + *(ptr++)) & 0xff;
    if(chksum != sfp->chksum)
143
      EE_RET_CORRPT;
144
  }
145
  else
146
  {
147 148 149 150 151 152 153 154 155
    /*count checksum*/
    ptr = (uint8_t*)sfp;
    for(i=0; i<sizeof(struct s_sfpinfo)-1; ++i) //'-1' because we do not include chksum in computation
      chksum = (uint8_t) ((uint16_t)chksum + *(ptr++)) & 0xff;
    sfp->chksum = chksum;
    /*add SFP at the end of DB*/
    eeprom_write(i2cif, i2c_addr, EE_BASE_SFP+sizeof(sfpcount) + sfpcount*sizeof(struct s_sfpinfo), sfp, sizeof(struct s_sfpinfo));
    sfpcount++;
    eeprom_write(i2cif, i2c_addr, EE_BASE_SFP, &sfpcount, sizeof(sfpcount));
156
  }
157 158

  return sfpcount;
159 160
}

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
int8_t eeprom_match_sfp(uint8_t i2cif, uint8_t i2c_addr, struct s_sfpinfo* sfp)
{
  uint8_t sfpcount = 1;
  int8_t i, temp;
  struct s_sfpinfo dbsfp;

  for(i=0; i<sfpcount; ++i)
  {   
    temp = eeprom_get_sfp(WRPC_FMC_I2C, FMC_EEPROM_ADR, &dbsfp, 0, i); 
    if(!i) 
    {   
      sfpcount=temp; //only in first round valid sfpcount is returned from eeprom_get_sfp
      if(sfpcount == 0 || sfpcount == 0xFF)
        return 0;
      else if(sfpcount<0) 
        return sfpcount;
    }   
    if( !strncmp(dbsfp.pn, sfp->pn, 16) )
    {
      sfp->dTx = dbsfp.dTx;
      sfp->dRx = dbsfp.dRx;
      sfp->alpha = dbsfp.alpha;
      return 1;
    }
  } 

  return 0;
}
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302

int8_t eeprom_init_erase(uint8_t i2cif, uint8_t i2c_addr)
{
  uint16_t used = 0;

  if( eeprom_write(i2cif, i2c_addr, EE_BASE_INIT, &used, sizeof(used)) != sizeof(used))
    return EE_RET_I2CERR;
  else
    return used;
}

int8_t eeprom_init_purge(uint8_t i2cif, uint8_t i2c_addr)
{
  uint16_t used = 0xffff, i;
  uint16_t pattern = 0xff;

  eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, &used, sizeof(used));
  if(used==0xffff) used=0;
  for(i=0; i<used; ++i)
    eeprom_write(i2cif, i2c_addr, EE_BASE_INIT+sizeof(used)+i, &pattern, 1);
  used = 0xffff;
  eeprom_write(i2cif, i2c_addr, EE_BASE_INIT, &used, 2);

  return used;
}

/* 
 * Appends a new shell command at the end of boot script
 */
int8_t eeprom_init_add(uint8_t i2cif, uint8_t i2c_addr, const char *args[])
{
  uint8_t i=1;
  char separator = ' ';
  uint16_t used, readback;

  if( eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, &used, sizeof(used)) != sizeof(used) )
    return EE_RET_I2CERR;

  if( used==0xffff ) used=0;  //this means the memory is blank

  while(args[i]!='\0')
  {
    if( eeprom_write(i2cif, i2c_addr, EE_BASE_INIT+sizeof(used)+used, args[i], strlen(args[i])) != strlen(args[i]))
      return EE_RET_I2CERR;
    used += strlen(args[i]);
    if( eeprom_write(i2cif, i2c_addr, EE_BASE_INIT+sizeof(used)+used, &separator, sizeof(separator)) != sizeof(separator) )
      return EE_RET_I2CERR;
    ++used;
    ++i;
  }
  //the end of the command, replace last separator with '\n'
  separator = '\n';
  if( eeprom_write(i2cif, i2c_addr, EE_BASE_INIT+sizeof(used)+used-1, &separator, sizeof(separator)) != sizeof(separator) )
    return EE_RET_I2CERR;
  //and finally update the size of the script
  if( eeprom_write(i2cif, i2c_addr, EE_BASE_INIT, &used, sizeof(used)) != sizeof(used) )
    return EE_RET_I2CERR;

  if( eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, &readback, sizeof(readback)) != sizeof(readback) )
    return EE_RET_I2CERR;

  return 0;
}

int32_t eeprom_init_show(uint8_t i2cif, uint8_t i2c_addr)
{
  uint16_t used, i;
  char byte;

  if( eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, &used, sizeof(used)) != sizeof(used) )
    return EE_RET_I2CERR;

  if(used==0 || used==0xffff) 
  {
    used = 0;  //this means the memory is blank
    mprintf("Empty init script...\n");
  }

  //just read and print to the screen char after char
  for(i=0; i<used; ++i)
  {
    if( eeprom_read(i2cif, i2c_addr, EE_BASE_INIT+sizeof(used)+i, &byte, sizeof(byte)) != sizeof(byte) )
      return EE_RET_I2CERR;
    mprintf("%c", byte);
  }

  return 0;
}

int8_t eeprom_init_readcmd(uint8_t i2cif, uint8_t i2c_addr, char* buf, uint8_t bufsize, uint8_t next)
{
  static uint16_t ptr;
  static uint16_t used = 0;
  uint8_t i=0;

  if(next == 0) 
  {
    if( eeprom_read(i2cif, i2c_addr, EE_BASE_INIT, &used, sizeof(used)) != sizeof(used) )
      return EE_RET_I2CERR;
    ptr = sizeof(used);
  }

  if(ptr-sizeof(used) >= used)
    return 0;

  do
  {
    if(ptr-sizeof(used) > bufsize) return EE_RET_CORRPT;
    if( eeprom_read(i2cif, i2c_addr, EE_BASE_INIT+(ptr++), &buf[i], sizeof(char)) != sizeof(char) )
      return EE_RET_I2CERR;
  }while(buf[i++]!='\n');

  return i;
}